[Ozone] Extends the lifetime of VaapiWrapper

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_
@@ skipping 13 matching lines @@
 #include "media/video/jpeg_decode_accelerator.h"
 #include "media/video/video_decode_accelerator.h"
 #include "media/video/video_encode_accelerator.h"
 #include "third_party/libva/va/va.h"
 #include "third_party/libva/va/va_vpp.h"
 #include "ui/gfx/geometry/size.h"
 #if defined(USE_X11)
 #include "third_party/libva/va/va_x11.h"
 #endif  // USE_X11
 
+#if defined(USE_OZONE)
+namespace ui {
+class NativePixmap;
+}
+#endif
+
 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::RefCountedThreadSafe<VaapiWrapper> {
  public:
   enum CodecMode {
     kDecode,
     kEncode,
     kCodecModeMax,
   };
 
   // Return an instance of VaapiWrapper initialized for |va_profile| and
   // |mode|. |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,
       VAProfile va_profile,
       const base::Closure& report_error_to_uma_cb);
 
   // Create VaapiWrapper for VideoCodecProfile. It maps VideoCodecProfile
   // |profile| to VAProfile.
   // |report_error_to_uma_cb| will be called independently from reporting
   // errors to clients via method return values.
-  static scoped_ptr<VaapiWrapper> CreateForVideoCodec(
+  static scoped_refptr<VaapiWrapper> CreateForVideoCodec(
       CodecMode mode,
       media::VideoCodecProfile profile,
       const base::Closure& report_error_to_uma_cb);
 
   // Return the supported video encode profiles.
   static media::VideoEncodeAccelerator::SupportedProfiles
       GetSupportedEncodeProfiles();
 
   // Return the supported video decode profiles.
   static media::VideoDecodeAccelerator::SupportedProfiles
       GetSupportedDecodeProfiles();
 
   // Return true when JPEG decode is supported.
   static bool IsJpegDecodeSupported();
 
-  ~VaapiWrapper();
-
   // Create |num_surfaces| backing surfaces in driver for VASurfaces of
   // |va_format|, 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(unsigned int va_format,
                       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 |va_format|, |size| and using |va_attribs|
   // attributes. The ownership of the surface is transferred to the
   // caller. It differs from surfaces created using CreateSurfaces(),
   // where VaapiWrapper is the owner of the surfaces.
   scoped_refptr<VASurface> CreateUnownedSurface(
       unsigned int va_format,
       const gfx::Size& size,
       const std::vector<VASurfaceAttrib>& va_attribs);
 
+#if defined(USE_OZONE)
+  // Create a VASurface for |pixmap| of |pixmap_size|. The ownership of the
+  // surface is transferred to the caller. It differs from surfaces created
+  // using CreateSurfaces(), where VaapiWrapper is the owner of the surfaces.
+  scoped_refptr<VASurface> CreateVASurfaceForPixmap(
+      const scoped_refptr<ui::NativePixmap>& pixmap,
+      const gfx::Size& pixmap_size);
+
+  // Use VPP to process |source_pixmap|, scaling to |target_size| and
+  // converting to |target_format|. Return the processed pixmap.
+  scoped_refptr<ui::NativePixmap> ProcessPixmap(
+      const scoped_refptr<ui::NativePixmap>& source_pixmap,
+      const gfx::Size& target_size,
+      gfx::BufferFormat target_format);
+
+  // Create native pixmap with size |size| and format |format|.
+  scoped_refptr<ui::NativePixmap> CreateNativePixmap(gfx::Size size,

[Pawel Osciak, 2015/11/30 05:57:02]

Sorry, I think you misunderstood me previously:

I only suggested having CreateVASurfaceForPixmap in VaapiWrapper, as it creates
a VA surface from a pixmap. CreateNativePixmap() itself should not be an
external API of VaapiWrapper, it's not related to VAAPI or a service that a
VAAPI-specific class should be providing. We should be using SurfaceFactoryOzone
to produce native pixmaps.

Also, in my previous comment I suggested we should have the caller of the
callback create the native pixmap for the processing target and pass it to the
callback. The callback should be static and call
VaapiWrapper::CreateVASurfaceForPixmap for the pixmap given by the caller of the
callback, and then call VaapiWrapper::BlitSurface on it.

Would that be possible please?

[william.xie1, 2015/11/30 08:02:02]

Done.

+                                                     gfx::BufferFormat format);
+#endif
+
   // 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
@@ skipping 73 matching lines @@
   bool BlitSurface(const scoped_refptr<VASurface>& va_surface_src,
                    const scoped_refptr<VASurface>& va_surface_dest);
 
   // Initialize static data before sandbox is enabled.
   static void PreSandboxInitialization();
 
   // Get the created surfaces format.
   unsigned int va_surface_format() const { return va_surface_format_; }
 
  private:
+  friend class base::RefCountedThreadSafe<VaapiWrapper>;
+
   struct ProfileInfo {
     VAProfile va_profile;
     gfx::Size max_resolution;
   };
 
   class LazyProfileInfos {
    public:
     LazyProfileInfos();
     ~LazyProfileInfos();
     std::vector<ProfileInfo> GetSupportedProfileInfosForCodecMode(
@@ skipping 43 matching lines @@
     VADisplay va_display_;
 
     // The VAAPI version.
     int major_version_, minor_version_;
 
     // True if vaInitialize has been called successfully.
     bool va_initialized_;
   };
 
   VaapiWrapper();
+  ~VaapiWrapper();
 
   bool Initialize(CodecMode mode, VAProfile va_profile);
   void Deinitialize();
   bool VaInitialize(const base::Closure& report_error_to_uma_cb);
   bool GetSupportedVaProfiles(std::vector<VAProfile>* profiles);
 
   // Check if |va_profile| supports |entrypoint| or not. |va_lock_| must be
   // held on entry.
   bool IsEntrypointSupported_Locked(VAProfile va_profile,
                                     VAEntrypoint entrypoint);
@@ skipping 88 matching lines @@
   // Singleton variable to store supported profile information for encode and
   // decode.
   static base::LazyInstance<LazyProfileInfos> profile_infos_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiWrapper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_WRAPPER_H_