Introduce Dolby Vision video codec and Demuxer support

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 <map>
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 122 matching lines @@
     case MimeUtil::H264:
       return kCodecH264;
     case MimeUtil::HEVC:
       return kCodecHEVC;
     case MimeUtil::VP8:
       return kCodecVP8;
     case MimeUtil::VP9:
       return kCodecVP9;
     case MimeUtil::THEORA:
       return kCodecTheora;
+    case MimeUtil::DOLBY_VISION:
+      return kCodecDolbyVision;
     default:
       break;
   }
   return kUnknownVideoCodec;
 }
 
 SupportsType MimeUtil::AreSupportedCodecs(
     const CodecSet& supported_codecs,
     const std::vector<std::string>& codecs,
     const std::string& mime_type_lower_case,
@@ skipping 108 matching lines @@
 #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);
 #endif  // BUILDFLAG(ENABLE_HEVC_DEMUXING)
   // Only VP9 with valid codec string vp09.xx.xx.xx.xx.xx.xx.xx is supported.
   // See ParseVp9CodecID for details.
   mp4_video_codecs.insert(VP9);
+#if BUILDFLAG(ENABLE_DOLBY_VISION_DEMUXING)
+  mp4_video_codecs.insert(DOLBY_VISION);
+#endif  // BUILDFLAG(ENABLE_DOLBY_VISION_DEMUXING)
   CodecSet mp4_codecs(mp4_audio_codecs);
   mp4_codecs.insert(mp4_video_codecs.begin(), mp4_video_codecs.end());
 #endif  // BUILDFLAG(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);
   AddContainerWithCodecs("audio/ogg", ogg_audio_codecs, false);
@@ skipping 248 matching lines @@
       if (!platform_info.has_platform_vp9_decoder)
         return false;
 
       // Encrypted content is demuxed so the container is irrelevant.
       if (is_encrypted)
         return true;
 
       // MediaPlayer only supports VP9 in WebM.
       return mime_type_lower_case == "video/webm";
     }
+
+    case DOLBY_VISION:
+      // This function is only called on Android which doesn't support Dolby
+      // Vision.
+      return false;
   }
 
   return false;
 }
 
 bool MimeUtil::ParseCodecString(const std::string& mime_type_lower_case,
                                 const std::string& codec_id,
                                 Codec* codec,
                                 bool* ambiguous_codec_string,
                                 VideoCodecProfile* out_profile,
@@ skipping 46 matching lines @@
     return true;
   }
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecId(codec_id, out_profile, out_level)) {
     *codec = MimeUtil::HEVC;
     return true;
   }
 #endif
 
+#if BUILDFLAG(ENABLE_DOLBY_VISION_DEMUXING)
+  if (ParseDolbyVisionCodecId(codec_id, out_profile, out_level)) {
+    *codec = MimeUtil::DOLBY_VISION;
+    return true;
+  }
+#endif
+
   DVLOG(2) << __func__ << ": Unrecognized codec id " << codec_id;
   return false;
 }
 
 SupportsType MimeUtil::IsSimpleCodecSupported(
     const std::string& mime_type_lower_case,
     Codec codec,
     bool is_encrypted) const {
   // Video codecs are not "simple" because they require a profile and level to
   // be specified. There is no "default" video codec for a given container.
@@ skipping 81 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:
+    case DOLBY_VISION:
       return true;
 
     case PCM:
     case VORBIS:
     case OPUS:
     case FLAC:
     case VP8:
     case VP9:
     case THEORA:
       return false;
@@ skipping 26 matching lines @@
 SupportsType MimeUtil::IsDefaultCodecSupported(const std::string& mime_type,
                                                bool is_encrypted) const {
   Codec default_codec = Codec::INVALID_CODEC;
   if (!GetDefaultCodec(mime_type, &default_codec))
     return IsNotSupported;
   return IsSimpleCodecSupported(mime_type, default_codec, is_encrypted);
 }
 
 }  // namespace internal
 }  // namespace media