media: GMBVideoFramePool, crop VideoFrame using visible_rect.

media/video/gpu_memory_buffer_video_frame_pool.cc

 // Copyright 2015 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/video/gpu_memory_buffer_video_frame_pool.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
 #include <algorithm>
@@ skipping 239 matching lines @@
   TRACE_EVENT2("media", "CopyRowsToNV12Buffer", "bytes_per_row", bytes_per_row,
                "rows", rows);
   if (dest_y && dest_uv) {
     DCHECK_NE(dest_stride_y, 0);
     DCHECK_NE(dest_stride_uv, 0);
     DCHECK_LE(bytes_per_row, std::abs(dest_stride_y));
     DCHECK_LE(bytes_per_row, std::abs(dest_stride_uv));
     DCHECK_EQ(0, first_row % 2);
 
     libyuv::I420ToNV12(
-        source_frame->data(VideoFrame::kYPlane) +
+        source_frame->visible_data(VideoFrame::kYPlane) +
             first_row * source_frame->stride(VideoFrame::kYPlane),
         source_frame->stride(VideoFrame::kYPlane),
-        source_frame->data(VideoFrame::kUPlane) +
+        source_frame->visible_data(VideoFrame::kUPlane) +
             first_row / 2 * source_frame->stride(VideoFrame::kUPlane),
         source_frame->stride(VideoFrame::kUPlane),
-        source_frame->data(VideoFrame::kVPlane) +
+        source_frame->visible_data(VideoFrame::kVPlane) +
             first_row / 2 * source_frame->stride(VideoFrame::kVPlane),
         source_frame->stride(VideoFrame::kVPlane),
         dest_y + first_row * dest_stride_y, dest_stride_y,
         dest_uv + first_row / 2 * dest_stride_uv, dest_stride_uv, bytes_per_row,
         rows);
   }
   done.Run();
 }
 
 void CopyRowsToUYVYBuffer(int first_row,
                           int rows,
                           int width,
                           const scoped_refptr<VideoFrame>& source_frame,
                           uint8* output,
                           int dest_stride,
                           const base::Closure& done) {
   TRACE_EVENT2("media", "CopyRowsToUYVYBuffer", "bytes_per_row", width * 2,
                "rows", rows);
   if (output) {
     DCHECK_NE(dest_stride, 0);
     DCHECK_LE(width, std::abs(dest_stride / 2));
     DCHECK_EQ(0, first_row % 2);
     libyuv::I420ToUYVY(
-        source_frame->data(VideoFrame::kYPlane) +
+        source_frame->visible_data(VideoFrame::kYPlane) +
             first_row * source_frame->stride(VideoFrame::kYPlane),
         source_frame->stride(VideoFrame::kYPlane),
-        source_frame->data(VideoFrame::kUPlane) +
+        source_frame->visible_data(VideoFrame::kUPlane) +
             first_row / 2 * source_frame->stride(VideoFrame::kUPlane),
         source_frame->stride(VideoFrame::kUPlane),
-        source_frame->data(VideoFrame::kVPlane) +
+        source_frame->visible_data(VideoFrame::kVPlane) +
             first_row / 2 * source_frame->stride(VideoFrame::kVPlane),
         source_frame->stride(VideoFrame::kVPlane),
         output + first_row * dest_stride, dest_stride, width, rows);
   }
   done.Run();
 }
 
 }  // unnamed namespace
 
 // Creates a VideoFrame backed by native textures starting from a software
@@ skipping 36 matching lines @@
     case PIXEL_FORMAT_XRGB:
     case PIXEL_FORMAT_RGB24:
     case PIXEL_FORMAT_RGB32:
     case PIXEL_FORMAT_MJPEG:
     case PIXEL_FORMAT_MT21:
     case PIXEL_FORMAT_UNKNOWN:
       frame_ready_cb.Run(video_frame);
       return;
   }
 
-  DCHECK(video_frame->visible_rect().origin().IsOrigin());
   const gfx::Size size = video_frame->visible_rect().size();
 
   // Acquire resources. Incompatible ones will be dropped from the pool.
   FrameResources* frame_resources =
       GetOrCreateFrameResources(size, output_format_);
   if (!frame_resources) {
     frame_ready_cb.Run(video_frame);
     return;
   }
 
@@ skipping 20 matching lines @@
 // Copies |video_frame| into |frame_resources| asynchronously, posting n tasks
 // that will be synchronized by a barrier.
 // After the barrier is passed OnCopiesDone will be called.
 void GpuMemoryBufferVideoFramePool::PoolImpl::CopyVideoFrameToGpuMemoryBuffers(
     const scoped_refptr<VideoFrame>& video_frame,
     FrameResources* frame_resources,
     const FrameReadyCB& frame_ready_cb) {
   // Compute the number of tasks to post and create the barrier.
   const size_t num_planes = VideoFrame::NumPlanes(output_format_);
   const size_t planes_per_copy = PlanesPerCopy(output_format_);
-  gfx::Size size = video_frame->visible_rect().size();
+  const gfx::Size size = video_frame->visible_rect().size();
   size_t copies = 0;
   for (size_t i = 0; i < num_planes; i += planes_per_copy) {
     const int rows = VideoFrame::Rows(i, output_format_, size.height());
     const int rows_per_copy = RowsPerCopy(i, output_format_, size.width());
     copies += rows / rows_per_copy;
     if (rows % rows_per_copy)
       ++copies;
   }
   base::Closure copies_done =
       base::Bind(&PoolImpl::OnCopiesDone, this, video_frame, frame_resources,
@@ skipping 17 matching lines @@
     const int rows = VideoFrame::Rows(i, output_format_, size.height());
     const int rows_per_copy = RowsPerCopy(i, output_format_, size.width());
 
     for (int row = 0; row < rows; row += rows_per_copy) {
       const int rows_to_copy = std::min(rows_per_copy, rows - row);
       switch (output_format_) {
         case PIXEL_FORMAT_I420: {
           const int bytes_per_row =
               VideoFrame::RowBytes(i, output_format_, size.width());
           worker_task_runner_->PostTask(
-              FROM_HERE,
-              base::Bind(&CopyRowsToI420Buffer, row, rows_to_copy,
-                         bytes_per_row, video_frame->data(i),
-                         video_frame->stride(i), dest_buffers[0],
-                         dest_strides[0], barrier));
+              FROM_HERE, base::Bind(&CopyRowsToI420Buffer, row, rows_to_copy,
+                                    bytes_per_row, video_frame->visible_data(i),
+                                    video_frame->stride(i), dest_buffers[0],
+                                    dest_strides[0], barrier));
           break;
         }
         case PIXEL_FORMAT_NV12:
           worker_task_runner_->PostTask(
               FROM_HERE,
               base::Bind(&CopyRowsToNV12Buffer, row, rows_to_copy,
                          size.width(), video_frame, dest_buffers[0],
                          dest_strides[0], dest_buffers[1], dest_strides[1],
                          barrier));
           break;
@@ skipping 57 matching lines @@
 
   scoped_refptr<VideoFrame> frame;
   // Create the VideoFrame backed by native textures.
   switch (output_format_) {
     case PIXEL_FORMAT_I420:
       frame = VideoFrame::WrapYUV420NativeTextures(
           mailbox_holders[VideoFrame::kYPlane],
           mailbox_holders[VideoFrame::kUPlane],
           mailbox_holders[VideoFrame::kVPlane],
           base::Bind(&PoolImpl::MailboxHoldersReleased, this, frame_resources),
-          size, video_frame->visible_rect(), video_frame->natural_size(),
-          video_frame->timestamp());
+          size, gfx::Rect(size), size, video_frame->timestamp());
       if (video_frame->metadata()->IsTrue(VideoFrameMetadata::ALLOW_OVERLAY))
         frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY, true);
       break;
     case PIXEL_FORMAT_NV12:
     case PIXEL_FORMAT_UYVY:
       frame = VideoFrame::WrapNativeTexture(
           output_format_, mailbox_holders[VideoFrame::kYPlane],
           base::Bind(&PoolImpl::MailboxHoldersReleased, this, frame_resources),
-          size, video_frame->visible_rect(), video_frame->natural_size(),
-          video_frame->timestamp());
+          size, gfx::Rect(size), size, video_frame->timestamp());
       frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY, true);
       break;
     default:
       NOTREACHED();
   }
   frame_ready_cb.Run(frame);
 }
 
 // Destroy all the resources posting one task per FrameResources
 // to the |media_task_runner_|.
@@ skipping 117 matching lines @@
 }
 
 void GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
   DCHECK(video_frame);
   pool_impl_->CreateHardwareFrame(video_frame, frame_ready_cb);
 }
 
 }  // namespace media