Fix mime type mappings when the unified media pipeline is enabled.

media/base/mime_util_internal.cc

 // Copyright 2012 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/mime_util_internal.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
+#include "media/base/media.h"
 #include "media/base/video_codecs.h"
 #include "media/media_features.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
+#include "media/base/android/media_codec_util.h"
 #endif
 
 namespace media {
 namespace internal {
 
 enum MediaFormatType { COMMON, PROPRIETARY };
 
 struct MediaFormat {
   const char* const mime_type;
   MediaFormatType format_type;
@@ skipping 233 matching lines @@
     }
 
     return true;
   }
 
   return false;
 }
 #endif
 
 MimeUtil::MimeUtil() : allow_proprietary_codecs_(false) {
+#if defined(OS_ANDROID)
+  platform_info_.is_unified_media_pipeline_enabled =
+      IsUnifiedMediaPipelineEnabled();
+  // When the unified media pipeline is enabled, we need support for both GPU
+  // video decoders and MediaCodec; indicated by HasPlatformDecoderSupport().
+  // When the Android pipeline is used, we only need access to MediaCodec.
+  platform_info_.has_platform_decoders =
+      platform_info_.is_unified_media_pipeline_enabled
+          ? HasPlatformDecoderSupport()
+          : MediaCodecUtil::IsMediaCodecAvailable();
+  platform_info_.has_platform_vp8_decoder = !MediaCodecUtil::IsVp8Blacklisted();
+  platform_info_.supports_opus = PlatformHasOpusSupport();
+  platform_info_.supports_vp9 = PlatformHasVp9Support();
+#endif
+
   InitializeMimeTypeMaps();
 }
 
 MimeUtil::~MimeUtil() {}
 
 SupportsType MimeUtil::AreSupportedCodecs(
     const CodecSet& supported_codecs,
-    const std::vector<std::string>& codecs) const {
+    const std::vector<std::string>& codecs,
+    const std::string& mime_type_lower_case,
+    bool is_encrypted) const {
   DCHECK(!supported_codecs.empty());
   DCHECK(!codecs.empty());
 
   SupportsType result = IsSupported;
   for (size_t i = 0; i < codecs.size(); ++i) {
     bool is_ambiguous = true;
     Codec codec = INVALID_CODEC;
     if (!StringToCodec(codecs[i], &codec, &is_ambiguous))
       return IsNotSupported;
 
-    if (!IsCodecSupported(codec) ||
+    if (!IsCodecSupported(codec, mime_type_lower_case, is_encrypted) ||
         supported_codecs.find(codec) == supported_codecs.end()) {
       return IsNotSupported;
     }
 
     if (is_ambiguous)
       result = MayBeSupported;
   }
 
   return result;
 }
@@ skipping 56 matching lines @@
   for (std::vector<std::string>::iterator it = codecs_out->begin();
        it != codecs_out->end(); ++it) {
     size_t found = it->find_first_of('.');
     if (found != std::string::npos)
       it->resize(found);
   }
 }
 
 SupportsType MimeUtil::IsSupportedMediaFormat(
     const std::string& mime_type,
-    const std::vector<std::string>& codecs) const {
+    const std::vector<std::string>& codecs,
+    bool is_encrypted) const {
   const std::string mime_type_lower_case = base::ToLowerASCII(mime_type);
   MediaFormatMappings::const_iterator it_media_format_map =
       media_format_map_.find(mime_type_lower_case);
   if (it_media_format_map == media_format_map_.end())
     return IsNotSupported;
 
   if (it_media_format_map->second.empty()) {
     // We get here if the mimetype does not expect a codecs parameter.
-    return (codecs.empty() &&
-            IsDefaultCodecSupportedLowerCase(mime_type_lower_case))
+    return (codecs.empty() && IsDefaultCodecSupportedLowerCase(
+                                  mime_type_lower_case, is_encrypted))
                ? IsSupported
                : IsNotSupported;
   }
 
   if (codecs.empty()) {
     // We get here if the mimetype expects to get a codecs parameter,
     // but didn't get one. If |mime_type_lower_case| does not have a default
     // codec the best we can do is say "maybe" because we don't have enough
     // information.
     Codec default_codec = INVALID_CODEC;
     if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec))
       return MayBeSupported;
 
-    return IsCodecSupported(default_codec) ? IsSupported : IsNotSupported;
+    return IsCodecSupported(default_codec, mime_type_lower_case, is_encrypted)
+               ? IsSupported
+               : IsNotSupported;
   }
 
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
   if (mime_type_lower_case == "video/mp2t") {
     std::vector<std::string> codecs_to_check;
     for (const auto& codec_id : codecs) {
       codecs_to_check.push_back(TranslateLegacyAvc1CodecIds(codec_id));
     }
-    return AreSupportedCodecs(it_media_format_map->second, codecs_to_check);
+    return AreSupportedCodecs(it_media_format_map->second, codecs_to_check,
+                              mime_type_lower_case, is_encrypted);
   }
 #endif
 
-  return AreSupportedCodecs(it_media_format_map->second, codecs);
+  return AreSupportedCodecs(it_media_format_map->second, codecs,
+                            mime_type_lower_case, is_encrypted);
 }
 
 void MimeUtil::RemoveProprietaryMediaTypesAndCodecs() {
   for (size_t i = 0; i < arraysize(kFormatCodecMappings); ++i)
     if (kFormatCodecMappings[i].format_type == PROPRIETARY)
       media_format_map_.erase(kFormatCodecMappings[i].mime_type);
   allow_proprietary_codecs_ = false;
 }
 
+// static
+bool MimeUtil::IsCodecSupportedOnPlatform(
+    Codec codec,
+    const std::string& mime_type_lower_case,
+    bool is_encrypted,
+    const PlatformInfo& platform_info) {
+  DCHECK_NE(mime_type_lower_case, "");
+
+  // Encrypted block support is never available without platform decoders.
+  if (is_encrypted && !platform_info.has_platform_decoders)
+    return false;
+
+  // NOTE: We do not account for Media Source Extensions (MSE) within these
+  // checks since it has its own isTypeSupported() which will handle platform
+  // specific codec rejections.  See http://crbug.com/587303.
+
+  switch (codec) {
+    // ----------------------------------------------------------------------
+    // The following codecs are never supported.
+    // ----------------------------------------------------------------------
+    case INVALID_CODEC:
+    case AC3:
+    case EAC3:
+    case THEORA:
+      return false;
+
+    // ----------------------------------------------------------------------
+    // The remaining codecs may be supported depending on platform abilities.
+    // ----------------------------------------------------------------------
+
+    case PCM:
+    case MP3:
+    case MPEG4_AAC_LC:
+    case MPEG4_AAC_SBR_v1:
+    case MPEG4_AAC_SBR_PS_v2:
+    case VORBIS:
+      // These codecs are always supported; via a platform decoder (when used
+      // with MSE/EME), a software decoder (the unified pipeline), or with
+      // MediaPlayer.
+      DCHECK(!is_encrypted || platform_info.has_platform_decoders);
+      return true;
+
+    case MPEG2_AAC_LC:
+    case MPEG2_AAC_MAIN:
+    case MPEG2_AAC_SSR:
+      // MPEG-2 variants of AAC are not supported on Android unless the unified
+      // media pipeline can be used. These codecs will be decoded in software.
+      return !is_encrypted && platform_info.is_unified_media_pipeline_enabled;
+
+    case OPUS:
+      // If clear, the unified pipeline can always decode OPUS in software.
+      if (!is_encrypted && platform_info.is_unified_media_pipeline_enabled)
+        return true;
+
+      // Otherwise, platform support is required.
+      if (!platform_info.supports_opus)
+        return false;
+
+      // MediaPlayer does not support opus in ogg containers.
+      if (base::EndsWith(mime_type_lower_case, "ogg",
+                         base::CompareCase::SENSITIVE)) {
+        return false;
+      }
+
+      DCHECK(!is_encrypted || platform_info.has_platform_decoders);
+      return true;
+
+    case H264:
+      // The unified pipeline requires platform support for h264.
+      if (platform_info.is_unified_media_pipeline_enabled)
+        return platform_info.has_platform_decoders;
+
+      // When MediaPlayer is used, h264 is always supported.

[ddorwin, 2016/02/19 19:53:23]

For EME, MediaCodec too.

[DaleCurtis, 2016/02/19 20:28:35]

Done.

+      DCHECK(!is_encrypted || platform_info.has_platform_decoders);
+      return true;
+
+    case HEVC_MAIN:
+#if BUILDFLAG(ENABLE_HEVC_DEMUXING) && defined(OS_ANDROID)
+      if (platform_info.is_unified_media_pipeline_enabled &&
+          !platform_info.has_platform_decoders) {
+        return false;
+      }
+
+      // HEVC/H.265 is supported in Lollipop+ (API Level 21), according to
+      // http://developer.android.com/reference/android/media/MediaFormat.html
+      return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
+#else
+      return false;
+#endif
+
+    case VP8:
+      // If clear, the unified pipeline can always decode VP8 in software.
+      if (!is_encrypted && platform_info.is_unified_media_pipeline_enabled)
+        return true;
+
+      if (is_encrypted)
+        return platform_info.has_platform_vp8_decoder;
+
+      // MediaPlayer can always play VP8. Note: This is incorrect for MSE, but
+      // MSE does not use this code. http://crbug.com/587303.
+      return true;
+
+    case VP9: {
+      // If clear, the unified pipeline can always decode VP9 in software.
+      if (!is_encrypted && platform_info.is_unified_media_pipeline_enabled)
+        return true;
+
+      // Otherwise, platform support is required.
+      return platform_info.supports_vp9;
+    }
+  }
+
+  return false;
+}
+
 bool MimeUtil::StringToCodec(const std::string& codec_id,
                              Codec* codec,
                              bool* is_ambiguous) const {
   StringToCodecMappings::const_iterator itr =
       string_to_codec_map_.find(codec_id);
   if (itr != string_to_codec_map_.end()) {
     *codec = itr->second.codec;
     *is_ambiguous = itr->second.is_ambiguous;
     return true;
   }
@@ skipping 16 matching lines @@
         (profile != H264PROFILE_BASELINE && profile != H264PROFILE_MAIN &&
          profile != H264PROFILE_HIGH) ||
         !IsValidH264Level(level_idc);
     return true;
   }
 
   DVLOG(4) << __FUNCTION__ << ": Unrecognized codec id " << codec_id;
   return false;
 }
 
-bool MimeUtil::IsCodecSupported(Codec codec) const {
+bool MimeUtil::IsCodecSupported(Codec codec,
+                                const std::string& mime_type_lower_case,
+                                bool is_encrypted) const {
   DCHECK_NE(codec, INVALID_CODEC);
 
 #if defined(OS_ANDROID)
-  if (!IsCodecSupportedOnAndroid(codec))
+  if (!IsCodecSupportedOnPlatform(codec, mime_type_lower_case, is_encrypted,
+                                  platform_info_)) {
     return false;
+  }
 #endif
 
   return allow_proprietary_codecs_ || !IsCodecProprietary(codec);
 }
 
 bool MimeUtil::IsCodecProprietary(Codec codec) const {
   switch (codec) {
     case INVALID_CODEC:
     case AC3:
     case EAC3:
@@ skipping 31 matching lines @@
 
   if (mime_type_lower_case == "audio/aac") {
     *default_codec = MimeUtil::MPEG4_AAC_LC;
     return true;
   }
 
   return false;
 }
 
 bool MimeUtil::IsDefaultCodecSupportedLowerCase(
-    const std::string& mime_type_lower_case) const {
+    const std::string& mime_type_lower_case,
+    bool is_encrypted) const {
   Codec default_codec = Codec::INVALID_CODEC;
   if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec))
     return false;
-  return IsCodecSupported(default_codec);
+  return IsCodecSupported(default_codec, mime_type_lower_case, is_encrypted);
 }
 
-#if defined(OS_ANDROID)
-bool MimeUtil::IsCodecSupportedOnAndroid(Codec codec) const {
-  switch (codec) {
-    case INVALID_CODEC:
-      return false;
-
-    case PCM:
-    case MP3:
-    case MPEG4_AAC_LC:
-    case MPEG4_AAC_SBR_v1:
-    case MPEG4_AAC_SBR_PS_v2:
-    case VORBIS:
-    case H264:
-    case VP8:
-      return true;
-
-    case AC3:
-    case EAC3:
-      // TODO(servolk): Revisit this for AC3/EAC3 support on AndroidTV
-      return false;
-
-    case MPEG2_AAC_LC:
-    case MPEG2_AAC_MAIN:
-    case MPEG2_AAC_SSR:
-      // MPEG-2 variants of AAC are not supported on Android.
-      return false;
-
-    case OPUS:
-      // Opus is supported only in Lollipop+ (API Level 21).
-      return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
-
-    case HEVC_MAIN:
-#if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-      // HEVC/H.265 is supported in Lollipop+ (API Level 21), according to
-      // http://developer.android.com/reference/android/media/MediaFormat.html
-      return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
-#else
-      return false;
-#endif
-
-    case VP9:
-      // VP9 is supported only in KitKat+ (API Level 19).
-      return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
-
-    case THEORA:
-      return false;
-  }
-
-  return false;
-}
-#endif
-
 }  // namespace internal
 }  // namespace media