Plumb through cropped output size for VideoFrame

media/tools/player_x11/x11_video_renderer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/tools/player_x11/x11_video_renderer.h"
 
 #include <dlfcn.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xrender.h>
 #include <X11/extensions/Xcomposite.h>
@@ skipping 66 matching lines @@
 }
 
 X11VideoRenderer::~X11VideoRenderer() {
   if (image_)
     XDestroyImage(image_);
   if (use_render_)
     XRenderFreePicture(display_, picture_);
 }
 
 void X11VideoRenderer::Paint(media::VideoFrame* video_frame) {
-  int width = video_frame->data_size().width();
-  int height = video_frame->data_size().height();
+  if (!image_)
+    Initialize(video_frame->coded_size(), video_frame->visible_rect());
 
-  if (!image_)
-    Initialize(width, height);
+  const int coded_width = video_frame->coded_size().width();
+  const int coded_height = video_frame->coded_size().height();
+  const int visible_width = video_frame->visible_rect().width();
+  const int visible_height = video_frame->visible_rect().height();
 
   // Check if we need to reallocate our XImage.
-  if (image_->width != width || image_->height != height) {
+  if (image_->width != coded_width || image_->height != coded_height) {
     XDestroyImage(image_);
-    image_ = CreateImage(display_, width, height);
+    image_ = CreateImage(display_, coded_width, coded_height);
   }
 
   // Convert YUV frame to RGB.
   DCHECK(video_frame->format() == media::VideoFrame::YV12 ||
          video_frame->format() == media::VideoFrame::YV16);
   DCHECK(video_frame->stride(media::VideoFrame::kUPlane) ==
          video_frame->stride(media::VideoFrame::kVPlane));
 
   DCHECK(image_->data);
   media::YUVType yuv_type =
       (video_frame->format() == media::VideoFrame::YV12) ?
       media::YV12 : media::YV16;
   media::ConvertYUVToRGB32(video_frame->data(media::VideoFrame::kYPlane),
                            video_frame->data(media::VideoFrame::kUPlane),
                            video_frame->data(media::VideoFrame::kVPlane),
-                           (uint8*)image_->data,
-                           video_frame->data_size().width(),
-                           video_frame->data_size().height(),
+                           (uint8*)image_->data, coded_width, coded_height,
                            video_frame->stride(media::VideoFrame::kYPlane),
                            video_frame->stride(media::VideoFrame::kUPlane),
                            image_->bytes_per_line,
                            yuv_type);
 
   if (use_render_) {
     // If XRender is used, we'll upload the image to a pixmap. And then
     // creats a picture from the pixmap and composite the picture over
     // the picture represending the window.
 
     // Creates a XImage.
     XImage image;
     memset(&image, 0, sizeof(image));
-    image.width = width;
-    image.height = height;
+    image.width = coded_width;
+    image.height = coded_height;
     image.depth = 32;
     image.bits_per_pixel = 32;
     image.format = ZPixmap;
     image.byte_order = LSBFirst;
     image.bitmap_unit = 8;
     image.bitmap_bit_order = LSBFirst;
     image.bytes_per_line = image_->bytes_per_line;
     image.red_mask = 0xff;
     image.green_mask = 0xff00;
     image.blue_mask = 0xff0000;
     image.data = image_->data;
 
     // Creates a pixmap and uploads from the XImage.
-    unsigned long pixmap = XCreatePixmap(display_,
-                                         window_,
-                                         width,
-                                         height,
+    unsigned long pixmap = XCreatePixmap(display_, window_,
+                                         visible_width, visible_height,
                                          32);
     GC gc = XCreateGC(display_, pixmap, 0, NULL);
     XPutImage(display_, pixmap, gc, &image,
-              0, 0, 0, 0,
-              width, height);
+              video_frame->visible_rect().x(),
+              video_frame->visible_rect().y(),
+              0, 0,
+              visible_width, visible_height);
     XFreeGC(display_, gc);
 
     // Creates the picture representing the pixmap.
     unsigned long picture = XRenderCreatePicture(
         display_, pixmap, GetRenderARGB32Format(display_), 0, NULL);
 
     // Composite the picture over the picture representing the window.
     XRenderComposite(display_, PictOpSrc, picture, 0,
                      picture_, 0, 0, 0, 0, 0, 0,
-                     width, height);
+                     visible_width, visible_height);
 
     XRenderFreePicture(display_, picture);
     XFreePixmap(display_, pixmap);
     return;
   }
 
   // If XRender is not used, simply put the image to the server.
   // This will have a tearing effect but this is OK.
   // TODO(hclam): Upload the image to a pixmap and do XCopyArea()
   // to the window.
   GC gc = XCreateGC(display_, window_, 0, NULL);
   XPutImage(display_, window_, gc, image_,
-            0, 0, 0, 0, width, height);
+            video_frame->visible_rect().x(),
+            video_frame->visible_rect().y(),
+            0, 0, visible_width, visible_height);
   XFlush(display_);
   XFreeGC(display_, gc);
 }
 
-void X11VideoRenderer::Initialize(int width, int height) {
+void X11VideoRenderer::Initialize(gfx::Size coded_size,
+                                  gfx::Rect visible_rect) {
   CHECK(!image_);
   LOG(INFO) << "Initializing X11 Renderer...";
 
   // Resize the window to fit that of the video.
-  XResizeWindow(display_, window_, width, height);
-  image_ = CreateImage(display_, width, height);
+  XResizeWindow(display_, window_, visible_rect.width(), visible_rect.height());
+  image_ = CreateImage(display_, coded_size.width(), coded_size.height());
 
   // Testing XRender support. We'll use the very basic of XRender
   // so if it presents it is already good enough. We don't need
   // to check its version.
   int dummy;
   use_render_ = XRenderQueryExtension(display_, &dummy, &dummy);
 
   if (use_render_) {
     LOG(INFO) << "Using XRender extension.";
 
     // If we are using XRender, we'll create a picture representing the
     // window.
     XWindowAttributes attr;
     XGetWindowAttributes(display_, window_, &attr);
 
     XRenderPictFormat* pictformat = XRenderFindVisualFormat(
         display_,
         attr.visual);
     CHECK(pictformat) << "XRender does not support default visual";
 
     picture_ = XRenderCreatePicture(display_, window_, pictformat, 0, NULL);
     CHECK(picture_) << "Backing picture not created";
   }
 }