Refactor VP9 codec string parsing

- Also fixed source_buffer_state failed to find codec with vp9 in mp4 contents when VP9 in MP4 is enabled.

- And added a few playback/demuxer tests.

BUG=580623

Review-Url: https://codereview.chromium.org/2495193004
Cr-Commit-Position: refs/heads/master@{#436144}

chrome/browser/media/encrypted_media_browsertest.cc

@@ -19,6 +19,7 @@
 #include "chrome/test/base/test_launcher_utils.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
+#include "media/base/media_switches.h"
 #include "ppapi/features/features.h"
 #include "testing/gtest/include/gtest/gtest-spi.h"
 
@@ -66,6 +67,8 @@ const char kWebMVP9VideoOnly[] = "video/webm; codecs=\"vp9\"";
 #if defined(USE_PROPRIETARY_CODECS)
 const char kMP4AudioOnly[] = "audio/mp4; codecs=\"mp4a.40.2\"";
 const char kMP4VideoOnly[] = "video/mp4; codecs=\"avc1.4D000C\"";
+const char kMP4VideoVp9Only[] =
+    "video/mp4; codecs=\"vp09.00.01.08.02.01.01.00\"";
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
 // Sessions to load.
@@ -242,6 +245,7 @@ class EncryptedMediaTestBase : public MediaBrowserTest {
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(
         switches::kDisableGestureRequirementForMediaPlayback);
+    command_line->AppendSwitch(switches::kEnableVp9InMp4);
   }
 
 #if BUILDFLAG(ENABLE_PEPPER_CDMS)
@@ -549,6 +553,15 @@ IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioOnly_MP4) {
   TestSimplePlayback("bear-640x360-a_frag-cenc.mp4", kMP4AudioOnly);
 }
 
+IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_VideoOnly_MP4_VP9) {
+  // MP4 without MSE is not support yet, http://crbug.com/170793.
+  if (CurrentSourceType() != MSE) {
+    DVLOG(0) << "Skipping test; Can only play MP4 encrypted streams by MSE.";
+    return;
+  }
+  TestSimplePlayback("bear-320x240-v_frag-vp9-cenc.mp4", kMP4VideoVp9Only);
+}
+
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest,
                        Playback_EncryptedVideo_MP4_ClearAudio_WEBM) {
   // MP4 without MSE is not support yet, http://crbug.com/170793.

content/browser/media/media_browsertest.cc

@@ -13,6 +13,7 @@
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
+#include "media/base/media_switches.h"
 #include "media/base/test_data_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 
@@ -26,6 +27,7 @@ const char MediaBrowserTest::kFailed[] = "FAILED";
 void MediaBrowserTest::SetUpCommandLine(base::CommandLine* command_line) {
   command_line->AppendSwitch(
       switches::kDisableGestureRequirementForMediaPlayback);
+  command_line->AppendSwitch(switches::kEnableVp9InMp4);
 }
 
 void MediaBrowserTest::RunMediaTestPage(const std::string& html_page,
@@ -150,6 +152,10 @@ IN_PROC_BROWSER_TEST_P(MediaTest, MAYBE_VideoBearMp4) {
   PlayVideo("bear.mp4", GetParam());
 }
 
+IN_PROC_BROWSER_TEST_P(MediaTest, VideoBearMp4Vp9) {
+  PlayVideo("bear-320x240-v_frag-vp9.mp4", GetParam());
+}
+
 // Android devices usually only support baseline, main and high.
 #if !defined(OS_ANDROID)
 IN_PROC_BROWSER_TEST_P(MediaTest, VideoBearHighBitDepthMp4) {

content/browser/media/media_canplaytype_browsertest.cc

@@ -797,9 +797,9 @@ IN_PROC_BROWSER_TEST_F(MediaCanPlayTypeTest, CodecSupportTest_mp4) {
   EXPECT_EQ(kHevcSupported,
             CanPlay("'video/mp4; codecs=\"hvc1.1.6.L93.B0, mp4a.40.5\"'"));
 
-  // Note: set to kPropProbably when switches::kEnableVp9InMp4 is enabled by
-  // default.
-  EXPECT_EQ(kNot, CanPlay("'video/mp4; codecs=\"vp09.00.01.08.02.01.01.00\"'"));
+  // switches::kEnableVp9InMp4 is enabled in MediaBrowserTest.
+  EXPECT_EQ(kPropProbably,
+            CanPlay("'video/mp4; codecs=\"vp09.00.01.08.02.01.01.00\"'"));
 
   TestMPEGUnacceptableCombinations("video/mp4");
   EXPECT_EQ(kNot, CanPlay("'video/mp4; codecs=\"flac\"'"));
@@ -1645,7 +1645,6 @@ class MediaCanPlayTypeTestMp4Vp9Demuxing
       public ::testing::WithParamInterface<bool> {
  public:
   void SetUpCommandLine(base::CommandLine* command_line) override {
-    MediaCanPlayTypeTest::SetUpCommandLine(command_line);
     const bool enable_mp4_vp9_demuxing = GetParam();
     if (enable_mp4_vp9_demuxing)
       command_line->AppendSwitch(switches::kEnableVp9InMp4);

media/base/mime_util_internal.cc

@@ -140,6 +140,23 @@ static std::string TranslateLegacyAvc1CodecIds(const std::string& codec_id) {
 }
 #endif
 
+static bool ParseVp9CodecID(const std::string& mime_type_lower_case,
+                            const std::string& codec_id,
+                            VideoCodecProfile* out_profile,
+                            uint8_t* out_level) {
+  if (mime_type_lower_case == "video/mp4") {
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnableVp9InMp4)) {
+      return ParseNewStyleVp9CodecID(codec_id, out_profile, out_level);
+    }
+  } else if (mime_type_lower_case == "video/webm") {
+    // Only legacy codec strings are supported in WebM.
+    // TODO(kqyang): Should we support new codec string in WebM?
+    return ParseLegacyVp9CodecID(codec_id, out_profile, out_level);
+  }
+  return false;
+}
+
 static bool IsValidH264Level(uint8_t level_idc) {
   // Valid levels taken from Table A-1 in ISO/IEC 14496-10.
   // Level_idc represents the standard level represented as decimal number
@@ -151,98 +168,6 @@ static bool IsValidH264Level(uint8_t level_idc) {
           (level_idc >= 50 && level_idc <= 51));
 }
 
-// Handle parsing of vp9 codec IDs.
-static bool ParseVp9CodecID(const std::string& mime_type_lower_case,
-                            const std::string& codec_id,
-                            VideoCodecProfile* profile) {
-  if (mime_type_lower_case == "video/webm") {
-    if (codec_id == "vp9" || codec_id == "vp9.0") {
-      // Profile is not included in the codec string. Assuming profile 0 to be
-      // backward compatible.
-      *profile = VP9PROFILE_PROFILE0;
-      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 (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableVp9InMp4)) {
-    return false;
-  }
-
-  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")
-    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_idc = values[0];
-  switch (profile_idc) {
-    case 0:
-      *profile = VP9PROFILE_PROFILE0;
-      break;
-    case 1:
-      *profile = VP9PROFILE_PROFILE1;
-      break;
-    case 2:
-      *profile = VP9PROFILE_PROFILE2;
-      break;
-    case 3:
-      *profile = VP9PROFILE_PROFILE3;
-      break;
-    default:
-      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;
-}
-
 MimeUtil::MimeUtil() : allow_proprietary_codecs_(false) {
 #if defined(OS_ANDROID)
   platform_info_.is_unified_media_pipeline_enabled =
@@ -682,9 +607,27 @@ bool MimeUtil::StringToCodec(const std::string& mime_type_lower_case,
     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 |codec_id| is not in |string_to_codec_map_|, then we assume that it is
+  // either VP9, 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 (ParseVp9CodecID(mime_type_lower_case, codec_id, out_profile, out_level)) {
+    *codec = MimeUtil::VP9;
+    switch (*out_profile) {
+      case VP9PROFILE_PROFILE0:
+        // Profile 0 should always be supported if VP9 is supported.
+        *is_ambiguous = false;
+        break;
+      default:
+        // We don't know if the underlying platform supports these profiles.
+        // Need to add platform level querying to get supported profiles
+        // (crbug/604566).
+        *is_ambiguous = true;
+        break;
+    }
+    return true;
+  }
+
   if (ParseAVCCodecId(codec_id, out_profile, out_level)) {
     *codec = MimeUtil::H264;
     switch (*out_profile) {
@@ -712,23 +655,6 @@ bool MimeUtil::StringToCodec(const std::string& mime_type_lower_case,
     return true;
   }
 
-  if (ParseVp9CodecID(mime_type_lower_case, codec_id, out_profile)) {
-    *codec = MimeUtil::VP9;
-    *out_level = 1;
-    switch (*out_profile) {
-      case VP9PROFILE_PROFILE0:
-        // Profile 0 should always be supported if VP9 is supported.
-        *is_ambiguous = false;
-        break;
-      default:
-        // We don't know if the underlying platform supports these profiles.
-        // Need to add platform level querying to get supported profiles
-        // (crbug/604566).
-        *is_ambiguous = true;
-    }
-    return true;
-  }
-
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecId(codec_id, out_profile, out_level)) {
     *codec = MimeUtil::HEVC;

media/base/video_codecs.cc

@@ -84,6 +84,91 @@ std::string GetProfileName(VideoCodecProfile profile) {
   return "";
 }
 
+bool ParseNewStyleVp9CodecID(const std::string& codec_id,
+                             VideoCodecProfile* profile,
+                             uint8_t* level_idc) {
+  std::vector<std::string> fields = base::SplitString(
+      codec_id, ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+
+  // TODO(kqyang): The spec specifies 8 fields. We do not allow missing or extra
+  // fields. See crbug.com/667834.
+  if (fields.size() != 8)
+    return false;
+
+  if (fields[0] != "vp09")
+    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);
+  }
+
+  const int profile_idc = values[0];
+  switch (profile_idc) {
+    case 0:
+      *profile = VP9PROFILE_PROFILE0;
+      break;
+    case 1:
+      *profile = VP9PROFILE_PROFILE1;
+      break;
+    case 2:
+      *profile = VP9PROFILE_PROFILE2;
+      break;
+    case 3:
+      *profile = VP9PROFILE_PROFILE3;
+      break;
+    default:
+      return false;
+  }
+
+  *level_idc = values[1];
+  // TODO(kqyang): Check if |level_idc| is valid. See crbug.com/667834.
+
+  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;
+}
+
+bool ParseLegacyVp9CodecID(const std::string& codec_id,
+                           VideoCodecProfile* profile,
+                           uint8_t* level_idc) {
+  if (codec_id == "vp9" || codec_id == "vp9.0") {
+    // Profile is not included in the codec string. Assuming profile 0 to be
+    // backward compatible.
+    *profile = VP9PROFILE_PROFILE0;
+    // Use 0 to indicate unknown level.
+    *level_idc = 0;
+    return true;
+  }
+  return false;
+}
+
 bool ParseAVCCodecId(const std::string& codec_id,
                      VideoCodecProfile* profile,
                      uint8_t* level_idc) {
@@ -292,14 +377,16 @@ VideoCodec StringToVideoCodec(const std::string& codec_id) {
     return kUnknownVideoCodec;
   VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
   uint8_t level = 0;
-  if (ParseAVCCodecId(codec_id, &profile, &level))
-    return kCodecH264;
   if (codec_id == "vp8" || codec_id == "vp8.0")
     return kCodecVP8;
-  if (codec_id == "vp9" || codec_id == "vp9.0")
+  if (ParseNewStyleVp9CodecID(codec_id, &profile, &level) ||
+      ParseLegacyVp9CodecID(codec_id, &profile, &level)) {
     return kCodecVP9;
+  }
   if (codec_id == "theora")
     return kCodecTheora;
+  if (ParseAVCCodecId(codec_id, &profile, &level))
+    return kCodecH264;
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecId(codec_id, &profile, &level))
     return kCodecHEVC;

media/base/video_codecs.h

@@ -78,6 +78,19 @@ enum VideoCodecProfile {
 std::string MEDIA_EXPORT GetCodecName(VideoCodec codec);
 std::string MEDIA_EXPORT GetProfileName(VideoCodecProfile profile);
 
+// ParseNewStyleVp9CodecID handles parsing of new style vp9 codec IDs per
+// proposed VP Codec ISO Media File Format Binding specification:
+// https://storage.googleapis.com/downloads.webmproject.org/docs/vp9/vp-codec-iso-media-file-format-binding-20160516-draft.pdf
+// ParseLegacyVp9CodecID handles parsing of legacy VP9 codec strings defined
+// for WebM.
+// TODO(kqyang): Consolidate the two functions once we address crbug.com/667834
+MEDIA_EXPORT bool ParseNewStyleVp9CodecID(const std::string& codec_id,
+                                          VideoCodecProfile* profile,
+                                          uint8_t* level_idc);
+MEDIA_EXPORT bool ParseLegacyVp9CodecID(const std::string& codec_id,
+                                        VideoCodecProfile* profile,
+                                        uint8_t* level_idc);
+
 // Handle parsing AVC/H.264 codec ids as outlined in RFC 6381 and ISO-14496-10.
 MEDIA_EXPORT bool ParseAVCCodecId(const std::string& codec_id,
                                   VideoCodecProfile* profile,

media/filters/chunk_demuxer_unittest.cc

@@ -10,6 +10,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ -21,6 +22,7 @@
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/media.h"
+#include "media/base/media_switches.h"
 #include "media/base/media_tracks.h"
 #include "media/base/mock_demuxer_host.h"
 #include "media/base/mock_media_log.h"
@@ -35,12 +37,14 @@
 
 using ::testing::AnyNumber;
 using ::testing::Exactly;
+using ::testing::HasSubstr;
 using ::testing::InSequence;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
+using ::testing::WithParamInterface;
 using ::testing::_;
 
 namespace media {
@@ -4746,4 +4750,39 @@ TEST_F(ChunkDemuxerTest, RemovingIdMustRemoveStreams) {
 // same codec type in a single SourceBufferState, when WebM parser supports
 // multiple tracks. crbug.com/646900
 
+class ChunkDemuxerMp4Vp9Test : public ChunkDemuxerTest,
+                               public WithParamInterface<bool> {
+ public:
+  void SetUp() override {
+    ChunkDemuxerTest::SetUp();
+    const bool enable_mp4_vp9_demuxing = GetParam();
+    if (enable_mp4_vp9_demuxing) {
+      base::CommandLine::ForCurrentProcess()->AppendSwitch(
+          switches::kEnableVp9InMp4);
+    }
+  }
+};
+
+TEST_P(ChunkDemuxerMp4Vp9Test, CodecSupport) {
+  ChunkDemuxer::Status expected = ChunkDemuxer::kNotSupported;
+
+#if defined(USE_PROPRIETARY_CODECS)
+  const bool enable_mp4_vp9_demuxing = GetParam();
+  if (enable_mp4_vp9_demuxing) {
+    expected = ChunkDemuxer::kOk;
+  } else {
+    EXPECT_MEDIA_LOG(HasSubstr(
+        "Codec 'vp09.00.01.08.02.01.01.00' is not supported for 'video/mp4'"));
+  }
+#endif
+
+  EXPECT_EQ(
+      demuxer_->AddId("source_id", "video/mp4", "vp09.00.01.08.02.01.01.00"),
+      expected);
+}
+
+INSTANTIATE_TEST_CASE_P(EnableDisableMp4Vp9Demuxing,
+                        ChunkDemuxerMp4Vp9Test,
+                        ::testing::Bool());
+
 }  // namespace media

media/test/data/README

@@ -67,7 +67,9 @@ bear-1280x720-a_frag-cenc_missing-saiz-saio.mp4 - An invalid file similar to bea
 bear-320x240-v_frag-vp9.mp4 - Bear video with VP9 codec in MP4 container. Generated with shaka-packager (https://github.com/google/shaka-packager):
                               packager in=bear-vp9.webm,stream=video,out=bear-320x240-v_frag-vp9.mp4
 bear-320x240-v_frag-vp9-cenc.mp4 - Same as above, with video encrypted using key ID [1] and key [2]. Generated with shaka-packager (https://github.com/google/shaka-packager):
-                                   packager in=bear-vp9.webm,stream=video,out=bear-320x240-v_frag-vp9-cenc.mp4 --enable_fixed_key_encryption --key_id 30313233343536373839303132333435 --key ebdd62f16814d27b68ef122afce4ae3c
+                                   packager in=bear-vp9.webm,stream=video,out=bear-320x240-v_frag-vp9-cenc.mp4 --enable_fixed_key_encryption --key_id 30313233343536373839303132333435
+                                            --key ebdd62f16814d27b68ef122afce4ae3c --clear_lead 0
+                                            --pssh 0000003470737368010000001077EFECC0B24D02ACE33C1E52E2FB4B000000013031323334353637383930313233343500000000000000467073736800000000EDEF8BA979D64ACEA3C827DCD51D21ED000000261210303132333435363738393031323334351A00221030313233343536373839303132333435
 bear-320x240-16x9-aspect-av_enc-av.webm - bear-320x240-16x9-aspect.webm with audio & video encrypted using key ID [1] and key [2]
 bear-320x240-av_enc-av.webm - bear-320x240.webm with audio & video encrypted using key ID [1] and key [2].
 bear-320x240-av_enc-av_clear-1s.webm - Same as bear-320x240-av_enc-av.webm but with no frames in the first second encrypted.