VaapiVideoAccelerator: make Vaapi accelerator work with ozone

content/common/gpu/media/vaapi_video_decode_accelerator.h

 // Copyright (c) 2012 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 implementation of VideoDecoderAccelerator
 // that utilizes hardware video decoder present on Intel CPUs.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <map>
 #include <queue>
 #include <utility>
 #include <vector>
 
+#include "base/containers/scoped_ptr_hash_map.h"
 #include "base/logging.h"
-#include "base/memory/linked_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
-#include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/media/vaapi_h264_decoder.h"
+#include "content/common/gpu/media/vaapi_picture_provider.h"
 #include "content/common/gpu/media/vaapi_wrapper.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/video/picture.h"
 #include "media/video/video_decode_accelerator.h"
-#include "ui/gl/gl_bindings.h"
+
+namespace gfx {
+class GLContext;
+}  // namespace gfx
 
 namespace content {
 
 // Class to provide video decode acceleration for Intel systems with hardware
 // support for it, and on which libva is available.
 // Decoding tasks are performed in a separate decoding thread.
 //
 // Threading/life-cycle: this object is created & destroyed on the GPU
 // ChildThread.  A few methods on it are called on the decoder thread which is
 // stopped during |this->Destroy()|, so any tasks posted to the decoder thread
 // can assume |*this| is still alive.  See |weak_this_| below for more details.
 class CONTENT_EXPORT VaapiVideoDecodeAccelerator
     : public media::VideoDecodeAccelerator {
  public:
   VaapiVideoDecodeAccelerator(
-      Display* x_display,
+      gfx::GLContext* gl_context,
       const base::Callback<bool(void)>& make_context_current);
   virtual ~VaapiVideoDecodeAccelerator();
 
   // media::VideoDecodeAccelerator implementation.
   virtual bool Initialize(media::VideoCodecProfile profile,
                           Client* client) OVERRIDE;
   virtual void Decode(const media::BitstreamBuffer& bitstream_buffer) OVERRIDE;
   virtual void AssignPictureBuffers(
       const std::vector<media::PictureBuffer>& buffers) OVERRIDE;
   virtual void ReusePictureBuffer(int32 picture_buffer_id) OVERRIDE;
@@ skipping 58 matching lines @@
   void Cleanup();
 
   // Get a usable framebuffer configuration for use in binding textures
   // or return false on failure.
   bool InitializeFBConfig();
 
   // Callback for the decoder to execute when it wants us to output given
   // |va_surface|.
   void SurfaceReady(int32 input_id, const scoped_refptr<VASurface>& va_surface);
 
-  // Represents a texture bound to an X Pixmap for output purposes.
-  class TFPPicture;
-
   // Callback to be executed once we have a |va_surface| to be output and
-  // an available |tfp_picture| to use for output.
-  // Puts contents of |va_surface| into given |tfp_picture|, releases the
+  // an available |picture| to use for output.
+  // Puts contents of |va_surface| into given |picture|, releases the
   // surface and passes the resulting picture to client for output.
   void OutputPicture(const scoped_refptr<VASurface>& va_surface,
                      int32 input_id,
-                     TFPPicture* tfp_picture);
+                     VaapiPictureProvider::Picture* picture);
 
   // Try to OutputPicture() if we have both a ready surface and picture.
   void TryOutputSurface();
 
   // Called when a VASurface is no longer in use by the decoder or is not being
   // synced/waiting to be synced to a picture. Returns it to available surfaces
   // pool.
   void RecycleVASurfaceID(VASurfaceID va_surface_id);
 
   // Initiate wait cycle for surfaces to be released before we release them
   // and allocate new ones, as requested by the decoder.
   void InitiateSurfaceSetChange(size_t num_pics, gfx::Size size);
   // Check if the surfaces have been released or post ourselves for later.
   void TryFinishSurfaceSetChange();
 
   // Client-provided X/GLX state.

[Pawel Osciak, 2014/10/08 08:17:22]

Stale comment.

[llandwerlin-old, 2014/10/08 09:31:18]

Acknowledged.

-  Display* x_display_;
+  gfx::GLContext* gl_context_;
   base::Callback<bool(void)> make_context_current_;
-  GLXFBConfig fb_config_;
 
   // VAVDA state.
   enum State {
     // Initialize() not called yet or failed.
     kUninitialized,
     // DecodeTask running.
     kDecoding,
     // Resetting, waiting for decoder to finish current task and cleanup.
     kResetting,
     // Flushing, waiting for decoder to finish current task and cleanup.
@@ skipping 24 matching lines @@
   // Signalled when input buffers are queued onto the input_buffers_ queue.
   base::ConditionVariable input_ready_;
 
   // Current input buffer at decoder.
   linked_ptr<InputBuffer> curr_input_buffer_;
 
   // Queue for incoming output buffers (texture ids).
   typedef std::queue<int32> OutputBuffers;
   OutputBuffers output_buffers_;
 
-  typedef std::map<int32, linked_ptr<TFPPicture> > TFPPictures;
-  // All allocated TFPPictures, regardless of their current state. TFPPictures
+  typedef base::ScopedPtrHashMap<int32, VaapiPictureProvider::Picture> Pictures;
+  // All allocated Pictures, regardless of their current state. Pictures
   // are allocated once and destroyed at the end of decode.
-  TFPPictures tfp_pictures_;
+  Pictures pictures_;
 
   // Return a TFPPicture associated with given client-provided id.
-  TFPPicture* TFPPictureById(int32 picture_buffer_id);
+  VaapiPictureProvider::Picture* PictureById(int32 picture_buffer_id);
 
   // VA Surfaces no longer in use that can be passed back to the decoder for
   // reuse, once it requests them.
   std::list<VASurfaceID> available_va_surfaces_;
   // Signalled when output surfaces are queued onto the available_va_surfaces_
   // queue.
   base::ConditionVariable surfaces_available_;
 
   // Pending output requests from the decoder. When it indicates that we should
-  // output a surface and we have an available TFPPicture (i.e. texture) ready
-  // to use, we'll execute the callback passing the TFPPicture. The callback
+  // output a surface and we have an available Picture (i.e. texture) ready
+  // to use, we'll execute the callback passing the Picture. The callback
   // will put the contents of the surface into the picture and return it to
   // the client, releasing the surface as well.
-  // If we don't have any available TFPPictures at the time when the decoder
+  // If we don't have any available Pictures at the time when the decoder
   // requests output, we'll store the request on pending_output_cbs_ queue for
   // later and run it once the client gives us more textures
   // via ReusePictureBuffer().
-  typedef base::Callback<void(TFPPicture*)> OutputCB;
+  typedef base::Callback<void(VaapiPictureProvider::Picture*)> OutputCB;
   std::queue<OutputCB> pending_output_cbs_;
 
   // ChildThread's message loop
   base::MessageLoop* message_loop_;
 
   // WeakPtr<> pointing to |this| for use in posting tasks from the decoder
   // thread back to the ChildThread.  Because the decoder thread is a member of
   // this class, any task running on the decoder thread is guaranteed that this
   // object is still alive.  As a result, tasks posted from ChildThread to
   // decoder thread should use base::Unretained(this), and tasks posted from the
   // decoder thread to the ChildThread should use |weak_this_|.
   base::WeakPtr<VaapiVideoDecodeAccelerator> weak_this_;
 
   // Callback used when creating VASurface objects.
   VASurface::ReleaseCB va_surface_release_cb_;
 
   // To expose client callbacks from VideoDecodeAccelerator.
   // NOTE: all calls to these objects *MUST* be executed on message_loop_.
   scoped_ptr<base::WeakPtrFactory<Client> > client_ptr_factory_;
   base::WeakPtr<Client> client_;
 
   scoped_ptr<VaapiWrapper> vaapi_wrapper_;
 
+  scoped_ptr<VaapiPictureProvider> vaapi_picture_provider_;

[Pawel Osciak, 2014/10/08 08:17:22]

We should add a comment that it is important this outlives wrapper, and has to
stay defined after it for proper destruction order.

[llandwerlin-old, 2014/10/08 09:31:18]

It would be good to have the pictures down here too, to ensure they're destroyed
before the VaapiWrapper

[Pawel Osciak, 2014/10/26 13:06:46]

Providers have a ref to the wrapper now, so this is not a problem anymore?

[llandwerlin-old, 2014/10/29 13:52:47]

Acknowledged.

+
   // Comes after vaapi_wrapper_ to ensure its destructor is executed before
   // vaapi_wrapper_ is destroyed.
   scoped_ptr<VaapiH264Decoder> decoder_;
   base::Thread decoder_thread_;
   // Use this to post tasks to |decoder_thread_| instead of
   // |decoder_thread_.message_loop()| because the latter will be NULL once
   // |decoder_thread_.Stop()| returns.
   scoped_refptr<base::MessageLoopProxy> decoder_thread_proxy_;
 
   int num_frames_at_client_;
@@ skipping 13 matching lines @@
 
   // The WeakPtrFactory for |weak_this_|.
   base::WeakPtrFactory<VaapiVideoDecodeAccelerator> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiVideoDecodeAccelerator);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_