Home | History | Annotate | Download | only in client 
      1 /*
      2  *  Copyright 2012 The WebRTC Project Authors. All rights reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 #include "webrtc/examples/peerconnection/client/main_wnd.h"
     12 
     13 #include <math.h>
     14 
     15 #include "webrtc/examples/peerconnection/client/defaults.h"
     16 #include "webrtc/base/arraysize.h"
     17 #include "webrtc/base/common.h"
     18 #include "webrtc/base/logging.h"
     19 
     20 ATOM MainWnd::wnd_class_ = 0;
     21 const wchar_t MainWnd::kClassName[] = L"WebRTC_MainWnd";
     22 
     23 using rtc::sprintfn;
     24 
     25 namespace {
     26 
     27 const char kConnecting[] = "Connecting... ";
     28 const char kNoVideoStreams[] = "(no video streams either way)";
     29 const char kNoIncomingStream[] = "(no incoming video)";
     30 
     31 void CalculateWindowSizeForText(HWND wnd, const wchar_t* text,
     32                                 size_t* width, size_t* height) {
     33   HDC dc = ::GetDC(wnd);
     34   RECT text_rc = {0};
     35   ::DrawText(dc, text, -1, &text_rc, DT_CALCRECT | DT_SINGLELINE);
     36   ::ReleaseDC(wnd, dc);
     37   RECT client, window;
     38   ::GetClientRect(wnd, &client);
     39   ::GetWindowRect(wnd, &window);
     40 
     41   *width = text_rc.right - text_rc.left;
     42   *width += (window.right - window.left) -
     43             (client.right - client.left);
     44   *height = text_rc.bottom - text_rc.top;
     45   *height += (window.bottom - window.top) -
     46              (client.bottom - client.top);
     47 }
     48 
     49 HFONT GetDefaultFont() {
     50   static HFONT font = reinterpret_cast<HFONT>(GetStockObject(DEFAULT_GUI_FONT));
     51   return font;
     52 }
     53 
     54 std::string GetWindowText(HWND wnd) {
     55   char text[MAX_PATH] = {0};
     56   ::GetWindowTextA(wnd, &text[0], ARRAYSIZE(text));
     57   return text;
     58 }
     59 
     60 void AddListBoxItem(HWND listbox, const std::string& str, LPARAM item_data) {
     61   LRESULT index = ::SendMessageA(listbox, LB_ADDSTRING, 0,
     62       reinterpret_cast<LPARAM>(str.c_str()));
     63   ::SendMessageA(listbox, LB_SETITEMDATA, index, item_data);
     64 }
     65 
     66 }  // namespace
     67 
     68 MainWnd::MainWnd(const char* server, int port, bool auto_connect,
     69                  bool auto_call)
     70   : ui_(CONNECT_TO_SERVER), wnd_(NULL), edit1_(NULL), edit2_(NULL),
     71     label1_(NULL), label2_(NULL), button_(NULL), listbox_(NULL),
     72     destroyed_(false), callback_(NULL), nested_msg_(NULL),
     73     server_(server), auto_connect_(auto_connect), auto_call_(auto_call) {
     74   char buffer[10] = {0};
     75   sprintfn(buffer, sizeof(buffer), "%i", port);
     76   port_ = buffer;
     77 }
     78 
     79 MainWnd::~MainWnd() {
     80   ASSERT(!IsWindow());
     81 }
     82 
     83 bool MainWnd::Create() {
     84   ASSERT(wnd_ == NULL);
     85   if (!RegisterWindowClass())
     86     return false;
     87 
     88   ui_thread_id_ = ::GetCurrentThreadId();
     89   wnd_ = ::CreateWindowExW(WS_EX_OVERLAPPEDWINDOW, kClassName, L"WebRTC",
     90       WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_CLIPCHILDREN,
     91       CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
     92       NULL, NULL, GetModuleHandle(NULL), this);
     93 
     94   ::SendMessage(wnd_, WM_SETFONT, reinterpret_cast<WPARAM>(GetDefaultFont()),
     95                 TRUE);
     96 
     97   CreateChildWindows();
     98   SwitchToConnectUI();
     99 
    100   return wnd_ != NULL;
    101 }
    102 
    103 bool MainWnd::Destroy() {
    104   BOOL ret = FALSE;
    105   if (IsWindow()) {
    106     ret = ::DestroyWindow(wnd_);
    107   }
    108 
    109   return ret != FALSE;
    110 }
    111 
    112 void MainWnd::RegisterObserver(MainWndCallback* callback) {
    113   callback_ = callback;
    114 }
    115 
    116 bool MainWnd::IsWindow() {
    117   return wnd_ && ::IsWindow(wnd_) != FALSE;
    118 }
    119 
    120 bool MainWnd::PreTranslateMessage(MSG* msg) {
    121   bool ret = false;
    122   if (msg->message == WM_CHAR) {
    123     if (msg->wParam == VK_TAB) {
    124       HandleTabbing();
    125       ret = true;
    126     } else if (msg->wParam == VK_RETURN) {
    127       OnDefaultAction();
    128       ret = true;
    129     } else if (msg->wParam == VK_ESCAPE) {
    130       if (callback_) {
    131         if (ui_ == STREAMING) {
    132           callback_->DisconnectFromCurrentPeer();
    133         } else {
    134           callback_->DisconnectFromServer();
    135         }
    136       }
    137     }
    138   } else if (msg->hwnd == NULL && msg->message == UI_THREAD_CALLBACK) {
    139     callback_->UIThreadCallback(static_cast<int>(msg->wParam),
    140                                 reinterpret_cast<void*>(msg->lParam));
    141     ret = true;
    142   }
    143   return ret;
    144 }
    145 
    146 void MainWnd::SwitchToConnectUI() {
    147   ASSERT(IsWindow());
    148   LayoutPeerListUI(false);
    149   ui_ = CONNECT_TO_SERVER;
    150   LayoutConnectUI(true);
    151   ::SetFocus(edit1_);
    152 
    153   if (auto_connect_)
    154     ::PostMessage(button_, BM_CLICK, 0, 0);
    155 }
    156 
    157 void MainWnd::SwitchToPeerList(const Peers& peers) {
    158   LayoutConnectUI(false);
    159 
    160   ::SendMessage(listbox_, LB_RESETCONTENT, 0, 0);
    161 
    162   AddListBoxItem(listbox_, "List of currently connected peers:", -1);
    163   Peers::const_iterator i = peers.begin();
    164   for (; i != peers.end(); ++i)
    165     AddListBoxItem(listbox_, i->second.c_str(), i->first);
    166 
    167   ui_ = LIST_PEERS;
    168   LayoutPeerListUI(true);
    169   ::SetFocus(listbox_);
    170 
    171   if (auto_call_ && peers.begin() != peers.end()) {
    172     // Get the number of items in the list
    173     LRESULT count = ::SendMessage(listbox_, LB_GETCOUNT, 0, 0);
    174     if (count != LB_ERR) {
    175       // Select the last item in the list
    176       LRESULT selection = ::SendMessage(listbox_, LB_SETCURSEL , count - 1, 0);
    177       if (selection != LB_ERR)
    178         ::PostMessage(wnd_, WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(listbox_),
    179                                                    LBN_DBLCLK),
    180                       reinterpret_cast<LPARAM>(listbox_));
    181     }
    182   }
    183 }
    184 
    185 void MainWnd::SwitchToStreamingUI() {
    186   LayoutConnectUI(false);
    187   LayoutPeerListUI(false);
    188   ui_ = STREAMING;
    189 }
    190 
    191 void MainWnd::MessageBox(const char* caption, const char* text, bool is_error) {
    192   DWORD flags = MB_OK;
    193   if (is_error)
    194     flags |= MB_ICONERROR;
    195 
    196   ::MessageBoxA(handle(), text, caption, flags);
    197 }
    198 
    199 
    200 void MainWnd::StartLocalRenderer(webrtc::VideoTrackInterface* local_video) {
    201   local_renderer_.reset(new VideoRenderer(handle(), 1, 1, local_video));
    202 }
    203 
    204 void MainWnd::StopLocalRenderer() {
    205   local_renderer_.reset();
    206 }
    207 
    208 void MainWnd::StartRemoteRenderer(webrtc::VideoTrackInterface* remote_video) {
    209   remote_renderer_.reset(new VideoRenderer(handle(), 1, 1, remote_video));
    210 }
    211 
    212 void MainWnd::StopRemoteRenderer() {
    213   remote_renderer_.reset();
    214 }
    215 
    216 void MainWnd::QueueUIThreadCallback(int msg_id, void* data) {
    217   ::PostThreadMessage(ui_thread_id_, UI_THREAD_CALLBACK,
    218       static_cast<WPARAM>(msg_id), reinterpret_cast<LPARAM>(data));
    219 }
    220 
    221 void MainWnd::OnPaint() {
    222   PAINTSTRUCT ps;
    223   ::BeginPaint(handle(), &ps);
    224 
    225   RECT rc;
    226   ::GetClientRect(handle(), &rc);
    227 
    228   VideoRenderer* local_renderer = local_renderer_.get();
    229   VideoRenderer* remote_renderer = remote_renderer_.get();
    230   if (ui_ == STREAMING && remote_renderer && local_renderer) {
    231     AutoLock<VideoRenderer> local_lock(local_renderer);
    232     AutoLock<VideoRenderer> remote_lock(remote_renderer);
    233 
    234     const BITMAPINFO& bmi = remote_renderer->bmi();
    235     int height = abs(bmi.bmiHeader.biHeight);
    236     int width = bmi.bmiHeader.biWidth;
    237 
    238     const uint8_t* image = remote_renderer->image();
    239     if (image != NULL) {
    240       HDC dc_mem = ::CreateCompatibleDC(ps.hdc);
    241       ::SetStretchBltMode(dc_mem, HALFTONE);
    242 
    243       // Set the map mode so that the ratio will be maintained for us.
    244       HDC all_dc[] = { ps.hdc, dc_mem };
    245       for (int i = 0; i < arraysize(all_dc); ++i) {
    246         SetMapMode(all_dc[i], MM_ISOTROPIC);
    247         SetWindowExtEx(all_dc[i], width, height, NULL);
    248         SetViewportExtEx(all_dc[i], rc.right, rc.bottom, NULL);
    249       }
    250 
    251       HBITMAP bmp_mem = ::CreateCompatibleBitmap(ps.hdc, rc.right, rc.bottom);
    252       HGDIOBJ bmp_old = ::SelectObject(dc_mem, bmp_mem);
    253 
    254       POINT logical_area = { rc.right, rc.bottom };
    255       DPtoLP(ps.hdc, &logical_area, 1);
    256 
    257       HBRUSH brush = ::CreateSolidBrush(RGB(0, 0, 0));
    258       RECT logical_rect = {0, 0, logical_area.x, logical_area.y };
    259       ::FillRect(dc_mem, &logical_rect, brush);
    260       ::DeleteObject(brush);
    261 
    262       int x = (logical_area.x / 2) - (width / 2);
    263       int y = (logical_area.y / 2) - (height / 2);
    264 
    265       StretchDIBits(dc_mem, x, y, width, height,
    266                     0, 0, width, height, image, &bmi, DIB_RGB_COLORS, SRCCOPY);
    267 
    268       if ((rc.right - rc.left) > 200 && (rc.bottom - rc.top) > 200) {
    269         const BITMAPINFO& bmi = local_renderer->bmi();
    270         image = local_renderer->image();
    271         int thumb_width = bmi.bmiHeader.biWidth / 4;
    272         int thumb_height = abs(bmi.bmiHeader.biHeight) / 4;
    273         StretchDIBits(dc_mem,
    274             logical_area.x - thumb_width - 10,
    275             logical_area.y - thumb_height - 10,
    276             thumb_width, thumb_height,
    277             0, 0, bmi.bmiHeader.biWidth, -bmi.bmiHeader.biHeight,
    278             image, &bmi, DIB_RGB_COLORS, SRCCOPY);
    279       }
    280 
    281       BitBlt(ps.hdc, 0, 0, logical_area.x, logical_area.y,
    282              dc_mem, 0, 0, SRCCOPY);
    283 
    284       // Cleanup.
    285       ::SelectObject(dc_mem, bmp_old);
    286       ::DeleteObject(bmp_mem);
    287       ::DeleteDC(dc_mem);
    288     } else {
    289       // We're still waiting for the video stream to be initialized.
    290       HBRUSH brush = ::CreateSolidBrush(RGB(0, 0, 0));
    291       ::FillRect(ps.hdc, &rc, brush);
    292       ::DeleteObject(brush);
    293 
    294       HGDIOBJ old_font = ::SelectObject(ps.hdc, GetDefaultFont());
    295       ::SetTextColor(ps.hdc, RGB(0xff, 0xff, 0xff));
    296       ::SetBkMode(ps.hdc, TRANSPARENT);
    297 
    298       std::string text(kConnecting);
    299       if (!local_renderer->image()) {
    300         text += kNoVideoStreams;
    301       } else {
    302         text += kNoIncomingStream;
    303       }
    304       ::DrawTextA(ps.hdc, text.c_str(), -1, &rc,
    305           DT_SINGLELINE | DT_CENTER | DT_VCENTER);
    306       ::SelectObject(ps.hdc, old_font);
    307     }
    308   } else {
    309     HBRUSH brush = ::CreateSolidBrush(::GetSysColor(COLOR_WINDOW));
    310     ::FillRect(ps.hdc, &rc, brush);
    311     ::DeleteObject(brush);
    312   }
    313 
    314   ::EndPaint(handle(), &ps);
    315 }
    316 
    317 void MainWnd::OnDestroyed() {
    318   PostQuitMessage(0);
    319 }
    320 
    321 void MainWnd::OnDefaultAction() {
    322   if (!callback_)
    323     return;
    324   if (ui_ == CONNECT_TO_SERVER) {
    325     std::string server(GetWindowText(edit1_));
    326     std::string port_str(GetWindowText(edit2_));
    327     int port = port_str.length() ? atoi(port_str.c_str()) : 0;
    328     callback_->StartLogin(server, port);
    329   } else if (ui_ == LIST_PEERS) {
    330     LRESULT sel = ::SendMessage(listbox_, LB_GETCURSEL, 0, 0);
    331     if (sel != LB_ERR) {
    332       LRESULT peer_id = ::SendMessage(listbox_, LB_GETITEMDATA, sel, 0);
    333       if (peer_id != -1 && callback_) {
    334         callback_->ConnectToPeer(peer_id);
    335       }
    336     }
    337   } else {
    338     MessageBoxA(wnd_, "OK!", "Yeah", MB_OK);
    339   }
    340 }
    341 
    342 bool MainWnd::OnMessage(UINT msg, WPARAM wp, LPARAM lp, LRESULT* result) {
    343   switch (msg) {
    344     case WM_ERASEBKGND:
    345       *result = TRUE;
    346       return true;
    347 
    348     case WM_PAINT:
    349       OnPaint();
    350       return true;
    351 
    352     case WM_SETFOCUS:
    353       if (ui_ == CONNECT_TO_SERVER) {
    354         SetFocus(edit1_);
    355       } else if (ui_ == LIST_PEERS) {
    356         SetFocus(listbox_);
    357       }
    358       return true;
    359 
    360     case WM_SIZE:
    361       if (ui_ == CONNECT_TO_SERVER) {
    362         LayoutConnectUI(true);
    363       } else if (ui_ == LIST_PEERS) {
    364         LayoutPeerListUI(true);
    365       }
    366       break;
    367 
    368     case WM_CTLCOLORSTATIC:
    369       *result = reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_WINDOW));
    370       return true;
    371 
    372     case WM_COMMAND:
    373       if (button_ == reinterpret_cast<HWND>(lp)) {
    374         if (BN_CLICKED == HIWORD(wp))
    375           OnDefaultAction();
    376       } else if (listbox_ == reinterpret_cast<HWND>(lp)) {
    377         if (LBN_DBLCLK == HIWORD(wp)) {
    378           OnDefaultAction();
    379         }
    380       }
    381       return true;
    382 
    383     case WM_CLOSE:
    384       if (callback_)
    385         callback_->Close();
    386       break;
    387   }
    388   return false;
    389 }
    390 
    391 // static
    392 LRESULT CALLBACK MainWnd::WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
    393   MainWnd* me = reinterpret_cast<MainWnd*>(
    394       ::GetWindowLongPtr(hwnd, GWLP_USERDATA));
    395   if (!me && WM_CREATE == msg) {
    396     CREATESTRUCT* cs = reinterpret_cast<CREATESTRUCT*>(lp);
    397     me = reinterpret_cast<MainWnd*>(cs->lpCreateParams);
    398     me->wnd_ = hwnd;
    399     ::SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(me));
    400   }
    401 
    402   LRESULT result = 0;
    403   if (me) {
    404     void* prev_nested_msg = me->nested_msg_;
    405     me->nested_msg_ = &msg;
    406 
    407     bool handled = me->OnMessage(msg, wp, lp, &result);
    408     if (WM_NCDESTROY == msg) {
    409       me->destroyed_ = true;
    410     } else if (!handled) {
    411       result = ::DefWindowProc(hwnd, msg, wp, lp);
    412     }
    413 
    414     if (me->destroyed_ && prev_nested_msg == NULL) {
    415       me->OnDestroyed();
    416       me->wnd_ = NULL;
    417       me->destroyed_ = false;
    418     }
    419 
    420     me->nested_msg_ = prev_nested_msg;
    421   } else {
    422     result = ::DefWindowProc(hwnd, msg, wp, lp);
    423   }
    424 
    425   return result;
    426 }
    427 
    428 // static
    429 bool MainWnd::RegisterWindowClass() {
    430   if (wnd_class_)
    431     return true;
    432 
    433   WNDCLASSEX wcex = { sizeof(WNDCLASSEX) };
    434   wcex.style = CS_DBLCLKS;
    435   wcex.hInstance = GetModuleHandle(NULL);
    436   wcex.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1);
    437   wcex.hCursor = ::LoadCursor(NULL, IDC_ARROW);
    438   wcex.lpfnWndProc = &WndProc;
    439   wcex.lpszClassName = kClassName;
    440   wnd_class_ = ::RegisterClassEx(&wcex);
    441   ASSERT(wnd_class_ != 0);
    442   return wnd_class_ != 0;
    443 }
    444 
    445 void MainWnd::CreateChildWindow(HWND* wnd, MainWnd::ChildWindowID id,
    446                                 const wchar_t* class_name, DWORD control_style,
    447                                 DWORD ex_style) {
    448   if (::IsWindow(*wnd))
    449     return;
    450 
    451   // Child windows are invisible at first, and shown after being resized.
    452   DWORD style = WS_CHILD | control_style;
    453   *wnd = ::CreateWindowEx(ex_style, class_name, L"", style,
    454                           100, 100, 100, 100, wnd_,
    455                           reinterpret_cast<HMENU>(id),
    456                           GetModuleHandle(NULL), NULL);
    457   ASSERT(::IsWindow(*wnd) != FALSE);
    458   ::SendMessage(*wnd, WM_SETFONT, reinterpret_cast<WPARAM>(GetDefaultFont()),
    459                 TRUE);
    460 }
    461 
    462 void MainWnd::CreateChildWindows() {
    463   // Create the child windows in tab order.
    464   CreateChildWindow(&label1_, LABEL1_ID, L"Static", ES_CENTER | ES_READONLY, 0);
    465   CreateChildWindow(&edit1_, EDIT_ID, L"Edit",
    466                     ES_LEFT | ES_NOHIDESEL | WS_TABSTOP, WS_EX_CLIENTEDGE);
    467   CreateChildWindow(&label2_, LABEL2_ID, L"Static", ES_CENTER | ES_READONLY, 0);
    468   CreateChildWindow(&edit2_, EDIT_ID, L"Edit",
    469                     ES_LEFT | ES_NOHIDESEL | WS_TABSTOP, WS_EX_CLIENTEDGE);
    470   CreateChildWindow(&button_, BUTTON_ID, L"Button", BS_CENTER | WS_TABSTOP, 0);
    471 
    472   CreateChildWindow(&listbox_, LISTBOX_ID, L"ListBox",
    473                     LBS_HASSTRINGS | LBS_NOTIFY, WS_EX_CLIENTEDGE);
    474 
    475   ::SetWindowTextA(edit1_, server_.c_str());
    476   ::SetWindowTextA(edit2_, port_.c_str());
    477 }
    478 
    479 void MainWnd::LayoutConnectUI(bool show) {
    480   struct Windows {
    481     HWND wnd;
    482     const wchar_t* text;
    483     size_t width;
    484     size_t height;
    485   } windows[] = {
    486     { label1_, L"Server" },
    487     { edit1_, L"XXXyyyYYYgggXXXyyyYYYggg" },
    488     { label2_, L":" },
    489     { edit2_, L"XyXyX" },
    490     { button_, L"Connect" },
    491   };
    492 
    493   if (show) {
    494     const size_t kSeparator = 5;
    495     size_t total_width = (ARRAYSIZE(windows) - 1) * kSeparator;
    496 
    497     for (size_t i = 0; i < ARRAYSIZE(windows); ++i) {
    498       CalculateWindowSizeForText(windows[i].wnd, windows[i].text,
    499                                  &windows[i].width, &windows[i].height);
    500       total_width += windows[i].width;
    501     }
    502 
    503     RECT rc;
    504     ::GetClientRect(wnd_, &rc);
    505     size_t x = (rc.right / 2) - (total_width / 2);
    506     size_t y = rc.bottom / 2;
    507     for (size_t i = 0; i < ARRAYSIZE(windows); ++i) {
    508       size_t top = y - (windows[i].height / 2);
    509       ::MoveWindow(windows[i].wnd, static_cast<int>(x), static_cast<int>(top),
    510                    static_cast<int>(windows[i].width),
    511                    static_cast<int>(windows[i].height),
    512                    TRUE);
    513       x += kSeparator + windows[i].width;
    514       if (windows[i].text[0] != 'X')
    515         ::SetWindowText(windows[i].wnd, windows[i].text);
    516       ::ShowWindow(windows[i].wnd, SW_SHOWNA);
    517     }
    518   } else {
    519     for (size_t i = 0; i < ARRAYSIZE(windows); ++i) {
    520       ::ShowWindow(windows[i].wnd, SW_HIDE);
    521     }
    522   }
    523 }
    524 
    525 void MainWnd::LayoutPeerListUI(bool show) {
    526   if (show) {
    527     RECT rc;
    528     ::GetClientRect(wnd_, &rc);
    529     ::MoveWindow(listbox_, 0, 0, rc.right, rc.bottom, TRUE);
    530     ::ShowWindow(listbox_, SW_SHOWNA);
    531   } else {
    532     ::ShowWindow(listbox_, SW_HIDE);
    533     InvalidateRect(wnd_, NULL, TRUE);
    534   }
    535 }
    536 
    537 void MainWnd::HandleTabbing() {
    538   bool shift = ((::GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0);
    539   UINT next_cmd = shift ? GW_HWNDPREV : GW_HWNDNEXT;
    540   UINT loop_around_cmd = shift ? GW_HWNDLAST : GW_HWNDFIRST;
    541   HWND focus = GetFocus(), next;
    542   do {
    543     next = ::GetWindow(focus, next_cmd);
    544     if (IsWindowVisible(next) &&
    545         (GetWindowLong(next, GWL_STYLE) & WS_TABSTOP)) {
    546       break;
    547     }
    548 
    549     if (!next) {
    550       next = ::GetWindow(focus, loop_around_cmd);
    551       if (IsWindowVisible(next) &&
    552           (GetWindowLong(next, GWL_STYLE) & WS_TABSTOP)) {
    553         break;
    554       }
    555     }
    556     focus = next;
    557   } while (true);
    558   ::SetFocus(next);
    559 }
    560 
    561 //
    562 // MainWnd::VideoRenderer
    563 //
    564 
    565 MainWnd::VideoRenderer::VideoRenderer(
    566     HWND wnd, int width, int height,
    567     webrtc::VideoTrackInterface* track_to_render)
    568     : wnd_(wnd), rendered_track_(track_to_render) {
    569   ::InitializeCriticalSection(&buffer_lock_);
    570   ZeroMemory(&bmi_, sizeof(bmi_));
    571   bmi_.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    572   bmi_.bmiHeader.biPlanes = 1;
    573   bmi_.bmiHeader.biBitCount = 32;
    574   bmi_.bmiHeader.biCompression = BI_RGB;
    575   bmi_.bmiHeader.biWidth = width;
    576   bmi_.bmiHeader.biHeight = -height;
    577   bmi_.bmiHeader.biSizeImage = width * height *
    578                               (bmi_.bmiHeader.biBitCount >> 3);
    579   rendered_track_->AddRenderer(this);
    580 }
    581 
    582 MainWnd::VideoRenderer::~VideoRenderer() {
    583   rendered_track_->RemoveRenderer(this);
    584   ::DeleteCriticalSection(&buffer_lock_);
    585 }
    586 
    587 void MainWnd::VideoRenderer::SetSize(int width, int height) {
    588   AutoLock<VideoRenderer> lock(this);
    589 
    590   if (width == bmi_.bmiHeader.biWidth && height == bmi_.bmiHeader.biHeight) {
    591     return;
    592   }
    593 
    594   bmi_.bmiHeader.biWidth = width;
    595   bmi_.bmiHeader.biHeight = -height;
    596   bmi_.bmiHeader.biSizeImage = width * height *
    597                                (bmi_.bmiHeader.biBitCount >> 3);
    598   image_.reset(new uint8_t[bmi_.bmiHeader.biSizeImage]);
    599 }
    600 
    601 void MainWnd::VideoRenderer::RenderFrame(
    602     const cricket::VideoFrame* video_frame) {
    603   if (!video_frame)
    604     return;
    605 
    606   {
    607     AutoLock<VideoRenderer> lock(this);
    608 
    609     const cricket::VideoFrame* frame =
    610         video_frame->GetCopyWithRotationApplied();
    611 
    612     SetSize(static_cast<int>(frame->GetWidth()),
    613             static_cast<int>(frame->GetHeight()));
    614 
    615     ASSERT(image_.get() != NULL);
    616     frame->ConvertToRgbBuffer(cricket::FOURCC_ARGB,
    617                               image_.get(),
    618                               bmi_.bmiHeader.biSizeImage,
    619                               bmi_.bmiHeader.biWidth *
    620                               bmi_.bmiHeader.biBitCount / 8);
    621   }
    622   InvalidateRect(wnd_, NULL, TRUE);
    623 }
    624