src/third_party/libjingle/source/talk/examples/peerconnection/client/main_wnd.h

   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 #ifndef PEERCONNECTION_SAMPLES_CLIENT_MAIN_WND_H_
  29 #define PEERCONNECTION_SAMPLES_CLIENT_MAIN_WND_H_
  30 #pragma once
  31
  32 #include <map>
  33 #include <string>
  34
  35 #include "talk/app/webrtc/mediastreaminterface.h"
  36 #include "talk/examples/peerconnection/client/peer_connection_client.h"
  37 #include "talk/media/base/mediachannel.h"
  38 #include "talk/media/base/videocommon.h"
  39 #include "talk/media/base/videoframe.h"
  40 #include "talk/media/base/videorenderer.h"
  41 #include "webrtc/base/win32.h"
  42
  43 class MainWndCallback {
  44  public:
  45   virtual void StartLogin(const std::string& server, int port) = 0;
  46   virtual void DisconnectFromServer() = 0;
  47   virtual void ConnectToPeer(int peer_id) = 0;
  48   virtual void DisconnectFromCurrentPeer() = 0;
  49   virtual void UIThreadCallback(int msg_id, void* data) = 0;
  50   virtual void Close() = 0;
  51  protected:
  52   virtual ~MainWndCallback() {}
  53 };
  54
  55 // Pure virtual interface for the main window.
  56 class MainWindow {
  57  public:
  58   virtual ~MainWindow() {}
  59
  60   enum UI {
  61     CONNECT_TO_SERVER,
  62     LIST_PEERS,
  63     STREAMING,
  64   };
  65
  66   virtual void RegisterObserver(MainWndCallback* callback) = 0;
  67
  68   virtual bool IsWindow() = 0;
  69   virtual void MessageBox(const char* caption, const char* text,
  70                           bool is_error) = 0;
  71
  72   virtual UI current_ui() = 0;
  73
  74   virtual void SwitchToConnectUI() = 0;
  75   virtual void SwitchToPeerList(const Peers& peers) = 0;
  76   virtual void SwitchToStreamingUI() = 0;
  77
  78   virtual void StartLocalRenderer(webrtc::VideoTrackInterface* local_video) = 0;
  79   virtual void StopLocalRenderer() = 0;
  80   virtual void StartRemoteRenderer(webrtc::VideoTrackInterface* remote_video) = 0;
  81   virtual void StopRemoteRenderer() = 0;
  82
  83   virtual void QueueUIThreadCallback(int msg_id, void* data) = 0;
  84 };
  85
  86 #ifdef WIN32
  87
  88 class MainWnd : public MainWindow {
  89  public:
  90   static const wchar_t kClassName[];
  91
  92   enum WindowMessages {
  93     UI_THREAD_CALLBACK = WM_APP + 1,
  94   };
  95
  96   MainWnd(const char* server, int port, bool auto_connect, bool auto_call);
  97   ~MainWnd();
  98
  99   bool Create();
 100   bool Destroy();
 101   bool PreTranslateMessage(MSG* msg);
 102
 103   virtual void RegisterObserver(MainWndCallback* callback);
 104   virtual bool IsWindow();
 105   virtual void SwitchToConnectUI();
 106   virtual void SwitchToPeerList(const Peers& peers);
 107   virtual void SwitchToStreamingUI();
 108   virtual void MessageBox(const char* caption, const char* text,
 109                           bool is_error);
 110   virtual UI current_ui() { return ui_; }
 111
 112   virtual void StartLocalRenderer(webrtc::VideoTrackInterface* local_video);
 113   virtual void StopLocalRenderer();
 114   virtual void StartRemoteRenderer(webrtc::VideoTrackInterface* remote_video);
 115   virtual void StopRemoteRenderer();
 116
 117   virtual void QueueUIThreadCallback(int msg_id, void* data);
 118
 119   HWND handle() const { return wnd_; }
 120
 121   class VideoRenderer : public webrtc::VideoRendererInterface {
 122    public:
 123     VideoRenderer(HWND wnd, int width, int height,
 124                   webrtc::VideoTrackInterface* track_to_render);
 125     virtual ~VideoRenderer();
 126
 127     void Lock() {
 128       ::EnterCriticalSection(&buffer_lock_);
 129     }
 130
 131     void Unlock() {
 132       ::LeaveCriticalSection(&buffer_lock_);
 133     }
 134
 135     // VideoRendererInterface implementation
 136     virtual void SetSize(int width, int height);
 137     virtual void RenderFrame(const cricket::VideoFrame* frame);
 138
 139     const BITMAPINFO& bmi() const { return bmi_; }
 140     const uint8* image() const { return image_.get(); }
 141
 142    protected:
 143     enum {
 144       SET_SIZE,
 145       RENDER_FRAME,
 146     };
 147
 148     HWND wnd_;
 149     BITMAPINFO bmi_;
 150     rtc::scoped_ptr<uint8[]> image_;
 151     CRITICAL_SECTION buffer_lock_;
 152     rtc::scoped_refptr<webrtc::VideoTrackInterface> rendered_track_;
 153   };
 154
 155   // A little helper class to make sure we always to proper locking and
 156   // unlocking when working with VideoRenderer buffers.
 157   template <typename T>
 158   class AutoLock {
 159    public:
 160     explicit AutoLock(T* obj) : obj_(obj) { obj_->Lock(); }
 161     ~AutoLock() { obj_->Unlock(); }
 162    protected:
 163     T* obj_;
 164   };
 165
 166  protected:
 167   enum ChildWindowID {
 168     EDIT_ID = 1,
 169     BUTTON_ID,
 170     LABEL1_ID,
 171     LABEL2_ID,
 172     LISTBOX_ID,
 173   };
 174
 175   void OnPaint();
 176   void OnDestroyed();
 177
 178   void OnDefaultAction();
 179
 180   bool OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT* result);
 181
 182   static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp);
 183   static bool RegisterWindowClass();
 184
 185   void CreateChildWindow(HWND* wnd, ChildWindowID id, const wchar_t* class_name,
 186                          DWORD control_style, DWORD ex_style);
 187   void CreateChildWindows();
 188
 189   void LayoutConnectUI(bool show);
 190   void LayoutPeerListUI(bool show);
 191
 192   void HandleTabbing();
 193
 194  private:
 195   rtc::scoped_ptr<VideoRenderer> local_renderer_;
 196   rtc::scoped_ptr<VideoRenderer> remote_renderer_;
 197   UI ui_;
 198   HWND wnd_;
 199   DWORD ui_thread_id_;
 200   HWND edit1_;
 201   HWND edit2_;
 202   HWND label1_;
 203   HWND label2_;
 204   HWND button_;
 205   HWND listbox_;
 206   bool destroyed_;
 207   void* nested_msg_;
 208   MainWndCallback* callback_;
 209   static ATOM wnd_class_;
 210   std::string server_;
 211   std::string port_;
 212   bool auto_connect_;
 213   bool auto_call_;
 214 };
 215 #endif  // WIN32
 216
 217 #endif  // PEERCONNECTION_SAMPLES_CLIENT_MAIN_WND_H_