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.
+    bool Initialize(VAStatus* status);
+    void Deinitialize(VAStatus* status);
+
+    base::Lock* va_lock() { return &va_lock_; }
+    VADisplay GetVADisplay() const { return va_display_; }
+
+#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_;
+
+    // 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_;
+
+#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 40 matching lines @@
   // Lazily initialize static data after sandbox is enabled.  Return false on
   // init failure.
   static bool PostSandboxInitialization();
 
   // Map VideoCodecProfile enum values to VaProfile values. This function
   // includes a workaround for crbug.com/345569. If va_profile is h264 baseline
   // and it is not supported, we try constrained baseline.
   static VAProfile ProfileToVAProfile(media::VideoCodecProfile profile,
                                       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_;
+  // Pointer to VADisplayState's member |va_lock_|. Guaranteed to be valid for
+  // the lifetime of VaapiWrapper.
+  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_;

[piman, 2015/05/11 21:54:07]

Why does it have to be different between X11 and OZONE? Can't we have a
singleton VADisplayState on X11? The Display* would play the role of the drm fd.

[hshi1, 2015/05/11 22:26:40]

Done.

+#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_