vaapi: detect supported profiles in runtime.

content/common/gpu/media/vaapi_wrapper.cc

 // 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.
 
 #include "content/common/gpu/media/vaapi_wrapper.h"
 
 #include <dlfcn.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 39 matching lines @@
     {VAConfigAttribRTFormat, VA_RT_FORMAT_YUV420},
 };
 
 // Attributes required for encode.
 static const VAConfigAttrib kEncodeVAConfigAttribs[] = {
     {VAConfigAttribRateControl, VA_RC_CBR},
     {VAConfigAttribEncPackedHeaders,
      VA_ENC_PACKED_HEADER_SEQUENCE | VA_ENC_PACKED_HEADER_PICTURE},
 };
 
+static std::vector<VAConfigAttrib> GetRequiredAttribs(
+    VaapiWrapper::CodecMode mode) {
+  std::vector<VAConfigAttrib> required_attribs;
+  required_attribs.insert(
+      required_attribs.end(),
+      kCommonVAConfigAttribs,
+      kCommonVAConfigAttribs + arraysize(kCommonVAConfigAttribs));
+  if (mode == VaapiWrapper::kEncode) {
+    required_attribs.insert(
+        required_attribs.end(),
+        kEncodeVAConfigAttribs,
+        kEncodeVAConfigAttribs + arraysize(kEncodeVAConfigAttribs));
+  }
+  return required_attribs;
+}
+
 // Maps Profile enum values to VaProfile values.
 static VAProfile ProfileToVAProfile(
     media::VideoCodecProfile profile,
     const std::vector<VAProfile>& supported_profiles) {
 
   VAProfile va_profile = VAProfileNone;
 
   switch (profile) {
     case media::H264PROFILE_BASELINE:
       va_profile = VAProfileH264Baseline;
@@ skipping 62 matching lines @@
     const base::Closure& report_error_to_uma_cb) {
   scoped_ptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
 
   if (!vaapi_wrapper->Initialize(
           mode, profile, x_display, report_error_to_uma_cb))
     vaapi_wrapper.reset();
 
   return vaapi_wrapper.Pass();
 }
 
+std::vector<media::VideoCodecProfile> VaapiWrapper::GetSupportedProfiles(
+    Display* x_display,
+    const base::Closure& report_error_to_uma_cb) {
+  std::vector<media::VideoCodecProfile> supported_profiles;
+  media::VideoCodecProfile profiles[3] = {media::H264PROFILE_BASELINE,

[Pawel Osciak, 2014/09/26 07:15:12]

Ideally we'd like to use all va_profiles and use something like
VAProfileToVideoCodecProfile, but the baseline thing is making it difficult.
But I'd like to eliminate this hardcoded list from here at least, we have it in
ProfileToVaProfile already. How about we iterate over all VideoCodecProfile
instead? It'd be a bit inefficient to do this for 20 profiles instead of 3, but
maybe worth it in order to contain this list to ProfileToVaProfile only?

[wuchengli, 2014/09/26 09:02:28]

GetSupportedProfiles is called when GPU process starts, so it has to be as fast
as possible. I combined the hardcoded list here and in ProfileToVaProfile.

+                                          media::H264PROFILE_MAIN,
+                                          media::H264PROFILE_HIGH};
+
+  scoped_ptr<VaapiWrapper> wrapper(new VaapiWrapper());
+  std::vector<VAProfile> va_profiles;
+  if (!wrapper->VaInitialize(x_display, report_error_to_uma_cb)) {
+    return supported_profiles;
+  }
+  if (!wrapper->GetSupportedVaProfiles(&va_profiles))
+    return supported_profiles;
+  std::vector<VAConfigAttrib> required_attribs = GetRequiredAttribs(kEncode);
+  for (size_t i = 0; i < arraysize(profiles); i++) {
+    VAProfile va_profile = ProfileToVAProfile(profiles[i], va_profiles);

[Pawel Osciak, 2014/09/26 07:15:12]

We have this chunk of code duplicated here and in Initialize. Can we wrap this
in something like

bool IsProfileSupported(VideoCodecProfile, CodecMode) ?

[wuchengli, 2014/09/26 09:02:28]

Done.

vaCreateConfig needs VA profile, entrypoint, and required attribs. So I changed
the prototype. Also, it's more efficient not to call vaQueryConfigProfiles
multiple times because GetSupportedProfiles is called when GPU process starts.

+    if (va_profile != VAProfileNone &&
+        wrapper->IsEntrypointSupported(va_profile, VAEntrypointEncSlice) &&
+        wrapper->IsAttribSupported(
+            va_profile, VAEntrypointEncSlice, required_attribs)) {
+      supported_profiles.push_back(profiles[i]);
+    }
+  }
+  return supported_profiles;
+}
+
 void VaapiWrapper::TryToSetVADisplayAttributeToLocalGPU() {
   VADisplayAttribute item = {VADisplayAttribRenderMode,
                              1,  // At least support '_LOCAL_OVERLAY'.
                              -1,  // The maximum possible support 'ALL'.
                              VA_RENDER_MODE_LOCAL_GPU,
                              VA_DISPLAY_ATTRIB_SETTABLE};
 
   VAStatus va_res = vaSetDisplayAttributes(va_display_, &item, 1);
   if (va_res != VA_STATUS_SUCCESS)
     DVLOG(2) << "vaSetDisplayAttributes unsupported, ignoring by default.";
 }
 
-bool VaapiWrapper::Initialize(CodecMode mode,
-                              media::VideoCodecProfile profile,
-                              Display* x_display,
-                              const base::Closure& report_error_to_uma_cb) {
+bool VaapiWrapper::VaInitialize(Display* x_display,
+                                const base::Closure& report_error_to_uma_cb) {
   static bool vaapi_functions_initialized = PostSandboxInitialization();
   if (!vaapi_functions_initialized) {
     DVLOG(1) << "Failed to initialize VAAPI libs";
     return false;
   }
 
   report_error_to_uma_cb_ = report_error_to_uma_cb;
 
   base::AutoLock auto_lock(va_lock_);
 
   va_display_ = vaGetDisplay(x_display);
   if (!vaDisplayIsValid(va_display_)) {
     DVLOG(1) << "Could not get a valid VA display";
     return false;
   }
 
   VAStatus va_res = vaInitialize(va_display_, &major_version_, &minor_version_);
   VA_SUCCESS_OR_RETURN(va_res, "vaInitialize failed", false);
   DVLOG(1) << "VAAPI version: " << major_version_ << "." << minor_version_;
 
   if (VAAPIVersionLessThan(0, 34)) {
     DVLOG(1) << "VAAPI version < 0.34 is not supported.";
     return false;
   }
+  return true;
+}
 
+bool VaapiWrapper::GetSupportedVaProfiles(std::vector<VAProfile>* profiles) {
+  base::AutoLock auto_lock(va_lock_);
   // Query the driver for supported profiles.
   int max_profiles = vaMaxNumProfiles(va_display_);
   std::vector<VAProfile> supported_profiles(
       base::checked_cast<size_t>(max_profiles));
 
   int num_supported_profiles;
-  va_res = vaQueryConfigProfiles(
+  VAStatus va_res = vaQueryConfigProfiles(
       va_display_, &supported_profiles[0], &num_supported_profiles);
   VA_SUCCESS_OR_RETURN(va_res, "vaQueryConfigProfiles failed", false);
   if (num_supported_profiles < 0 || num_supported_profiles > max_profiles) {
     DVLOG(1) << "vaQueryConfigProfiles returned: " << num_supported_profiles;
     return false;
   }
 
   supported_profiles.resize(base::checked_cast<size_t>(num_supported_profiles));
+  *profiles = supported_profiles;
+  return true;
+}
 
-  VAProfile va_profile = ProfileToVAProfile(profile, supported_profiles);
-  if (va_profile == VAProfileNone) {
-    DVLOG(1) << "Unsupported profile";
-    return false;
-  }
-
+bool VaapiWrapper::IsEntrypointSupported(VAProfile va_profile,
+                                         VAEntrypoint entrypoint) {
+  base::AutoLock auto_lock(va_lock_);
   // Query the driver for supported entrypoints.
   int max_entrypoints = vaMaxNumEntrypoints(va_display_);
   std::vector<VAEntrypoint> supported_entrypoints(
       base::checked_cast<size_t>(max_entrypoints));
 
   int num_supported_entrypoints;
-  va_res = vaQueryConfigEntrypoints(va_display_,
-                                    va_profile,
-                                    &supported_entrypoints[0],
-                                    &num_supported_entrypoints);
+  VAStatus va_res = vaQueryConfigEntrypoints(va_display_,
+                                             va_profile,
+                                             &supported_entrypoints[0],
+                                             &num_supported_entrypoints);
   VA_SUCCESS_OR_RETURN(va_res, "vaQueryConfigEntrypoints failed", false);
   if (num_supported_entrypoints < 0 ||
       num_supported_entrypoints > max_entrypoints) {
     DVLOG(1) << "vaQueryConfigEntrypoints returned: "
              << num_supported_entrypoints;
     return false;
   }
 
-  VAEntrypoint entrypoint =
-      (mode == kEncode ? VAEntrypointEncSlice : VAEntrypointVLD);
-
   if (std::find(supported_entrypoints.begin(),
                 supported_entrypoints.end(),
                 entrypoint) == supported_entrypoints.end()) {
     DVLOG(1) << "Unsupported entrypoint";
     return false;
   }
+  return true;
+}
 
+bool VaapiWrapper::IsAttribSupported(
+    VAProfile va_profile,
+    VAEntrypoint entrypoint,
+    const std::vector<VAConfigAttrib>& required_attribs) {
+  base::AutoLock auto_lock(va_lock_);
   // Query the driver for required attributes.
-  std::vector<VAConfigAttrib> required_attribs;
-  required_attribs.insert(
-      required_attribs.end(),
-      kCommonVAConfigAttribs,
-      kCommonVAConfigAttribs + arraysize(kCommonVAConfigAttribs));
-  if (mode == kEncode) {
-    required_attribs.insert(
-        required_attribs.end(),
-        kEncodeVAConfigAttribs,
-        kEncodeVAConfigAttribs + arraysize(kEncodeVAConfigAttribs));
-  }
-
   std::vector<VAConfigAttrib> attribs = required_attribs;
   for (size_t i = 0; i < required_attribs.size(); ++i)
     attribs[i].value = 0;
 
-  va_res = vaGetConfigAttributes(
+  VAStatus va_res = vaGetConfigAttributes(
       va_display_, va_profile, entrypoint, &attribs[0], attribs.size());
   VA_SUCCESS_OR_RETURN(va_res, "vaGetConfigAttributes failed", false);
 
   for (size_t i = 0; i < required_attribs.size(); ++i) {
     if (attribs[i].type != required_attribs[i].type ||
         (attribs[i].value & required_attribs[i].value) !=
             required_attribs[i].value) {
       DVLOG(1) << "Unsupported value " << required_attribs[i].value
                << " for attribute type " << required_attribs[i].type;
       return false;
     }
   }
+  return true;
+}
+
+bool VaapiWrapper::Initialize(CodecMode mode,
+                              media::VideoCodecProfile profile,
+                              Display* x_display,
+                              const base::Closure& report_error_to_uma_cb) {
+  if (!VaInitialize(x_display, report_error_to_uma_cb))
+    return false;
+  std::vector<VAProfile> supported_profiles;
+  if (!GetSupportedVaProfiles(&supported_profiles))
+    return false;
+  VAProfile va_profile = ProfileToVAProfile(profile, supported_profiles);
+  if (va_profile == VAProfileNone) {
+    DVLOG(1) << "Unsupported profile";
+    return false;
+  }
+  VAEntrypoint entrypoint =
+      (mode == kEncode ? VAEntrypointEncSlice : VAEntrypointVLD);
+  if (!IsEntrypointSupported(va_profile, entrypoint))
+    return false;
+  std::vector<VAConfigAttrib> required_attribs = GetRequiredAttribs(mode);
+  if (!IsAttribSupported(va_profile, entrypoint, required_attribs))
+    return false;
 
   TryToSetVADisplayAttributeToLocalGPU();
 
-  va_res = vaCreateConfig(va_display_,
-                          va_profile,
-                          entrypoint,
-                          &required_attribs[0],
-                          required_attribs.size(),
-                          &va_config_id_);
+  VAStatus va_res = vaCreateConfig(va_display_,

[kcwu, 2014/09/26 07:50:45]

va_lock_ for this?

[wuchengli, 2014/09/26 09:02:28]

Done. Thanks for catching this.

+                                   va_profile,
+                                   entrypoint,
+                                   &required_attribs[0],
+                                   required_attribs.size(),
+                                   &va_config_id_);
   VA_SUCCESS_OR_RETURN(va_res, "vaCreateConfig failed", false);
 
   return true;
 }
 
 void VaapiWrapper::Deinitialize() {
   base::AutoLock auto_lock(va_lock_);
 
   if (va_config_id_ != VA_INVALID_ID) {
     VAStatus va_res = vaDestroyConfig(va_display_, va_config_id_);
@@ skipping 385 matching lines @@
 
 // static
 bool VaapiWrapper::PostSandboxInitialization() {
   StubPathMap paths;
   paths[kModuleVa].push_back(kVaLib);
 
   return InitializeStubs(paths);
 }
 
 }  // namespace content