Implement support for vp9 in ISO-BMFF

media/base/mime_util.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.

[ddorwin, 2016/02/24 22:44:33]

Please rebase. Most of this code has moved.

 // 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"
@@ skipping 25 matching lines @@
     MPEG2_AAC_SSR,
     MPEG4_AAC_LC,
     MPEG4_AAC_SBR_v1,
     MPEG4_AAC_SBR_PS_v2,
     VORBIS,
     OPUS,
     H264_BASELINE,
     H264_MAIN,
     H264_HIGH,
     HEVC_MAIN,
-    VP8,
-    VP9,
+    WEBM_VP8,

[ddorwin, 2016/02/24 22:44:33]

We may not need these anymore. We can now (after rebasing) check the MIME type
string with the codec for Android.

However, we may still need them because the codec strings are different, BUT I
do not think that should be exposed in this enum.

We may need to pass the MIME type to StringToCodec() to make sure we are
checking the appropriate strings. This would also help us avoid adding support
for new codecs with legacy container strings.

[kqyang, 2016/03/01 01:18:52]

Removed and pass MIME type to StringToCodec instead as suggested.

+    WEBM_VP9,
+    MPEG4_VP8,

[ddorwin, 2016/02/24 22:44:33]

As discussed, unless there is a demand for VP8 in MP4, let's not enable it.

[kqyang, 2016/03/01 01:18:52]

Removed.

+    MPEG4_VP9,
     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(
@@ skipping 85 matching lines @@
 
     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:
     case MimeUtil::H264_BASELINE:
     case MimeUtil::H264_MAIN:
     case MimeUtil::H264_HIGH:
-    case MimeUtil::VP8:
+    case MimeUtil::WEBM_VP8:
       return 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;
 
     case MimeUtil::OPUS:
       // Opus is supported only in Lollipop+ (API Level 21).
       return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
 
     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:
+    case MimeUtil::WEBM_VP9:
       // VP9 is supported only in KitKat+ (API Level 19).
       return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
 
     case MimeUtil::THEORA:
       return false;
+
+    case MimeUtil::MPEG4_VP8:
+    case MimeUtil::MPEG4_VP9:
+      // TODO(kqyang): Verify if it is supported in Android. Return false for

[ddorwin, 2016/02/25 00:27:47]

This will work with the unified pipeline (see new code) but not otherwise.

+      // now.
+      return false;
   }
 
   return false;
 }
 #endif
 
 enum MediaFormatType { COMMON, PROPRIETARY };
 
 struct MediaFormat {
   const char* const mime_type;
@@ skipping 11 matching lines @@
 //   mp4a.40.2   - MPEG-4 AAC LC
 //   mp4a.40.02  - MPEG-4 AAC LC (leading 0 in aud-oti for compatibility)
 //   mp4a.40.5   - MPEG-4 HE-AAC v1 (AAC LC + SBR)
 //   mp4a.40.05  - MPEG-4 HE-AAC v1 (AAC LC + SBR) (leading 0 in aud-oti for
 //                 compatibility)
 //   mp4a.40.29  - MPEG-4 HE-AAC v2 (AAC LC + SBR + PS)
 //
 //   avc1.42E0xx - H.264 Baseline
 //   avc1.4D40xx - H.264 Main
 //   avc1.6400xx - H.264 High
+//   vp08....    - MPEG4 VP8
+//   vp09....    - MPEG4 VP9
 static const char kMP4AudioCodecsExpression[] =
     "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.02,mp4a.40.5,"
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
     // Only one variant each of ac3 and eac3 codec string is sufficient here,
     // since these strings are parsed and mapped to MimeUtil::Codec enum values.
     "ac-3,ec-3,"
 #endif
     "mp4a.40.05,mp4a.40.29";
 static const char kMP4VideoCodecsExpression[] =
     // This is not a complete list of supported avc1 codecs. It is simply used
     // to register support for the corresponding Codec enum. Instead of using
     // strings in these three arrays, we should use the Codec enum values.
     // This will avoid confusion and unnecessary parsing at runtime.
     // kUnambiguousCodecStringMap/kAmbiguousCodecStringMap should be the only
     // mapping from strings to codecs. See crbug.com/461009.
     "avc1.42E00A,avc1.4D400A,avc1.64000A,"
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
     // Any valid unambiguous HEVC codec id will work here, since these strings
     // are parsed and mapped to MimeUtil::Codec enum values.
     "hev1.1.6.L93.B0,"
 #endif
-    "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.02,mp4a.40.5,"
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
     // Only one variant each of ac3 and eac3 codec string is sufficient here,
     // since these strings are parsed and mapped to MimeUtil::Codec enum values.
     "ac-3,ec-3,"
 #endif
+#if BUILDFLAG(ENABLE_MP4_VP8_VP9_DEMUXING)
+    // This is not a complete list of supported vpx codecs. Similar to avc1
+    // comments above.
+    "vp08.00.00.08.01.01.00.00,vp09.00.00.08.00.01.00.00,"
+#endif
+    "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.02,mp4a.40.5,"
     "mp4a.40.05,mp4a.40.29";
 #endif  // USE_PROPRIETARY_CODECS
 
 // 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"},
@@ skipping 35 matching lines @@
 };
 
 // List of codec IDs that provide enough information to determine the
 // codec and profile being requested.
 //
 // The "mp4a" strings come from RFC 6381.
 static const CodecIDMappings kUnambiguousCodecStringMap[] = {
     {"1", MimeUtil::PCM},  // We only allow this for WAV so it isn't ambiguous.
     // avc1/avc3.XXXXXX may be unambiguous; handled by ParseH264CodecID().
     // hev1/hvc1.XXXXXX may be unambiguous; handled by ParseHEVCCodecID().
+    // vp08/vp09.xx.xx.xx.xx.xx.xx.xx may be unambiguous; handled by
+    // ParseVpxCodecID().
     {"mp3", MimeUtil::MP3},
     {"mp4a.66", MimeUtil::MPEG2_AAC_MAIN},
     {"mp4a.67", MimeUtil::MPEG2_AAC_LC},
     {"mp4a.68", MimeUtil::MPEG2_AAC_SSR},
     {"mp4a.69", MimeUtil::MP3},
     {"mp4a.6B", MimeUtil::MP3},
     {"mp4a.40.2", MimeUtil::MPEG4_AAC_LC},
     {"mp4a.40.02", MimeUtil::MPEG4_AAC_LC},
     {"mp4a.40.5", MimeUtil::MPEG4_AAC_SBR_v1},
     {"mp4a.40.05", MimeUtil::MPEG4_AAC_SBR_v1},
     {"mp4a.40.29", MimeUtil::MPEG4_AAC_SBR_PS_v2},
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
     // TODO(servolk): Strictly speaking only mp4a.A5 and mp4a.A6 codec ids are
     // valid according to RFC 6381 section 3.3, 3.4. Lower-case oti (mp4a.a5 and
     // mp4a.a6) should be rejected. But we used to allow those in older versions
     // of Chromecast firmware and some apps (notably MPL) depend on those codec
     // types being supported, so they should be allowed for now
     // (crbug.com/564960).
     {"ac-3", MimeUtil::AC3},
     {"mp4a.a5", MimeUtil::AC3},
     {"mp4a.A5", MimeUtil::AC3},
     {"ec-3", MimeUtil::EAC3},
     {"mp4a.a6", MimeUtil::EAC3},
     {"mp4a.A6", MimeUtil::EAC3},
 #endif
     {"vorbis", MimeUtil::VORBIS},
     {"opus", MimeUtil::OPUS},
-    {"vp8", MimeUtil::VP8},
-    {"vp8.0", MimeUtil::VP8},
-    {"vp9", MimeUtil::VP9},
-    {"vp9.0", MimeUtil::VP9},
+    {"vp8", MimeUtil::WEBM_VP8},
+    {"vp8.0", MimeUtil::WEBM_VP8},
+    {"vp9", MimeUtil::WEBM_VP9},
+    {"vp9.0", MimeUtil::WEBM_VP9},
     {"theora", MimeUtil::THEORA}};
 
 // List of codec IDs that are ambiguous and don't provide
 // enough information to determine the codec and profile.
 // The codec in these entries indicate the codec and profile
 // we assume the user is trying to indicate.
 static const CodecIDMappings kAmbiguousCodecStringMap[] = {
     {"mp4a.40", MimeUtil::MPEG4_AAC_LC},
     {"avc1", MimeUtil::H264_BASELINE},
     {"avc3", MimeUtil::H264_BASELINE},
@@ skipping 285 matching lines @@
       *is_ambiguous = false;
     }
 
     return true;
   }
 
   return false;
 }
 #endif
 
+#if BUILDFLAG(ENABLE_MP4_VP8_VP9_DEMUXING)
+// Handle parsing of vpx codec IDs.
+static bool ParseVpxCodecID(const std::string& codec_id,
+                            MimeUtil::Codec* codec,
+                            bool* is_ambiguous) {
+  std::vector<std::string> fields = base::SplitString(
+      codec_id, ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+  if (fields.size() < 1)
+    return false;
+
+  if (fields[0] == "vp08") {
+    *codec = MimeUtil::MPEG4_VP8;
+  } else if (fields[0] == "vp09") {
+    *codec = MimeUtil::MPEG4_VP9;
+  } else {
+    return false;
+  }
+
+  if (fields.size() > 8)
+    return false;
+
+  std::vector<int> values;
+  for (size_t i = 1; i < fields.size(); ++i) {
+    // Missing value is not allowed.
+    if (fields[i] == "")
+      return false;
+    int value;
+    if (!base::StringToInt(fields[i], &value))
+      return false;
+    if (value < 0)
+      return false;
+    values.push_back(value);
+  }
+
+  // The spec specifies 8 fields (7 values excluding the first codec field).
+  // We do not allow missing fields.
+  if (values.size() < 7)
+    return false;
+
+  const int profile = values[0];
+  if (profile > 3)
+    return false;
+
+  const int bit_depth = values[2];
+  if (bit_depth != 8 && bit_depth != 10 && bit_depth != 12)
+    return false;
+
+  const int color_space = values[3];
+  if (color_space > 7)
+    return false;
+
+  const int chroma_subsampling = values[4];
+  if (chroma_subsampling > 3)
+    return false;
+
+  const int transfer_function = values[5];
+  if (transfer_function > 1)
+    return false;
+
+  const int video_full_range_flag = values[6];
+  if (video_full_range_flag > 1)
+    return false;
+
+  *is_ambiguous = false;
+  return true;
+}
+#endif
+
 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
-  // 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.
+  // either H.264, HEVC/H.265, VP8 or VP9 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);
+  if (ParseH264CodecID(codec_id, codec, is_ambiguous)) {
+    return true;
+  }
+#if BUILDFLAG(ENABLE_MP4_VP8_VP9_DEMUXING)
+  if (ParseVpxCodecID(codec_id, codec, is_ambiguous)) {
+    return true;
+  }
+#endif
+  return false;
 }
 
 bool MimeUtil::IsCodecSupported(Codec codec) const {
   DCHECK_NE(codec, INVALID_CODEC);
 
 #if defined(OS_ANDROID)
   if (!IsCodecSupportedOnAndroid(codec))
     return false;
 #endif
 
   return allow_proprietary_codecs_ || !IsCodecProprietary(codec);
 }
 
 bool MimeUtil::IsCodecProprietary(Codec codec) const {
   switch (codec) {
     case INVALID_CODEC:
     case AC3:
     case EAC3:
     case MP3:
     case MPEG2_AAC_LC:
     case MPEG2_AAC_MAIN:
     case MPEG2_AAC_SSR:
     case MPEG4_AAC_LC:
     case MPEG4_AAC_SBR_v1:
     case MPEG4_AAC_SBR_PS_v2:
     case H264_BASELINE:
     case H264_MAIN:
     case H264_HIGH:
     case HEVC_MAIN:
+    case MPEG4_VP8:

[ddorwin, 2016/02/24 22:44:33]

These codecs aren't actually proprietary. Really, though, I think we should
avoid the container in the name.

[kqyang, 2016/03/01 01:18:52]

Removed.

+    case MPEG4_VP9:
       return true;
 
     case PCM:
     case VORBIS:
     case OPUS:
-    case VP8:
-    case VP9:
+    case WEBM_VP8:
+    case WEBM_VP9:
     case THEORA:
       return false;
   }
 
   return true;
 }
 
 bool MimeUtil::GetDefaultCodecLowerCase(const std::string& mime_type_lower_case,
                                         Codec* default_codec) const {
   if (mime_type_lower_case == "audio/mpeg" ||
@@ skipping 32 matching lines @@
                       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