media/gpu/vaapi: Set visible size to (E)GLImage

We have set coded_size to (E)GLImage. It causes that a green line
is shown at the bottom and right edge when playing a video.

The correct set size is visible size so that GPU doesn't access
non-visible area on compositing.

Bug: 1043582
Test: Play a 1080p video on soraka
Change-Id: Ide3008bf602be3a4e189af1f6ab18213fca74753
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2011583
Commit-Queue: Hirokazu Honda <hiroh@chromium.org>
Reviewed-by: Alexandre Courbot <acourbot@chromium.org>
Cr-Commit-Position: refs/heads/master@{#733868}

media/gpu/vaapi/vaapi_picture.cc

@@ -18,6 +18,7 @@ VaapiPicture::VaapiPicture(
     const BindGLImageCallback& bind_image_cb,
     int32_t picture_buffer_id,
     const gfx::Size& size,
+    const gfx::Size& visible_size,
     uint32_t texture_id,
     uint32_t client_texture_id,
     uint32_t texture_target)
@@ -25,6 +26,7 @@ VaapiPicture::VaapiPicture(
       make_context_current_cb_(make_context_current_cb),
       bind_image_cb_(bind_image_cb),
       size_(size),
+      visible_size_(visible_size),
       texture_id_(texture_id),
       client_texture_id_(client_texture_id),
       texture_target_(texture_target),

media/gpu/vaapi/vaapi_picture.h

@@ -59,6 +59,7 @@ class MEDIA_GPU_EXPORT VaapiPicture {
                const BindGLImageCallback& bind_image_cb,
                int32_t picture_buffer_id,
                const gfx::Size& size,
+               const gfx::Size& visible_size,
                uint32_t texture_id,
                uint32_t client_texture_id,
                uint32_t texture_target);
@@ -69,6 +70,7 @@ class MEDIA_GPU_EXPORT VaapiPicture {
   const BindGLImageCallback bind_image_cb_;
 
   const gfx::Size size_;
+  const gfx::Size visible_size_;
   const uint32_t texture_id_;
   const uint32_t client_texture_id_;
   const uint32_t texture_target_;

media/gpu/vaapi/vaapi_picture_factory.cc

@@ -44,7 +44,8 @@ std::unique_ptr<VaapiPicture> VaapiPictureFactory::Create(
     scoped_refptr<VaapiWrapper> vaapi_wrapper,
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const BindGLImageCallback& bind_image_cb,
-    const PictureBuffer& picture_buffer) {
+    const PictureBuffer& picture_buffer,
+    const gfx::Size& visible_size) {
   // ARC++ sends |picture_buffer| with no texture_target().
   DCHECK(picture_buffer.texture_target() == GetGLTextureTarget() ||
          picture_buffer.texture_target() == 0u);
@@ -70,15 +71,17 @@ std::unique_ptr<VaapiPicture> VaapiPictureFactory::Create(
     case kVaapiImplementationDrm:
       picture.reset(new VaapiPictureNativePixmapOzone(
           std::move(vaapi_wrapper), make_context_current_cb, bind_image_cb,
-          picture_buffer.id(), picture_buffer.size(), service_texture_id,
-          client_texture_id, picture_buffer.texture_target()));
+          picture_buffer.id(), picture_buffer.size(), visible_size,
+          service_texture_id, client_texture_id,
+          picture_buffer.texture_target()));
       break;
 #elif defined(USE_EGL)
     case kVaapiImplementationDrm:
       picture.reset(new VaapiPictureNativePixmapEgl(
           std::move(vaapi_wrapper), make_context_current_cb, bind_image_cb,
-          picture_buffer.id(), picture_buffer.size(), service_texture_id,
-          client_texture_id, picture_buffer.texture_target()));
+          picture_buffer.id(), picture_buffer.size(), visible_size,
+          service_texture_id, client_texture_id,
+          picture_buffer.texture_target()));
       break;
 #endif
 
@@ -86,8 +89,9 @@ std::unique_ptr<VaapiPicture> VaapiPictureFactory::Create(
     case kVaapiImplementationX11:
       picture.reset(new VaapiTFPPicture(
           std::move(vaapi_wrapper), make_context_current_cb, bind_image_cb,
-          picture_buffer.id(), picture_buffer.size(), service_texture_id,
-          client_texture_id, picture_buffer.texture_target()));
+          picture_buffer.id(), picture_buffer.size(), visible_size,
+          service_texture_id, client_texture_id,
+          picture_buffer.texture_target()));
       break;
 #endif  // USE_X11
 

media/gpu/vaapi/vaapi_picture_factory.h

@@ -36,7 +36,8 @@ class MEDIA_GPU_EXPORT VaapiPictureFactory {
       scoped_refptr<VaapiWrapper> vaapi_wrapper,
       const MakeGLContextCurrentCallback& make_context_current_cb,
       const BindGLImageCallback& bind_image_cb,
-      const PictureBuffer& picture_buffer);
+      const PictureBuffer& picture_buffer,
+      const gfx::Size& visible_size);
 
   // Return the type of the VaapiPicture implementation for the given GL
   // implementation.

media/gpu/vaapi/vaapi_picture_native_pixmap.cc

@@ -21,6 +21,7 @@ VaapiPictureNativePixmap::VaapiPictureNativePixmap(
     const BindGLImageCallback& bind_image_cb,
     int32_t picture_buffer_id,
     const gfx::Size& size,
+    const gfx::Size& visible_size,
     uint32_t texture_id,
     uint32_t client_texture_id,
     uint32_t texture_target)
@@ -29,6 +30,7 @@ VaapiPictureNativePixmap::VaapiPictureNativePixmap(
                    bind_image_cb,
                    picture_buffer_id,
                    size,
+                   visible_size,
                    texture_id,
                    client_texture_id,
                    texture_target) {}

media/gpu/vaapi/vaapi_picture_native_pixmap.h

@@ -31,6 +31,7 @@ class VaapiPictureNativePixmap : public VaapiPicture {
       const BindGLImageCallback& bind_image_cb_,
       int32_t picture_buffer_id,
       const gfx::Size& size,
+      const gfx::Size& visible_size,
       uint32_t texture_id,
       uint32_t client_texture_id,
       uint32_t texture_target);

media/gpu/vaapi/vaapi_picture_native_pixmap_egl.cc

@@ -21,6 +21,7 @@ VaapiPictureNativePixmapEgl::VaapiPictureNativePixmapEgl(
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const BindGLImageCallback& bind_image_cb,
     int32_t picture_buffer_id,
+    const gfx::Size& visible_size,
     const gfx::Size& size,
     uint32_t texture_id,
     uint32_t client_texture_id,
@@ -30,6 +31,7 @@ VaapiPictureNativePixmapEgl::VaapiPictureNativePixmapEgl(
                                bind_image_cb,
                                picture_buffer_id,
                                size,
+                               visible_size,
                                texture_id,
                                client_texture_id,
                                texture_target) {
@@ -75,7 +77,8 @@ bool VaapiPictureNativePixmapEgl::Allocate(gfx::BufferFormat format) {
   if (make_context_current_cb_ && !make_context_current_cb_.Run())
     return false;
 
-  auto image = base::MakeRefCounted<gl::GLImageNativePixmap>(size_, format);
+  auto image =
+      base::MakeRefCounted<gl::GLImageNativePixmap>(visible_size_, format);
   // Create an EGLImage from a gl texture
   if (!image->InitializeFromTexture(texture_id_)) {
     DLOG(ERROR) << "Failed to initialize eglimage from texture id: "
@@ -90,6 +93,14 @@ bool VaapiPictureNativePixmapEgl::Allocate(gfx::BufferFormat format) {
     return false;
   }
 
+  if (size_.width() > static_cast<int>(native_pixmap_handle.planes[0].stride) ||
+      size_.GetArea() > static_cast<int>(native_pixmap_handle.planes[0].size)) {
+    DLOG(ERROR) << "EGLImage (stride=" << native_pixmap_handle.planes[0].stride
+                << ", size=" << native_pixmap_handle.planes[0].size
+                << "is smaller than size_=" << size_.ToString();
+    return false;
+  }
+
   // Convert NativePixmapHandle to NativePixmapDmaBuf.
   scoped_refptr<gfx::NativePixmap> native_pixmap_dmabuf(
       new gfx::NativePixmapDmaBuf(size_, format,

media/gpu/vaapi/vaapi_picture_native_pixmap_egl.h

@@ -32,6 +32,7 @@ class VaapiPictureNativePixmapEgl : public VaapiPictureNativePixmap {
       const BindGLImageCallback& bind_image_cb_,
       int32_t picture_buffer_id,
       const gfx::Size& size,
+      const gfx::Size& visible_size,
       uint32_t texture_id,
       uint32_t client_texture_id,
       uint32_t texture_target);

media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.cc

@@ -22,6 +22,7 @@ VaapiPictureNativePixmapOzone::VaapiPictureNativePixmapOzone(
     const BindGLImageCallback& bind_image_cb,
     int32_t picture_buffer_id,
     const gfx::Size& size,
+    const gfx::Size& visible_size,
     uint32_t texture_id,
     uint32_t client_texture_id,
     uint32_t texture_target)
@@ -30,6 +31,7 @@ VaapiPictureNativePixmapOzone::VaapiPictureNativePixmapOzone(
                                bind_image_cb,
                                picture_buffer_id,
                                size,
+                               visible_size,
                                texture_id,
                                client_texture_id,
                                texture_target) {
@@ -71,11 +73,13 @@ bool VaapiPictureNativePixmapOzone::Initialize(
 
   const gfx::BufferFormat format = pixmap->GetBufferFormat();
 
-  auto image = base::MakeRefCounted<gl::GLImageNativePixmap>(size_, format);
+  auto image =
+      base::MakeRefCounted<gl::GLImageNativePixmap>(visible_size_, format);
   if (!image->Initialize(std::move(pixmap))) {
     LOG(ERROR) << "Failed to create GLImage";
     return false;
   }
+
   gl_image_ = image;
   if (!gl_image_->BindTexImage(texture_target_)) {
     LOG(ERROR) << "Failed to bind texture to GLImage";
@@ -113,6 +117,15 @@ bool VaapiPictureNativePixmapOzone::ImportGpuMemoryBufferHandle(
     gfx::GpuMemoryBufferHandle gpu_memory_buffer_handle) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
+  const auto& plane = gpu_memory_buffer_handle.native_pixmap_handle.planes[0];
+  if (size_.width() > static_cast<int>(plane.stride) ||
+      size_.GetArea() > static_cast<int>(plane.size)) {
+    DLOG(ERROR) << "GpuMemoryBufferHandle (stride=" << plane.stride
+                << ", size=" << plane.size
+                << "is smaller than size_=" << size_.ToString();
+    return false;
+  }
+
   ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
   ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
   // CreateNativePixmapFromHandle() will take ownership of the handle.

media/gpu/vaapi/vaapi_picture_native_pixmap_ozone.h

@@ -31,6 +31,7 @@ class VaapiPictureNativePixmapOzone : public VaapiPictureNativePixmap {
       const BindGLImageCallback& bind_image_cb_,
       int32_t picture_buffer_id,
       const gfx::Size& size,
+      const gfx::Size& visible_size,
       uint32_t texture_id,
       uint32_t client_texture_id,
       uint32_t texture_target);

media/gpu/vaapi/vaapi_picture_tfp.cc

@@ -19,6 +19,7 @@ VaapiTFPPicture::VaapiTFPPicture(
     const BindGLImageCallback& bind_image_cb,
     int32_t picture_buffer_id,
     const gfx::Size& size,
+    const gfx::Size& visible_size,
     uint32_t texture_id,
     uint32_t client_texture_id,
     uint32_t texture_target)
@@ -27,6 +28,7 @@ VaapiTFPPicture::VaapiTFPPicture(
                    bind_image_cb,
                    picture_buffer_id,
                    size,
+                   visible_size,
                    texture_id,
                    client_texture_id,
                    texture_target),

media/gpu/vaapi/vaapi_picture_tfp.h

@@ -30,6 +30,7 @@ class VaapiTFPPicture : public VaapiPicture {
                   const BindGLImageCallback& bind_image_cb,
                   int32_t picture_buffer_id,
                   const gfx::Size& size,
+                  const gfx::Size& visible_size,
                   uint32_t texture_id,
                   uint32_t client_texture_id,
                   uint32_t texture_target);

media/gpu/vaapi/vaapi_video_decode_accelerator.cc

@@ -688,7 +688,8 @@ void VaapiVideoDecodeAccelerator::AssignPictureBuffers(
         (buffer_allocation_mode_ == BufferAllocationMode::kNone)
             ? vaapi_wrapper_
             : vpp_vaapi_wrapper_,
-        make_context_current_cb_, bind_image_cb_, buffer);
+        make_context_current_cb_, bind_image_cb_, buffer,
+        decoder_->GetVisibleRect().size());
     RETURN_AND_NOTIFY_ON_FAILURE(picture, "Failed creating a VaapiPicture",
                                  PLATFORM_FAILURE, );
 

media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc

@@ -89,6 +89,7 @@ class MockVaapiPicture : public VaapiPicture {
                    const BindGLImageCallback& bind_image_cb,
                    int32_t picture_buffer_id,
                    const gfx::Size& size,
+                   const gfx::Size& visible_size,
                    uint32_t texture_id,
                    uint32_t client_texture_id,
                    uint32_t texture_target)
@@ -97,6 +98,7 @@ class MockVaapiPicture : public VaapiPicture {
                      bind_image_cb,
                      picture_buffer_id,
                      size,
+                     visible_size,
                      texture_id,
                      client_texture_id,
                      texture_target) {}
@@ -124,19 +126,22 @@ class MockVaapiPictureFactory : public VaapiPictureFactory {
   MockVaapiPictureFactory() = default;
   ~MockVaapiPictureFactory() override = default;
 
-  MOCK_METHOD2(MockCreateVaapiPicture, void(VaapiWrapper*, const gfx::Size&));
+  MOCK_METHOD3(MockCreateVaapiPicture,
+               void(VaapiWrapper*, const gfx::Size&, const gfx::Size&));
   std::unique_ptr<VaapiPicture> Create(
       scoped_refptr<VaapiWrapper> vaapi_wrapper,
       const MakeGLContextCurrentCallback& make_context_current_cb,
       const BindGLImageCallback& bind_image_cb,
-      const PictureBuffer& picture_buffer) override {
+      const PictureBuffer& picture_buffer,
+      const gfx::Size& visible_size) override {
     const uint32_t service_texture_id = picture_buffer.service_texture_ids()[0];
     const uint32_t client_texture_id = picture_buffer.client_texture_ids()[0];
-    MockCreateVaapiPicture(vaapi_wrapper.get(), picture_buffer.size());
+    MockCreateVaapiPicture(vaapi_wrapper.get(), picture_buffer.size(),
+                           visible_size);
     return std::make_unique<MockVaapiPicture>(
         std::move(vaapi_wrapper), make_context_current_cb, bind_image_cb,
-        picture_buffer.id(), picture_buffer.size(), service_texture_id,
-        client_texture_id, picture_buffer.texture_target());
+        picture_buffer.id(), picture_buffer.size(), visible_size,
+        service_texture_id, client_texture_id, picture_buffer.texture_target());
   }
 };
 
@@ -288,9 +293,11 @@ class VaapiVideoDecodeAcceleratorTest : public TestWithParam<TestParams>,
     if (GetParam().decode_using_client_picture_buffers) {
       EXPECT_CALL(*mock_vaapi_wrapper_, CreateContext(picture_size))
           .WillOnce(Return(true));
-      EXPECT_CALL(
-          *mock_vaapi_picture_factory_,
-          MockCreateVaapiPicture(mock_vaapi_wrapper_.get(), picture_size))
+      EXPECT_CALL(*mock_decoder_, GetVisibleRect())
+          .WillRepeatedly(Return(gfx::Rect(picture_size)));
+      EXPECT_CALL(*mock_vaapi_picture_factory_,
+                  MockCreateVaapiPicture(mock_vaapi_wrapper_.get(),
+                                         picture_size, picture_size))
           .Times(num_pictures);
     } else {
       EXPECT_EQ(
@@ -308,8 +315,10 @@ class VaapiVideoDecodeAcceleratorTest : public TestWithParam<TestParams>,
                 va_surface_ids->resize(kNumReferenceFrames);
               })),
               Return(true)));
+      EXPECT_CALL(*mock_decoder_, GetVisibleRect())
+          .WillRepeatedly(Return(gfx::Rect(picture_size)));
       EXPECT_CALL(*mock_vaapi_picture_factory_,
-                  MockCreateVaapiPicture(_, picture_size))
+                  MockCreateVaapiPicture(_, picture_size, picture_size))
           .Times(num_pictures);
     }