Implement support for vp9 in ISO-BMFF

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"
@@ skipping 27 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
+//   vp09....    - 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
+#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+    // This is not a complete list of supported vp9 codecs. Similar to avc1
+    // comments above.
+    "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,"
 #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";
 #endif  // USE_PROPRIETARY_CODECS
 
 // A list of media types (https://en.wikipedia.org/wiki/Media_type) and
@@ skipping 41 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 ParseAVCCodecId().
     // hev1/hvc1.XXXXXX may be unambiguous; handled by ParseHEVCCodecID().
+    // vp09.xx.xx.xx.xx.xx.xx.xx may be unambiguous; handled by
+    // ParseVpxCodecID().

[ddorwin, 2016/02/29 23:57:34]

s/x/9/

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

Done.

     {"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},

[ddorwin, 2016/02/29 23:57:34]

As discussed, you may want to remove these and rely on ParseVp9CodecID in all
cases.

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

Done.

     {"vp9.0", MimeUtil::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},
@@ skipping 90 matching lines @@
       *is_ambiguous = false;
     }
 
     return true;
   }
 
   return false;
 }
 #endif
 
+#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+// Handle parsing of vp9 codec IDs.
+static bool ParseVp9CodecID(const std::string& codec_id,
+                            MimeUtil::Codec* codec,
+                            bool* is_ambiguous) {

[ddorwin, 2016/03/01 00:21:40]

Since there are no ambiguous VPx strings (ignoring the fact that "vp9" is
assumed to be profile 0), I don't think we need this parameter. Just set it at
the call site.

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

Done.

+  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] == "vp09") {
+    *codec = MimeUtil::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)

[ddorwin, 2016/02/29 23:57:34]

We'll need to actually check whether platform supports the profile, etc. before
shipping this. For libvpx, we can know statically. This may share some querying
and IPC infrastructure with similar efforts for HEVC.

+    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  // #if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+
 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()
@@ skipping 22 matching lines @@
     bool is_ambiguous = true;
     Codec codec = INVALID_CODEC;
     if (!StringToCodec(codecs[i], &codec, &is_ambiguous))
       return IsNotSupported;
 
     if (!IsCodecSupported(codec, mime_type_lower_case, is_encrypted) ||
         supported_codecs.find(codec) == supported_codecs.end()) {
       return IsNotSupported;
     }
 
+#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+    // VP9 is supported in mp4, but the old style codec string is not supported.
+    if ((mime_type_lower_case == "video/x-m4v" ||
+         mime_type_lower_case == "video/mp4") &&
+        codec == MimeUtil::VP9) {

[ddorwin, 2016/03/01 00:21:40]

Check the enum first.
As we discussed, should be moved inside StringToCodec() and the logic may
change.

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

No longer needed. Removed.

+      if (!ParseVp9CodecID(codecs[i], &codec, &is_ambiguous))
+        return IsNotSupported;
+    }
+#endif
+
     if (is_ambiguous)
       result = MayBeSupported;
   }
 
   return result;
 }
 
 void MimeUtil::InitializeMimeTypeMaps() {
 // Initialize the supported media types.
 #if defined(USE_PROPRIETARY_CODECS)
@@ skipping 223 matching lines @@
         return true;
 
       // Otherwise, platform support is required.
       return platform_info.supports_vp9;
     }
   }
 
   return false;
 }
 
 bool MimeUtil::StringToCodec(const std::string& codec_id,

[ddorwin, 2016/03/01 00:21:40]

This is no longer a simple conversion. I think we may want to rename it to
ParseCodecString().

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

Unfortunately ParseCodecString is already taken.

[ddorwin, 2016/03/02 00:58:21]

Okay, I'll work on this.

                              Codec* codec,

[ddorwin, 2016/03/01 00:21:40]

When we add platform checks, we'll either need to add them after each of the
Parse*() calls before returning true or expose generic values for profile, etc.
as output parameters and make a single check, including the Codec enum. In the
former case, we'd need to rename this beyond my suggestion above. Having a
function whose sole purpose is to parse (the latter case) seems appealing,
though, and is easier to test.

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

Another option is to define different Codec enums for different profiles, e.g.

VP9_PROFILE_0, VP9_PROFILE_1,
HEVC_MAIN etc.

[ddorwin, 2016/03/02 00:58:21]

Yes, but I think we want to avoid that in general since it pollutes the switch
statements for general codec checks.

                              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;

[ddorwin, 2016/02/29 23:57:34]

// Exact match. No further parsing necessary.

     *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.
 
 #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;
   }
 
+#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+  if (ParseVp9CodecID(codec_id, codec, is_ambiguous)) {
+    return true;
+  }
+#endif
+
   DVLOG(4) << __FUNCTION__ << ": Unrecognized codec id " << codec_id;
   return false;
 }
 
 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)
@@ skipping 55 matching lines @@
     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, mime_type_lower_case, is_encrypted);
 }
 
 }  // namespace internal
 }  // namespace media