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(

[Pawel Osciak, 2015/01/25 08:51:11]

We should not fall back to use Constrained if VAProfile Baseline is passed
directly to Create().

The fallback mechanism is needed because of a problem with
media::VideoCodecProfile and not with VAProfile. We fall back, because
VideoCodecProfile Baseline usually means VAProfile Constrained. But VAProfile
Baseline will never mean VAProfile Constrained. So we can only fall back when
passed VideoCodecProfile Baseline, not on VAProfile Baseline as well. With that
we should not need this split into two methods.

[kcwu, 2015/01/26 12:12:09]

The problem is GetSupportedVaProfiles() cannot be called before VaIntialize().
If we don't split this, we may need to split Initalize() as my previous patch.

Now I use a flag to control fallback or not. How do you think?

[Pawel Osciak, 2015/01/27 00:55:44]

Can we do the fallback in ProfileToVAProfile only?

[kcwu, 2015/01/27 01:12:46]

Do you mean like what I did in patch set 4?
https://chromiumcodereview.appspot.com/825843002/diff/60001/content/common/gp...

+    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,
-    media::VideoCodecProfile profile,
+    VAProfile va_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();
+  if (!vaapi_wrapper->Initialize(mode, va_profile, 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) {
+  VAProfile va_profile = ProfileToVAProfile(profile);
+  return Create(mode, va_profile, report_error_to_uma_cb);
+}
+
 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,
                               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);
+  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