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 131 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 93 matching lines @@
   CodecSet mp4_audio_codecs(aac);
   mp4_audio_codecs.insert(MP3);
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
   mp4_audio_codecs.insert(AC3);
   mp4_audio_codecs.insert(EAC3);
 #endif  // BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
 
   CodecSet mp4_video_codecs;
   mp4_video_codecs.insert(H264);
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-  mp4_video_codecs.insert(HEVC_MAIN);
+  mp4_video_codecs.insert(HEVC);
 #endif  // BUILDFLAG(ENABLE_HEVC_DEMUXING)
   CodecSet mp4_codecs(mp4_audio_codecs);
   mp4_codecs.insert(mp4_video_codecs.begin(), mp4_video_codecs.end());
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
   AddContainerWithCodecs("audio/wav", wav_codecs, false);
   AddContainerWithCodecs("audio/x-wav", wav_codecs, false);
   AddContainerWithCodecs("audio/webm", webm_audio_codecs, false);
   DCHECK(!webm_video_codecs.empty());
   AddContainerWithCodecs("video/webm", webm_codecs, false);
@@ skipping 198 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 37 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.
-
-#if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-  if (ParseHEVCCodecID(codec_id, codec, is_ambiguous)) {
-    return true;
-  }
-#endif
-
   VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
   uint8_t level_idc = 0;
+
   if (ParseAVCCodecId(codec_id, &profile, &level_idc)) {
     *codec = MimeUtil::H264;
     switch (profile) {
 // HIGH10PROFILE is supported through fallback to the ffmpeg decoder
 // which is not available on Android, or if FFMPEG is not used.
 #if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID)
       case H264PROFILE_HIGH10PROFILE:
         if (is_encrypted) {
           // FFmpeg is not generally used for encrypted videos, so we do not
           // know whether 10-bit is supported.
           *is_ambiguous = true;
           break;
         }
 // Fall through.
 #endif
 
       case H264PROFILE_BASELINE:
       case H264PROFILE_MAIN:
       case H264PROFILE_HIGH:
         *is_ambiguous = !IsValidH264Level(level_idc);
         break;
       default:
         *is_ambiguous = true;
     }
     return true;
   }
 
+#if BUILDFLAG(ENABLE_HEVC_DEMUXING)
+  if (ParseHEVCCodecId(codec_id, &profile, &level_idc)) {
+    // TODO(servolk): Set |is_ambiguous| to false for now to make sure
+    // CanPlayType result is 'probably' and not 'maybe', since that's what unit
+    // tests expect. We'll need to add platform level checks to ensure that the

[ddorwin, 2016/04/07 20:29:46]

What tests expect 'probably'? Can't we just update these?
The point is that we should err on the side of underpromising, which is 'maybe'.

[servolk, 2016/04/07 20:44:03]

The MediaCanPlayTypeTest.CodecSupportTest_HEVCVariants test that I've added in
content/browser/media/media_canplaytype_browsertest.cc in this CL (see
cast_shell trybot failure in PS #30). I guess we can update that test to expect
'maybe', but then it would fail on platforms that do actually support HEVC.
Since Chromecast is the only platform that enables HEVC I think it's ok to
overpromise here for the time being, while we are working on better
platform-level checks.

[ddorwin, 2016/04/08 20:43:24]

If there are profiles, level, etc. combinations that will always be supported
when this build flag is enabled, you could report "probably" for those, but
currently this would make requests for 12-bit and whatever else return
"probably". If the results are meaningless, authors will learn to ignore them.

As for the tests, you can change kHevcSupported to "maybe" with a TODO noting
this should be "probably" for some, preferably with a crbug ID.

We are going to need to come up with a new solution for those tests when we add
platform querying anyway.

[servolk, 2016/04/08 22:11:45]

Done.

+    // given combination of HEVC profile and level is actually supported.
+    *is_ambiguous = false;
+    *codec = MimeUtil::HEVC;
+    return true;
+  }
+#endif
+
   DVLOG(4) << __FUNCTION__ << ": Unrecognized codec id " << codec_id;
   return false;
 }
 
 bool MimeUtil::IsCodecSupported(Codec codec,
                                 const std::string& mime_type_lower_case,
                                 bool is_encrypted) const {
   DCHECK_NE(codec, INVALID_CODEC);
 
 #if defined(OS_ANDROID)
   if (!IsCodecSupportedOnPlatform(codec, mime_type_lower_case, is_encrypted,
                                   platform_info_)) {
     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:
     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