VaapiVideoAccelerator: make Vaapi accelerator work with ozone

content/common/gpu/media/vaapi_wrapper.h

 // Copyright 2013 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 VaapiWrapper, used by
 // VaapiVideoDecodeAccelerator and VaapiH264Decoder for decode,
 // and VaapiVideoEncodeAccelerator for encode, to interface
 // with libva (VA-API library for hardware video codec).
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_VAAPI_WRAPPER_H_
 #define CONTENT_COMMON_GPU_MEDIA_VAAPI_WRAPPER_H_
 
 #include <set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/media/va_surface.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
+#include "third_party/libva/va/va.h"
+#include "third_party/libva/va/va_vpp.h"
+#include "ui/gfx/size.h"
+#if defined(USE_X11)
 #include "third_party/libva/va/va_x11.h"
-#include "ui/gfx/size.h"
+#endif  // USE_X11
 
 namespace content {
 
 // This class handles VA-API calls and ensures proper locking of VA-API calls
 // to libva, the userspace shim to the HW codec driver. libva is not
 // thread-safe, so we have to perform locking ourselves. This class is fully
 // synchronous and its methods can be called from any thread and may wait on
 // the va_lock_ while other, concurrent calls run.
 //
 // This class is responsible for managing VAAPI connection, contexts and state.
 // It is also responsible for managing and freeing VABuffers (not VASurfaces),
 // which are used to queue parameters and slice data to the HW codec,
 // as well as underlying memory for VASurfaces themselves.
-class CONTENT_EXPORT VaapiWrapper {
+class CONTENT_EXPORT VaapiWrapper : public base::RefCounted<VaapiWrapper> {
  public:
   enum CodecMode {
     kDecode,
     kEncode,
   };
 
   // |report_error_to_uma_cb| will be called independently from reporting
   // errors to clients via method return values.
-  static scoped_ptr<VaapiWrapper> Create(
+  static scoped_refptr<VaapiWrapper> Create(
       CodecMode mode,
       media::VideoCodecProfile profile,
-      Display* x_display,
       const base::Closure& report_error_to_uma_cb);
 
   ~VaapiWrapper();
 
   // Create |num_surfaces| backing surfaces in driver for VASurfaces, each
   // of size |size|. Returns true when successful, with the created IDs in
   // |va_surfaces| to be managed and later wrapped in VASurfaces.
   // The client must DestroySurfaces() each time before calling this method
   // again to free the allocated surfaces first, but is not required to do so
   // at destruction time, as this will be done automatically from
   // the destructor.
-  bool CreateSurfaces(gfx::Size size,
+  bool CreateSurfaces(const gfx::Size& size,
                       size_t num_surfaces,
                       std::vector<VASurfaceID>* va_surfaces);
 
   // Free all memory allocated in CreateSurfaces.
   void DestroySurfaces();
 
+  // Create a VASurface of |format|, |size| and using attributes

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

s/format/va_format/

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

Acknowledged.

+  // |attribs|. The Client must call DestroyOutputSurface() to destroy

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

where |num_va_attribs| is the size of |va_attribs|.

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

Acknowledged.

+  // the created surface.

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

What if we returned a VASurface instead and have DestroyOutputSurface() as its
release_cb(), would that work?

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

Yes, doing this.

+  bool CreateOutputSurface(unsigned int va_format,

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

I'd call it CreateUnmanagedSurface, or CreateUnownedSurface, and clearly state
in the documentation how this differs from CreateSurfaces.

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

Acknowledged.

+                           const gfx::Size& size,
+                           VASurfaceAttrib* va_attribs,
+                           size_t num_va_attribs,
+                           VASurfaceID* va_surface);

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

Please document va_surface too.
Also please always call *ID *_id, i.e. va_surface_id, here and everywhere.

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

Acknowledged.

+
+  // Destroys a |va_surface| created using CreateOutputSurface.
+  void DestroyOutputSurface(VASurfaceID va_surface);
+
   // Submit parameters or slice data of |va_buffer_type|, copying them from
   // |buffer| of size |size|, into HW codec. The data in |buffer| is no
   // longer needed and can be freed after this method returns.
   // Data submitted via this method awaits in the HW codec until
   // ExecuteAndDestroyPendingBuffers() is called to execute or
   // DestroyPendingBuffers() is used to cancel a pending job.
   bool SubmitBuffer(VABufferType va_buffer_type, size_t size, void* buffer);
 
   // Submit a VAEncMiscParameterBuffer of given |misc_param_type|, copying its
   // data from |buffer| of size |size|, into HW codec. The data in |buffer| is
   // no longer needed and can be freed after this method returns.
   // Data submitted via this method awaits in the HW codec until
   // ExecuteAndDestroyPendingBuffers() is called to execute or
   // DestroyPendingBuffers() is used to cancel a pending job.
   bool SubmitVAEncMiscParamBuffer(VAEncMiscParameterType misc_param_type,
                                   size_t size,
                                   void* buffer);
 
   // Cancel and destroy all buffers queued to the HW codec via SubmitBuffer().
   // Useful when a pending job is to be cancelled (on reset or error).
   void DestroyPendingBuffers();
 
   // Execute job in hardware on target |va_surface_id| and destroy pending
   // buffers. Return false if Execute() fails.
   bool ExecuteAndDestroyPendingBuffers(VASurfaceID va_surface_id);
 
-  // Put data from |va_surface_id| into |x_pixmap| of size |size|,
-  // converting/scaling to it.
-  bool PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
-                            Pixmap x_pixmap,
-                            gfx::Size dest_size);
-
   // Returns true if the VAAPI version is less than the specified version.
   bool VAAPIVersionLessThan(int major, int minor);
 
   // Get a VAImage from a VASurface and map it into memory. The VAImage should
   // be released using the ReturnVaImage function. Returns true when successful.
   // This is intended for testing only.
   bool GetVaImageForTesting(VASurfaceID va_surface_id,
                             VAImage* image,
                             void** mem);
 
@@ skipping 16 matching lines @@
   // to the encode job.
   bool DownloadAndDestroyCodedBuffer(VABufferID buffer_id,
                                      VASurfaceID sync_surface_id,
                                      uint8* target_ptr,
                                      size_t target_size,
                                      size_t* coded_data_size);
 
   // Destroy all previously-allocated (and not yet destroyed) coded buffers.
   void DestroyCodedBuffers();
 
+  // Converts a VASurface from decoder preferred format (NV12) to
+  // output picture format (RGBA)

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

Full stop at the end of sentence please. Also please mention that this may
scale.

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

Acknowledged.

+  bool PutSurfaceIntoSurface(VASurfaceID va_surface_id_src,

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

PutSurfaceIntoPixmap() is a download, but this is not. I'd suggest something
like ConvertSurface() perhaps?

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

Went with BlitSurface().

+                             const gfx::Size& src_size,
+                             VASurfaceID va_surface_id_dest,
+                             const gfx::Size& dest_size);
+
+#if defined(USE_X11)
+  // Put data from |va_surface_id| into |x_pixmap| of size |size|,
+  // converting/scaling to it.
+  bool PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
+                            Pixmap x_pixmap,
+                            gfx::Size dest_size);
+#endif  // USE_X11
+
  private:
   VaapiWrapper();
 
-  bool Initialize(CodecMode mode,
+  bool Initialize(VADisplay display,
+                  CodecMode mode,
                   media::VideoCodecProfile profile,
-                  Display* x_display,
                   const base::Closure& report_error__to_uma_cb);
   void Deinitialize();
 
+  // Initialize the video post processing context with the |size| of
+  // the decoder output pictures.

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

I think we don't want to mention decoder here. We could even use this for
something else not related to decode.
Also, please say that this is going to be the source size.
Moreover, could we make this universal and pass source format as well? I'm
forgetting right now, is the source format changeable as well?

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

Actually looking into the code of the va driver on Intel, the size given to 
initialize the context is irrelevant for the post processor. I'll just drop the
size.

+  bool InitializeVpp(const gfx::Size& size);
+
+  // Deinitialize the video post processing context

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

Please full stop at the end of sentences.

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

Acknowledged.

+  void DeinitializeVpp();
+
   // Execute pending job in hardware and destroy pending buffers. Return false
   // if vaapi driver refuses to accept parameter or slice buffers submitted
   // by client, or if execution fails in hardware.
   bool Execute(VASurfaceID va_surface_id);
 
   // Attempt to set render mode to "render to texture.". Failure is non-fatal.
   void TryToSetVADisplayAttributeToLocalGPU();
 
   // Lazily initialize static data after sandbox is enabled.  Return false on
   // init failure.
   static bool PostSandboxInitialization();
 
   // Libva is not thread safe, so we have to do locking for it ourselves.
   // This lock is to be taken for the duration of all VA-API calls and for
   // the entire job submission sequence in ExecuteAndDestroyPendingBuffers().
   base::Lock va_lock_;
 
   // Allocated ids for VASurfaces.
   std::vector<VASurfaceID> va_surface_ids_;
 
   // The VAAPI version.
   int major_version_, minor_version_;
 
   // VA handles.
-  // Both valid after successful Initialize() and until Deinitialize().
+  // All valid after successful Initialize() and until Deinitialize().
   VADisplay va_display_;
   VAConfigID va_config_id_;
   // Created for the current set of va_surface_ids_ in CreateSurfaces() and
   // valid until DestroySurfaces().
   VAContextID va_context_id_;
 
   // Data queued up for HW codec, to be committed on next execution.
   std::vector<VABufferID> pending_slice_bufs_;
   std::vector<VABufferID> pending_va_bufs_;
 
   // Bitstream buffers for encode.
   std::set<VABufferID> coded_buffers_;
 
   // Called to report codec errors to UMA. Errors to clients are reported via
   // return values from public methods.
   base::Closure report_error_to_uma_cb_;
 
+  // VPP context
+  VAConfigID va_vpp_config_;

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

Please add _id at the end of each of these.

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

Acknowledged.

+  VAContextID va_vpp_context_;
+  VABufferID va_vpp_buffer_;
+
+  // Cache of the size of the VPP input pictures

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

"Input surface size, to which VPP is currently configured."

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

Removed.

+  gfx::Size vpp_picture_size_;
+
   DISALLOW_COPY_AND_ASSIGN(VaapiWrapper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_WRAPPER_H_