VaapiVEA: Get maximum resolution from libva

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"
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/sys_info.h"
 // Auto-generated for dlopen libva libraries
 #include "content/common/gpu/media/va_stubs.h"
 #include "content/common/gpu/media/vaapi_picture.h"
+#include "content/public/common/content_switches.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "ui/gl/gl_bindings.h"
 #if defined(USE_X11)
 #include "ui/gfx/x/x11_types.h"
 #elif defined(USE_OZONE)
 #include "third_party/libva/va/drm/va_drm.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #endif  // USE_X11
 
@@ skipping 22 matching lines @@
 #define VA_SUCCESS_OR_RETURN(va_error, err_msg, ret)       \
   do {                                                     \
     if ((va_error) != VA_STATUS_SUCCESS) {                 \
       LOG_VA_ERROR_AND_REPORT(va_error, err_msg);          \
       return (ret);                                        \
     }                                                      \
   } while (0)
 
 namespace content {
 
+// Maximum framerate of encoded profile. This value is an arbitary limit
+// and not taken from HW documentation.
+const int kMaxEncoderFramerate = 30;
+
+base::LazyInstance<VaapiWrapper::LazyProfileInfos>
+    VaapiWrapper::profile_infos_ = LAZY_INSTANCE_INITIALIZER;
+
 // Config attributes common for both encode and decode.
 static const VAConfigAttrib kCommonVAConfigAttribs[] = {
     {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},
@@ skipping 22 matching lines @@
       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;
-  for (size_t i = 0; i < arraysize(kProfileMap); i++) {
-    if (kProfileMap[i].profile == profile) {
-      va_profile = kProfileMap[i].va_profile;
-      break;
-    }
-  }
-
-  bool supported = std::find(supported_profiles.begin(),
-                             supported_profiles.end(),
-                             va_profile) != supported_profiles.end();
-
-  if (!supported && va_profile == VAProfileH264Baseline) {
-    // crbug.com/345569: media::ProfileIDToVideoCodecProfile() currently strips
-    // the information whether the profile is constrained or not, so we have no
-    // way to know here. Try for baseline first, but if it is not supported,
-    // try constrained baseline and hope this is what it actually is
-    // (which in practice is true for a great majority of cases).
-    if (std::find(supported_profiles.begin(),
-                  supported_profiles.end(),
-                  VAProfileH264ConstrainedBaseline) !=
-        supported_profiles.end()) {
-      va_profile = VAProfileH264ConstrainedBaseline;
-      DVLOG(1) << "Falling back to constrained baseline profile.";
-    }
-  }
-
-  return va_profile;
-}
-
 VASurface::VASurface(VASurfaceID va_surface_id,
                      const gfx::Size& size,
                      const ReleaseCB& release_cb)
     : va_surface_id_(va_surface_id), size_(size), release_cb_(release_cb) {
   DCHECK(!release_cb_.is_null());
 }
 
 VASurface::~VASurface() {
   release_cb_.Run(va_surface_id_);
 }
 
 VaapiWrapper::VaapiWrapper()
     : va_display_(NULL),
       va_config_id_(VA_INVALID_ID),
       va_context_id_(VA_INVALID_ID),
       va_initialized_(false),
       va_vpp_config_id_(VA_INVALID_ID),
       va_vpp_context_id_(VA_INVALID_ID),
       va_vpp_buffer_id_(VA_INVALID_ID) {
 }
 
 VaapiWrapper::~VaapiWrapper() {
   DestroyPendingBuffers();
   DestroyCodedBuffers();
   DestroySurfaces();
   DeinitializeVpp();
   Deinitialize();
 }
 
+// static
 scoped_ptr<VaapiWrapper> VaapiWrapper::Create(
     CodecMode mode,
     VAProfile va_profile,
     const base::Closure& report_error_to_uma_cb) {
   scoped_ptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
 
   if (!vaapi_wrapper->VaInitialize(report_error_to_uma_cb))
     return nullptr;
-  if (!vaapi_wrapper->Initialize(mode, va_profile))
+
+  if (!vaapi_wrapper->Initialize(mode, va_profile)) {
+    DVLOG(1) << "Unsupported va profile: " << va_profile;

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

Initialize() may fail for other reasons too. Perhaps move this log and one at
l.168 to Initialize() itself?

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

Done.

     return nullptr;
+  }
 
   return vaapi_wrapper.Pass();
 }
 
+// static
 scoped_ptr<VaapiWrapper> VaapiWrapper::CreateForVideoCodec(
     CodecMode mode,
     media::VideoCodecProfile profile,
     const base::Closure& report_error_to_uma_cb) {
   scoped_ptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
 
   if (!vaapi_wrapper->VaInitialize(report_error_to_uma_cb))
     return nullptr;
 
-  std::vector<VAProfile> supported_va_profiles;
-  if (!vaapi_wrapper->GetSupportedVaProfiles(&supported_va_profiles))
+  VAProfile va_profile = ProfileToVAProfile(profile, mode);
+  if (!vaapi_wrapper->Initialize(mode, va_profile)) {
+    DVLOG(1) << "Initialize failed. Profile: " << profile;
     return nullptr;
-
-  VAProfile va_profile = ProfileToVAProfile(profile, supported_va_profiles);
-  if (!vaapi_wrapper->Initialize(mode, va_profile))
-    return nullptr;
-
+  }
   return vaapi_wrapper.Pass();
 }
 
-std::vector<media::VideoCodecProfile> VaapiWrapper::GetSupportedEncodeProfiles(
-    const base::Closure& report_error_to_uma_cb) {
-  std::vector<media::VideoCodecProfile> supported_profiles;
+// static
+std::vector<media::VideoEncodeAccelerator::SupportedProfile>
+VaapiWrapper::GetSupportedEncodeProfiles() {
+  std::vector<media::VideoEncodeAccelerator::SupportedProfile> profiles;
+  const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+  if (cmd_line->HasSwitch(switches::kDisableVaapiAcceleratedVideoEncode))
+    return profiles;
 
-  scoped_ptr<VaapiWrapper> wrapper(new VaapiWrapper());
-  if (!wrapper->VaInitialize(report_error_to_uma_cb)) {
-    return supported_profiles;
-  }
+  std::vector<ProfileInfo> encode_profile_infos =
+      profile_infos_.Get().GetSupportedProfileInfosForCodecMode(kEncode);
 
-  std::vector<VAProfile> va_profiles;
-  if (!wrapper->GetSupportedVaProfiles(&va_profiles))
-    return supported_profiles;
-
-  std::vector<VAConfigAttrib> required_attribs = GetRequiredAttribs(kEncode);
-  for (size_t i = 0; i < arraysize(kProfileMap); i++) {
-    VAProfile va_profile =
-        ProfileToVAProfile(kProfileMap[i].profile, va_profiles);
-    if (va_profile != VAProfileNone &&
-        wrapper->IsEntrypointSupported(va_profile, VAEntrypointEncSlice) &&
-        wrapper->AreAttribsSupported(
-            va_profile, VAEntrypointEncSlice, required_attribs)) {
-      supported_profiles.push_back(kProfileMap[i].profile);
+  for (size_t i = 0; i < arraysize(kProfileMap); ++i) {
+    VAProfile va_profile = ProfileToVAProfile(kProfileMap[i].profile, kEncode);
+    if (va_profile == VAProfileNone)
+      continue;
+    for (const auto& profile_info : encode_profile_infos) {
+      if (profile_info.va_profile == va_profile) {
+        media::VideoEncodeAccelerator::SupportedProfile profile;
+        profile.profile = kProfileMap[i].profile;
+        profile.max_resolution = profile_info.max_resolution;
+        profile.max_framerate_numerator = kMaxEncoderFramerate;
+        profile.max_framerate_denominator = 1;
+        profiles.push_back(profile);
+      }

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

Could we break here?

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

Done.

     }
   }
-  return supported_profiles;
+  return profiles;
+}
+
+// static
+std::vector<VaapiWrapper::ProfileInfo>
+VaapiWrapper::GetSupportedProfileInfosForCodecMode(CodecMode mode) {
+  scoped_ptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
+  if (!vaapi_wrapper->VaInitialize(base::Bind(&base::DoNothing)))
+    return std::vector<ProfileInfo>();
+  return vaapi_wrapper->GetSupportedProfileInfosForCodecModeInternal(mode);
 }
 
 void VaapiWrapper::TryToSetVADisplayAttributeToLocalGPU() {
   base::AutoLock auto_lock(va_lock_);
   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.";
 }
 
+// static
+VAProfile VaapiWrapper::ProfileToVAProfile(
+    media::VideoCodecProfile profile, CodecMode mode) {
+  VAProfile va_profile = VAProfileNone;
+  for (size_t i = 0; i < arraysize(kProfileMap); ++i) {
+    if (kProfileMap[i].profile == profile) {
+      va_profile = kProfileMap[i].va_profile;
+      break;
+    }
+  }
+  if (!profile_infos_.Get().IsProfileSupported(mode, va_profile) &&
+      va_profile == VAProfileH264Baseline) {
+    // crbug.com/345569: media::ProfileIDToVideoCodecProfile() currently strips
+    // the information whether the profile is constrained or not, so we have no
+    // way to know here. Try for baseline first, but if it is not supported,
+    // try constrained baseline and hope this is what it actually is
+    // (which in practice is true for a great majority of cases).
+    if (profile_infos_.Get().IsProfileSupported(
+          mode, VAProfileH264ConstrainedBaseline)) {
+      va_profile = VAProfileH264ConstrainedBaseline;
+      DVLOG(1) << "Fall back to constrained baseline profile.";
+    }
+  }
+  return va_profile;
+}
+
+std::vector<VaapiWrapper::ProfileInfo>
+VaapiWrapper::GetSupportedProfileInfosForCodecModeInternal(CodecMode mode) {
+  std::vector<ProfileInfo> supported_profile_infos;
+  std::vector<VAProfile> va_profiles;
+  if (!GetSupportedVaProfiles(&va_profiles))
+    return supported_profile_infos;
+
+  std::vector<VAConfigAttrib> required_attribs = GetRequiredAttribs(mode);
+  VAEntrypoint entrypoint =
+      (mode == kEncode ? VAEntrypointEncSlice: VAEntrypointVLD);
+
+  base::AutoLock auto_lock(va_lock_);
+  for (const auto& va_profile : va_profiles) {
+    if (!IsEntrypointSupported(va_profile, entrypoint))
+      continue;
+    if (!AreAttribsSupported(va_profile, entrypoint, required_attribs))
+      continue;
+    VAConfigID config_id;
+    VAStatus va_res = vaCreateConfig(
+        va_display_,
+        va_profile,
+        entrypoint,
+        &required_attribs[0],
+        required_attribs.size(),
+        &config_id);
+    if (va_res != VA_STATUS_SUCCESS) {
+      LOG_VA_ERROR_AND_REPORT(va_res, "vaCreateConfig failed");
+      continue;
+    }
+    ProfileInfo profile_info;
+    if (!GetMaxResolutionForVAConfigID(config_id, &profile_info.max_resolution))

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

I think we should LOG(ERROR) here, failure here may make us silently ignore some
profiles, which we would've supported otherwise. This may be important if more
profiles are added, but we don't add their resolutions to libva.

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

Done.

+      continue;
+    profile_info.va_profile = va_profile;
+    supported_profile_infos.push_back(profile_info);
+  }
+  return supported_profile_infos;
+}
+
 bool VaapiWrapper::VaInitialize(const base::Closure& report_error_to_uma_cb) {
   static bool vaapi_functions_initialized = PostSandboxInitialization();
   if (!vaapi_functions_initialized) {
     bool running_on_chromeos = false;
 #if defined(OS_CHROMEOS)
     // When chrome runs on linux with chromeos=1, do not log error message
     // without VAAPI libraries.
     running_on_chromeos = base::SysInfo::IsRunningOnChromeOS();
 #endif
     static const char kErrorMsg[] = "Failed to initialize VAAPI libs";
@@ skipping 50 matching lines @@
     return false;
   }
 
   supported_profiles.resize(base::checked_cast<size_t>(num_supported_profiles));
   *profiles = supported_profiles;
   return true;
 }
 
 bool VaapiWrapper::IsEntrypointSupported(VAProfile va_profile,
                                          VAEntrypoint entrypoint) {
-  base::AutoLock auto_lock(va_lock_);
+  va_lock_.AssertAcquired();
   // 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;
   VAStatus va_res = vaQueryConfigEntrypoints(va_display_,
                                              va_profile,
                                              &supported_entrypoints[0],
                                              &num_supported_entrypoints);
@@ skipping 11 matching lines @@
     DVLOG(1) << "Unsupported entrypoint";
     return false;
   }
   return true;
 }
 
 bool VaapiWrapper::AreAttribsSupported(
     VAProfile va_profile,
     VAEntrypoint entrypoint,
     const std::vector<VAConfigAttrib>& required_attribs) {
-  base::AutoLock auto_lock(va_lock_);
+  va_lock_.AssertAcquired();
   // Query the driver for required attributes.
   std::vector<VAConfigAttrib> attribs = required_attribs;
   for (size_t i = 0; i < required_attribs.size(); ++i)
     attribs[i].value = 0;
 
   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::GetMaxResolutionForVAConfigID(VAConfigID va_config_id,
+                                                 gfx::Size* resolution) {
+  va_lock_.AssertAcquired();
+  unsigned int num_attribs;
+
+  // Calls vaQuerySurfaceAttributes twice. The first time is to get the number
+  // of attributes to prepare the space and the second time is to get all
+  // attributes.
+  VAStatus va_res;
+  va_res = vaQuerySurfaceAttributes(
+      va_display_, va_config_id, NULL, &num_attribs);

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

s/NULL/nullptr/

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

Done.

+  VA_SUCCESS_OR_RETURN(va_res, "vaQuerySurfaceAttributes failed", false);
+  if (!num_attribs)
+    return false;
+
+  std::vector<VASurfaceAttrib> attrib_list(
+      base::checked_cast<size_t>(num_attribs));
+
+  va_res = vaQuerySurfaceAttributes(
+      va_display_, va_config_id, &attrib_list[0], &num_attribs);
+  VA_SUCCESS_OR_RETURN(va_res, "vaQuerySurfaceAttributes failed", false);
+
+  resolution->SetSize(0, 0);
+  for (size_t i = 0; i < num_attribs; i++) {

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

for (const auto& attrib : attrib_list)

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

Done.

+    if (attrib_list[i].type == VASurfaceAttribMaxWidth)
+      resolution->set_width(attrib_list[i].value.value.i);
+    else if (attrib_list[i].type == VASurfaceAttribMaxHeight)
+      resolution->set_height(attrib_list[i].value.value.i);
+  }
+  if (resolution->IsEmpty()) {
+    LOG(ERROR) << "Codec resolution " << resolution->ToString()
+               << " cannot be zero.";
+    return false;
+  }
+  return true;
+}
+
 bool VaapiWrapper::Initialize(CodecMode mode, VAProfile va_profile) {
-  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 (!AreAttribsSupported(va_profile, entrypoint, required_attribs))
+  if (!profile_infos_.Get().IsProfileSupported(mode, va_profile))
     return false;
 
   TryToSetVADisplayAttributeToLocalGPU();
 
+  VAEntrypoint entrypoint =
+    (mode == kEncode ? VAEntrypointEncSlice : VAEntrypointVLD);
+  std::vector<VAConfigAttrib> required_attribs = GetRequiredAttribs(mode);
   base::AutoLock auto_lock(va_lock_);
   VAStatus va_res = vaCreateConfig(va_display_,
                                    va_profile,
                                    entrypoint,
                                    &required_attribs[0],
                                    required_attribs.size(),
                                    &va_config_id_);
   VA_SUCCESS_OR_RETURN(va_res, "vaCreateConfig failed", false);
 
   return true;
@@ skipping 178 matching lines @@
   va_res = vaUnmapBuffer(va_display_, buffer_id);
   VA_LOG_ON_ERROR(va_res, "vaUnmapBuffer failed");
 
   pending_va_bufs_.push_back(buffer_id);
   return true;
 }
 
 void VaapiWrapper::DestroyPendingBuffers() {
   base::AutoLock auto_lock(va_lock_);
 
-  for (size_t i = 0; i < pending_va_bufs_.size(); ++i) {
-    VAStatus va_res = vaDestroyBuffer(va_display_, pending_va_bufs_[i]);
+  for (const auto& pending_va_buf : pending_va_bufs_) {
+    VAStatus va_res = vaDestroyBuffer(va_display_, pending_va_buf);
     VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
   }
 
-  for (size_t i = 0; i < pending_slice_bufs_.size(); ++i) {
-    VAStatus va_res = vaDestroyBuffer(va_display_, pending_slice_bufs_[i]);
+  for (const auto& pending_slice_buf : pending_slice_bufs_) {
+    VAStatus va_res = vaDestroyBuffer(va_display_, pending_slice_buf);
     VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
   }
 
   pending_va_bufs_.clear();
   pending_slice_bufs_.clear();
 }
 
 bool VaapiWrapper::CreateCodedBuffer(size_t size, VABufferID* buffer_id) {
   base::AutoLock auto_lock(va_lock_);
   VAStatus va_res = vaCreateBuffer(va_display_,
@@ skipping 359 matching lines @@
 
 #if defined(USE_X11)
   paths[kModuleVa_x11].push_back("libva-x11.so.1");
 #elif defined(USE_OZONE)
   paths[kModuleVa_drm].push_back("libva-drm.so.1");
 #endif
 
   return InitializeStubs(paths);
 }
 
+VaapiWrapper::LazyProfileInfos::LazyProfileInfos() {
+  for (size_t i = 0; i < kCodecModeMax; ++i) {

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

Ok, but let's at least do static_assert(arraysize(supported_profiles_),
kCodecModeMax)

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

Done.

+    supported_profiles_[i] =
+        VaapiWrapper::GetSupportedProfileInfosForCodecMode(
+            static_cast<CodecMode>(i));
+  }
+}
+
+VaapiWrapper::LazyProfileInfos::~LazyProfileInfos() {
+}
+
+std::vector<VaapiWrapper::ProfileInfo>
+VaapiWrapper::LazyProfileInfos::GetSupportedProfileInfosForCodecMode(
+    CodecMode mode) {
+  return supported_profiles_[mode];
+}
+
+bool VaapiWrapper::LazyProfileInfos::IsProfileSupported(
+    CodecMode mode, VAProfile va_profile) {
+  for (const auto& profile : supported_profiles_[mode]) {
+    if (profile.va_profile == va_profile)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace content