src/third_party/libjingle/source/talk/media/devices/gdivideorenderer.cc

   1 // libjingle
   2 // Copyright 2004 Google Inc.
   3 //
   4 // Redistribution and use in source and binary forms, with or without
   5 // modification, are permitted provided that the following conditions are met:
   6 //
   7 //  1. Redistributions of source code must retain the above copyright notice,
   8 //     this list of conditions and the following disclaimer.
   9 //  2. Redistributions in binary form must reproduce the above copyright notice,
  10 //     this list of conditions and the following disclaimer in the documentation
  11 //     and/or other materials provided with the distribution.
  12 //  3. The name of the author may not be used to endorse or promote products
  13 //     derived from this software without specific prior written permission.
  14 //
  15 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  16 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  17 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  18 // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  19 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  21 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  22 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  24 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25 //
  26 // Implementation of GdiVideoRenderer on Windows
  27
  28 #ifdef WIN32
  29
  30 #include "talk/media/devices/gdivideorenderer.h"
  31
  32 #include "talk/media/base/videocommon.h"
  33 #include "talk/media/base/videoframe.h"
  34 #include "webrtc/base/scoped_ptr.h"
  35 #include "webrtc/base/thread.h"
  36 #include "webrtc/base/win32window.h"
  37
  38 namespace cricket {
  39
  40 /////////////////////////////////////////////////////////////////////////////
  41 // Definition of private class VideoWindow. We use a worker thread to manage
  42 // the window.
  43 /////////////////////////////////////////////////////////////////////////////
  44 class GdiVideoRenderer::VideoWindow : public rtc::Win32Window {
  45  public:
  46   VideoWindow(int x, int y, int width, int height);
  47   virtual ~VideoWindow();
  48
  49   // Called when the video size changes. If it is called the first time, we
  50   // create and start the thread. Otherwise, we send kSetSizeMsg to the thread.
  51   // Context: non-worker thread.
  52   bool SetSize(int width, int height);
  53
  54   // Called when a new frame is available. Upon this call, we send
  55   // kRenderFrameMsg to the window thread. Context: non-worker thread. It may be
  56   // better to pass RGB bytes to VideoWindow. However, we pass VideoFrame to put
  57   // all the thread synchronization within VideoWindow.
  58   bool RenderFrame(const VideoFrame* frame);
  59
  60  protected:
  61   // Override virtual method of rtc::Win32Window. Context: worker Thread.
  62   virtual bool OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
  63                          LRESULT& result);
  64
  65  private:
  66   enum { kSetSizeMsg = WM_USER, kRenderFrameMsg};
  67
  68   class WindowThread : public rtc::Thread {
  69    public:
  70     explicit WindowThread(VideoWindow* window) : window_(window) {}
  71
  72     virtual ~WindowThread() {
  73       Stop();
  74     }
  75
  76     // Override virtual method of rtc::Thread. Context: worker Thread.
  77     virtual void Run() {
  78       // Initialize the window
  79       if (!window_ || !window_->Initialize()) {
  80         return;
  81       }
  82       // Run the message loop
  83       MSG msg;
  84       while (GetMessage(&msg, NULL, 0, 0) > 0) {
  85         TranslateMessage(&msg);
  86         DispatchMessage(&msg);
  87       }
  88     }
  89
  90   private:
  91     VideoWindow* window_;
  92   };
  93
  94   // Context: worker Thread.
  95   bool Initialize();
  96   void OnPaint();
  97   void OnSize(int width, int height, bool frame_changed);
  98   void OnRenderFrame(const VideoFrame* frame);
  99
 100   BITMAPINFO bmi_;
 101   rtc::scoped_ptr<uint8[]> image_;
 102   rtc::scoped_ptr<WindowThread> window_thread_;
 103   // The initial position of the window.
 104   int initial_x_;
 105   int initial_y_;
 106 };
 107
 108 /////////////////////////////////////////////////////////////////////////////
 109 // Implementation of class VideoWindow
 110 /////////////////////////////////////////////////////////////////////////////
 111 GdiVideoRenderer::VideoWindow::VideoWindow(
 112     int x, int y, int width, int height)
 113     : initial_x_(x),
 114       initial_y_(y) {
 115   memset(&bmi_.bmiHeader, 0, sizeof(bmi_.bmiHeader));
 116   bmi_.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 117   bmi_.bmiHeader.biPlanes = 1;
 118   bmi_.bmiHeader.biBitCount = 32;
 119   bmi_.bmiHeader.biCompression = BI_RGB;
 120   bmi_.bmiHeader.biWidth = width;
 121   bmi_.bmiHeader.biHeight = -height;
 122   bmi_.bmiHeader.biSizeImage = width * height * 4;
 123
 124   image_.reset(new uint8[bmi_.bmiHeader.biSizeImage]);
 125 }
 126
 127 GdiVideoRenderer::VideoWindow::~VideoWindow() {
 128   // Context: caller Thread. We cannot call Destroy() since the window was
 129   // created by another thread. Instead, we send WM_CLOSE message.
 130   if (handle()) {
 131     SendMessage(handle(), WM_CLOSE, 0, 0);
 132   }
 133 }
 134
 135 bool GdiVideoRenderer::VideoWindow::SetSize(int width, int height) {
 136   if (!window_thread_.get()) {
 137     // Create and start the window thread.
 138     window_thread_.reset(new WindowThread(this));
 139     return window_thread_->Start();
 140   } else if (width != bmi_.bmiHeader.biWidth ||
 141       height != -bmi_.bmiHeader.biHeight) {
 142     SendMessage(handle(), kSetSizeMsg, 0, MAKELPARAM(width, height));
 143   }
 144   return true;
 145 }
 146
 147 bool GdiVideoRenderer::VideoWindow::RenderFrame(const VideoFrame* frame) {
 148   if (!handle()) {
 149     return false;
 150   }
 151
 152   SendMessage(handle(), kRenderFrameMsg, reinterpret_cast<WPARAM>(frame), 0);
 153   return true;
 154 }
 155
 156 bool GdiVideoRenderer::VideoWindow::OnMessage(UINT uMsg, WPARAM wParam,
 157                                               LPARAM lParam, LRESULT& result) {
 158   switch (uMsg) {
 159     case WM_PAINT:
 160       OnPaint();
 161       return true;
 162
 163     case WM_DESTROY:
 164       PostQuitMessage(0);  // post WM_QUIT to end the message loop in Run()
 165       return false;
 166
 167     case WM_SIZE:  // The window UI was resized.
 168       OnSize(LOWORD(lParam), HIWORD(lParam), false);
 169       return true;
 170
 171     case kSetSizeMsg:  // The video resolution changed.
 172       OnSize(LOWORD(lParam), HIWORD(lParam), true);
 173       return true;
 174
 175     case kRenderFrameMsg:
 176       OnRenderFrame(reinterpret_cast<const VideoFrame*>(wParam));
 177       return true;
 178   }
 179   return false;
 180 }
 181
 182 bool GdiVideoRenderer::VideoWindow::Initialize() {
 183   if (!rtc::Win32Window::Create(
 184       NULL, L"Video Renderer",
 185       WS_OVERLAPPEDWINDOW | WS_SIZEBOX,
 186       WS_EX_APPWINDOW,
 187       initial_x_, initial_y_,
 188       bmi_.bmiHeader.biWidth, -bmi_.bmiHeader.biHeight)) {
 189         return false;
 190   }
 191   OnSize(bmi_.bmiHeader.biWidth, -bmi_.bmiHeader.biHeight, false);
 192   return true;
 193 }
 194
 195 void GdiVideoRenderer::VideoWindow::OnPaint() {
 196   RECT rcClient;
 197   GetClientRect(handle(), &rcClient);
 198   PAINTSTRUCT ps;
 199   HDC hdc = BeginPaint(handle(), &ps);
 200   StretchDIBits(hdc,
 201     0, 0, rcClient.right, rcClient.bottom,  // destination rect
 202     0, 0, bmi_.bmiHeader.biWidth, -bmi_.bmiHeader.biHeight,  // source rect
 203     image_.get(), &bmi_, DIB_RGB_COLORS, SRCCOPY);
 204   EndPaint(handle(), &ps);
 205 }
 206
 207 void GdiVideoRenderer::VideoWindow::OnSize(int width, int height,
 208                                            bool frame_changed) {
 209   // Get window and client sizes
 210   RECT rcClient, rcWindow;
 211   GetClientRect(handle(), &rcClient);
 212   GetWindowRect(handle(), &rcWindow);
 213
 214   // Find offset between window size and client size
 215   POINT ptDiff;
 216   ptDiff.x = (rcWindow.right - rcWindow.left) - rcClient.right;
 217   ptDiff.y = (rcWindow.bottom - rcWindow.top) - rcClient.bottom;
 218
 219   // Resize client
 220   MoveWindow(handle(), rcWindow.left, rcWindow.top,
 221              width + ptDiff.x, height + ptDiff.y, false);
 222   UpdateWindow(handle());
 223   ShowWindow(handle(), SW_SHOW);
 224
 225   if (frame_changed && (width != bmi_.bmiHeader.biWidth ||
 226     height != -bmi_.bmiHeader.biHeight)) {
 227     // Update the bmi and image buffer
 228     bmi_.bmiHeader.biWidth = width;
 229     bmi_.bmiHeader.biHeight = -height;
 230     bmi_.bmiHeader.biSizeImage = width * height * 4;
 231     image_.reset(new uint8[bmi_.bmiHeader.biSizeImage]);
 232   }
 233 }
 234
 235 void GdiVideoRenderer::VideoWindow::OnRenderFrame(const VideoFrame* frame) {
 236   if (!frame) {
 237     return;
 238   }
 239   // Convert frame to ARGB format, which is accepted by GDI
 240   frame->ConvertToRgbBuffer(cricket::FOURCC_ARGB, image_.get(),
 241                             bmi_.bmiHeader.biSizeImage,
 242                             bmi_.bmiHeader.biWidth * 4);
 243   InvalidateRect(handle(), 0, 0);
 244 }
 245
 246 /////////////////////////////////////////////////////////////////////////////
 247 // Implementation of class GdiVideoRenderer
 248 /////////////////////////////////////////////////////////////////////////////
 249 GdiVideoRenderer::GdiVideoRenderer(int x, int y)
 250     : initial_x_(x),
 251       initial_y_(y) {
 252 }
 253 GdiVideoRenderer::~GdiVideoRenderer() {}
 254
 255 bool GdiVideoRenderer::SetSize(int width, int height, int reserved) {
 256   if (!window_.get()) {  // Create the window for the first frame
 257     window_.reset(new VideoWindow(initial_x_, initial_y_, width, height));
 258   }
 259   return window_->SetSize(width, height);
 260 }
 261
 262 bool GdiVideoRenderer::RenderFrame(const VideoFrame* frame) {
 263   if (!frame || !window_.get()) {
 264     return false;
 265   }
 266   return window_->RenderFrame(frame);
 267 }
 268
 269 }  // namespace cricket
 270 #endif  // WIN32