Remove constraint_set_flag checks from ParseH264CodecID().

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 <map>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 462 matching lines @@
 
   return AreSupportedCodecs(it_strict_map->second, codecs);
 }
 
 void MimeUtil::RemoveProprietaryMediaTypesAndCodecsForTests() {
   for (size_t i = 0; i < arraysize(proprietary_media_types); ++i)
     media_map_.erase(proprietary_media_types[i]);
   allow_proprietary_codecs_ = false;
 }
 
-// Returns true iff |profile_str| conforms to hex string "42y0".
-//
-// |profile_str| is the first four characters of the H.264 suffix string. From
-// ISO-14496-10 7.3.2.1, it consists of:
-//   8 bits: profile_idc; required to be 0x42 here.
-//   1 bit: constraint_set0_flag; ignored here.
-//   1 bit: constraint_set1_flag; ignored here.
-//   1 bit: constraint_set2_flag; ignored here.
-//   1 bit: constraint_set3_flag; ignored here.
-//   4 bits: reserved; required to be 0 here.
-//
-// The spec indicates other ways, not implemented here, that a |profile_str|
-// can indicate a baseline conforming decoder is sufficient for decode in Annex
-// A.2.1: "[profile_idc not necessarily 0x42] with constraint_set0_flag set and
-// in which level_idc and constraint_set3_flag represent a level less than or
-// equal to the specified level."
-static bool IsValidH264BaselineProfile(const std::string& profile_str) {
-  return (profile_str.size() == 4 && profile_str[0] == '4' &&
-          profile_str[1] == '2' && base::IsHexDigit(profile_str[2]) &&
-          profile_str[3] == '0');
-}
-
 static bool IsValidH264Level(const std::string& level_str) {
   uint32 level;
   if (level_str.size() != 2 || !base::HexStringToUInt(level_str, &level))
     return false;
 
   // Valid levels taken from Table A-1 in ISO-14496-10.
   // Essentially |level_str| is toHex(10 * level).
   return ((level >= 10 && level <= 13) ||
           (level >= 20 && level <= 22) ||
           (level >= 30 && level <= 32) ||
           (level >= 40 && level <= 42) ||
           (level >= 50 && level <= 51));
 }
 
 // Handle parsing H.264 codec IDs as outlined in RFC 6381 and ISO-14496-10.
-//   avc1.42y0xx, y >= 8 - H.264 Baseline
-//   avc1.4D40xx         - H.264 Main
-//   avc1.6400xx         - H.264 High
+//   avc1.42x0yy - H.264 Baseline
+//   avc1.4Dx0yy - H.264 Main
+//   avc1.64x0yy - H.264 High

[wolenetz, 2015/08/20 21:06:43]

The comment in previous l.494 still seems relevant. Or am I misreading that in
the spec (or is my spec outdated), too?

[wolenetz, 2015/08/20 21:12:37]

Never mind (per our chat, l502 in this patch set retains enough of this context
from previous l.494 comment, though we consider such as "ambiguous" signalling).

[sandersd (OOO until July 31), 2015/08/20 21:14:01]

That's correct, but I believe the existing comment below covers the important
parts of that.

 //
 //   avc1.xxxxxx & avc3.xxxxxx are considered ambiguous forms that are trying to
 //   signal H.264 Baseline. For example, the idc_level, profile_idc and
 //   constraint_set3_flag pieces may explicitly require decoder to conform to
 //   baseline profile at the specified level (see Annex A and constraint_set0 in
 //   ISO-14496-10).
 static bool ParseH264CodecID(const std::string& codec_id,
                              MimeUtil::Codec* codec,
                              bool* is_ambiguous) {
   // Make sure we have avc1.xxxxxx or avc3.xxxxxx
   if (codec_id.size() != 11 ||
       (!base::StartsWith(codec_id, "avc1.", base::CompareCase::SENSITIVE) &&
        !base::StartsWith(codec_id, "avc3.", base::CompareCase::SENSITIVE))) {
     return false;
   }
 
-  std::string profile = base::ToUpperASCII(codec_id.substr(5, 4));
-  if (IsValidH264BaselineProfile(profile)) {
+  // Validate constraint flags and reserved bits.
+  if (!base::IsHexDigit(codec_id[7]) || codec_id[8] != '0') {
     *codec = MimeUtil::H264_BASELINE;
-  } else if (profile == "4D40") {
+    *is_ambiguous = true;
+    return true;
+  }
+
+  // Extract the profile.
+  std::string profile = base::ToUpperASCII(codec_id.substr(5, 2));
+  if (profile == "42") {
+    *codec = MimeUtil::H264_BASELINE;
+  } else if (profile == "4D") {
     *codec = MimeUtil::H264_MAIN;
-  } else if (profile == "6400") {
+  } else if (profile == "64") {
     *codec = MimeUtil::H264_HIGH;
   } else {
     *codec = MimeUtil::H264_BASELINE;
     *is_ambiguous = true;
     return true;
   }
 
+  // Validate level.
   *is_ambiguous = !IsValidH264Level(base::ToUpperASCII(codec_id.substr(9)));
   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()) {
@@ skipping 89 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