Make AVDA fall back to software decoding if needed.

media/base/android/media_codec_util.cc

 // Copyright 2015 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_util.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 48 matching lines @@
 
 static bool IsSupportedAndroidMimeType(const std::string& mime_type) {
   std::vector<std::string> supported{
       kMp4aMimeType, kOpusMimeType, kVorbisMimeType, kAvcMimeType,
       kHevcMimeType, kVp8MimeType,  kVp9MimeType};
   return std::find(supported.begin(), supported.end(), mime_type) !=
          supported.end();
 }
 
 static std::string GetDefaultCodecName(const std::string& mime_type,
-                                       MediaCodecDirection direction) {
+                                       MediaCodecDirection direction,
+                                       bool require_software) {

[DaleCurtis, 2016/06/22 21:20:11]

require_software_codec here and elsewhere.

[liberato (no reviews please), 2016/06/22 21:43:55]

done, sorry.

   DCHECK(MediaCodecUtil::IsMediaCodecAvailable());
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime_type);
   ScopedJavaLocalRef<jstring> j_codec_name =
-      Java_MediaCodecUtil_getDefaultCodecName(env, j_mime.obj(), direction);
+      Java_MediaCodecUtil_getDefaultCodecName(env, j_mime.obj(), direction,
+                                              require_software);
   return ConvertJavaStringToUTF8(env, j_codec_name.obj());
 }
 
 static bool IsDecoderSupportedByDevice(const std::string& android_mime_type) {
   DCHECK(MediaCodecUtil::IsMediaCodecAvailable());
   DCHECK(IsSupportedAndroidMimeType(android_mime_type));
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, android_mime_type);
   return Java_MediaCodecUtil_isDecoderSupportedForDevice(env, j_mime.obj());
@@ skipping 55 matching lines @@
   return Java_MediaCodecUtil_canDecode(env, j_mime.obj(), is_secure);
 }
 
 // static
 bool MediaCodecUtil::IsKnownUnaccelerated(const std::string& android_mime_type,
                                           MediaCodecDirection direction) {
   DCHECK(IsSupportedAndroidMimeType(android_mime_type));
   if (!IsMediaCodecAvailable())
     return true;
 
-  std::string codec_name = GetDefaultCodecName(android_mime_type, direction);
+  std::string codec_name =
+      GetDefaultCodecName(android_mime_type, direction, false);
   DVLOG(1) << __FUNCTION__ << "Default codec for " << android_mime_type << " : "
            << codec_name << ", direction: " << direction;
   if (!codec_name.size())
     return true;
 
   // MediaTek hardware vp8 is known slower than the software implementation.
   // MediaTek hardware vp9 is known crashy, see http://crbug.com/446974 and
   // http://crbug.com/597836.
   if (base::StartsWith(codec_name, "OMX.MTK.", base::CompareCase::SENSITIVE)) {
     if (android_mime_type == kVp8MimeType)
@@ skipping 78 matching lines @@
     if (base::StartsWith(model, model_prefixes[i],
                          base::CompareCase::INSENSITIVE_ASCII)) {
       return false;
     }
   }
 
   return true;
 }
 
 }  // namespace media