VaapiVEA: Get maximum resolution from libva

content/common/gpu/media/vaapi_wrapper.h

Index: content/common/gpu/media/vaapi_wrapper.h
diff --git a/content/common/gpu/media/vaapi_wrapper.h b/content/common/gpu/media/vaapi_wrapper.h
index d21f3f1ee5ec52ece294ce53594c01e4f7252846..7f948ef5f1897c527999bc897d04537864654117 100644
--- a/content/common/gpu/media/vaapi_wrapper.h
+++ b/content/common/gpu/media/vaapi_wrapper.h
@@ -13,12 +13,14 @@
 #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"
@@ -43,14 +45,15 @@ class CONTENT_EXPORT VaapiWrapper {
   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
@@ -63,8 +66,8 @@ class CONTENT_EXPORT VaapiWrapper {
       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();
 
@@ -183,17 +186,45 @@ class CONTENT_EXPORT VaapiWrapper {
                    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);
+
+  // Check |va_profile| support |entrypoint| or not. |va_lock_| must be held on

[wuchengli, 2015/03/05 16:24:21]

s/Check |va_profile| support/Check if |va_profile| supports/

[henryhsu, 2015/03/09 03:56:52]

Done.

+  // entry.
   bool IsEntrypointSupported(VAProfile va_profile, VAEntrypoint entrypoint);

[Pawel Osciak, 2015/03/08 00:58:24]

s/IsEntrypointSupported/IsEntrypointSupported_Locked/

[henryhsu, 2015/03/09 03:56:52]

Done.

+
+  // Check |va_profile| support |required_attribs| or not. |va_lock_| must be

[wuchengli, 2015/03/05 16:24:21]

Checks if |va_profile| / |entrypoint| pair supports

[henryhsu, 2015/03/09 03:56:52]

Done.

+  // held on entry.
   bool AreAttribsSupported(VAProfile va_profile,

[Pawel Osciak, 2015/03/08 00:58:24]

s/AreAttribsSupported/AreAttribsSupported_Locked/

[henryhsu, 2015/03/09 03:56:52]

Done.

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

[Pawel Osciak, 2015/03/08 00:58:24]

s/by |config|/for |va_config_id|/

[henryhsu, 2015/03/09 03:56:52]

Done.

+  // |resolution| is the maximum resolution. |va_lock_| must be held on entry.
+  bool GetMaxResolutionForVAConfigID(VAConfigID va_config_id,
+                                     gfx::Size* resolution);
+
   // Destroys a |va_surface| created using CreateUnownedSurface.
   void DestroyUnownedSurface(VASurfaceID va_surface_id);
 
@@ -212,10 +243,25 @@ class CONTENT_EXPORT VaapiWrapper {
   // 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.

[Pawel Osciak, 2015/03/08 00:58:24]

It looks like GetSupportedProfileInfosForCodecModeInternal() is never called
outside of GetSupportedProfileInfosForCodecMode(), so the body of Internal could
be put back into GetSupportedProfileInfosForCodecMode()?

[henryhsu, 2015/03/09 03:56:52]

I prefer not. Because GetSupportedProfileInfosForCodecMode is static function.
If we put the body of Internal to the function, all used functions should be
static function as well.

[wuchengli, 2015/03/09 04:59:17]

Can you move the body of GetSupportedProfileInfosForCodecMode to the contrustor
of LazyProfileInfos? Then GetSupportedProfileInfosForCodecModeInternal can be
renamed to GetSupportedProfileInfosForCodecMode.

+  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().
@@ -255,6 +301,10 @@ class CONTENT_EXPORT VaapiWrapper {
   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);
 };