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 196 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 = ArePlatformDecodersAvailable();
   platform_info_.has_platform_vp8_decoder =
       MediaCodecUtil::IsVp8DecoderAvailable();
@@ skipping 220 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 24 matching lines @@
       // Otherwise, platform support is required.
       return platform_info.supports_vp9;
     }
   }
 
   return false;
 }
 
 bool MimeUtil::StringToCodec(const std::string& codec_id,
                              Codec* codec,
                              bool* is_ambiguous) const {

[ddorwin, 2016/04/02 00:56:09]

As you mentioned below, this is confusing. Perhaps (in a separate CL) we should
change to is_unsure, is_maybe, or something like that. (It's the opposite of "is
known supported.)

The only case where anything is actually _ambiguous_ now is in
kAmbiguousCodecStringMap.

[servolk, 2016/04/07 00:59:40]

Acknowledged.

   StringToCodecMappings::const_iterator itr =
       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)

[ddorwin, 2016/04/02 00:09:06]

I believe there was a reason this was originally added before AVC, but should we
move it after? (It's also less likely than AVC.)

[servolk, 2016/04/02 00:35:04]

Yes, we used to have 'return ParseH264CodecId' at the end of this function in
the past, so HEVC was inserted above ParseH264. Now that this code looks
differently we can move HEVC below.

-  if (ParseHEVCCodecID(codec_id, codec, is_ambiguous)) {
+  if (ParseHEVCCodecId(codec_id, &profile, &level_idc)) {
+    *is_ambiguous = false;

[ddorwin, 2016/04/02 00:09:06]

This assumes that only supported profiles are returned (at least DCHECK that)
AND that the level is valid. Is the latter a safe assumption?

[servolk, 2016/04/02 00:35:04]

Well, HEVC codec ids contain enough information to be unambiguous, so I've set
it to false here. And yes, there are already a few CHECKs inside
ParseHEVCCodecId function that ensure that returned values are within valid
ranges. The actual issue here is that this is_ambiguous flag is actually used to
decide whether we need to return 'maybe' or 'probably' as CanPlayType result,
but the problem is that we  don't have enough information here to decide that.
We'll need to ask actual platform/decoder whether this combination of
profile/level is supported or not. That part is not implemented yet.

[ddorwin, 2016/04/02 00:56:09]

See above. Ambiguous no longer makes sense, BUT we should prefer "maybe" for
things we are unsure about. In this case, until the platform checking is added.
This should not affect most apps.

This will cause the DCHECK in AddContainerWithCodecs() to fire, but, especially
since we want to eliminate this call there (https://crbug.com/461009), you could
just add "|| codec==HEVC".

[ddorwin, 2016/04/06 01:43:56]

That bug is now fixed, so you don't need to worry about the DCHECK.
https://codereview.chromium.org/1864743002/

[servolk, 2016/04/07 00:59:40]

Done.

+    *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 17 matching lines @@
 
 bool MimeUtil::IsCodecProprietary(Codec codec) const {
   switch (codec) {
     case INVALID_CODEC:
     case AC3:
     case EAC3:
     case MP3:
     case MPEG2_AAC:
     case MPEG4_AAC:
     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