AndroidVDA: only engage if it's likely that the codec is backed by hardware.

BUG=311581

Review URL: https://codereview.chromium.org/45073002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@231231 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 65 insertions, 16 deletions

diff --git a/media/base/android/java/src/org/chromium/media/MediaCodecBridge.java b/media/base/android/java/src/org/chromium/media/MediaCodecBridge.java
index d9bb48b..74bec56 100644
--- a/media/base/android/java/src/org/chromium/media/MediaCodecBridge.java
+++ b/media/base/android/java/src/org/chromium/media/MediaCodecBridge.java
@@ -81,11 +81,13 @@ class MediaCodecBridge {
      * This class represents supported android codec information.
      */
     private static class CodecInfo {
-        private final String mCodecType;
+        private final String mCodecType;  // e.g. "video/x-vnd.on2.vp8".
+        private final String mCodecName;  // e.g. "OMX.google.vp8.decoder".
         private final boolean mIsSecureDecoderSupported;
 
-        private CodecInfo(String codecType, boolean isSecureDecoderSupported) {
+        private CodecInfo(String codecType, String codecName, boolean isSecureDecoderSupported) {
             mCodecType = codecType;
+            mCodecName = codecName;
             mIsSecureDecoderSupported = isSecureDecoderSupported;
         }
 
@@ -93,6 +95,9 @@ class MediaCodecBridge {
         private String codecType() { return mCodecType; }
 
         @CalledByNative("CodecInfo")
+        private String codecName() { return mCodecName; }
+
+        @CalledByNative("CodecInfo")
         private boolean isSecureDecoderSupported() { return mIsSecureDecoderSupported; }
     }
 
@@ -159,8 +164,8 @@ class MediaCodecBridge {
             }
             for (int j = 0; j < supportedTypes.length; ++j) {
                 if (!CodecInfoMap.containsKey(supportedTypes[j]) || secureDecoderSupported) {
-                    CodecInfoMap.put(supportedTypes[j],
-                                     new CodecInfo(supportedTypes[j], secureDecoderSupported));
+                    CodecInfoMap.put(supportedTypes[j], new CodecInfo(
+                        supportedTypes[j], codecString, secureDecoderSupported));
                 }
             }
         }
diff --git a/media/base/android/media_codec_bridge.cc b/media/base/android/media_codec_bridge.cc
index 75d103c..1c4928a 100644
--- a/media/base/android/media_codec_bridge.cc
+++ b/media/base/android/media_codec_bridge.cc
@@ -15,6 +15,7 @@
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/safe_numerics.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "jni/MediaCodecBridge_jni.h"
 #include "media/base/bit_reader.h"
@@ -29,7 +30,7 @@ namespace media {
 
 enum { kBufferFlagEndOfStream = 4 };
 
-static const std::string AudioCodecToAndroidMimeType(const AudioCodec codec) {
+static const std::string AudioCodecToAndroidMimeType(const AudioCodec& codec) {
   switch (codec) {
     case kCodecMP3:
       return "audio/mpeg";
@@ -42,7 +43,7 @@ static const std::string AudioCodecToAndroidMimeType(const AudioCodec codec) {
   }
 }
 
-static const std::string VideoCodecToAndroidMimeType(const VideoCodec codec) {
+static const std::string VideoCodecToAndroidMimeType(const VideoCodec& codec) {
   switch (codec) {
     case kCodecH264:
       return "video/avc";
@@ -106,6 +107,7 @@ void MediaCodecBridge::GetCodecsInfo(
     return;
 
   std::string mime_type;
+  std::string codec_name;
   ScopedJavaLocalRef<jobjectArray> j_codec_info_array =
       Java_MediaCodecBridge_getCodecsInfo(env);
   jsize len = env->GetArrayLength(j_codec_info_array.obj());
@@ -115,8 +117,11 @@ void MediaCodecBridge::GetCodecsInfo(
     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.secure_decoder_supported =
         Java_CodecInfo_isSecureDecoderSupported(env, j_info.obj());
     codecs_info->push_back(info);
@@ -139,6 +144,22 @@ bool MediaCodecBridge::CanDecode(const std::string& codec, bool is_secure) {
   return false;
 }
 
+// static
+bool MediaCodecBridge::IsKnownUnaccelerated(const std::string& mime_type) {
+  std::string codec_type = AndroidMimeTypeToCodecType(mime_type);
+  std::vector<media::MediaCodecBridge::CodecsInfo> codecs_info;
+  media::MediaCodecBridge::GetCodecsInfo(&codecs_info);
+  for (size_t i = 0; i < codecs_info.size(); ++i) {
+    if (codecs_info[i].codecs == codec_type) {
+      // 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.
+      return StartsWithASCII(codecs_info[i].name, "OMX.google.", true);
+    }
+  }
+  return true;
+}
+
 MediaCodecBridge::MediaCodecBridge(const std::string& mime, bool is_secure) {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
@@ -312,7 +333,7 @@ AudioCodecBridge::AudioCodecBridge(const std::string& mime)
 }
 
 bool AudioCodecBridge::Start(
-    const AudioCodec codec, int sample_rate, int channel_count,
+    const AudioCodec& codec, int sample_rate, int channel_count,
     const uint8* extra_data, size_t extra_data_size, bool play_audio,
     jobject media_crypto) {
   JNIEnv* env = AttachCurrentThread();
@@ -343,7 +364,7 @@ bool AudioCodecBridge::Start(
 }
 
 bool AudioCodecBridge::ConfigureMediaFormat(
-    jobject j_format, const AudioCodec codec, const uint8* extra_data,
+    jobject j_format, const AudioCodec& codec, const uint8* extra_data,
     size_t extra_data_size) {
   if (extra_data_size == 0)
     return true;
@@ -470,7 +491,7 @@ VideoCodecBridge::VideoCodecBridge(const std::string& mime, bool is_secure)
 }
 
 bool VideoCodecBridge::Start(
-    const VideoCodec codec, const gfx::Size& size, jobject surface,
+    const VideoCodec& codec, const gfx::Size& size, jobject surface,
     jobject media_crypto) {
   JNIEnv* env = AttachCurrentThread();
 
@@ -495,17 +516,29 @@ bool VideoCodecBridge::Start(
   return StartInternal();
 }
 
-AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec codec) {
+AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec& codec) {
   const std::string mime = AudioCodecToAndroidMimeType(codec);
   return mime.empty() ? NULL : new AudioCodecBridge(mime);
 }
 
-VideoCodecBridge* VideoCodecBridge::Create(const VideoCodec codec,
+// static
+bool AudioCodecBridge::IsKnownUnaccelerated(const AudioCodec& codec) {
+  return MediaCodecBridge::IsKnownUnaccelerated(
+      AudioCodecToAndroidMimeType(codec));
+}
+
+VideoCodecBridge* VideoCodecBridge::Create(const VideoCodec& codec,
                                            bool is_secure) {
   const std::string mime = VideoCodecToAndroidMimeType(codec);
   return mime.empty() ? NULL : new VideoCodecBridge(mime, is_secure);
 }
 
+// static
+bool VideoCodecBridge::IsKnownUnaccelerated(const VideoCodec& codec) {
+  return MediaCodecBridge::IsKnownUnaccelerated(
+      VideoCodecToAndroidMimeType(codec));
+}
+
 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
diff --git a/media/base/android/media_codec_bridge.h b/media/base/android/media_codec_bridge.h
index 15b707c..64c7357 100644
--- a/media/base/android/media_codec_bridge.h
+++ b/media/base/android/media_codec_bridge.h
@@ -54,6 +54,7 @@ class MEDIA_EXPORT MediaCodecBridge {
   // need more specific codecs separated by comma. (e.g. "vp8" -> "vp8, vp8.0")
   struct CodecsInfo {
     std::string codecs;
+    std::string name;
     bool secure_decoder_supported;
   };
 
@@ -137,6 +138,10 @@ class MEDIA_EXPORT MediaCodecBridge {
   static bool RegisterMediaCodecBridge(JNIEnv* env);
 
  protected:
+  // Returns true if |mime_type| is known to be unaccelerated (i.e. backed by a
+  // software codec instead of a hardware one).
+  static bool IsKnownUnaccelerated(const std::string& mime_type);
+
   MediaCodecBridge(const std::string& mime, bool is_secure);
 
   // Calls start() against the media codec instance. Used in StartXXX() after
@@ -163,10 +168,13 @@ class AudioCodecBridge : public MediaCodecBridge {
  public:
   // Returns an AudioCodecBridge instance if |codec| is supported, or a NULL
   // pointer otherwise.
-  static AudioCodecBridge* Create(const AudioCodec codec);
+  static AudioCodecBridge* Create(const AudioCodec& codec);
+
+  // See MediaCodecBridge::IsKnownUnaccelerated().
+  static bool IsKnownUnaccelerated(const AudioCodec& codec);
 
   // Start the audio codec bridge.
-  bool Start(const AudioCodec codec, int sample_rate, int channel_count,
+  bool Start(const AudioCodec& codec, int sample_rate, int channel_count,
              const uint8* extra_data, size_t extra_data_size,
              bool play_audio, jobject media_crypto) WARN_UNUSED_RESULT;
 
@@ -181,7 +189,7 @@ class AudioCodecBridge : public MediaCodecBridge {
   explicit AudioCodecBridge(const std::string& mime);
 
   // Configure the java MediaFormat object with the extra codec data passed in.
-  bool ConfigureMediaFormat(jobject j_format, const AudioCodec codec,
+  bool ConfigureMediaFormat(jobject j_format, const AudioCodec& codec,
                             const uint8* extra_data, size_t extra_data_size);
 };
 
@@ -189,11 +197,14 @@ class MEDIA_EXPORT VideoCodecBridge : public MediaCodecBridge {
  public:
   // Returns an VideoCodecBridge instance if |codec| is supported, or a NULL
   // pointer otherwise.
-  static VideoCodecBridge* Create(const VideoCodec codec, bool is_secure);
+  static VideoCodecBridge* Create(const VideoCodec& codec, bool is_secure);
+
+  // See MediaCodecBridge::IsKnownUnaccelerated().
+  static bool IsKnownUnaccelerated(const VideoCodec& codec);
 
   // Start the video codec bridge.
   // TODO(qinmin): Pass codec specific data if available.
-  bool Start(const VideoCodec codec, const gfx::Size& size, jobject surface,
+  bool Start(const VideoCodec& codec, const gfx::Size& size, jobject surface,
              jobject media_crypto);
 
  private: