Implemented parsing for H.264/AVC codec ids

media/base/mime_util.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.

[ddorwin, 2016/02/17 19:31:20]

This is going to conflict with Dale's CL to move most of this code to an
_internal.cc file.

 // 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"
 #include "base/lazy_instance.h"
 #include "base/macros.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"
 #include "media/base/mime_util.h"
+#include "media/base/video_codecs.h"
 #include "media/media_features.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 namespace media {
 
 // Singleton utility class for mime types.
 class MimeUtil {
  public:
   enum Codec {
     INVALID_CODEC,
     PCM,
     MP3,
     AC3,
     EAC3,
     MPEG2_AAC_LC,
     MPEG2_AAC_MAIN,
     MPEG2_AAC_SSR,
     MPEG4_AAC_LC,
     MPEG4_AAC_SBR_v1,
     MPEG4_AAC_SBR_PS_v2,
     VORBIS,
     OPUS,
-    H264_BASELINE,
-    H264_MAIN,
-    H264_HIGH,
+    H264,
     HEVC_MAIN,

[ddorwin, 2016/02/17 19:31:20]

Should we remove _MAIN here too?

[servolk, 2016/02/17 19:49:54]

Yes, I'm planning to do that in a separate CL which will implement parsing of
HEVC codec ids (WIP: https://codereview.chromium.org/1677133003/)

     VP8,
     VP9,
     THEORA
   };
 
   bool IsSupportedMediaMimeType(const std::string& mime_type) const;
 
   void ParseCodecString(const std::string& codecs,
                         std::vector<std::string>* codecs_out,
                         bool strip);
@@ skipping 84 matching lines @@
   switch (codec) {
     case MimeUtil::INVALID_CODEC:
       return false;
 
     case MimeUtil::PCM:
     case MimeUtil::MP3:
     case MimeUtil::MPEG4_AAC_LC:
     case MimeUtil::MPEG4_AAC_SBR_v1:
     case MimeUtil::MPEG4_AAC_SBR_PS_v2:
     case MimeUtil::VORBIS:
-    case MimeUtil::H264_BASELINE:
-    case MimeUtil::H264_MAIN:
-    case MimeUtil::H264_HIGH:
+    case MimeUtil::H264:
     case MimeUtil::VP8:
       return true;
 
     case MimeUtil::AC3:
     case MimeUtil::EAC3:
       // TODO(servolk): Revisit this for AC3/EAC3 support on AndroidTV
       return false;
 
     case MimeUtil::MPEG2_AAC_LC:
     case MimeUtil::MPEG2_AAC_MAIN:
@@ skipping 124 matching lines @@
   const char* const codec_id;
   MimeUtil::Codec codec;
 };
 
 // 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().
+    // avc1/avc3.XXXXXX may be unambiguous; handled by ParseAVCCodecId().
     // hev1/hvc1.XXXXXX may be unambiguous; handled by ParseHEVCCodecID().
     {"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},
@@ skipping 20 matching lines @@
     {"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_LC},
-    {"avc1", MimeUtil::H264_BASELINE},
-    {"avc3", MimeUtil::H264_BASELINE},
-    // avc1/avc3.XXXXXX may be ambiguous; handled by ParseH264CodecID().
+    {"avc1", MimeUtil::H264},
+    {"avc3", MimeUtil::H264},
+    // avc1/avc3.XXXXXX may be ambiguous; handled by ParseAVCCodecId().
 };
 
 #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 173 matching lines @@
   return AreSupportedCodecs(it_media_format_map->second, codecs);
 }
 
 void MimeUtil::RemoveProprietaryMediaTypesAndCodecsForTests() {
   for (size_t i = 0; i < arraysize(kFormatCodecMappings); ++i)
     if (kFormatCodecMappings[i].format_type == PROPRIETARY)
       media_format_map_.erase(kFormatCodecMappings[i].mime_type);
   allow_proprietary_codecs_ = false;
 }
 
-static bool IsValidH264Level(const std::string& level_str) {
-  uint32_t 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.42x0yy - H.264 Baseline
-//   avc1.4Dx0yy - H.264 Main
-//   avc1.64x0yy - H.264 High
-//
-//   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 , where xxxxxx are hex digits
-  if (!base::StartsWith(codec_id, "avc1.", base::CompareCase::SENSITIVE) &&
-      !base::StartsWith(codec_id, "avc3.", base::CompareCase::SENSITIVE)) {
-    return false;
-  }
-  if (codec_id.size() != 11 ||
-      !base::IsHexDigit(codec_id[5]) || !base::IsHexDigit(codec_id[6]) ||
-      !base::IsHexDigit(codec_id[7]) || !base::IsHexDigit(codec_id[8]) ||
-      !base::IsHexDigit(codec_id[9]) || !base::IsHexDigit(codec_id[10])) {
-    return false;
-  }
-
-  // Validate constraint flags and reserved bits.
-  if (!base::IsHexDigit(codec_id[7]) || codec_id[8] != '0') {
-    *codec = MimeUtil::H264_BASELINE;
-    *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 == "64") {
-    *codec = MimeUtil::H264_HIGH;
-  } else {
-    *codec = MimeUtil::H264_BASELINE;
-    *is_ambiguous = true;
-    return true;
-  }
-
-  // Validate level.
-  *is_ambiguous = !IsValidH264Level(codec_id.substr(9));
-  return true;
+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
+  // multiplied by ten, e.g. level_idc==32 corresponds to level==3.2
+  return ((level_idc >= 10 && level_idc <= 13) ||
+          (level_idc >= 20 && level_idc <= 22) ||
+          (level_idc >= 30 && level_idc <= 32) ||
+          (level_idc >= 40 && level_idc <= 42) ||
+          (level_idc >= 50 && level_idc <= 51));
 }
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
 // ISO/IEC FDIS 14496-15 standard section E.3 describes the syntax of codec ids
 // reserved for HEVC. According to that spec HEVC codec id must start with
 // either "hev1." or "hvc1.". We don't yet support full parsing of HEVC codec
 // ids, but since no other codec id starts with those string we'll just treat
 // any string starting with "hev1." or "hvc1." as valid HEVC codec ids.
 // crbug.com/482761
 static bool ParseHEVCCodecID(const std::string& codec_id,
@@ skipping 37 matching lines @@
   }
 
   // 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 BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecID(codec_id, codec, is_ambiguous)) {
     return true;
   }
 #endif
-  return ParseH264CodecID(codec_id, codec, is_ambiguous);
+
+  VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
+  uint8_t level_idc = 0;
+  if (ParseAVCCodecId(codec_id, &profile, &level_idc)) {
+    *codec = MimeUtil::H264;
+    *is_ambiguous =
+        (profile != H264PROFILE_BASELINE && profile != H264PROFILE_MAIN &&
+         profile != H264PROFILE_HIGH) ||
+        !IsValidH264Level(level_idc);
+    return true;
+  }
+
+  DVLOG(4) << __FUNCTION__ << ": Unrecognized codec id " << codec_id;
+  return false;
 }
 
 bool MimeUtil::IsCodecSupported(Codec codec) const {
   DCHECK_NE(codec, INVALID_CODEC);
 
 #if defined(OS_ANDROID)
   if (!IsCodecSupportedOnAndroid(codec))
     return false;
 #endif
 
   return allow_proprietary_codecs_ || !IsCodecProprietary(codec);
 }
 
 bool MimeUtil::IsCodecProprietary(Codec codec) const {
   switch (codec) {
     case INVALID_CODEC:
     case AC3:
     case EAC3:
     case MP3:
     case MPEG2_AAC_LC:
     case MPEG2_AAC_MAIN:
     case MPEG2_AAC_SSR:
     case MPEG4_AAC_LC:
     case MPEG4_AAC_SBR_v1:
     case MPEG4_AAC_SBR_PS_v2:
-    case H264_BASELINE:
-    case H264_MAIN:
-    case H264_HIGH:
+    case H264:
     case HEVC_MAIN:
       return true;
 
     case PCM:
     case VORBIS:
     case OPUS:
     case VP8:
     case VP9:
     case THEORA:
       return false;
@@ skipping 40 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