Plumb through cropped output size for VideoFrame

The video playback path needs to be able to handle cropped video frames,
e.g. for HW decoders that output to macroblock-rounded buffer sizes.

* Composite only the visible subrect from WebVideoFrame in
  cc::VideoLayerImpl
* Remove some extraneous cropping logic from cc::VideoLayerImpl now that
  we have exact cropping info.
* media::VideoFrame replaces "data_size_" member with "coded_size_", and
  adds a "visible_rect_" gfx::Rect to indicate the sub-rect of the
  entire frame that should be visible (after cropping)
* Associated changes to various decoder/capture pipelines to plumb this
  through.

TEST=build, run on x86, ARM
BUG=155416,140509,chrome-os-partner:15230

Change-Id: I284bc893959db427bc9ae677aed8b07292d228ae

Review URL: https://chromiumcodereview.appspot.com/11269017

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@166988 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 75 insertions, 52 deletions

diff --git a/media/tools/player_wtl/view.h b/media/tools/player_wtl/view.h
index b0e4737..cc34aa8 100644
--- a/media/tools/player_wtl/view.h
+++ b/media/tools/player_wtl/view.h
@@ -144,11 +144,12 @@ class WtlVideoWindow : public CScrollWindowImpl<WtlVideoWindow> {
     uint8 *movie_dib_bits = reinterpret_cast<uint8 *>(bm.bmBits) +
         bm.bmWidthBytes * (bm.bmHeight - 1);
     int dibrowbytes = -bm.bmWidthBytes;
-    int clipped_width = video_frame->data_size().width();
+    // Not accounting for cropping presently.
+    int clipped_width = video_frame->coded_size().width();
     if (dibwidth < clipped_width) {
       clipped_width = dibwidth;
     }
-    int clipped_height = video_frame->data_size().height();
+    int clipped_height = video_frame->coded_size().height();
     if (dibheight < clipped_height) {
       clipped_height = dibheight;
     }
@@ -243,7 +244,7 @@ class WtlVideoWindow : public CScrollWindowImpl<WtlVideoWindow> {
       if (frame) {
         // Size the window the first time we get a frame.
         if (!last_frame_)
-          SetSize(frame->data_size().width(), frame->data_size().height());
+          SetSize(frame->coded_size().width(), frame->coded_size().height());
 
         base::TimeDelta frame_timestamp = frame->GetTimestamp();
         if (frame != last_frame_ || frame_timestamp != last_timestamp_) {
@@ -436,24 +437,24 @@ class WtlVideoWindow : public CScrollWindowImpl<WtlVideoWindow> {
     if (file_yuv != NULL) {
       fseek(file_yuv, 0, SEEK_END);
       const int frame_size =
-        video_frame->data_size().width() * video_frame->data_size().height();
-      for (int y = 0; y < video_frame->data_size().height(); ++y)
+        video_frame->coded_size().width() * video_frame->coded_size().height();
+      for (int y = 0; y < video_frame->coded_size().height(); ++y)
         fwrite(video_frame->data(0) + video_frame->stride(0)*y,
-          video_frame->data_size().width(), sizeof(uint8), file_yuv);
-      for (int y = 0; y < video_frame->data_size().height()/2; ++y)
+          video_frame->coded_size().width(), sizeof(uint8), file_yuv);
+      for (int y = 0; y < video_frame->coded_size().height()/2; ++y)
         fwrite(video_frame->data(1) + video_frame->stride(1)*y,
-          video_frame->data_size().width() / 2, sizeof(uint8), file_yuv);
-      for (int y = 0; y < video_frame->data_size().height()/2; ++y)
+          video_frame->coded_size().width() / 2, sizeof(uint8), file_yuv);
+      for (int y = 0; y < video_frame->coded_size().height()/2; ++y)
         fwrite(video_frame->data(2) + video_frame->stride(2)*y,
-          video_frame->data_size().width() / 2, sizeof(uint8), file_yuv);
+          video_frame->coded_size().width() / 2, sizeof(uint8), file_yuv);
       fclose(file_yuv);
 
 #if TESTING
       static int frame_dump_count = 0;
       char outputbuf[512];
       _snprintf_s(outputbuf, sizeof(outputbuf), "yuvdump %4d %dx%d stride %d\n",
-                  frame_dump_count, video_frame->data_size().width(),
-                  video_frame->data_size().height(),
+                  frame_dump_count, video_frame->coded_size().width(),
+                  video_frame->coded_size().height(),
                   video_frame->stride(0));
       OutputDebugStringA(outputbuf);
       ++frame_dump_count;
diff --git a/media/tools/player_x11/gl_video_renderer.cc b/media/tools/player_x11/gl_video_renderer.cc
index 50abdd9..334dfad 100644
--- a/media/tools/player_x11/gl_video_renderer.cc
+++ b/media/tools/player_x11/gl_video_renderer.cc
@@ -121,8 +121,7 @@ GlVideoRenderer::~GlVideoRenderer() {
 
 void GlVideoRenderer::Paint(media::VideoFrame* video_frame) {
   if (!gl_context_)
-    Initialize(video_frame->data_size().width(),
-               video_frame->data_size().height());
+    Initialize(video_frame->coded_size(), video_frame->visible_rect());
 
   // Convert YUV frame to RGB.
   DCHECK(video_frame->format() == media::VideoFrame::YV12 ||
@@ -147,12 +146,12 @@ void GlVideoRenderer::Paint(media::VideoFrame* video_frame) {
   glXSwapBuffers(display_, window_);
 }
 
-void GlVideoRenderer::Initialize(int width, int height) {
+void GlVideoRenderer::Initialize(gfx::Size coded_size, gfx::Rect visible_rect) {
   CHECK(!gl_context_);
   LOG(INFO) << "Initializing GL Renderer...";
 
   // Resize the window to fit that of the video.
-  XResizeWindow(display_, window_, width, height);
+  XResizeWindow(display_, window_, visible_rect.width(), visible_rect.height());
 
   gl_context_ = InitGLContext(display_, window_);
   CHECK(gl_context_) << "Failed to initialize GL context";
@@ -241,8 +240,16 @@ void GlVideoRenderer::Initialize(int width, int height) {
 
   int tc_location = glGetAttribLocation(program, "in_tc");
   glEnableVertexAttribArray(tc_location);
-  glVertexAttribPointer(tc_location, 2, GL_FLOAT, GL_FALSE, 0,
-                        kTextureCoords);
+  float verts[8];
+  float x0 = static_cast<float>(visible_rect.x()) / coded_size.width();
+  float y0 = static_cast<float>(visible_rect.y()) / coded_size.height();
+  float x1 = static_cast<float>(visible_rect.right()) / coded_size.width();
+  float y1 = static_cast<float>(visible_rect.bottom()) / coded_size.height();
+  verts[0] = x0; verts[1] = y0;
+  verts[2] = x0; verts[3] = y1;
+  verts[4] = x1; verts[5] = y0;
+  verts[6] = x1; verts[7] = y1;
+  glVertexAttribPointer(tc_location, 2, GL_FLOAT, GL_FALSE, 0, verts);
 
   // We are getting called on a thread. Release the context so that it can be
   // made current on the main thread.
diff --git a/media/tools/player_x11/gl_video_renderer.h b/media/tools/player_x11/gl_video_renderer.h
index 28d3ffb..b8818a1 100644
--- a/media/tools/player_x11/gl_video_renderer.h
+++ b/media/tools/player_x11/gl_video_renderer.h
@@ -7,6 +7,8 @@
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/size.h"
 #include "ui/gl/gl_bindings.h"
 
 class MessageLoop;
@@ -27,7 +29,7 @@ class GlVideoRenderer : public base::RefCountedThreadSafe<GlVideoRenderer> {
 
  private:
   // Initializes GL rendering for the given dimensions.
-  void Initialize(int width, int height);
+  void Initialize(gfx::Size coded_size, gfx::Rect visible_rect);
 
   Display* display_;
   Window window_;
diff --git a/media/tools/player_x11/x11_video_renderer.cc b/media/tools/player_x11/x11_video_renderer.cc
index d259d6b..43a18cd 100644
--- a/media/tools/player_x11/x11_video_renderer.cc
+++ b/media/tools/player_x11/x11_video_renderer.cc
@@ -84,16 +84,18 @@ X11VideoRenderer::~X11VideoRenderer() {
 }
 
 void X11VideoRenderer::Paint(media::VideoFrame* video_frame) {
-  int width = video_frame->data_size().width();
-  int height = video_frame->data_size().height();
-
   if (!image_)
-    Initialize(width, height);
+    Initialize(video_frame->coded_size(), video_frame->visible_rect());
+
+  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.
@@ -109,9 +111,7 @@ void X11VideoRenderer::Paint(media::VideoFrame* video_frame) {
   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,
@@ -125,8 +125,8 @@ void X11VideoRenderer::Paint(media::VideoFrame* video_frame) {
     // 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;
@@ -140,15 +140,15 @@ void X11VideoRenderer::Paint(media::VideoFrame* video_frame) {
     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.
@@ -158,7 +158,7 @@ void X11VideoRenderer::Paint(media::VideoFrame* video_frame) {
     // 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);
@@ -171,18 +171,21 @@ void X11VideoRenderer::Paint(media::VideoFrame* video_frame) {
   // 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
diff --git a/media/tools/player_x11/x11_video_renderer.h b/media/tools/player_x11/x11_video_renderer.h
index b91c565..05c624c 100644
--- a/media/tools/player_x11/x11_video_renderer.h
+++ b/media/tools/player_x11/x11_video_renderer.h
@@ -9,6 +9,8 @@
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/size.h"
 
 class MessageLoop;
 
@@ -28,7 +30,7 @@ class X11VideoRenderer : public base::RefCountedThreadSafe<X11VideoRenderer> {
 
  private:
   // Initializes X11 rendering for the given dimensions.
-  void Initialize(int width, int height);
+  void Initialize(gfx::Size coded_size, gfx::Rect visible_rect);
 
   Display* display_;
   Window window_;
diff --git a/media/tools/scaler_bench/scaler_bench.cc b/media/tools/scaler_bench/scaler_bench.cc
index d8525d1..18c4ca1 100644
--- a/media/tools/scaler_bench/scaler_bench.cc
+++ b/media/tools/scaler_bench/scaler_bench.cc
@@ -122,7 +122,8 @@ static double BenchmarkFilter(media::ScaleFilter filter) {
 
     gfx::Size dest_size(dest_width, dest_height);
     dest_frames.push_back(
-        VideoFrame::CreateFrame(VideoFrame::RGB32, dest_size, dest_size,
+        VideoFrame::CreateFrame(VideoFrame::RGB32, dest_size,
+                                gfx::Rect(dest_size), dest_size,
                                 TimeDelta::FromSeconds(0)));
   }
 
@@ -160,7 +161,8 @@ static double BenchmarkScaleWithRect() {
 
     gfx::Size dest_size(dest_width, dest_height);
     dest_frames.push_back(
-        VideoFrame::CreateFrame(VideoFrame::RGB32, dest_size, dest_size,
+        VideoFrame::CreateFrame(VideoFrame::RGB32, dest_size,
+                                gfx::Rect(dest_size), dest_size,
                                 TimeDelta::FromSeconds(0)));
   }
 
diff --git a/media/tools/shader_bench/cpu_color_painter.cc b/media/tools/shader_bench/cpu_color_painter.cc
index b99b803..a7cb570 100644
--- a/media/tools/shader_bench/cpu_color_painter.cc
+++ b/media/tools/shader_bench/cpu_color_painter.cc
@@ -67,7 +67,8 @@ void CPUColorPainter::Paint(scoped_refptr<media::VideoFrame> video_frame) {
   // Convert to RGB32 frame.
   scoped_refptr<media::VideoFrame> rgba_frame =
       media::VideoFrame::CreateFrame(media::VideoFrame::RGB32,
-                                     video_frame->data_size(),
+                                     video_frame->coded_size(),
+                                     video_frame->visible_rect(),
                                      video_frame->natural_size(),
                                      base::TimeDelta());
 
@@ -75,16 +76,19 @@ void CPUColorPainter::Paint(scoped_refptr<media::VideoFrame> video_frame) {
                            video_frame->data(media::VideoFrame::kUPlane),
                            video_frame->data(media::VideoFrame::kVPlane),
                            rgba_frame->data(0),
-                           video_frame->data_size().width(),
-                           video_frame->data_size().height(),
+                           video_frame->coded_size().width(),
+                           video_frame->coded_size().height(),
                            video_frame->stride(media::VideoFrame::kYPlane),
                            video_frame->stride(media::VideoFrame::kUPlane),
                            rgba_frame->stride(0),
                            media::YV12);
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
-  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, rgba_frame->data_size().width(),
-                  rgba_frame->data_size().height(), GL_RGBA, GL_UNSIGNED_BYTE,
+  // Not accounting for x/y offset presently.
+  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
+                  rgba_frame->visible_rect().width(),
+                  rgba_frame->visible_rect().height(),
+                  GL_RGBA, GL_UNSIGNED_BYTE,
                   rgba_frame->data(0));
 
   glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
diff --git a/media/tools/shader_bench/gpu_color_painter.cc b/media/tools/shader_bench/gpu_color_painter.cc
index a408de2..17155ee 100644
--- a/media/tools/shader_bench/gpu_color_painter.cc
+++ b/media/tools/shader_bench/gpu_color_painter.cc
@@ -104,8 +104,9 @@ void GPUColorWithLuminancePainter::Initialize(int width, int height) {
 
 void GPUColorWithLuminancePainter::Paint(
     scoped_refptr<media::VideoFrame> video_frame) {
-  int width = video_frame->data_size().width();
-  int height = video_frame->data_size().height();
+  // Not accounting for x/y offset presently.
+  int width = video_frame->visible_rect().width();
+  int height = video_frame->visible_rect().height();
   for (unsigned int i = 0; i < kNumYUVPlanes; ++i) {
     unsigned int plane_width =
         (i == media::VideoFrame::kYPlane) ? width : width / 2;
diff --git a/media/tools/shader_bench/shader_bench.cc b/media/tools/shader_bench/shader_bench.cc
index 17a45a4..897e588 100644
--- a/media/tools/shader_bench/shader_bench.cc
+++ b/media/tools/shader_bench/shader_bench.cc
@@ -53,7 +53,8 @@ void GetFrames(std::string file_name,
   gfx::Size size(width, height);
   for (int i = 0; i < num_frames; i++) {
     scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::CreateFrame(media::VideoFrame::YV12, size, size,
+        media::VideoFrame::CreateFrame(media::VideoFrame::YV12, size,
+                                       gfx::Rect(size), size,
                                        base::TimeDelta());
     long bytes_read =
         fread(video_frame->data(0), 1, frame_size, file_handle);