Fix wrong selection of VP8 video decoder on some Samsung devices.

media/base/android/media_codec_bridge.cc

 // Copyright (c) 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 "media/base/android/media_codec_bridge.h"
 
 #include <jni.h>
 #include <string>
 
 #include "base/android/build_info.h"
@@ skipping 96 matching lines @@
   return base::android::BuildInfo::GetInstance()->sdk_int() >= 16;
 }
 
 // static
 bool MediaCodecBridge::SupportsSetParameters() {
   // MediaCodec.setParameters() is only available starting with K.
   return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
 }
 
 // static
+bool MediaCodecBridge::SupportsGetName() {
+  // MediaCodec.getName() is only available on JB MR2 and greater.
+  return base::android::BuildInfo::GetInstance()->sdk_int() >= 18;
+}
+
+// static
 std::vector<MediaCodecBridge::CodecsInfo> MediaCodecBridge::GetCodecsInfo() {
   std::vector<CodecsInfo> codecs_info;
   if (!IsAvailable())
     return codecs_info;
 
   JNIEnv* env = AttachCurrentThread();
   std::string mime_type;
   ScopedJavaLocalRef<jobjectArray> j_codec_info_array =
       Java_MediaCodecBridge_getCodecsInfo(env);
   jsize len = env->GetArrayLength(j_codec_info_array.obj());
   for (jsize i = 0; i < len; ++i) {
     ScopedJavaLocalRef<jobject> j_info(
         env, env->GetObjectArrayElement(j_codec_info_array.obj(), i));
     ScopedJavaLocalRef<jstring> j_codec_type =
         Java_CodecInfo_codecType(env, j_info.obj());
     ConvertJavaStringToUTF8(env, j_codec_type.obj(), &mime_type);
     ScopedJavaLocalRef<jstring> j_codec_name =
         Java_CodecInfo_codecName(env, j_info.obj());
     CodecsInfo info;
     info.codecs = AndroidMimeTypeToCodecType(mime_type);
     ConvertJavaStringToUTF8(env, j_codec_name.obj(), &info.name);
     info.direction = static_cast<MediaCodecDirection>(
         Java_CodecInfo_direction(env, j_info.obj()));
     codecs_info.push_back(info);
   }
   return codecs_info;
 }
 
 // static
+std::string MediaCodecBridge::GetDefaultCodecName(
+    const std::string& mime_type,
+    MediaCodecDirection direction) {
+  if (!IsAvailable())
+    return std::string();
+
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime_type);
+  ScopedJavaLocalRef<jstring> j_codec_name =
+      Java_MediaCodecBridge_getDefaultCodecName(env, j_mime.obj(), direction);
+  return ConvertJavaStringToUTF8(env, j_codec_name.obj());
+}
+
+// static
 bool MediaCodecBridge::CanDecode(const std::string& codec, bool is_secure) {
   if (!IsAvailable())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   std::string mime = CodecTypeToAndroidMimeType(codec);
   if (mime.empty())
     return false;
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   ScopedJavaLocalRef<jobject> j_media_codec_bridge =
       Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure, false);
   if (!j_media_codec_bridge.is_null()) {
     Java_MediaCodecBridge_release(env, j_media_codec_bridge.obj());
     return true;
   }
   return false;
 }
 
 // static
 bool MediaCodecBridge::IsKnownUnaccelerated(const std::string& mime_type,
                                             MediaCodecDirection direction) {
   if (!IsAvailable())
     return true;
 
-  std::string codec_type = AndroidMimeTypeToCodecType(mime_type);
-  std::vector<media::MediaCodecBridge::CodecsInfo> codecs_info =
-      MediaCodecBridge::GetCodecsInfo();
-  for (size_t i = 0; i < codecs_info.size(); ++i) {
-    if (codecs_info[i].codecs == codec_type &&
-        codecs_info[i].direction == direction) {
-      // It would be nice if MediaCodecInfo externalized some notion of
-      // HW-acceleration but it doesn't. Android Media guidance is that the
-      // prefix below is always used for SW decoders, so that's what we use.
-      if (!StartsWithASCII(codecs_info[i].name, "OMX.google.", true))
-        return false;
+  std::string codec_name;
+  if (SupportsGetName()) {
+    codec_name = GetDefaultCodecName(mime_type, direction);
+  } else {
+    std::string codec_type = AndroidMimeTypeToCodecType(mime_type);
+    std::vector<media::MediaCodecBridge::CodecsInfo> codecs_info =
+        MediaCodecBridge::GetCodecsInfo();
+    for (size_t i = 0; i < codecs_info.size(); ++i) {
+      if (codecs_info[i].codecs == codec_type &&
+          codecs_info[i].direction == direction) {
+        codec_name = codecs_info[i].name;
+        break;
+      }
     }
   }
+  DVLOG(1) << __PRETTY_FUNCTION__ << "Default codec for " << mime_type <<
+      " : " << codec_name;
+  // It would be nice if MediaCodecInfo externalized some notion of
+  // HW-acceleration but it doesn't. Android Media guidance is that the
+  // "OMX.google" prefix is always used for SW decoders, so that's what we
+  // use. "OMX.SEC.*" codec is Samsung software implementation - report it
+  // as unaccelerated as well.
+  if (codec_name.length() > 0) {
+    return (StartsWithASCII(codec_name, "OMX.google.", true) ||
+        StartsWithASCII(codec_name, "OMX.SEC.", true));
+  }
   return true;
 }
 
 MediaCodecBridge::MediaCodecBridge(const std::string& mime,
                                    bool is_secure,
                                    MediaCodecDirection direction) {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   DCHECK(!mime.empty());
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
@@ skipping 545 matching lines @@
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_isAdaptivePlaybackSupported(
       env, media_codec(), width, height);
 }
 
 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace media