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

media/base/mime_util.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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/macros.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/mime_util.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 {
 
 // Singleton utility class for mime types.
 class MimeUtil {
  public:
   enum Codec {
     INVALID_CODEC,
     PCM,
@@ skipping 17 matching lines @@
     THEORA
   };
 
   bool IsSupportedMediaMimeType(const std::string& mime_type) const;
 
   void ParseCodecString(const std::string& codecs,
                         std::vector<std::string>* codecs_out,
                         bool strip);
 
   SupportsType IsSupportedMediaFormat(
+      bool is_encrypted,

[ddorwin, 2016/02/16 20:34:37]

nit: It seems odd that |is_encrypted| is the first and "most important"
parameter.

[DaleCurtis, 2016/02/17 03:01:05]

Had to redo all of these changes after the split, so done :)

       const std::string& mime_type,
       const std::vector<std::string>& codecs) const;
 
   void RemoveProprietaryMediaTypesAndCodecsForTests();
 
  private:
   friend struct base::DefaultLazyInstanceTraits<MimeUtil>;
 
   typedef base::hash_set<int> CodecSet;
   typedef std::map<std::string, CodecSet> MediaFormatMappings;
   struct CodecEntry {
     CodecEntry() : codec(INVALID_CODEC), is_ambiguous(true) {}
     CodecEntry(Codec c, bool ambiguous) : codec(c), is_ambiguous(ambiguous) {}
     Codec codec;
     bool is_ambiguous;
   };
   typedef std::map<std::string, CodecEntry> StringToCodecMappings;
 
   MimeUtil();
 
   // For faster lookup, keep hash sets.
   void InitializeMimeTypeMaps();
 
-  // Returns IsSupported if all codec IDs in |codecs| are unambiguous
-  // and are supported by the platform. MayBeSupported is returned if
-  // at least one codec ID in |codecs| is ambiguous but all the codecs
-  // are supported by the platform. IsNotSupported is returned if at
-  // least one codec ID  is not supported by the platform.
-  SupportsType AreSupportedCodecs(
-      const CodecSet& supported_codecs,
-      const std::vector<std::string>& codecs) const;
+  // Returns IsSupported if all codec IDs in |codecs| are unambiguous and are
+  // supported by the platform when contained in |mime_type_lower_case|.

[ddorwin, 2016/02/16 20:34:37]

"platform" - This was the existing phrasing, but elsewhere
(*PlatformDecoderSupport) this CL uses it to mean OS-level codecs. Is there a
better phrasing?

[DaleCurtis, 2016/02/17 03:01:05]

Deleted platform from wording here.

+  // MayBeSupported is returned if at least one codec ID in |codecs| is
+  // ambiguous but all the codecs are supported by the platform. IsNotSupported
+  // is returned if at least one codec ID  is not supported by the platform.

[ddorwin, 2016/02/16 20:34:37]

nit: two spaces

[DaleCurtis, 2016/02/17 03:01:05]

Done.

+  // |is_encrypted| means the codec will be used with encrypted samples.

[ddorwin, 2016/02/16 20:34:37]

nit: s/samples/blocks/?

[DaleCurtis, 2016/02/17 03:01:05]

Done.

+  SupportsType AreSupportedCodecs(bool is_encrypted,
+                                  const std::string& mime_type_lower_case,
+                                  const CodecSet& supported_codecs,
+                                  const std::vector<std::string>& codecs) const;
 
   // Converts a codec ID into an Codec enum value and indicates
   // whether the conversion was ambiguous.
   // Returns true if this method was able to map |codec_id| to a specific
   // Codec enum value. |codec| and |is_ambiguous| are only valid if true
   // is returned. Otherwise their value is undefined after the call.
   // |is_ambiguous| is true if |codec_id| did not have enough information to
   // unambiguously determine the proper Codec enum value. If |is_ambiguous|
   // is true |codec| contains the best guess for the intended Codec enum value.
   bool StringToCodec(const std::string& codec_id,
                      Codec* codec,
                      bool* is_ambiguous) const;
 
-  // Returns true if |codec| is supported by the platform.
-  // Note: This method will return false if the platform supports proprietary
-  // codecs but |allow_proprietary_codecs_| is set to false.
-  bool IsCodecSupported(Codec codec) const;
+  // Returns true if |codec| and |mime_type_lower_case| are supported by the

[ddorwin, 2016/02/16 20:34:37]

Add "when contained in" as above?

[DaleCurtis, 2016/02/17 03:01:05]

Done.

+  // platform. Note: This method will return false if the platform supports

[ddorwin, 2016/02/16 20:34:37]

ditto for "platform"

[DaleCurtis, 2016/02/17 03:01:05]

Done.

+  // proprietary codecs but |allow_proprietary_codecs_| is set to false.
+  // |is_encrypted| means the codec will be used with encrypted samples.

[ddorwin, 2016/02/16 20:34:37]

ditto for "samples"

[DaleCurtis, 2016/02/17 03:01:05]

Done.

+  bool IsCodecSupported(bool is_encrypted,
+                        const std::string& mime_type_lower_case,
+                        Codec codec) const;
 
   // Returns true if |codec| refers to a proprietary codec.
   bool IsCodecProprietary(Codec codec) const;
 
   // Returns true and sets |*default_codec| if |mime_type| has a  default codec
   // associated with it. Returns false otherwise and the value of
   // |*default_codec| is undefined.
   bool GetDefaultCodecLowerCase(const std::string& mime_type_lower_case,
                                 Codec* default_codec) const;
 
   // Returns true if |mime_type_lower_case| has a default codec associated with
   // it and IsCodecSupported() returns true for that particular codec.
+  // |is_encrypted| means the codec will be used with encrypted samples.
   bool IsDefaultCodecSupportedLowerCase(
+      bool is_encrypted,
       const std::string& mime_type_lower_case) const;
 
   // A map of mime_types and hash map of the supported codecs for the mime_type.
   MediaFormatMappings media_format_map_;
 
   // Keeps track of whether proprietary codec support should be
   // advertised to callers.
   bool allow_proprietary_codecs_;
 
   // Lookup table for string compare based string -> Codec mappings.
   StringToCodecMappings string_to_codec_map_;
 
   DISALLOW_COPY_AND_ASSIGN(MimeUtil);
 };  // class MimeUtil
 
 // This variable is Leaky because it is accessed from WorkerPool threads.
 static base::LazyInstance<MimeUtil>::Leaky g_media_mime_util =
     LAZY_INSTANCE_INITIALIZER;
 
 #if defined(OS_ANDROID)
-static bool IsCodecSupportedOnAndroid(MimeUtil::Codec codec) {
+static bool IsCodecSupportedOnAndroid(bool is_encrypted,
+                                      const std::string& mime_type_lower_case,
+                                      MimeUtil::Codec codec) {
   switch (codec) {
     case MimeUtil::INVALID_CODEC:
       return false;
 
     case MimeUtil::PCM:
     case MimeUtil::MP3:
     case MimeUtil::MPEG4_AAC_LC:
     case MimeUtil::MPEG4_AAC_SBR_v1:
     case MimeUtil::MPEG4_AAC_SBR_PS_v2:
     case MimeUtil::VORBIS:
+      return is_encrypted ? MediaCodecUtil::IsMediaCodecAvailable() : true;

[ddorwin, 2016/02/16 20:34:37]

Note: The !is_encrypted path works for MSE because MSE will not be enabled if
IsMediaCodecAvailable() is false. (Otherwise, it would be similar to the
is_encrypted path.)

Perhaps this should be noted in a function-level comment.

[DaleCurtis, 2016/02/17 03:01:05]

As discussed via chat, added a comment above the switch about why we don't care
about MSE here.

+
     case MimeUtil::H264_BASELINE:
     case MimeUtil::H264_MAIN:
     case MimeUtil::H264_HIGH:
+      if (IsUnifiedMediaPipelineEnabled()) {
+        return HasPlatformDecoderSupport() &&

[ddorwin, 2016/02/16 20:34:37]

All HasPlatformDecoderSupport() means is that the HW video decoding is not
disabled. The name seems misleading. (Also, on Android, it may be disabling
audio codecs too(?).)

[DaleCurtis, 2016/02/17 03:01:05]

It can mean: no gpu process, vda is blacklisted, or !media_codec. As such, I
think the name is okay the way it is. It includes any reason why we wouldn't
have platform decoder support.  Audio should be included for encrypted codecs
since we'll be hosting the decoder in the GPU process.

[ddorwin, 2016/02/17 21:18:38]

The MediaCodec check was added in the next patch set, so this makes sense now.

+               MediaCodecUtil::IsMediaCodecAvailable();
+      }
+      return is_encrypted ? MediaCodecUtil::IsMediaCodecAvailable() : true;

[ddorwin, 2016/02/16 20:34:37]

Why are encrypted videos not also subject to HasPlatformDecoderSupport()?

[DaleCurtis, 2016/02/17 03:01:05]

Done.

+
     case MimeUtil::VP8:
-      return true;
+      if (!is_encrypted)

[ddorwin, 2016/02/16 20:34:37]

Doesn't encrypted require IsMediaCodecAvailable() (and
HasPlatformDecoderSupport())?

[DaleCurtis, 2016/02/17 03:01:05]

Done.

+        return true;
+
+      if (MediaCodecUtil::IsVp8Blacklisted())

[ddorwin, 2016/02/16 20:34:37]

Is VP8 blacklisted for Android MediaPlayer too?

It seems we should return true early for the WMPA non-encrypted non-MSE* case,
then check the blacklist, then check the others.

* Of course, we have no way to know if this is MSE here.

[DaleCurtis, 2016/02/17 03:01:05]

No it's only blacklisted for MediaCodec, I've cleaned this up a fair bit.

+        return false;
+
+      return IsUnifiedMediaPipelineEnabled() ? HasPlatformDecoderSupport()

[ddorwin, 2016/02/16 20:34:37]

libvpx can't used for VP8?

[DaleCurtis, 2016/02/17 03:01:05]

This was for encrypted cases, but is unclear, I've simplified the logic.

+                                             : true;
 
     case MimeUtil::AC3:
     case MimeUtil::EAC3:
       // TODO(servolk): Revisit this for AC3/EAC3 support on AndroidTV
       return false;
 
     case MimeUtil::MPEG2_AAC_LC:
     case MimeUtil::MPEG2_AAC_MAIN:
     case MimeUtil::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.

[ddorwin, 2016/02/16 20:34:37]

... and the software decoders...

[DaleCurtis, 2016/02/17 03:01:05]

Done.

+      return !is_encrypted && IsUnifiedMediaPipelineEnabled();
 
     case MimeUtil::OPUS:
-      // Opus is supported only in Lollipop+ (API Level 21).
-      return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
+      if (!is_encrypted && IsUnifiedMediaPipelineEnabled())
+        return true;

[ddorwin, 2016/02/16 20:34:37]

Perhaps:
  // Software decoder.

[DaleCurtis, 2016/02/17 03:01:05]

Done.

+
+      if (!MediaCodecUtil::PlatformHasOpusSupport())
+        return false;
+
+      // Android does not support opus in ogg containers.
+      if (base::EndsWith(mime_type_lower_case, "ogg",
+                         base::CompareCase::SENSITIVE)) {
+        return false;
+      }
+
+      return is_encrypted ? MediaCodecUtil::IsMediaCodecAvailable() : true;
 
     case MimeUtil::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 MimeUtil::VP9:
-      // VP9 is supported only in KitKat+ (API Level 19).
-      return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
+    case MimeUtil::VP9: {
+      const bool has_unified_media_pipeline = IsUnifiedMediaPipelineEnabled();
+      if (!is_encrypted && has_unified_media_pipeline)
+        return true;
+
+      if (!MediaCodecUtil::PlatformHasVp9Support())
+        return false;
+
+      if (!is_encrypted)
+        return true;
+
+      if (!MediaCodecUtil::IsMediaCodecAvailable())
+        return false;
+
+      return has_unified_media_pipeline ? HasPlatformDecoderSupport() : true;

[ddorwin, 2016/02/16 20:34:37]

Why is HasPlatformDecoderSupport() only required for the unified pipeline? All
encrypted media uses the platform decoders.

It seems 231 & 234 should be collapsed. (That would also make it a bit clearer
that this is all handling the encrypted case.)

[DaleCurtis, 2016/02/17 03:01:05]

Again this was confusing, though correct, simplified greatly.

+    }
 
     case MimeUtil::THEORA:
       return false;
   }
 
   return false;
 }
 #endif
 
 enum MediaFormatType { COMMON, PROPRIETARY };
@@ skipping 53 matching lines @@
 
 // A list of media types (https://en.wikipedia.org/wiki/Media_type) and
 // corresponding media codecs supported by these types/containers.
 // Media formats marked as PROPRIETARY are not supported by Chromium, only
 // Google Chrome browser supports them.
 static const MediaFormat kFormatCodecMappings[] = {
     {"video/webm", COMMON, "opus,vorbis,vp8,vp8.0,vp9,vp9.0"},
     {"audio/webm", COMMON, "opus,vorbis"},
     {"audio/wav", COMMON, "1"},
     {"audio/x-wav", COMMON, "1"},
-#if defined(OS_ANDROID)
-    // Android does not support Opus in Ogg container.
-    // Android does not support Theora and thus video/ogg.
-    {"audio/ogg", COMMON, "vorbis"},
-    {"application/ogg", COMMON, "vorbis"},
-#else
+#if !defined(OS_ANDROID)
+    // Note: Android does not support Theora and thus video/ogg.
     {"video/ogg", COMMON, "opus,theora,vorbis"},
+#endif
     {"audio/ogg", COMMON, "opus,vorbis"},
+    // Note: Theora is not supported on Android and will be rejected during the
+    // call to IsCodecSupportedOnAndroid().
     {"application/ogg", COMMON, "opus,theora,vorbis"},
-#endif
 #if defined(USE_PROPRIETARY_CODECS)
     {"audio/mpeg", PROPRIETARY, "mp3"},
     {"audio/mp3", PROPRIETARY, ""},
     {"audio/x-mp3", PROPRIETARY, ""},
     {"audio/aac", PROPRIETARY, ""},  // AAC / ADTS
     {"audio/mp4", PROPRIETARY, kMP4AudioCodecsExpression},
     {"audio/x-m4a", PROPRIETARY, kMP4AudioCodecsExpression},
     {"video/mp4", PROPRIETARY, kMP4VideoCodecsExpression},
     {"video/x-m4v", PROPRIETARY, kMP4VideoCodecsExpression},
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
@@ skipping 111 matching lines @@
   // This is not a valid legacy avc1 codec id - return the original codec id.
   return codec_id;
 }
 #endif
 
 MimeUtil::MimeUtil() : allow_proprietary_codecs_(false) {
   InitializeMimeTypeMaps();
 }
 
 SupportsType MimeUtil::AreSupportedCodecs(
+    bool is_encrypted,
+    const std::string& mime_type_lower_case,
     const CodecSet& supported_codecs,
     const std::vector<std::string>& codecs) 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(is_encrypted, mime_type_lower_case, codec) ||
         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(
+    bool is_encrypted,
     const std::string& mime_type,
     const std::vector<std::string>& codecs) 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(
+                                  is_encrypted, mime_type_lower_case))
                ? 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(is_encrypted, mime_type_lower_case, default_codec)
+               ? 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(is_encrypted, mime_type_lower_case,
+                              it_media_format_map->second, codecs_to_check);
   }
 #endif
 
-  return AreSupportedCodecs(it_media_format_map->second, codecs);
+  return AreSupportedCodecs(is_encrypted, mime_type_lower_case,
+                            it_media_format_map->second, codecs);
 }
 
 void MimeUtil::RemoveProprietaryMediaTypesAndCodecsForTests() {
   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 IsValidH264Level(const std::string& level_str) {
@@ skipping 112 matching lines @@
   // 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
   return ParseH264CodecID(codec_id, codec, is_ambiguous);
 }
 
-bool MimeUtil::IsCodecSupported(Codec codec) const {
+bool MimeUtil::IsCodecSupported(bool is_encrypted,
+                                const std::string& mime_type_lower_case,
+                                Codec codec) const {
   DCHECK_NE(codec, INVALID_CODEC);
 
 #if defined(OS_ANDROID)
-  if (!IsCodecSupportedOnAndroid(codec))
+  if (!IsCodecSupportedOnAndroid(is_encrypted, mime_type_lower_case, codec))
     return false;
 #endif
 
   return allow_proprietary_codecs_ || !IsCodecProprietary(codec);
 }
 
 bool MimeUtil::IsCodecProprietary(Codec codec) const {
   switch (codec) {
     case INVALID_CODEC:
     case AC3:
@@ skipping 34 matching lines @@
 
   if (mime_type_lower_case == "audio/aac") {
     *default_codec = MimeUtil::MPEG4_AAC_LC;
     return true;
   }
 
   return false;
 }
 
 bool MimeUtil::IsDefaultCodecSupportedLowerCase(
+    bool is_encrypted,
     const std::string& mime_type_lower_case) const {
   Codec default_codec = Codec::INVALID_CODEC;
   if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec))
     return false;
-  return IsCodecSupported(default_codec);
+  return IsCodecSupported(is_encrypted, mime_type_lower_case, default_codec);
 }
 
 bool IsSupportedMediaMimeType(const std::string& mime_type) {
   return g_media_mime_util.Get().IsSupportedMediaMimeType(mime_type);
 }
 
 SupportsType IsSupportedMediaFormat(const std::string& mime_type,

[ddorwin, 2016/02/16 20:34:37]

To avoid misuse in the future, should we rename this to
IsSupportedClearMediaFormat? We don't need to do that churn in this CL.

[DaleCurtis, 2016/02/17 03:01:05]

Acknowledged.

                                     const std::vector<std::string>& codecs) {
-  return g_media_mime_util.Get().IsSupportedMediaFormat(mime_type, codecs);
+  return g_media_mime_util.Get().IsSupportedMediaFormat(false, mime_type,
+                                                        codecs);
+}
+
+SupportsType IsSupportedEncryptedMediaFormat(
+    const std::string& mime_type,
+    const std::vector<std::string>& codecs) {
+  return g_media_mime_util.Get().IsSupportedMediaFormat(true, mime_type,
+                                                        codecs);
 }
 
 void ParseCodecString(const std::string& codecs,
                       std::vector<std::string>* codecs_out,
                       const bool strip) {
   g_media_mime_util.Get().ParseCodecString(codecs, codecs_out, strip);
 }
 
 void RemoveProprietaryMediaTypesAndCodecsForTests() {
   g_media_mime_util.Get().RemoveProprietaryMediaTypesAndCodecsForTests();
 }
 
 }  // namespace media