Implement support for vp9 in ISO-BMFF

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"
@@ skipping 197 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....    - VP8

[ddorwin, 2016/01/27 01:39:15]

We should have playback tests (both clear and encrypted) before we go
advertising this. Perhaps land the files that add playback support along with
tests before changing the type support code.

[ddorwin, 2016/01/27 03:17:09]

Specifically, playback tests for src=, MSE, and MSE/EME. (.src=.mp4 is not
supported for EME).

[kqyang, 2016/01/29 00:34:17]

Added tests and test files. Let me know if you'd like them to be in another cl
instead.

+//   vp09....    - VP9

[ddorwin, 2016/01/27 03:17:09]

Do we want to turn this on by default before the spec is finalized?
(It's fine to implement, but should it be behind a flag?)
Speaking of which, we may want to do an Intent To...

[kqyang, 2016/01/29 00:34:17]

Sure, added flag ENABLE_MP4_VP8_VP9_DEMUXING, off for now.

 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
+    // This is not a complete list of supported vpx codecs.

[ddorwin, 2016/01/27 01:39:15]

Does the same comment as for avc1 apply? Perhaps refer to it here (e.g. "Similar
to above...").

[kqyang, 2016/01/29 00:34:17]

Done.

+    "vp08.00.00.08.01.01.00.00,vp09.00.00.08.00.01.00.00,"
     "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)

[ddorwin, 2016/01/27 01:39:15]

It's unfortunate how this was inserted in the mp4a.* list. We should fix that
separately.

[kqyang, 2016/01/29 00:34:17]

Since it is just reordering, I'll fix it in this cl.

     // 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
 // corresponding media codecs supported by these types/containers.
 // Media formats marked as PROPRIETARY are not supported by Chromium, only
@@ skipping 39 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},
@@ skipping 22 matching lines @@
 
 // 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},
     // avc1/avc3.XXXXXX may be ambiguous; handled by ParseH264CodecID().
+    {"vp08", MimeUtil::VP8},
+    {"vp09", MimeUtil::VP9},
+    // vp08/vp09.xx.xx.xx.xx.xx.xx.xx may be ambiguous; handled by
+    // ParseVpxCodecID().
 };
 
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
 static const char kHexString[] = "0123456789ABCDEF";
 static char IntToHex(int i) {
   DCHECK_GE(i, 0) << i << " not a hex value";
   DCHECK_LE(i, 15) << i << " not a hex value";
   return kHexString[i];
 }
 
@@ skipping 274 matching lines @@
       *is_ambiguous = false;
     }
 
     return true;
   }
 
   return false;
 }
 #endif
 
+// 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);
+  DCHECK_GE(fields.size(), 1u);
+  if (fields[0] == "vp08") {
+    *codec = MimeUtil::VP8;
+  } else 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 ambiguous.
+    if (fields[i] == "") {
+      *is_ambiguous = true;
+      return true;
+    }
+    int value;
+    if (!base::StringToInt(fields[i], &value))
+      return false;
+    if (value < 0)
+      return false;
+    values.push_back(value);
+  }
+
+  *is_ambiguous = true;
+  // The spec specifies 8 fields (7 values excluding the first codec field).
+  // It is ambiguous with missing fields.

[ddorwin, 2016/01/27 01:39:15]

Do we want to support this? Having supported just "avc1" has led to the point
where we must support it indefinitely and cannot make any true determination
about what is being served. Since this is new and we are likely the first to
support it, can we be more strict and require exactly 8 fields?

[kqyang, 2016/01/29 00:34:17]

I am not sure whether that is a good idea as the spec explicitly mentions that
the fields can be omitted and truncated, but sure (we can always relax the code
later if needed).

Done.

+  if (values.size() < 7)
+    return true;
+
+  const int profile = values[0];
+  if (profile > 3)
+    return true;
+
+  const int bit_depth = values[2];
+  if (bit_depth != 8 && bit_depth != 10 && bit_depth != 12)
+    return true;
+
+  const int color_space = values[3];
+  if (color_space > 7)
+    return true;
+
+  const int chroma_subsampling = values[4];
+  if (chroma_subsampling > 3)
+    return true;
+
+  const int transfer_function = values[5];
+  if (transfer_function > 1)
+    return true;
+
+  const int video_full_range_flag = values[6];
+  if (video_full_range_flag > 1)
+    return true;
+
+  *is_ambiguous = false;
+  return true;
+}
+
 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 VPx, 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);
+  if (ParseH264CodecID(codec_id, codec, is_ambiguous)) {
+    return true;
+  }
+  if (ParseVpxCodecID(codec_id, codec, is_ambiguous)) {
+    return true;
+  }
+  return false;
 }
 
 bool MimeUtil::IsCodecSupported(Codec codec) const {
   DCHECK_NE(codec, INVALID_CODEC);
 
 #if defined(OS_ANDROID)
   if (!IsCodecSupportedOnAndroid(codec))
     return false;
 #endif
 
@@ skipping 68 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