src/third_party/libjingle/source/talk/examples/peerconnection/client/linux/main_wnd.cc

   1 /*
   2  * libjingle
   3  * Copyright 2012, Google Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *  1. Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  *  2. Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  *  3. The name of the author may not be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28
  29 #include "talk/examples/peerconnection/client/linux/main_wnd.h"
  30
  31 #include <gdk/gdkkeysyms.h>
  32 #include <gtk/gtk.h>
  33 #include <stddef.h>
  34
  35 #include "talk/examples/peerconnection/client/defaults.h"
  36 #include "webrtc/base/common.h"
  37 #include "webrtc/base/logging.h"
  38 #include "webrtc/base/stringutils.h"
  39
  40 using rtc::sprintfn;
  41
  42 namespace {
  43
  44 //
  45 // Simple static functions that simply forward the callback to the
  46 // GtkMainWnd instance.
  47 //
  48
  49 gboolean OnDestroyedCallback(GtkWidget* widget, GdkEvent* event,
  50                              gpointer data) {
  51   reinterpret_cast<GtkMainWnd*>(data)->OnDestroyed(widget, event);
  52   return FALSE;
  53 }
  54
  55 void OnClickedCallback(GtkWidget* widget, gpointer data) {
  56   reinterpret_cast<GtkMainWnd*>(data)->OnClicked(widget);
  57 }
  58
  59 gboolean SimulateButtonClick(gpointer button) {
  60   g_signal_emit_by_name(button, "clicked");
  61   return false;
  62 }
  63
  64 gboolean OnKeyPressCallback(GtkWidget* widget, GdkEventKey* key,
  65                             gpointer data) {
  66   reinterpret_cast<GtkMainWnd*>(data)->OnKeyPress(widget, key);
  67   return false;
  68 }
  69
  70 void OnRowActivatedCallback(GtkTreeView* tree_view, GtkTreePath* path,
  71                             GtkTreeViewColumn* column, gpointer data) {
  72   reinterpret_cast<GtkMainWnd*>(data)->OnRowActivated(tree_view, path, column);
  73 }
  74
  75 gboolean SimulateLastRowActivated(gpointer data) {
  76   GtkTreeView* tree_view = reinterpret_cast<GtkTreeView*>(data);
  77   GtkTreeModel* model = gtk_tree_view_get_model(tree_view);
  78
  79   // "if iter is NULL, then the number of toplevel nodes is returned."
  80   int rows = gtk_tree_model_iter_n_children(model, NULL);
  81   GtkTreePath* lastpath = gtk_tree_path_new_from_indices(rows - 1, -1);
  82
  83   // Select the last item in the list
  84   GtkTreeSelection* selection = gtk_tree_view_get_selection(tree_view);
  85   gtk_tree_selection_select_path(selection, lastpath);
  86
  87   // Our TreeView only has one column, so it is column 0.
  88   GtkTreeViewColumn* column = gtk_tree_view_get_column(tree_view, 0);
  89
  90   gtk_tree_view_row_activated(tree_view, lastpath, column);
  91
  92   gtk_tree_path_free(lastpath);
  93   return false;
  94 }
  95
  96 // Creates a tree view, that we use to display the list of peers.
  97 void InitializeList(GtkWidget* list) {
  98   GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
  99   GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
 100       "List Items", renderer, "text", 0, NULL);
 101   gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
 102   GtkListStore* store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
 103   gtk_tree_view_set_model(GTK_TREE_VIEW(list), GTK_TREE_MODEL(store));
 104   g_object_unref(store);
 105 }
 106
 107 // Adds an entry to a tree view.
 108 void AddToList(GtkWidget* list, const gchar* str, int value) {
 109   GtkListStore* store = GTK_LIST_STORE(
 110       gtk_tree_view_get_model(GTK_TREE_VIEW(list)));
 111
 112   GtkTreeIter iter;
 113   gtk_list_store_append(store, &iter);
 114   gtk_list_store_set(store, &iter, 0, str, 1, value, -1);
 115 }
 116
 117 struct UIThreadCallbackData {
 118   explicit UIThreadCallbackData(MainWndCallback* cb, int id, void* d)
 119       : callback(cb), msg_id(id), data(d) {}
 120   MainWndCallback* callback;
 121   int msg_id;
 122   void* data;
 123 };
 124
 125 gboolean HandleUIThreadCallback(gpointer data) {
 126   UIThreadCallbackData* cb_data = reinterpret_cast<UIThreadCallbackData*>(data);
 127   cb_data->callback->UIThreadCallback(cb_data->msg_id, cb_data->data);
 128   delete cb_data;
 129   return false;
 130 }
 131
 132 gboolean Redraw(gpointer data) {
 133   GtkMainWnd* wnd = reinterpret_cast<GtkMainWnd*>(data);
 134   wnd->OnRedraw();
 135   return false;
 136 }
 137 }  // end anonymous
 138
 139 //
 140 // GtkMainWnd implementation.
 141 //
 142
 143 GtkMainWnd::GtkMainWnd(const char* server, int port, bool autoconnect,
 144                        bool autocall)
 145     : window_(NULL), draw_area_(NULL), vbox_(NULL), server_edit_(NULL),
 146       port_edit_(NULL), peer_list_(NULL), callback_(NULL),
 147       server_(server), autoconnect_(autoconnect), autocall_(autocall) {
 148   char buffer[10];
 149   sprintfn(buffer, sizeof(buffer), "%i", port);
 150   port_ = buffer;
 151 }
 152
 153 GtkMainWnd::~GtkMainWnd() {
 154   ASSERT(!IsWindow());
 155 }
 156
 157 void GtkMainWnd::RegisterObserver(MainWndCallback* callback) {
 158   callback_ = callback;
 159 }
 160
 161 bool GtkMainWnd::IsWindow() {
 162   return window_ != NULL && GTK_IS_WINDOW(window_);
 163 }
 164
 165 void GtkMainWnd::MessageBox(const char* caption, const char* text,
 166                             bool is_error) {
 167   GtkWidget* dialog = gtk_message_dialog_new(GTK_WINDOW(window_),
 168       GTK_DIALOG_DESTROY_WITH_PARENT,
 169       is_error ? GTK_MESSAGE_ERROR : GTK_MESSAGE_INFO,
 170       GTK_BUTTONS_CLOSE, "%s", text);
 171   gtk_window_set_title(GTK_WINDOW(dialog), caption);
 172   gtk_dialog_run(GTK_DIALOG(dialog));
 173   gtk_widget_destroy(dialog);
 174 }
 175
 176 MainWindow::UI GtkMainWnd::current_ui() {
 177   if (vbox_)
 178     return CONNECT_TO_SERVER;
 179
 180   if (peer_list_)
 181     return LIST_PEERS;
 182
 183   return STREAMING;
 184 }
 185
 186
 187 void GtkMainWnd::StartLocalRenderer(webrtc::VideoTrackInterface* local_video) {
 188   local_renderer_.reset(new VideoRenderer(this, local_video));
 189 }
 190
 191 void GtkMainWnd::StopLocalRenderer() {
 192   local_renderer_.reset();
 193 }
 194
 195 void GtkMainWnd::StartRemoteRenderer(webrtc::VideoTrackInterface* remote_video) {
 196   remote_renderer_.reset(new VideoRenderer(this, remote_video));
 197 }
 198
 199 void GtkMainWnd::StopRemoteRenderer() {
 200   remote_renderer_.reset();
 201 }
 202
 203 void GtkMainWnd::QueueUIThreadCallback(int msg_id, void* data) {
 204   g_idle_add(HandleUIThreadCallback,
 205              new UIThreadCallbackData(callback_, msg_id, data));
 206 }
 207
 208 bool GtkMainWnd::Create() {
 209   ASSERT(window_ == NULL);
 210
 211   window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 212   if (window_) {
 213     gtk_window_set_position(GTK_WINDOW(window_), GTK_WIN_POS_CENTER);
 214     gtk_window_set_default_size(GTK_WINDOW(window_), 640, 480);
 215     gtk_window_set_title(GTK_WINDOW(window_), "PeerConnection client");
 216     g_signal_connect(G_OBJECT(window_), "delete-event",
 217                      G_CALLBACK(&OnDestroyedCallback), this);
 218     g_signal_connect(window_, "key-press-event", G_CALLBACK(OnKeyPressCallback),
 219                      this);
 220
 221     SwitchToConnectUI();
 222   }
 223
 224   return window_ != NULL;
 225 }
 226
 227 bool GtkMainWnd::Destroy() {
 228   if (!IsWindow())
 229     return false;
 230
 231   gtk_widget_destroy(window_);
 232   window_ = NULL;
 233
 234   return true;
 235 }
 236
 237 void GtkMainWnd::SwitchToConnectUI() {
 238   LOG(INFO) << __FUNCTION__;
 239
 240   ASSERT(IsWindow());
 241   ASSERT(vbox_ == NULL);
 242
 243   gtk_container_set_border_width(GTK_CONTAINER(window_), 10);
 244
 245   if (peer_list_) {
 246     gtk_widget_destroy(peer_list_);
 247     peer_list_ = NULL;
 248   }
 249
 250   vbox_ = gtk_vbox_new(FALSE, 5);
 251   GtkWidget* valign = gtk_alignment_new(0, 1, 0, 0);
 252   gtk_container_add(GTK_CONTAINER(vbox_), valign);
 253   gtk_container_add(GTK_CONTAINER(window_), vbox_);
 254
 255   GtkWidget* hbox = gtk_hbox_new(FALSE, 5);
 256
 257   GtkWidget* label = gtk_label_new("Server");
 258   gtk_container_add(GTK_CONTAINER(hbox), label);
 259
 260   server_edit_ = gtk_entry_new();
 261   gtk_entry_set_text(GTK_ENTRY(server_edit_), server_.c_str());
 262   gtk_widget_set_size_request(server_edit_, 400, 30);
 263   gtk_container_add(GTK_CONTAINER(hbox), server_edit_);
 264
 265   port_edit_ = gtk_entry_new();
 266   gtk_entry_set_text(GTK_ENTRY(port_edit_), port_.c_str());
 267   gtk_widget_set_size_request(port_edit_, 70, 30);
 268   gtk_container_add(GTK_CONTAINER(hbox), port_edit_);
 269
 270   GtkWidget* button = gtk_button_new_with_label("Connect");
 271   gtk_widget_set_size_request(button, 70, 30);
 272   g_signal_connect(button, "clicked", G_CALLBACK(OnClickedCallback), this);
 273   gtk_container_add(GTK_CONTAINER(hbox), button);
 274
 275   GtkWidget* halign = gtk_alignment_new(1, 0, 0, 0);
 276   gtk_container_add(GTK_CONTAINER(halign), hbox);
 277   gtk_box_pack_start(GTK_BOX(vbox_), halign, FALSE, FALSE, 0);
 278
 279   gtk_widget_show_all(window_);
 280
 281   if (autoconnect_)
 282     g_idle_add(SimulateButtonClick, button);
 283 }
 284
 285 void GtkMainWnd::SwitchToPeerList(const Peers& peers) {
 286   LOG(INFO) << __FUNCTION__;
 287
 288   if (!peer_list_) {
 289     gtk_container_set_border_width(GTK_CONTAINER(window_), 0);
 290     if (vbox_) {
 291       gtk_widget_destroy(vbox_);
 292       vbox_ = NULL;
 293       server_edit_ = NULL;
 294       port_edit_ = NULL;
 295     } else if (draw_area_) {
 296       gtk_widget_destroy(draw_area_);
 297       draw_area_ = NULL;
 298       draw_buffer_.reset();
 299     }
 300
 301     peer_list_ = gtk_tree_view_new();
 302     g_signal_connect(peer_list_, "row-activated",
 303                      G_CALLBACK(OnRowActivatedCallback), this);
 304     gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(peer_list_), FALSE);
 305     InitializeList(peer_list_);
 306     gtk_container_add(GTK_CONTAINER(window_), peer_list_);
 307     gtk_widget_show_all(window_);
 308   } else {
 309     GtkListStore* store =
 310         GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(peer_list_)));
 311     gtk_list_store_clear(store);
 312   }
 313
 314   AddToList(peer_list_, "List of currently connected peers:", -1);
 315   for (Peers::const_iterator i = peers.begin(); i != peers.end(); ++i)
 316     AddToList(peer_list_, i->second.c_str(), i->first);
 317
 318   if (autocall_ && peers.begin() != peers.end())
 319     g_idle_add(SimulateLastRowActivated, peer_list_);
 320 }
 321
 322 void GtkMainWnd::SwitchToStreamingUI() {
 323   LOG(INFO) << __FUNCTION__;
 324
 325   ASSERT(draw_area_ == NULL);
 326
 327   gtk_container_set_border_width(GTK_CONTAINER(window_), 0);
 328   if (peer_list_) {
 329     gtk_widget_destroy(peer_list_);
 330     peer_list_ = NULL;
 331   }
 332
 333   draw_area_ = gtk_drawing_area_new();
 334   gtk_container_add(GTK_CONTAINER(window_), draw_area_);
 335
 336   gtk_widget_show_all(window_);
 337 }
 338
 339 void GtkMainWnd::OnDestroyed(GtkWidget* widget, GdkEvent* event) {
 340   callback_->Close();
 341   window_ = NULL;
 342   draw_area_ = NULL;
 343   vbox_ = NULL;
 344   server_edit_ = NULL;
 345   port_edit_ = NULL;
 346   peer_list_ = NULL;
 347 }
 348
 349 void GtkMainWnd::OnClicked(GtkWidget* widget) {
 350   // Make the connect button insensitive, so that it cannot be clicked more than
 351   // once.  Now that the connection includes auto-retry, it should not be
 352   // necessary to click it more than once.
 353   gtk_widget_set_sensitive(widget, false);
 354   server_ = gtk_entry_get_text(GTK_ENTRY(server_edit_));
 355   port_ = gtk_entry_get_text(GTK_ENTRY(port_edit_));
 356   int port = port_.length() ? atoi(port_.c_str()) : 0;
 357   callback_->StartLogin(server_, port);
 358 }
 359
 360 void GtkMainWnd::OnKeyPress(GtkWidget* widget, GdkEventKey* key) {
 361   if (key->type == GDK_KEY_PRESS) {
 362     switch (key->keyval) {
 363      case GDK_Escape:
 364        if (draw_area_) {
 365          callback_->DisconnectFromCurrentPeer();
 366        } else if (peer_list_) {
 367          callback_->DisconnectFromServer();
 368        }
 369        break;
 370
 371      case GDK_KP_Enter:
 372      case GDK_Return:
 373        if (vbox_) {
 374          OnClicked(NULL);
 375        } else if (peer_list_) {
 376          // OnRowActivated will be called automatically when the user
 377          // presses enter.
 378        }
 379        break;
 380
 381      default:
 382        break;
 383     }
 384   }
 385 }
 386
 387 void GtkMainWnd::OnRowActivated(GtkTreeView* tree_view, GtkTreePath* path,
 388                                 GtkTreeViewColumn* column) {
 389   ASSERT(peer_list_ != NULL);
 390   GtkTreeIter iter;
 391   GtkTreeModel* model;
 392   GtkTreeSelection* selection =
 393       gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
 394   if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
 395      char* text;
 396      int id = -1;
 397      gtk_tree_model_get(model, &iter, 0, &text, 1, &id,  -1);
 398      if (id != -1)
 399        callback_->ConnectToPeer(id);
 400      g_free(text);
 401   }
 402 }
 403
 404 void GtkMainWnd::OnRedraw() {
 405   gdk_threads_enter();
 406
 407   VideoRenderer* remote_renderer = remote_renderer_.get();
 408   if (remote_renderer && remote_renderer->image() != NULL &&
 409       draw_area_ != NULL) {
 410     int width = remote_renderer->width();
 411     int height = remote_renderer->height();
 412
 413     if (!draw_buffer_.get()) {
 414       draw_buffer_size_ = (width * height * 4) * 4;
 415       draw_buffer_.reset(new uint8[draw_buffer_size_]);
 416       gtk_widget_set_size_request(draw_area_, width * 2, height * 2);
 417     }
 418
 419     const uint32* image = reinterpret_cast<const uint32*>(
 420         remote_renderer->image());
 421     uint32* scaled = reinterpret_cast<uint32*>(draw_buffer_.get());
 422     for (int r = 0; r < height; ++r) {
 423       for (int c = 0; c < width; ++c) {
 424         int x = c * 2;
 425         scaled[x] = scaled[x + 1] = image[c];
 426       }
 427
 428       uint32* prev_line = scaled;
 429       scaled += width * 2;
 430       memcpy(scaled, prev_line, (width * 2) * 4);
 431
 432       image += width;
 433       scaled += width * 2;
 434     }
 435
 436     VideoRenderer* local_renderer = local_renderer_.get();
 437     if (local_renderer && local_renderer->image()) {
 438       image = reinterpret_cast<const uint32*>(local_renderer->image());
 439       scaled = reinterpret_cast<uint32*>(draw_buffer_.get());
 440       // Position the local preview on the right side.
 441       scaled += (width * 2) - (local_renderer->width() / 2);
 442       // right margin...
 443       scaled -= 10;
 444       // ... towards the bottom.
 445       scaled += (height * width * 4) -
 446                 ((local_renderer->height() / 2) *
 447                  (local_renderer->width() / 2) * 4);
 448       // bottom margin...
 449       scaled -= (width * 2) * 5;
 450       for (int r = 0; r < local_renderer->height(); r += 2) {
 451         for (int c = 0; c < local_renderer->width(); c += 2) {
 452           scaled[c / 2] = image[c + r * local_renderer->width()];
 453         }
 454         scaled += width * 2;
 455       }
 456     }
 457
 458     gdk_draw_rgb_32_image(draw_area_->window,
 459                           draw_area_->style->fg_gc[GTK_STATE_NORMAL],
 460                           0,
 461                           0,
 462                           width * 2,
 463                           height * 2,
 464                           GDK_RGB_DITHER_MAX,
 465                           draw_buffer_.get(),
 466                           (width * 2) * 4);
 467   }
 468
 469   gdk_threads_leave();
 470 }
 471
 472 GtkMainWnd::VideoRenderer::VideoRenderer(
 473     GtkMainWnd* main_wnd,
 474     webrtc::VideoTrackInterface* track_to_render)
 475     : width_(0),
 476       height_(0),
 477       main_wnd_(main_wnd),
 478       rendered_track_(track_to_render) {
 479   rendered_track_->AddRenderer(this);
 480 }
 481
 482 GtkMainWnd::VideoRenderer::~VideoRenderer() {
 483   rendered_track_->RemoveRenderer(this);
 484 }
 485
 486 void GtkMainWnd::VideoRenderer::SetSize(int width, int height) {
 487   gdk_threads_enter();
 488   width_ = width;
 489   height_ = height;
 490   image_.reset(new uint8[width * height * 4]);
 491   gdk_threads_leave();
 492 }
 493
 494 void GtkMainWnd::VideoRenderer::RenderFrame(const cricket::VideoFrame* frame) {
 495   gdk_threads_enter();
 496
 497   int size = width_ * height_ * 4;
 498   // TODO: Convert directly to RGBA
 499   frame->ConvertToRgbBuffer(cricket::FOURCC_ARGB,
 500                             image_.get(),
 501                             size,
 502                             width_ * 4);
 503   // Convert the B,G,R,A frame to R,G,B,A, which is accepted by GTK.
 504   // The 'A' is just padding for GTK, so we can use it as temp.
 505   uint8* pix = image_.get();
 506   uint8* end = image_.get() + size;
 507   while (pix < end) {
 508     pix[3] = pix[0];     // Save B to A.
 509     pix[0] = pix[2];  // Set Red.
 510     pix[2] = pix[3];  // Set Blue.
 511     pix[3] = 0xFF;     // Fixed Alpha.
 512     pix += 4;
 513   }
 514
 515   gdk_threads_leave();
 516
 517   g_idle_add(Redraw, main_wnd_);
 518 }
 519
 520