media: Clean up MediaCodecBridge and remove subclasses

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 11 matching lines @@
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::JavaIntArrayToIntVector;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace media {
 
-namespace {
-
-const char kMp4aMimeType[] = "audio/mp4a-latm";
-const char kOpusMimeType[] = "audio/opus";
-const char kVorbisMimeType[] = "audio/vorbis";
-const char kAc3MimeType[] = "audio/ac3";
-const char kEac3MimeType[] = "audio/eac3";
-const char kAvcMimeType[] = "video/avc";
-const char kHevcMimeType[] = "video/hevc";
-const char kVp8MimeType[] = "video/x-vnd.on2.vp8";
-const char kVp9MimeType[] = "video/x-vnd.on2.vp9";
-
-}  // namespace
-
-static std::string CodecTypeToAndroidMimeType(const std::string& codec) {
-  // TODO(xhwang): Shall we handle more detailed strings like "mp4a.40.2"?
-  if (codec == "avc1")
-    return kAvcMimeType;
-  if (codec == "hvc1")
-    return kHevcMimeType;
-  if (codec == "mp4a")
-    return kMp4aMimeType;
-  if (codec == "vp8" || codec == "vp8.0")
-    return kVp8MimeType;
-  if (codec == "vp9" || codec == "vp9.0")
-    return kVp9MimeType;
-  if (codec == "vorbis")
-    return kVorbisMimeType;
-  if (codec == "opus")
-    return kOpusMimeType;
-  if (codec == "ac3")
-    return kAc3MimeType;
-  if (codec == "eac3")
-    return kEac3MimeType;
-
-  DLOG(WARNING) << "Cannot convert codec to Android MIME type: " << codec;
-  return std::string();
-}
-
-static VideoCodec AndroidCodecToCodecEnum(const std::string& codec) {
-  if (codec == "AVC")
-    return kCodecH264;
-  if (codec == "VP8")
-    return kCodecVP8;
-  if (codec == "VP9")
-    return kCodecVP9;
-  if (codec == "HEVC")
-    return kCodecHEVC;
-  DLOG(WARNING) << "Unknown video codec name \"" << codec << "\"";
-  return kUnknownVideoCodec;
-}
+namespace mime_type {

[liberato (no reviews please), 2017/02/14 17:44:11]

these seem to be alternately named "android mime type" and "mime type" in the
various places it's used.  if these types have android-specific things, then
probably this namespace should be android_mime_type.

i really like that you've put these into a namespace.

if you want to go really crazy, 'using AndroidMimeType = std::string'.  however,
i don't know if there are cases where we actually preserve the resulting string
separately from the function that generates it.  if not, then it would add no
clarity.

[DaleCurtis, 2017/02/14 18:10:32]

I feel like these should share the values we have in
media/base/mime_util_internal.

[watk, 2017/02/14 23:28:57]

I agree, but didn't see an obvious way to share, so leaving it for now.

Renamed to android_mime_type because the vp8 and vp9 ones are android specific.
Thanks for noticing.

+const char kMp3[] = "audio/mpeg";
+const char kAac[] = "audio/mp4a-latm";
+const char kOpus[] = "audio/opus";
+const char kVorbis[] = "audio/vorbis";
+const char kAc3[] = "audio/ac3";
+const char kEac3[] = "audio/eac3";
+const char kAvc[] = "video/avc";
+const char kHevc[] = "video/hevc";
+const char kVp8[] = "video/x-vnd.on2.vp8";
+const char kVp9[] = "video/x-vnd.on2.vp9";
+}  // namespace mime_type
 
 static CodecProfileLevel MediaCodecProfileLevelToChromiumProfileLevel(
     JNIEnv* env,
     const jobject& j_codec_profile_level) {
-  ScopedJavaLocalRef<jstring> codec =
-      Java_CodecProfileLevelAdapter_getCodec(env, j_codec_profile_level);
-  int profile =
-      Java_CodecProfileLevelAdapter_getProfile(env, j_codec_profile_level);
+  VideoCodec codec = static_cast<VideoCodec>(
+      Java_CodecProfileLevelAdapter_getCodec(env, j_codec_profile_level));
+  VideoCodecProfile profile = static_cast<VideoCodecProfile>(
+      Java_CodecProfileLevelAdapter_getProfile(env, j_codec_profile_level));
   int level =
       Java_CodecProfileLevelAdapter_getLevel(env, j_codec_profile_level);
-  return {AndroidCodecToCodecEnum(ConvertJavaStringToUTF8(codec)),
-          static_cast<VideoCodecProfile>(profile), level};
+  return {codec, profile, level};
 }
 
 static bool IsSupportedAndroidMimeType(const std::string& mime_type) {
   std::vector<std::string> supported{
-      kMp4aMimeType, kOpusMimeType, kVorbisMimeType, kAvcMimeType,
-      kHevcMimeType, kVp8MimeType,  kVp9MimeType};
+      mime_type::kMp3, mime_type::kAac,  mime_type::kOpus, mime_type::kVorbis,

[watk, 2017/02/14 23:35:56]

I added mp3 here, because I didn't know why it would be missing.. It's only used
in DCHECKs anyway. Dale?

[DaleCurtis, 2017/02/14 23:44:43]

Probably because there are no protected content mp3s :)

+      mime_type::kAvc, mime_type::kHevc, mime_type::kVp8,  mime_type::kVp9};
   return std::find(supported.begin(), supported.end(), mime_type) !=
          supported.end();
 }
 
 static std::string GetDefaultCodecName(const std::string& mime_type,
                                        MediaCodecDirection direction,
                                        bool require_software_codec) {
   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, direction,
-                                              require_software_codec);
+      Java_MediaCodecUtil_getDefaultCodecName(
+          env, j_mime, static_cast<int>(direction), require_software_codec);
   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);
 }
 
 static bool IsEncoderSupportedByDevice(const std::string& android_mime_type) {
   DCHECK(MediaCodecUtil::IsMediaCodecAvailable());
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime =
       ConvertUTF8ToJavaString(env, android_mime_type);
   return Java_MediaCodecUtil_isEncoderSupportedByDevice(env, j_mime);
 }
 
 // static
+std::string MediaCodecUtil::CodecToAndroidMimeType(AudioCodec codec) {
+  switch (codec) {
+    case kCodecMP3:
+      return mime_type::kMp3;
+    case kCodecVorbis:
+      return mime_type::kVorbis;
+    case kCodecOpus:
+      return mime_type::kOpus;
+    case kCodecAAC:
+      return mime_type::kAac;
+    case kCodecAC3:
+      return mime_type::kAc3;
+    case kCodecEAC3:
+      return mime_type::kEac3;
+    default:
+      return std::string();
+  }
+}
+
+// static
+std::string MediaCodecUtil::CodecToAndroidMimeType(VideoCodec codec) {
+  switch (codec) {
+    case kCodecH264:
+      return mime_type::kAvc;
+    case kCodecHEVC:
+      return mime_type::kHevc;
+    case kCodecVP8:
+      return mime_type::kVp8;
+    case kCodecVP9:
+      return mime_type::kVp9;
+    default:
+      return std::string();
+  }
+}
+
+// static
 bool MediaCodecUtil::IsMediaCodecAvailable() {
   // Blacklist some devices on Jellybean as MediaCodec is buggy.
   // http://crbug.com/365494, http://crbug.com/615872
   // Blacklist Lenovo A6600 / A6800 on KitKat, which tends to crash a lot.
   // See crbug.com/628059 .  We include < K since they don't exist.
   // Blacklist Samsung Galaxy Star Pro (GT-S7262) (crbug.com/634920).
   // GT-S5282 and GT-I8552 are for crbug.com/634920 .
   if (base::android::BuildInfo::GetInstance()->sdk_int() <= 19) {
     std::string model(base::android::BuildInfo::GetInstance()->model());
     return model != "GT-I9100" && model != "GT-I9300" && model != "GT-N7000" &&
@@ skipping 31 matching lines @@
   if (j_color_format_array.obj()) {
     std::vector<int> formats;
     JavaIntArrayToIntVector(env, j_color_format_array.obj(), &formats);
     color_formats = std::set<int>(formats.begin(), formats.end());
   }
 
   return color_formats;
 }
 
 // static
-bool MediaCodecUtil::CanDecode(const std::string& codec, bool is_secure) {
+bool MediaCodecUtil::CanDecode(const std::string& mime, bool is_secure) {
   if (!IsMediaCodecAvailable())
     return false;
+  if (mime.empty())
+    return false;
 
   JNIEnv* env = AttachCurrentThread();
-  std::string mime = CodecTypeToAndroidMimeType(codec);
-  if (mime.empty())
-    return false;
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   return Java_MediaCodecUtil_canDecode(env, j_mime, is_secure);
 }
 
 // static
 bool MediaCodecUtil::AddSupportedCodecProfileLevels(
     std::vector<CodecProfileLevel>* result) {
   DCHECK(result);
   if (!IsMediaCodecAvailable())
     return false;
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobjectArray> j_codec_profile_levels(
       Java_MediaCodecUtil_getSupportedCodecProfileLevels(env));
   int java_array_length = env->GetArrayLength(j_codec_profile_levels.obj());
   for (int i = 0; i < java_array_length; ++i) {
     const jobject& java_codec_profile_level =
         env->GetObjectArrayElement(j_codec_profile_levels.obj(), i);
     result->push_back(MediaCodecProfileLevelToChromiumProfileLevel(
         env, java_codec_profile_level));
   }
   return true;
 }
 
 // static
-bool MediaCodecUtil::IsKnownUnaccelerated(const std::string& android_mime_type,
+bool MediaCodecUtil::IsKnownUnaccelerated(VideoCodec codec,
                                           MediaCodecDirection direction) {
-  DCHECK(IsSupportedAndroidMimeType(android_mime_type));
   if (!IsMediaCodecAvailable())
     return true;
 
   std::string codec_name =
-      GetDefaultCodecName(android_mime_type, direction, false);
-  DVLOG(1) << __func__ << "Default codec for " << android_mime_type << " : "
-           << codec_name << ", direction: " << direction;
+      GetDefaultCodecName(CodecToAndroidMimeType(codec), direction, false);
+  DVLOG(1) << __func__ << "Default codec for " << GetCodecName(codec) << " : "
+           << codec_name << ", direction: " << static_cast<int>(direction);
   if (codec_name.empty())
     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)
+    if (codec == kCodecVP8)
       return true;
 
-    if (android_mime_type == kVp9MimeType)
+    if (codec == kCodecVP9)
       return base::android::BuildInfo::GetInstance()->sdk_int() < 21;
 
     return false;
   }
 
   // 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.
@@ skipping 10 matching lines @@
 }
 
 // static
 bool MediaCodecUtil::IsHLSURL(const GURL& url) {
   return (url.SchemeIsHTTPOrHTTPS() || url.SchemeIsFile()) &&
          url.spec().find("m3u8") != std::string::npos;
 }
 
 // static
 bool MediaCodecUtil::IsVp8DecoderAvailable() {
-  return IsMediaCodecAvailable() && IsDecoderSupportedByDevice(kVp8MimeType);
+  return IsMediaCodecAvailable() && IsDecoderSupportedByDevice(mime_type::kVp8);
 }
 
 // static
 bool MediaCodecUtil::IsVp8EncoderAvailable() {
   // Currently the vp8 encoder and decoder blacklists cover the same devices,
   // but we have a second method for clarity in future issues.
   return IsVp8DecoderAvailable();
 }
 
 // static
 bool MediaCodecUtil::IsVp9DecoderAvailable() {
-  return IsMediaCodecAvailable() && IsDecoderSupportedByDevice(kVp9MimeType);
+  return IsMediaCodecAvailable() && IsDecoderSupportedByDevice(mime_type::kVp9);
 }
 
 // static
 bool MediaCodecUtil::IsH264EncoderAvailable() {
-  return IsMediaCodecAvailable() && IsEncoderSupportedByDevice(kAvcMimeType);
+  return IsMediaCodecAvailable() && IsEncoderSupportedByDevice(mime_type::kAvc);
 }
 
 // static
 bool MediaCodecUtil::IsSurfaceViewOutputSupported() {
   // Disable SurfaceView output for the Samsung Galaxy S3; it does not work
   // well enough for even 360p24 H264 playback.  http://crbug.com/602870.
   //
   // Notably this is codec agnostic at present, so any devices added to
   // the blacklist will avoid trying to play any codecs on SurfaceView.  If
   // needed in the future this can be expanded to be codec specific.
@@ skipping 29 matching lines @@
          (sdk_int == 18 && ("OMX.SEC.avc.dec" == codec_name ||
                             "OMX.SEC.avc.dec.secure" == codec_name)) ||
          (sdk_int == 19 &&
           base::StartsWith(base::android::BuildInfo::GetInstance()->model(),
                            "SM-G800", base::CompareCase::INSENSITIVE_ASCII) &&
           ("OMX.Exynos.avc.dec" == codec_name ||
            "OMX.Exynos.avc.dec.secure" == codec_name));
 }
 
 }  // namespace media