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
40using rtc::sprintfn;
41
42namespace {
43
44//
45// Simple static functions that simply forward the callback to the
46// GtkMainWnd instance.
47//
48
49gboolean OnDestroyedCallback(GtkWidget* widget, GdkEvent* event,
50                             gpointer data) {
51  reinterpret_cast<GtkMainWnd*>(data)->OnDestroyed(widget, event);
52  return FALSE;
53}
54
55void OnClickedCallback(GtkWidget* widget, gpointer data) {
56  reinterpret_cast<GtkMainWnd*>(data)->OnClicked(widget);
57}
58
59gboolean SimulateButtonClick(gpointer button) {
60  g_signal_emit_by_name(button, "clicked");
61  return false;
62}
63
64gboolean OnKeyPressCallback(GtkWidget* widget, GdkEventKey* key,
65                            gpointer data) {
66  reinterpret_cast<GtkMainWnd*>(data)->OnKeyPress(widget, key);
67  return false;
68}
69
70void OnRowActivatedCallback(GtkTreeView* tree_view, GtkTreePath* path,
71                            GtkTreeViewColumn* column, gpointer data) {
72  reinterpret_cast<GtkMainWnd*>(data)->OnRowActivated(tree_view, path, column);
73}
74
75gboolean 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.
97void 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.
108void 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
117struct 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
125gboolean 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
132gboolean 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
143GtkMainWnd::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
153GtkMainWnd::~GtkMainWnd() {
154  ASSERT(!IsWindow());
155}
156
157void GtkMainWnd::RegisterObserver(MainWndCallback* callback) {
158  callback_ = callback;
159}
160
161bool GtkMainWnd::IsWindow() {
162  return window_ != NULL && GTK_IS_WINDOW(window_);
163}
164
165void 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
176MainWindow::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
187void GtkMainWnd::StartLocalRenderer(webrtc::VideoTrackInterface* local_video) {
188  local_renderer_.reset(new VideoRenderer(this, local_video));
189}
190
191void GtkMainWnd::StopLocalRenderer() {
192  local_renderer_.reset();
193}
194
195void GtkMainWnd::StartRemoteRenderer(webrtc::VideoTrackInterface* remote_video) {
196  remote_renderer_.reset(new VideoRenderer(this, remote_video));
197}
198
199void GtkMainWnd::StopRemoteRenderer() {
200  remote_renderer_.reset();
201}
202
203void GtkMainWnd::QueueUIThreadCallback(int msg_id, void* data) {
204  g_idle_add(HandleUIThreadCallback,
205             new UIThreadCallbackData(callback_, msg_id, data));
206}
207
208bool 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
227bool GtkMainWnd::Destroy() {
228  if (!IsWindow())
229    return false;
230
231  gtk_widget_destroy(window_);
232  window_ = NULL;
233
234  return true;
235}
236
237void 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
285void 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
322void 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
339void 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
349void 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
360void 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
387void 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
404void 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
472GtkMainWnd::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
482GtkMainWnd::VideoRenderer::~VideoRenderer() {
483  rendered_track_->RemoveRenderer(this);
484}
485
486void 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
494void 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
521