Implemented parsing of HEVC codec ids

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 213 matching lines @@
   // 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,
-                             MimeUtil::Codec* codec,
-                             bool* is_ambiguous) {
-  if (base::StartsWith(codec_id, "hev1.", base::CompareCase::SENSITIVE) ||
-      base::StartsWith(codec_id, "hvc1.", base::CompareCase::SENSITIVE)) {
-    *codec = MimeUtil::HEVC_MAIN;
-
-    // TODO(servolk): Full HEVC codec id parsing is not implemented yet (see
-    // crbug.com/482761). So treat HEVC codec ids as ambiguous for now.
-    *is_ambiguous = true;
-
-    // TODO(servolk): Most HEVC codec ids are treated as ambiguous (see above),
-    // but we need to recognize at least one valid unambiguous HEVC codec id,
-    // which is added into kMP4VideoCodecsExpression. We need it to be
-    // unambiguous to avoid DCHECK(!is_ambiguous) in InitializeMimeTypeMaps. We
-    // also use these in unit tests (see
-    // content/browser/media/media_canplaytype_browsertest.cc).
-    // Remove this workaround after crbug.com/482761 is fixed.
-    if (codec_id == "hev1.1.6.L93.B0" || codec_id == "hvc1.1.6.L93.B0") {
-      *is_ambiguous = false;
-    }
-
-    return true;
-  }
-
-  return false;
-}
-#endif
-
 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 =
       platform_info_.is_unified_media_pipeline_enabled
           ? HasPlatformDecoderSupport()
@@ skipping 222 matching lines @@
 
     case H264:
       // The unified pipeline requires platform support for h264.
       if (platform_info.is_unified_media_pipeline_enabled)
         return platform_info.has_platform_decoders;
 
       // When MediaPlayer or MediaCodec is used, h264 is always supported.
       DCHECK(!is_encrypted || platform_info.has_platform_decoders);
       return true;
 
-    case HEVC_MAIN:
+    case HEVC:
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
       if (platform_info.is_unified_media_pipeline_enabled &&
           !platform_info.has_platform_decoders) {
         return false;
       }
 
 #if defined(OS_ANDROID)
       // HEVC/H.265 is supported in Lollipop+ (API Level 21), according to
       // http://developer.android.com/reference/android/media/MediaFormat.html
       return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
@@ skipping 36 matching lines @@
       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;
   }
 
 // 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.
+  VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
+  uint8_t level_idc = 0;
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-  if (ParseHEVCCodecID(codec_id, codec, is_ambiguous)) {
+  if (ParseHEVCCodecId(codec_id, &profile, &level_idc)) {
+    *is_ambiguous = false;
+    *codec = MimeUtil::HEVC;
     return true;
   }
 #endif
 
-  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;
@@ skipping 21 matching lines @@
     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:
-    case HEVC_MAIN:
+    case HEVC:
       return true;
 
     case PCM:
     case VORBIS:
     case OPUS:
     case VP8:
     case VP9:
     case THEORA:
       return false;
   }
@@ skipping 22 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