Change CHROMIUM_image declarations to support multi planar input.

content/common/gpu/media/vaapi_drm_picture.cc

 // Copyright 2014 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 <vector>
+
 #include "base/file_descriptor_posix.h"
 #include "content/common/gpu/media/va_surface.h"
 #include "content/common/gpu/media/vaapi_drm_picture.h"
 #include "content/common/gpu/media/vaapi_wrapper.h"
 #include "third_party/libva/va/drm/va_drm.h"
 #include "third_party/libva/va/va.h"
 #include "third_party/libva/va/va_drmcommon.h"
+#include "third_party/webrtc/base/scoped_ref_ptr.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_image_linux_dma_buffer.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h"
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 
 namespace content {
@@ skipping 33 matching lines @@
     LOG(ERROR) << "Failed creating an Ozone NativePixmap";
     return false;
   }
 
   // Get the dmabuf of the created buffer.
   int dmabuf_fd = pixmap_->GetDmaBufFd();
   if (dmabuf_fd < 0) {
     LOG(ERROR) << "Failed to get dmabuf from an Ozone NativePixmap";
     return false;
   }
-  int dmabuf_pitch = pixmap_->GetDmaBufPitch();
+  std::vector<int> dmabuf_pitches = { pixmap_->GetDmaBufPitch() };
 
   // Create a VASurface out of the created buffer using the dmabuf.
   VASurfaceAttribExternalBuffers va_attrib_extbuf;
   memset(&va_attrib_extbuf, 0, sizeof(va_attrib_extbuf));
   va_attrib_extbuf.pixel_format = VA_FOURCC_BGRX;
   va_attrib_extbuf.width = size().width();
   va_attrib_extbuf.height = size().height();
-  va_attrib_extbuf.data_size = size().height() * dmabuf_pitch;
+  va_attrib_extbuf.data_size = size().height() * dmabuf_pitches[0];
   va_attrib_extbuf.num_planes = 1;
-  va_attrib_extbuf.pitches[0] = dmabuf_pitch;
+  va_attrib_extbuf.pitches[0] = dmabuf_pitches[0];
   va_attrib_extbuf.offsets[0] = 0;
   va_attrib_extbuf.buffers = reinterpret_cast<unsigned long*>(&dmabuf_fd);
   va_attrib_extbuf.num_buffers = 1;
   va_attrib_extbuf.flags = 0;
   va_attrib_extbuf.private_data = NULL;
 
   std::vector<VASurfaceAttrib> va_attribs;
   va_attribs.resize(2);
 
   va_attribs[0].type = VASurfaceAttribMemoryType;
@@ skipping 11 matching lines @@
   if (!va_surface_) {
     LOG(ERROR) << "Failed to create VASurface for an Ozone NativePixmap";
     return false;
   }
 
   if (!make_context_current_.Run())
     return false;
 
   gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_EXTERNAL_OES,
                                           texture_id());
-  gl_image_ = ui::GpuMemoryBufferFactoryOzoneNativeBuffer::CreateImageForPixmap(
-      pixmap_, size(), gfx::GpuMemoryBuffer::BGRA_8888, GL_RGBA);
+  const std::vector<gfx::GpuMemoryBuffer::Format> formats(
+      1, gfx::GpuMemoryBuffer::BGRA_8888);
+  const std::vector<scoped_refptr<ui::NativePixmap>> pixmaps(1, pixmap_);
+  gl_image_ =
+      ui::GpuMemoryBufferFactoryOzoneNativeBuffer::CreateImageForPixmaps(
+          1, pixmaps, size(), formats, GL_RGBA);
   if (!gl_image_) {
     LOG(ERROR) << "Failed to create GLImage";
     return false;
   }
   if (!gl_image_->BindTexImage(GL_TEXTURE_EXTERNAL_OES)) {
     LOG(ERROR) << "Failed to bind texture to GLImage";
     return false;
   }
 
   return true;
 }
 
 bool VaapiDrmPicture::DownloadFromSurface(
     const scoped_refptr<VASurface>& va_surface) {
   return vaapi_wrapper_->BlitSurface(va_surface->id(), va_surface->size(),
                                      va_surface_->id(), va_surface_->size());
 }
 
 scoped_refptr<gfx::GLImage> VaapiDrmPicture::GetImageToBind() {
   return gl_image_;
 }
 
 bool VaapiDrmPicture::AllowOverlay() const {
   return true;
 }
 
 }  // namespace