VaapiVEA: Get maximum resolution from libva

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/lazy_instance.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 "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 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 {
  public:
   enum CodecMode {
     kDecode,
     kEncode,
+    kCodecModeMax,
   };
 
-  // Create VaapiWrapper for VAProfile.
-  // |report_error_to_uma_cb| will be called independently from reporting
-  // errors to clients via method return values.
+  // 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(
       CodecMode mode,
-      VAProfile profile,
+      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(
       CodecMode mode,
       media::VideoCodecProfile profile,
       const base::Closure& report_error_to_uma_cb);
 
   // Return the supported encode profiles.
-  static std::vector<media::VideoCodecProfile> GetSupportedEncodeProfiles(
-      const base::Closure& report_error_to_uma_cb);
+  static std::vector<media::VideoEncodeAccelerator::SupportedProfile>
+      GetSupportedEncodeProfiles();
 
   ~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.
@@ skipping 98 matching lines @@
 
   // 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);
 
  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];
+  };
+
   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);
   bool IsEntrypointSupported(VAProfile va_profile, VAEntrypoint entrypoint);

[wuchengli, 2015/03/05 03:40:28]

Add a comment to say |va_lock_| must be held on entry.

http://www.chromium.org/developers/lock-and-condition-variable
Each routine should have a comment indicating which mutexes must and must not be
held on entry. This allows implementors to edit routines without examining their
call sites, and allows clients to use routines without reading their bodies.

[henryhsu, 2015/03/05 09:14:40]

Done.

   bool AreAttribsSupported(VAProfile va_profile,

[wuchengli, 2015/03/05 03:40:29]

Add a comment to say |va_lock_| must be held on entry.

[henryhsu, 2015/03/05 09:14:40]

Done.

                            VAEntrypoint entrypoint,
                            const std::vector<VAConfigAttrib>& required_attribs);
 
+  // Get maximum resolution of a profile by |config|. If return value is true,
+  // |resolution| is the maximum resolution.

[wuchengli, 2015/03/05 03:40:28]

Add a comment to say |va_lock_| must be held on entry.

[henryhsu, 2015/03/05 09:14:40]

Done.

+  bool GetMaxResolutionForVAConfigID(VAConfigID va_config_id,
+                                     gfx::Size* resolution);
+
   // Destroys a |va_surface| created using CreateUnownedSurface.
   void DestroyUnownedSurface(VASurfaceID va_surface_id);
 
   // Initialize the video post processing context with the |size| of
   // the input pictures to be processed.
   bool InitializeVpp_Locked();
 
   // Deinitialize the video post processing context.
   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();
 
+  // Get supported profile infos for |mode|.
+  std::vector<ProfileInfo> GetSupportedProfileInfosForCodecModeInternal(
+      CodecMode mode);
+
   // Lazily initialize static data after sandbox is enabled.  Return false on
   // init failure.
   static bool PostSandboxInitialization();
 
+  // Get supported profile infos for |mode|. This is a wrapper of
+  // GetSupportedProfileInfosForCodecModeInternal for static usage.
+  static std::vector<ProfileInfo> GetSupportedProfileInfosForCodecMode(
+      CodecMode mode);
+
+  // 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_;
 
   // Allocated ids for VASurfaces.
   std::vector<VASurfaceID> va_surface_ids_;
 
   // The VAAPI version.
   int major_version_, minor_version_;
@@ skipping 19 matching lines @@
   // 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_;
 
+  // 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_