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_.using_unified_media_pipeline = IsUnifiedMediaPipelineEnabled();
+  platform_info_.has_platform_decoders =
+      platform_info_.using_unified_media_pipeline
+          ? HasPlatformDecoderSupport()
+          : MediaCodecUtil::IsMediaCodecAvailable();

[ddorwin, 2016/02/18 20:37:44]

Why doesn't HasPlatformDecoderSupport() - namely the flags - apply to the old
pipeline?

If those flags are to do what they say (i.e. if a user selected them), even WMPA
should be disabled. I understand that one case is there is no GPU process, and
this would make some sense there, but that's not what the flags indicate to the
user.

Perhaps you really want the previous line to ask whether GPU process-based
decoders are available.

[DaleCurtis, 2016/02/19 01:35:46]

As discussed via chat, comment added.

+  platform_info_.supports_encrypted_vp8 = !MediaCodecUtil::IsVp8Blacklisted();

[ddorwin, 2016/02/18 20:37:44]

Yes, VP8 only applies in the encrypted case, but that seems overly specific and
to expose implementation details to the caller of the function. Also, if MSE was
to start using this, we would need more general information.

Perhaps has_vp8_platform_decoder.

[DaleCurtis, 2016/02/19 01:35:46]

Done.

+  platform_info_.supports_opus = MediaCodecUtil::PlatformHasOpusSupport();
+  platform_info_.supports_vp9 = MediaCodecUtil::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;
 }
 
+void MimeUtil::SetPlatformInfoForTests(const PlatformInfo& info) {
+  platform_info_ = info;
+}
+
 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;
   }
 
 // If |codec_id| is not in |string_to_codec_map_|, then we assume that it is

[ddorwin, 2016/02/18 20:37:44]

Does the new line below not allow us to indent these comments as intended (clang
formatter unindented them)?

[DaleCurtis, 2016/02/19 01:35:46]

Apparently not. It does when I format a section manually, but git cl format
relocates it.

 // either H.264 or HEVC/H.265 codec ID because currently those are the only
 // ones that are not added to the |string_to_codec_map_| and require parsing.
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecID(codec_id, codec, is_ambiguous)) {
     return true;
   }
 #endif
 
   VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
   uint8_t level_idc = 0;
   if (ParseAVCCodecId(codec_id, &profile, &level_idc)) {
     *codec = MimeUtil::H264;
     *is_ambiguous =
         (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 (!IsCodecSupportedOnAndroid(codec, mime_type_lower_case, is_encrypted))
     return false;
 #endif
 
   return allow_proprietary_codecs_ || !IsCodecProprietary(codec);
 }
 
 bool MimeUtil::IsCodecProprietary(Codec codec) const {
   switch (codec) {
     case INVALID_CODEC:
     case AC3:
@@ skipping 32 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 {
+bool MimeUtil::IsCodecSupportedOnAndroid(
+    Codec codec,
+    const std::string& mime_type_lower_case,
+    bool is_encrypted) const {
+  // 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 AC3:
+    case EAC3:
     case INVALID_CODEC:

[ddorwin, 2016/02/18 20:37:44]

This should be first.

[DaleCurtis, 2016/02/19 01:35:46]

Done.

+    case THEORA:
       return false;
 
+    // ----------------------------------------------------------------------
+    // The remaining codecs may be supported depending on platform abilities.
+    // ----------------------------------------------------------------------
     case PCM:

[ddorwin, 2016/02/18 20:37:44]

WDYT of an empty line before this to avoid linking the comment to this specific
block?

[DaleCurtis, 2016/02/19 01:35:46]

Done.

     case MP3:
     case MPEG4_AAC_LC:
     case MPEG4_AAC_SBR_v1:
     case MPEG4_AAC_SBR_PS_v2:
     case VORBIS:
-    case H264:
-    case VP8:
+      // 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 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;
+      // 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_.using_unified_media_pipeline;
 
     case OPUS:
-      // Opus is supported only in Lollipop+ (API Level 21).
-      return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
+      // If clear, the unified pipeline can always decode OPUS in software.
+      if (!is_encrypted && platform_info_.using_unified_media_pipeline)
+        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_.using_unified_media_pipeline)
+        return platform_info_.has_platform_decoders;
+
+      // When MediaPlayer is used, h264 is always supported.
+      DCHECK(!is_encrypted || platform_info_.has_platform_decoders);
+      return true;
 
     case HEVC_MAIN:
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
+      if (platform_info_.using_unified_media_pipeline)
+        return platform_info_.has_platform_decoders;

[ddorwin, 2016/02/18 20:37:44]

This skips the API level check below. I think you need if (A && !B) return
false; instead.

[DaleCurtis, 2016/02/19 01:35:46]

Done.

+
       // 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;

[ddorwin, 2016/02/18 20:37:44]

This line will only compile on Android. This is the only such line in this
function. Either add guards or refactor to remove this check from the function.

[DaleCurtis, 2016/02/19 01:35:46]

Done.

 #else
       return false;
 #endif
 
-    case VP9:
-      // VP9 is supported only in KitKat+ (API Level 19).
-      return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
+    case VP8:
+      // If clear, the unified pipeline can always decode VP8 in software.
+      if (!is_encrypted && platform_info_.using_unified_media_pipeline)
+        return true;
 
-    case THEORA:
-      return false;
+      if (is_encrypted)
+        return platform_info_.supports_encrypted_vp8;
+
+      // MediaPlayer can always play vp8. Note: This is incorrect for MSE, but

[ddorwin, 2016/02/18 20:37:44]

nit: "VP8" for consistency.

[DaleCurtis, 2016/02/19 01:35:46]

Done.

+      // 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_.using_unified_media_pipeline)
+        return true;
+
+      // Otherwise, platform support is required.
+      return platform_info_.supports_vp9;
+    }
   }
 
   return false;
 }
-#endif
 
 }  // namespace internal
 }  // namespace media