vaapi plumbing to allow hardware video overlays

content/common/gpu/media/vaapi_picture.h

 // 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.
 //
 // This file contains an interface of output pictures for the Vaapi
 // video decoder. This is implemented by different window system
 // (X11/Ozone) and used by VaapiVideoDecodeAccelerator to produce
 // output pictures.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_VAAPI_PICTURE_H_
 #define CONTENT_COMMON_GPU_MEDIA_VAAPI_PICTURE_H_
 
 #include "base/callback.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/non_thread_safe.h"
 #include "ui/gfx/geometry/size.h"
 
+namespace gpu {
+namespace gles2 {
+class TextureManager;
+class TextureRef;
+}
+}
+
 namespace content {
 
 class VASurface;
 class VaapiWrapper;
 
 // Picture is native pixmap abstraction (X11/Ozone).
 class VaapiPicture : public base::NonThreadSafe {
  public:
   virtual ~VaapiPicture() {}
 
   // Try to allocate the underlying resources for the picture.
-  virtual bool Initialize() = 0;
+  virtual bool Initialize(gpu::gles2::TextureManager* texture_manager,

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

Please add documentation for changed methods in this file.

+                          gpu::gles2::TextureRef* texture_ref) = 0;
 
   int32 picture_buffer_id() const { return picture_buffer_id_; }
   uint32 texture_id() const { return texture_id_; }
   const gfx::Size& size() const { return size_; }
+  bool allow_overlay() const { return allow_overlay_; }

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

Could this instead be a virtual method returning false, and overriden to return
true in DrmPicture?

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

It could be, sure

 
   // Downloads the |va_surface| into the picture, potentially scaling
   // it if needed.
   virtual bool DownloadFromSurface(
       const scoped_refptr<VASurface>& va_surface) = 0;
 
   // Create a VaapiPicture of |size| to be associated with
   // |picture_buffer_id| and bound to |texture_id|.
   // |make_context_current| is provided for the GL operations.
   static linked_ptr<VaapiPicture> CreatePicture(
       VaapiWrapper* vaapi_wrapper,
+      gpu::gles2::TextureManager* texture_manager,
+      gpu::gles2::TextureRef* texture_ref,

[piman, 2015/01/21 23:58:22]

You may want to document that the texture_ref can't be kept around, or pass in a
scoped_refptr.
Otherwise the client could delete its texture id, causing the TextureRef to be
destroyed. The TextureRef is only valid from the time of the lookup and the next
command execution (in practice the next task).

       const base::Callback<bool(void)> make_context_current,
       int32 picture_buffer_id,
       uint32 texture_id,
       const gfx::Size& size);
 
   // Get the texture target used to bind EGLImages (either
   // GL_TEXTURE_2D on X11 or GL_TEXTURE_EXTERNAL_OES on DRM).
   static uint32 GetGLTextureTarget();
 
  protected:
   VaapiPicture(int32 picture_buffer_id,
                uint32 texture_id,
-               const gfx::Size& size)
+               const gfx::Size& size,
+               bool allow_overlay)
       : picture_buffer_id_(picture_buffer_id),
         texture_id_(texture_id),
-        size_(size) {}
+        size_(size),
+        allow_overlay_(allow_overlay) {}
 
  private:
   int32 picture_buffer_id_;
   uint32 texture_id_;
   gfx::Size size_;
+  bool allow_overlay_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiPicture);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_PICTURE_H_