media: Compute proper VideoFrame::coded_rect for copies to GMBs.

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 289 matching lines @@
             first_row / 2 * source_frame->stride(VideoFrame::kUPlane),
         source_frame->stride(VideoFrame::kUPlane),
         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();
 }
 
+gfx::Size CodedSize(const scoped_refptr<VideoFrame>& video_frame,
+                    VideoPixelFormat output_format) {
+  DCHECK(gfx::Rect(video_frame->coded_size())
+             .Contains(video_frame->visible_rect()));
+  DCHECK((video_frame->visible_rect().x() & 1) == 0);
+  gfx::Size output;
+  switch (output_format) {
+    case PIXEL_FORMAT_I420:
+    case PIXEL_FORMAT_NV12:
+      DCHECK((video_frame->visible_rect().y() & 1) == 0);
+      output = gfx::Size((video_frame->visible_rect().width() + 1) & ~1,
+                         (video_frame->visible_rect().height() + 1) & ~1);
+      break;
+    case PIXEL_FORMAT_UYVY:
+      output = gfx::Size((video_frame->visible_rect().width() + 1) & ~1,
+                         video_frame->visible_rect().height());
+      break;
+    default:
+      NOTREACHED();
+  }
+  DCHECK(gfx::Rect(video_frame->coded_size()).Contains(gfx::Rect(output)));
+  return output;
+}
 }  // unnamed namespace
 
 // Creates a VideoFrame backed by native textures starting from a software
 // VideoFrame.
 // The data contained in |video_frame| is copied into the VideoFrame passed to
 // |frame_ready_cb|.
 // This has to be called on the thread where |media_task_runner_| is current.
 void GpuMemoryBufferVideoFramePool::PoolImpl::CreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
@@ skipping 24 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;
   }
 
-  const gfx::Size size = video_frame->visible_rect().size();
-
+  const gfx::Size coded_size = CodedSize(video_frame, output_format_);
   // Acquire resources. Incompatible ones will be dropped from the pool.
   FrameResources* frame_resources =
-      GetOrCreateFrameResources(size, output_format_);
+      GetOrCreateFrameResources(coded_size, output_format_);
   if (!frame_resources) {
     frame_ready_cb.Run(video_frame);
     return;
   }
 
   worker_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PoolImpl::CopyVideoFrameToGpuMemoryBuffers, this,
                             video_frame, frame_resources, frame_ready_cb));
 }
 
@@ skipping 51 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_);
-  const gfx::Size size = video_frame->visible_rect().size();
+  const gfx::Size coded_size = CodedSize(video_frame, output_format_);
   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());
+    const int rows = VideoFrame::Rows(i, output_format_, coded_size.height());
+    const int rows_per_copy =
+        RowsPerCopy(i, output_format_, coded_size.width());
     copies += rows / rows_per_copy;
     if (rows % rows_per_copy)
       ++copies;
   }
   const base::Closure copies_done =
       base::Bind(&PoolImpl::OnCopiesDone, this, video_frame, frame_resources,
                  frame_ready_cb);
   const base::Closure barrier = base::BarrierClosure(copies, copies_done);
 
   // Post all the async tasks.
   for (size_t i = 0; i < num_planes; i += planes_per_copy) {
     gfx::GpuMemoryBuffer* buffer =
         frame_resources->plane_resources[i].gpu_memory_buffer.get();
 
     if (!buffer || !buffer->Map()) {
       DLOG(ERROR) << "Could not get or Map() buffer";
       return;
     }
     DCHECK_EQ(planes_per_copy,
               gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat()));
 
-    const int rows = VideoFrame::Rows(i, output_format_, size.height());
-    const int rows_per_copy = RowsPerCopy(i, output_format_, size.width());
+    const int rows = VideoFrame::Rows(i, output_format_, coded_size.height());
+    const int rows_per_copy =
+        RowsPerCopy(i, output_format_, coded_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());
+              VideoFrame::RowBytes(i, output_format_, coded_size.width());
           worker_task_runner_->PostTask(
               FROM_HERE, base::Bind(&CopyRowsToI420Buffer, row, rows_to_copy,
                                     bytes_per_row, video_frame->visible_data(i),
                                     video_frame->stride(i),
                                     static_cast<uint8_t*>(buffer->memory(0)),
                                     buffer->stride(0), barrier));
           break;
         }
         case PIXEL_FORMAT_NV12:
           worker_task_runner_->PostTask(
-              FROM_HERE,
-              base::Bind(&CopyRowsToNV12Buffer, row, rows_to_copy, size.width(),
-                         video_frame, static_cast<uint8_t*>(buffer->memory(0)),
-                         buffer->stride(0),
-                         static_cast<uint8_t*>(buffer->memory(1)),
-                         buffer->stride(1), barrier));
+              FROM_HERE, base::Bind(&CopyRowsToNV12Buffer, row, rows_to_copy,
+                                    coded_size.width(), video_frame,
+                                    static_cast<uint8_t*>(buffer->memory(0)),
+                                    buffer->stride(0),
+                                    static_cast<uint8_t*>(buffer->memory(1)),
+                                    buffer->stride(1), barrier));
           break;
         case PIXEL_FORMAT_UYVY:
           worker_task_runner_->PostTask(
-              FROM_HERE,
-              base::Bind(&CopyRowsToUYVYBuffer, row, rows_to_copy, size.width(),
-                         video_frame, static_cast<uint8_t*>(buffer->memory(0)),
-                         buffer->stride(0), barrier));
+              FROM_HERE, base::Bind(&CopyRowsToUYVYBuffer, row, rows_to_copy,
+                                    coded_size.width(), video_frame,
+                                    static_cast<uint8_t*>(buffer->memory(0)),
+                                    buffer->stride(0), barrier));
           break;
         default:
           NOTREACHED();
       }
     }
   }
 }
 
 void GpuMemoryBufferVideoFramePool::PoolImpl::
     BindAndCreateMailboxesHardwareFrameResources(
         const scoped_refptr<VideoFrame>& video_frame,
         FrameResources* frame_resources,
         const FrameReadyCB& frame_ready_cb) {
   scoped_ptr<GpuVideoAcceleratorFactories::ScopedGLContextLock> lock(
       gpu_factories_->GetGLContextLock());
   if (!lock) {
     frame_ready_cb.Run(video_frame);
     return;
   }
   gpu::gles2::GLES2Interface* gles2 = lock->ContextGL();
 
   const size_t num_planes = VideoFrame::NumPlanes(output_format_);
   const size_t planes_per_copy = PlanesPerCopy(output_format_);
-  const gfx::Size size = video_frame->visible_rect().size();
+  const gfx::Size coded_size = CodedSize(video_frame, output_format_);
   gpu::MailboxHolder mailbox_holders[VideoFrame::kMaxPlanes];
   // Set up the planes creating the mailboxes needed to refer to the textures.
   for (size_t i = 0; i < num_planes; i += planes_per_copy) {
     PlaneResource& plane_resource = frame_resources->plane_resources[i];
     // Bind the texture and create or rebind the image.
     gles2->BindTexture(texture_target_, plane_resource.texture_id);
 
     if (plane_resource.gpu_memory_buffer && !plane_resource.image_id) {
-      const size_t width = VideoFrame::Columns(i, output_format_, size.width());
-      const size_t height = VideoFrame::Rows(i, output_format_, size.height());
+      const size_t width =
+          VideoFrame::Columns(i, output_format_, coded_size.width());
+      const size_t height =
+          VideoFrame::Rows(i, output_format_, coded_size.height());
       plane_resource.image_id = gles2->CreateImageCHROMIUM(
           plane_resource.gpu_memory_buffer->AsClientBuffer(), width, height,
           ImageInternalFormat(output_format_, i));
     } else if (plane_resource.image_id) {
       gles2->ReleaseTexImage2DCHROMIUM(texture_target_,
                                        plane_resource.image_id);
     }
     if (plane_resource.image_id)
       gles2->BindTexImage2DCHROMIUM(texture_target_, plane_resource.image_id);
     mailbox_holders[i] =
         gpu::MailboxHolder(plane_resource.mailbox, texture_target_, 0);
   }
 
   // Insert a sync_point, this is needed to make sure that the textures the
   // mailboxes refer to will be used only after all the previous commands posted
   // in the command buffer have been processed.
   unsigned sync_point = gles2->InsertSyncPointCHROMIUM();
   for (size_t i = 0; i < num_planes; i += planes_per_copy)
     mailbox_holders[i].sync_point = sync_point;
 
   scoped_refptr<VideoFrame> frame;
 
   auto release_mailbox_callback =
       base::Bind(&PoolImpl::MailboxHoldersReleased, this, frame_resources);
 
   // Create the VideoFrame backed by native textures.
+  gfx::Size visible_size = video_frame->visible_rect().size();
   switch (output_format_) {
     case PIXEL_FORMAT_I420:
       frame = VideoFrame::WrapYUV420NativeTextures(
           mailbox_holders[VideoFrame::kYPlane],
           mailbox_holders[VideoFrame::kUPlane],
-          mailbox_holders[VideoFrame::kVPlane], release_mailbox_callback, size,
-          gfx::Rect(size), video_frame->natural_size(),
+          mailbox_holders[VideoFrame::kVPlane], release_mailbox_callback,
+          coded_size, gfx::Rect(visible_size), video_frame->natural_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],
-          release_mailbox_callback, size, gfx::Rect(size),
+          release_mailbox_callback, coded_size, gfx::Rect(visible_size),
           video_frame->natural_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
@@ skipping 128 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