vaapi plumbing to allow hardware video overlays

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 "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 "gpu/command_buffer/service/texture_manager.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 "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 {
 
 VaapiDrmPicture::VaapiDrmPicture(
     VaapiWrapper* vaapi_wrapper,
     const base::Callback<bool(void)>& make_context_current,
     int32 picture_buffer_id,
     uint32 texture_id,
     const gfx::Size& size)
-    : VaapiPicture(picture_buffer_id, texture_id, size),
+    : VaapiPicture(picture_buffer_id, texture_id, size, true),
       vaapi_wrapper_(vaapi_wrapper),
       make_context_current_(make_context_current) {
 }
 
 VaapiDrmPicture::~VaapiDrmPicture() {
   if (gl_image_ && make_context_current_.Run()) {
     gl_image_->ReleaseTexImage(GL_TEXTURE_EXTERNAL_OES);
     gl_image_->Destroy(true);
 
     DCHECK_EQ(glGetError(), static_cast<GLenum>(GL_NO_ERROR));
   }
 }
 
-bool VaapiDrmPicture::Initialize() {
+bool VaapiDrmPicture::Initialize(gpu::gles2::TextureManager* texture_manager,
+                                 gpu::gles2::TextureRef* texture_ref) {
   // We want to create a VASurface and an EGLImage out of the same
   // memory buffer, so we can output decoded pictures to it using
   // VAAPI and also use it to paint with GL.
   ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
   ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
 
   // Create a buffer from Ozone.
   pixmap_ = factory->CreateNativePixmap(gfx::kNullAcceleratedWidget, size(),
                                         ui::SurfaceFactoryOzone::RGBA_8888,
                                         ui::SurfaceFactoryOzone::SCANOUT);
@@ skipping 41 matching lines @@
   va_surface_ = vaapi_wrapper_->CreateUnownedSurface(VA_RT_FORMAT_RGB32, size(),
                                                      va_attribs);
   if (!va_surface_) {
     LOG(ERROR) << "Failed to create VASurface for an Ozone NativePixmap";
     return false;
   }
 
   if (!make_context_current_.Run())
     return false;
 
-  // Create an EGLImage out of the same buffer.
-  gl_image_ = new gfx::GLImageLinuxDMABuffer(size(), GL_RGBA);
-  if (!gl_image_->Initialize(base::FileDescriptor(dmabuf_fd, false),
-                             gfx::GpuMemoryBuffer::BGRA_8888, dmabuf_pitch)) {
-    LOG(ERROR) << "Failed to create a GLImageLinuxDMABuffer for a NativePixmap";
+  gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_EXTERNAL_OES,
+                                          texture_id());
+  gl_image_ = ui::GpuMemoryBufferFactoryOzoneNativeBuffer::CreateImageForPixmap(
+      pixmap_, size(), gfx::GpuMemoryBuffer::RGBA_8888, GL_RGBA);
+  if (!gl_image_) {
+    LOG(ERROR) << "Failed to create GLImage";
     return false;
   }
-
-  // Bind the EGLImage to the given GL texture.
-  gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_EXTERNAL_OES,
-                                          texture_id());
   if (!gl_image_->BindTexImage(GL_TEXTURE_EXTERNAL_OES)) {
     LOG(ERROR) << "Failed to bind texture to GLImage";
     return false;
   }
+  texture_manager->SetLevelImage(texture_ref, GL_TEXTURE_EXTERNAL_OES, 0,

[Pawel Osciak, 2015/01/21 13:07:08]

I think we can get texture_ref from texture_manager by passing texture_id? 
Could we just pass texture_manager only to this method to save on arguments?

[achaulk, 2015/01/21 17:10:03]

Unfortunately, it's the wrong texture_id, we need the client ID to get the
TextureRef, but have the service ID. We would still need to pass the extra arg
either way, all that would change is the lookup location

+                                 gl_image_.get());
 
   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());
 }
 
 }  // namespace