Add JPEG decoder for VAAPI JPEG decode acceleration

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 81 matching lines @@
   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) {
-
+static VAProfile ProfileToVAProfile(media::VideoCodecProfile profile) {
   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;
     }
   }
+  return va_profile;
+}
 
+// 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).
+static VAProfile FallbackVaProfileIfNecessary(
+    VAProfile va_profile,
+    const std::vector<VAProfile>& supported_profiles) {
   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;
@@ skipping 23 matching lines @@
 VaapiWrapper::~VaapiWrapper() {
   DestroyPendingBuffers();
   DestroyCodedBuffers();
   DestroySurfaces();
   DeinitializeVpp();
   Deinitialize();
 }
 
 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->Initialize(mode, va_profile, false,
+                                 report_error_to_uma_cb))
+    return nullptr;
+
+  return vaapi_wrapper.Pass();
+}
+
+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->Initialize(mode, profile, report_error_to_uma_cb))
-    vaapi_wrapper.reset();
+  VAProfile va_profile = ProfileToVAProfile(profile);
+  if (!vaapi_wrapper->Initialize(mode, va_profile, true,
+                                 report_error_to_uma_cb))
+    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;
 
   scoped_ptr<VaapiWrapper> wrapper(new VaapiWrapper());
   if (!wrapper->VaInitialize(report_error_to_uma_cb)) {
     return supported_profiles;
   }
 
   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);
+    VAProfile va_profile = ProfileToVAProfile(kProfileMap[i].profile);
+    va_profile = FallbackVaProfileIfNecessary(va_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);
     }
   }
   return supported_profiles;
 }
 
@@ skipping 128 matching lines @@
             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,
+                              VAProfile va_profile,
+                              bool va_profile_degraded,
                               const base::Closure& report_error_to_uma_cb) {
   if (!VaInitialize(report_error_to_uma_cb))
     return false;
-  std::vector<VAProfile> supported_va_profiles;
-  if (!GetSupportedVaProfiles(&supported_va_profiles))
-    return false;
-  VAProfile va_profile = ProfileToVAProfile(profile, supported_va_profiles);
+  if (va_profile_degraded) {
+    std::vector<VAProfile> supported_va_profiles;
+    if (!GetSupportedVaProfiles(&supported_va_profiles))
+      return false;
+    va_profile =
+        FallbackVaProfileIfNecessary(va_profile, supported_va_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 (!AreAttribsSupported(va_profile, entrypoint, required_attribs))
@@ skipping 298 matching lines @@
                         va_surface_id,
                         x_pixmap,
                         0, 0, dest_size.width(), dest_size.height(),
                         0, 0, dest_size.width(), dest_size.height(),
                         NULL, 0, 0);
   VA_SUCCESS_OR_RETURN(va_res, "Failed putting surface to pixmap", false);
   return true;
 }
 #endif  // USE_X11
 
-bool VaapiWrapper::GetVaImageForTesting(VASurfaceID va_surface_id,
-                                        VAImage* image,
-                                        void** mem) {
+bool VaapiWrapper::GetDerivedVaImage(VASurfaceID va_surface_id,
+                                     VAImage* image,
+                                     void** mem) {
   base::AutoLock auto_lock(va_lock_);
 
   VAStatus va_res = vaSyncSurface(va_display_, va_surface_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed syncing surface", false);
 
   // Derive a VAImage from the VASurface
   va_res = vaDeriveImage(va_display_, va_surface_id, image);
   VA_LOG_ON_ERROR(va_res, "vaDeriveImage failed");
   if (va_res != VA_STATUS_SUCCESS)
     return false;
 
   // Map the VAImage into memory
   va_res = vaMapBuffer(va_display_, image->buf, mem);
   VA_LOG_ON_ERROR(va_res, "vaMapBuffer failed");
   if (va_res == VA_STATUS_SUCCESS)
     return true;
 
   va_res = vaDestroyImage(va_display_, image->image_id);
   VA_LOG_ON_ERROR(va_res, "vaDestroyImage failed");
 
   return false;
 }
 
-void VaapiWrapper::ReturnVaImageForTesting(VAImage* image) {
+bool VaapiWrapper::GetVaImage(VASurfaceID va_surface_id,
+                              VAImageFormat* format,
+                              const gfx::Size& size,
+                              VAImage* image,
+                              void** mem) {
+  base::AutoLock auto_lock(va_lock_);
+
+  VAStatus va_res = vaSyncSurface(va_display_, va_surface_id);
+  VA_SUCCESS_OR_RETURN(va_res, "Failed syncing surface", false);
+
+  va_res =
+      vaCreateImage(va_display_, format, size.width(), size.height(), image);
+  VA_SUCCESS_OR_RETURN(va_res, "vaCreateImage failed", false);
+
+  va_res = vaGetImage(va_display_, va_surface_id, 0, 0, size.width(),
+                      size.height(), image->image_id);
+  VA_LOG_ON_ERROR(va_res, "vaGetImage failed");
+
+  if (va_res == VA_STATUS_SUCCESS) {
+    // Map the VAImage into memory
+    va_res = vaMapBuffer(va_display_, image->buf, mem);
+    VA_LOG_ON_ERROR(va_res, "vaMapBuffer failed");
+  }
+
+  if (va_res != VA_STATUS_SUCCESS) {
+    va_res = vaDestroyImage(va_display_, image->image_id);
+    VA_LOG_ON_ERROR(va_res, "vaDestroyImage failed");
+    return false;
+  }
+
+  return true;
+}
+
+void VaapiWrapper::ReturnVaImage(VAImage* image) {
   base::AutoLock auto_lock(va_lock_);
 
   VAStatus va_res = vaUnmapBuffer(va_display_, image->buf);
   VA_LOG_ON_ERROR(va_res, "vaUnmapBuffer failed");
 
   va_res = vaDestroyImage(va_display_, image->image_id);
   VA_LOG_ON_ERROR(va_res, "vaDestroyImage failed");
 }
 
 static void DestroyVAImage(VADisplay va_display, VAImage image) {
@@ skipping 201 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);
 }
 
 }  // namespace content