WebM support for new multipart VP9 string.

media/base/video_codecs.cc

 // Copyright 2015 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/video_codecs.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 68 matching lines @@
       return "vp9 profile2";
     case VP9PROFILE_PROFILE3:
       return "vp9 profile3";
   }
   NOTREACHED();
   return "";
 }
 
 bool ParseNewStyleVp9CodecID(const std::string& codec_id,
                              VideoCodecProfile* profile,
-                             uint8_t* level_idc) {
+                             uint8_t* level_idc,
+                             gfx::ColorSpace::TransferID* eotf) {
+  LOG(ERROR) << __func__ << " 0";

[servolk, 2017/03/02 18:56:36]

Nit: don't forget to remove this debug logging.

[chcunningham, 2017/03/02 23:13:08]

Acknowledged.

+
+  // Initialize optional fields to their defaults.
+  *eotf = gfx::ColorSpace::TransferID::BT709;
+
   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)
+  // First four fields are mandatory. No more than 9 fields are expected.
+  if (fields.size() < 4 || fields.size() > 9)
     return false;
 
   if (fields[0] != "vp09")
     return false;
 
+  LOG(ERROR) << __func__ << " 1";
+
   std::vector<int> values;
   for (size_t i = 1; i < fields.size(); ++i) {
-    // Missing value is not allowed.
+    // Missing value is not allowed. ------------------------------------------ is still this right?
     if (fields[i] == "")
       return false;
     int value;
     if (!base::StringToInt(fields[i], &value))
       return false;
     if (value < 0)
       return false;
     values.push_back(value);
   }
 
+  LOG(ERROR) << __func__ << " 2";
   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;
   }
 
+  LOG(ERROR) << __func__ << " 3";
   *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;
 
+  if (values.size() < 4)
+    return true;
+  LOG(ERROR) << __func__ << " 4";
   const int color_space = values[3];
-  if (color_space > 7)
+  if (color_space > 9)
     return false;
 
-  const int chroma_subsampling = values[4];
-  if (chroma_subsampling > 3)
+  LOG(ERROR) << __func__ << " 5";
+  if (values.size() < 5)
+    return true;
+  const int transfer_function = values[4];
+  switch (transfer_function) {
+    case 0:

[servolk, 2017/03/02 18:56:36]

Are those values taken from
https://docs.google.com/document/d/16kiRszCusuK-ph_3h2HKvPgk_zLuHiM1NUfdyIH8_...
?
Looks like that's still in the draft stage, in particular there is this comment
thread
https://docs.google.com/a/google.com/document/d/16kiRszCusuK-ph_3h2HKvPgk_zLu...
which indicates these values are going to be changed to match ISO spec. Perhaps
we should wait until the VP9 codec id format is more standardized, before we add
this code?

[chcunningham, 2017/03/02 23:13:08]

Right, these values are taken from a draft which is expected to be replaced by
values from ISO/IEC 23001-8:2016. I'll buy that spec and update accordingly.

+      // "0" bucket denotes one of:
+      //   Rec. ITU-R BT.709-6
+      //   Rec. ITU-R BT.601-7 525 or 625
+      //   Rec. ITU-R BT.2020.
+      // These are all non-HDR, so just grab 709 since they're all treated
+      // the same from a capabilities standpoint.
+      *eotf = gfx::ColorSpace::TransferID::BT709;
+      break;
+    case 1:
+      *eotf = gfx::ColorSpace::TransferID::SMPTEST2084;
+      break;
+    case 2:
+      *eotf = gfx::ColorSpace::TransferID::ARIB_STD_B67;  // AKA "HLG"
+      break;
+    default:
+      *eotf = gfx::ColorSpace::TransferID::INVALID;
+      DVLOG(4) << __func__ << ": invalid transfer function id ("
+               << transfer_function << ")";
+      return false;
+  }
+
+  LOG(ERROR) << __func__ << " 6";
+  if (values.size() < 6)
+    return true;
+  const int matrix_coefficients = values[5];
+  if (matrix_coefficients < 0)
     return false;
 
-  const int transfer_function = values[5];
-  if (transfer_function > 1)
+  LOG(ERROR) << __func__ << " 7";
+  if (values.size() < 7)
+    return true;
+  const int video_full_range_flag = values[6];
+  if (video_full_range_flag < 0 || video_full_range_flag > 1)
     return false;
 
-  const int video_full_range_flag = values[6];
-  if (video_full_range_flag > 1)
+  LOG(ERROR) << __func__ << " 8";
+  if (values.size() < 8)
+    return true;
+  const int chroma_subsampling = values[7];
+  if (chroma_subsampling < 0 || chroma_subsampling > 3)
     return false;
 
+  LOG(ERROR) << __func__ << " 9";
   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;
@@ skipping 252 matching lines @@
 
   return true;
 }
 #endif
 
 VideoCodec StringToVideoCodec(const std::string& codec_id) {
   std::vector<std::string> elem = base::SplitString(
       codec_id, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (elem.empty())
     return kUnknownVideoCodec;
+
   VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
   uint8_t level = 0;
+  gfx::ColorSpace::TransferID eotf = gfx::ColorSpace::TransferID::INVALID;
+
   if (codec_id == "vp8" || codec_id == "vp8.0")
     return kCodecVP8;
-  if (ParseNewStyleVp9CodecID(codec_id, &profile, &level) ||
+  if (ParseNewStyleVp9CodecID(codec_id, &profile, &level, &eotf) ||
       ParseLegacyVp9CodecID(codec_id, &profile, &level)) {
     return kCodecVP9;
   }
   if (codec_id == "theora")
     return kCodecTheora;
   if (ParseAVCCodecId(codec_id, &profile, &level))
     return kCodecH264;
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
   if (ParseAVCCodecId(TranslateLegacyAvc1CodecIds(codec_id), &profile, &level))
     return kCodecH264;
 #endif
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecId(codec_id, &profile, &level))
     return kCodecHEVC;
 #endif
   return kUnknownVideoCodec;
 }
 
 }  // namespace media