[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
 
+namespace ui {
+class NativePixmap;
+}
+
 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();

[kalyank, 2015/11/23 17:51:07]

This is refcounted, destructor should be made private/protected

[william.xie1, 2015/11/24 06:19:39]

Done.

 
   // 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);
 
+  // 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);
+
   // 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 72 matching lines @@
   // if needed.
   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_; }
 
+  // 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,
+                                                     gfx::BufferFormat format);
+
  private:
   struct ProfileInfo {
     VAProfile va_profile;
     gfx::Size max_resolution;
   };
 
   class LazyProfileInfos {
    public:
     LazyProfileInfos();
     ~LazyProfileInfos();
@@ skipping 152 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_