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 15 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().
+    // vp9, vp9.0, vp09.xx.xx.xx.xx.xx.xx.xx may be unambiguous; handled by

[ddorwin, 2016/04/18 22:53:29]

Is it possible for these to be ambiguous (at least in a way we consider - the
first two are assumed to be profile 0)?

I think the existing comments may be misleading and related to the fact that
"avc1" is ambiguous (line 87). Perhaps we should change these to just say,
"....XXXXXX are handled by ..."

[kqyang, 2016/04/19 00:28:05]

Per your suggestion below. Now it might be ambiguous, if profile > 0.

[ddorwin, 2016/04/19 17:10:00]

ambiguous is not the same as "maybe". I'll make this change in
https://codereview.chromium.org/1896983004/.

+    // ParseVp9CodecID().
     {"mp3", MimeUtil::MP3},
     // Following is the list of RFC 6381 compliant audio codec strings:
     //   mp4a.66     - MPEG-2 AAC MAIN
     //   mp4a.67     - MPEG-2 AAC LC
     //   mp4a.68     - MPEG-2 AAC SSR
     //   mp4a.69     - MPEG-2 extension to MPEG-1 (MP3)
     //   mp4a.6B     - MPEG-1 audio (MP3)
     //   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)
@@ skipping 21 matching lines @@
     {"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},
     {"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},
     {"avc1", MimeUtil::H264},
     {"avc3", MimeUtil::H264},
@@ skipping 89 matching lines @@
       *is_ambiguous = false;
     }
 
     return true;
   }
 
   return false;
 }
 #endif
 
+// Handle parsing of vp9 codec IDs.
+static bool ParseVp9CodecID(const std::string& mime_type_lower_case,
+                            const std::string& codec_id,
+                            MimeUtil::Codec* codec) {
+  if (mime_type_lower_case == "video/webm") {
+    if (codec_id == "vp9" || codec_id == "vp9.0") {
+      *codec = MimeUtil::VP9;
+      return true;
+    }
+    // TODO(kqyang): Should we support new codec string in WebM?
+    return false;
+  } else if (mime_type_lower_case == "audio/webm") {
+    return false;
+  }
+
+#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+  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)
+    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;
+
+  return true;
+#else
+  return false;
+#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 = ArePlatformDecodersAvailable();
   platform_info_.has_platform_vp8_decoder =
       MediaCodecUtil::IsVp8DecoderAvailable();
@@ skipping 12 matching lines @@
     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, is_encrypted))
+    if (!StringToCodec(mime_type_lower_case, codecs[i], &codec, &is_ambiguous,
+                       is_encrypted)) {
       return IsNotSupported;
+    }
 
     if (!IsCodecSupported(codec, mime_type_lower_case, is_encrypted) ||
         supported_codecs.find(codec) == supported_codecs.end()) {
       return IsNotSupported;
     }
 
     if (is_ambiguous)
       result = MayBeSupported;
   }
 
@@ skipping 62 matching lines @@
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
   mp4_audio_codecs.insert(AC3);
   mp4_audio_codecs.insert(EAC3);
 #endif  // BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
 
   CodecSet mp4_video_codecs;
   mp4_video_codecs.insert(H264);
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   mp4_video_codecs.insert(HEVC_MAIN);
 #endif  // BUILDFLAG(ENABLE_HEVC_DEMUXING)
+#if BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
+  // Only VP9 with valid codec string vp09.xx.xx.xx.xx.xx.xx.xx is supported.
+  // See ParseVp9CodecID for details.
+  mp4_video_codecs.insert(VP9);
+#endif  // BUILDFLAG(ENABLE_MP4_VP9_DEMUXING)
   CodecSet mp4_codecs(mp4_audio_codecs);
   mp4_codecs.insert(mp4_video_codecs.begin(), mp4_video_codecs.end());
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
   AddContainerWithCodecs("audio/wav", wav_codecs, false);
   AddContainerWithCodecs("audio/x-wav", wav_codecs, false);
   AddContainerWithCodecs("audio/webm", webm_audio_codecs, false);
   DCHECK(!webm_video_codecs.empty());
   AddContainerWithCodecs("video/webm", webm_codecs, false);
   AddContainerWithCodecs("audio/ogg", ogg_audio_codecs, false);
@@ skipping 232 matching lines @@
 
       // MediaPlayer can always play VP8. Note: This is incorrect for MSE, but
       // 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.is_unified_media_pipeline_enabled)
         return true;
 
-      // Otherwise, platform support is required.
-      return platform_info.has_platform_vp9_decoder;
+      if (!platform_info.has_platform_vp9_decoder)
+        return false;
+
+      // Encrypted content is demuxed so the container is irrelevant.
+      if (is_encrypted)
+        return true;
+
+      // MediaPlayer only supports VP9 in WebM.
+      return mime_type_lower_case == "video/webm";
     }
   }
 
   return false;
 }
 
-bool MimeUtil::StringToCodec(const std::string& codec_id,
+bool MimeUtil::StringToCodec(const std::string& mime_type_lower_case,
+                             const std::string& codec_id,
                              Codec* codec,
                              bool* is_ambiguous,
                              bool is_encrypted) 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;
   }
@@ skipping 30 matching lines @@
       case H264PROFILE_MAIN:
       case H264PROFILE_HIGH:
         *is_ambiguous = !IsValidH264Level(level_idc);
         break;
       default:
         *is_ambiguous = true;
     }
     return true;
   }
 
+  if (ParseVp9CodecID(mime_type_lower_case, codec_id, codec)) {
+    *is_ambiguous = false;

[ddorwin, 2016/04/18 22:53:29]

Please see the conversations at
https://codereview.chromium.org/1677133003/diff/490001/media/base/mime_util_i...
and
https://codereview.chromium.org/1677133003/diff/590001/media/base/mime_util_i....

The summary is that even though we know it is a valid string, we don't know
whether it is actually supported, and despite the naming of this variable, it is
really more about "maybe" vs. "probably" than whether something is "ambiguous."

In the future, we need to check whether the implementation supports the profile,
etc. That means either exposing the profile, etc. as is done for AVC or exposing
|is_certain| or similar.

For now, we should probably report "maybe" unless profile==0 and file a bug to
fix this.

[kqyang, 2016/04/19 00:28:05]

Done. vp9 and vp9.0 are assumed to be profile 0.

+    return true;
+  }
+
   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 51 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