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 "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ skipping 133 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::DolbyVision:
+      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 98 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(DolbyVision);
+#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 DolbyVision:
+      // This function is only called on Android which doesn't support Dolby
+      // Vision.
+      return false;
   }
 
   return false;
 }
 
 bool MimeUtil::StringToCodec(const std::string& mime_type_lower_case,
                              const std::string& codec_id,
                              Codec* codec,
                              bool* is_ambiguous,
                              VideoCodecProfile* out_profile,
@@ skipping 61 matching lines @@
   }
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecId(codec_id, out_profile, out_level)) {
     *codec = MimeUtil::HEVC;
     *is_ambiguous = false;
     return true;
   }
 #endif
 
+#if BUILDFLAG(ENABLE_DOLBY_VISION_DEMUXING)
+  if (ParseDolbyVisionCodecId(codec_id, out_profile, out_level)) {
+    *codec = MimeUtil::DolbyVision;
+    *is_ambiguous = false;
+    return true;
+  }
+#endif
+
   DVLOG(4) << __func__ << ": 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:
+    case DolbyVision:
       return true;
 
     case PCM:
     case VORBIS:
     case OPUS:
     case FLAC:
     case VP8:
     case VP9:
     case THEORA:
       return false;
@@ skipping 28 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