VAAPI Wrapper: refactor management of drm file

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 116 matching lines @@
   bool ExecuteAndDestroyPendingBuffers(VASurfaceID va_surface_id);
 
 #if defined(USE_X11)
   // Put data from |va_surface_id| into |x_pixmap| of size
   // |dest_size|, converting/scaling to it.
   bool PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
                             Pixmap x_pixmap,
                             gfx::Size dest_size);
 #endif  // USE_X11
 
-  // 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 size and format
   // are derived from the surface. Use GetVaImage() instead if |format| or
   // |size| are different from surface internal representation. The VAImage
   // should be released using the ReturnVaImage function. Returns true when
   // successful.
   bool GetDerivedVaImage(VASurfaceID va_surface_id, VAImage* image, void** mem);
 
   // Get a VAImage from a VASurface |va_surface_id| and map it into memory with
   // given |format| and |size|. The output is |image| and the mapped memory is
   // |mem|. If |format| doesn't equal to the internal format, the underlying
@@ skipping 34 matching lines @@
   void DestroyCodedBuffers();
 
   // Blits a VASurface |va_surface_id_src| into another VASurface
   // |va_surface_id_dest| applying pixel format conversion and scaling
   // if needed.
   bool BlitSurface(VASurfaceID va_surface_id_src,
                    const gfx::Size& src_size,
                    VASurfaceID va_surface_id_dest,
                    const gfx::Size& dest_size);
 
+  // Initialize static data before sandbox is enabled.
+  static void PreSandboxInitialization();
+
  private:
   struct ProfileInfo {
     VAProfile va_profile;
     gfx::Size max_resolution;
   };
 
   class LazyProfileInfos {
    public:
     LazyProfileInfos();
     ~LazyProfileInfos();
     std::vector<ProfileInfo> GetSupportedProfileInfosForCodecMode(
         CodecMode mode);
     bool IsProfileSupported(CodecMode mode, VAProfile va_profile);
 
    private:
     std::vector<ProfileInfo> supported_profiles_[kCodecModeMax];
   };
 
+  class VADisplayState {
+   public:
+    VADisplayState();
+    ~VADisplayState();
+
+    // |va_lock_| must be held on entry.

[Pawel Osciak, 2015/05/11 05:51:45]

va_lock_ is not a member of this class and is per-VaapiWrapper instance, while
this can be global, so this would not work as expected, unless I'm missing
something?

Separately, I'm wondering if we'll be ok not having all VaapiWrapper instances
on one lock if we are sharing one fd and one vaInitialized libva instance?

Also, would it perhaps be possible to make this : public RefCounted instead of
manual refcounting?

[hshi1, 2015/05/11 17:14:39]

I have moved va_lock_ into VADisplayState, which will be a global singleton
instance for USE_OZONE. This has passed all unit tests and works on chrome.
Unfortunately I have thought about that but it wouldn't work because
base::RefCounted would delete the instance when refcount hits zero. The
VADisplayState would still need to be kept alive to hold the |drm_fd_|, yet it
needs to free the VADisplay.

+    bool Initialize(VAStatus* status);
+    void Deinitialize(VAStatus* status);
+
+    VADisplay GetVADisplay() const;
+
+#if defined(USE_OZONE)
+    void SetDrmFd(base::PlatformFile fd);
+#endif  // USE_OZONE
+
+   private:
+#if defined(USE_OZONE)
+    friend class base::LazyInstance<VADisplayState>;
+#endif  // USE_OZONE
+
+    // Returns true if the VAAPI version is less than the specified version.
+    bool VAAPIVersionLessThan(int major, int minor);
+
+    int refcount_;
+
+#if defined(USE_OZONE)
+    // Drm fd used to obtain access to the driver interface by VA.
+    base::ScopedFD drm_fd_;
+#endif  // USE_OZONE
+
+    // The VADisplay handle.
+    VADisplay va_display_;
+
+    // The VAAPI version.
+    int major_version_, minor_version_;
+
+    // True if vaInitialize has been called successfully.
+    bool va_initialized_;
+  };
+
   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,
@@ skipping 48 matching lines @@
                                       CodecMode mode);
 
   // 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_;
+#if defined(USE_X11)
+  // VADisplay and related state.
+  scoped_ptr<VADisplayState> va_display_state_;
+#elif defined(USE_OZONE)
+  // Singleton instance of VADisplayState.
+  static base::LazyInstance<VADisplayState> g_va_display_state_;
+#endif  // USE_X11
 
   // VA handles.
   // 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_;
-  // True if vaInitialize has been called successfully.
-  bool va_initialized_;
 
   // 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 (Video Post Processing) context, this is used to convert
   // pictures used by the decoder to RGBA pictures usable by GL or the
   // display hardware.
   VAConfigID va_vpp_config_id_;
   VAContextID va_vpp_context_id_;
   VABufferID va_vpp_buffer_id_;
 
-#if defined(USE_OZONE)
-  // Drm file used to obtain access to the driver interface by VA.
-  base::File drm_file_;
-#endif  // USE_OZONE
-
   // 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_