Gate support for certain EOTFs/primaries/matrices on color management / hdr flags

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"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/media.h"
 #include "media/base/media_client.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_codecs.h"
+#include "media/base/video_color_space.h"
 #include "media/media_features.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #include "media/base/android/media_codec_util.h"
 #endif
 
 namespace media {
 namespace internal {
 
@@ skipping 51 matching lines @@
     {"theora", MimeUtil::THEORA}
   };
 
   return kStringToCodecMap;
 }
 
 static bool ParseVp9CodecID(const std::string& mime_type_lower_case,
                             const std::string& codec_id,
                             VideoCodecProfile* out_profile,
                             uint8_t* out_level,
-                            gfx::ColorSpace::TransferID* out_eotf) {
+                            VideoColorSpace* out_color_space) {
   if (mime_type_lower_case == "video/mp4") {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableVp9InMp4)) {
       // Only new style is allowed for mp4.
       return ParseNewStyleVp9CodecID(codec_id, out_profile, out_level,
-                                     out_eotf);
+                                     out_color_space);
     }
   } else if (mime_type_lower_case == "video/webm") {
     if (HasNewVp9CodecStringSupport() &&
-        ParseNewStyleVp9CodecID(codec_id, out_profile, out_level, out_eotf)) {
+        ParseNewStyleVp9CodecID(codec_id, out_profile, out_level,
+                                out_color_space)) {
       return true;
     }
 
     return ParseLegacyVp9CodecID(codec_id, out_profile, out_level);
   }
   return false;
 }
 
 static bool IsValidH264Level(uint8_t level_idc) {
   // Valid levels taken from Table A-1 in ISO/IEC 14496-10.
@@ skipping 54 matching lines @@
   DCHECK_EQ(base::ToLowerASCII(mime_type_lower_case), mime_type_lower_case);
 
   SupportsType combined_result = IsSupported;
 
   for (size_t i = 0; i < codecs.size(); ++i) {
     // Parse the string.
     bool ambiguous_codec_string = false;
     Codec codec = INVALID_CODEC;
     VideoCodecProfile video_profile = VIDEO_CODEC_PROFILE_UNKNOWN;
     uint8_t video_level = 0;
-    gfx::ColorSpace::TransferID eotf = gfx::ColorSpace::TransferID::INVALID;
+    VideoColorSpace color_space;
     if (!ParseCodecString(mime_type_lower_case, codecs[i], &codec,
                           &ambiguous_codec_string, &video_profile, &video_level,
-                          &eotf)) {
+                          &color_space)) {
       return IsNotSupported;
     }
 
     // Bail if codec not in supported list for given container.
     if (supported_codecs.find(codec) == supported_codecs.end())
       return IsNotSupported;
 
     // Make conservative guesses to resolve ambiguity before checking platform
     // support. H264 and VP9 are the only allowed ambiguous video codec. DO NOT
     // ADD SUPPORT FOR MORE AMIBIGUOUS STRINGS.
     if (codec == MimeUtil::H264 && ambiguous_codec_string) {
       if (video_profile == VIDEO_CODEC_PROFILE_UNKNOWN)
         video_profile = H264PROFILE_BASELINE;
       if (!IsValidH264Level(video_level))
         video_level = 10;
     } else if (codec == MimeUtil::VP9 && video_level == 0) {
       // Original VP9 content type (codecs="vp9") does not specify the level.
       // TODO(chcunningham): Mark this string as ambiguous when new multi-part
       // VP9 content type is published.
       video_level = 10;
     }
 
     // Check platform support.
     SupportsType result =
         IsCodecSupported(mime_type_lower_case, codec, video_profile,
-                         video_level, eotf, is_encrypted);
+                         video_level, color_space, is_encrypted);
     if (result == IsNotSupported)
       return IsNotSupported;
 
     // If any codec is "MayBeSupported", return Maybe for the combined result.
     // Downgrade to MayBeSupported if we had to guess the meaning of one of the
     // codec strings.
     if (result == MayBeSupported ||
         (result == IsSupported && ambiguous_codec_string))
       combined_result = MayBeSupported;
   }
@@ skipping 344 matching lines @@
 
   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,
                                 uint8_t* out_level,
-                                gfx::ColorSpace::TransferID* out_eotf) const {
+                                VideoColorSpace* out_color_space) const {
   DCHECK_EQ(base::ToLowerASCII(mime_type_lower_case), mime_type_lower_case);
   DCHECK(codec);
   DCHECK(out_profile);
   DCHECK(out_level);
 
   *codec = INVALID_CODEC;
   *ambiguous_codec_string = false;
   *out_profile = VIDEO_CODEC_PROFILE_UNKNOWN;
   *out_level = 0;
 
-  // Most codec strings do not yet specify EOTF. We choose 709 as default color
-  // space elsewhere, so defaulting to 709 EOTF as well. See here for context:
+  // Most codec strings do not yet specify color. We choose 709 as default color
+  // space elsewhere, so defaulting to 709 here as well. See here for context:
   // https://crrev.com/1221903003/
-  *out_eotf = gfx::ColorSpace::TransferID::BT709;
+  *out_color_space = VideoColorSpace::BT709();
 
   std::map<std::string, Codec>::const_iterator itr =
       GetStringToCodecMap().find(codec_id);
   if (itr != GetStringToCodecMap().end()) {
     *codec = itr->second;
 
     return true;
   }
 
   // Check codec string against short list of allowed ambiguous codecs.
   // Hard-coded to discourage expansion. DO NOT ADD TO THIS LIST. DO NOT
   // INCREASE PLACES WHERE |ambiguous_codec_string| = true.
   // NOTE: avc1/avc3.XXXXXX may be ambiguous handled after ParseAVCCodecId().
   if (codec_id == "avc1" || codec_id == "avc3") {
     *codec = MimeUtil::H264;
     *ambiguous_codec_string = true;
     return true;
   } else if (codec_id == "mp4a.40") {
     *codec = MimeUtil::MPEG4_AAC;
     *ambiguous_codec_string = true;
     return true;
   }
 
   // If |codec_id| is not in |kStringToCodecMap|, then we assume that it is
   // either VP9, H.264 or HEVC/H.265 codec ID because currently those are the
   // only ones that are not added to the |kStringToCodecMap| and require
   // parsing.
   if (ParseVp9CodecID(mime_type_lower_case, codec_id, out_profile, out_level,
-                      out_eotf)) {
+                      out_color_space)) {
     *codec = MimeUtil::VP9;
     return true;
   }
 
   if (ParseAVCCodecId(codec_id, out_profile, out_level)) {
     *codec = MimeUtil::H264;
     // Allowed string ambiguity since 2014. DO NOT ADD NEW CASES FOR AMBIGUITY.
     *ambiguous_codec_string = !IsValidH264Level(*out_level);
     return true;
   }
@@ skipping 19 matching lines @@
 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.
   DCHECK_EQ(MimeUtilToVideoCodec(codec), kUnknownVideoCodec);
 
   SupportsType result = IsCodecSupported(
       mime_type_lower_case, codec, VIDEO_CODEC_PROFILE_UNKNOWN,
-      0 /* video_level */, gfx::ColorSpace::TransferID::INVALID, is_encrypted);
+      0 /* video_level */, VideoColorSpace::BT709(), is_encrypted);
 
   // Platform support should never be ambiguous for simple codecs (no range of
   // profiles to consider).
   DCHECK_NE(result, MayBeSupported);
   return result;
 }
 
 SupportsType MimeUtil::IsCodecSupported(const std::string& mime_type_lower_case,
                                         Codec codec,
                                         VideoCodecProfile video_profile,
                                         uint8_t video_level,
-                                        gfx::ColorSpace::TransferID eotf,
+                                        const VideoColorSpace& color_space,
                                         bool is_encrypted) const {
   DCHECK_EQ(base::ToLowerASCII(mime_type_lower_case), mime_type_lower_case);
   DCHECK_NE(codec, INVALID_CODEC);
 
   VideoCodec video_codec = MimeUtilToVideoCodec(codec);
   if (video_codec != kUnknownVideoCodec &&
       // Theora and VP8 do not have profiles/levels.
       video_codec != kCodecTheora && video_codec != kCodecVP8) {
     DCHECK_NE(video_profile, VIDEO_CODEC_PROFILE_UNKNOWN);
     DCHECK_GT(video_level, 0);
@@ skipping 29 matching lines @@
     }
   } else if (codec == MimeUtil::VP9 && video_profile != VP9PROFILE_PROFILE0) {
     // We don't know if the underlying platform supports these profiles. Need
     // to add platform level querying to get supported profiles.
     // https://crbug.com/604566
     ambiguous_platform_support = true;
   }
 
   if (GetMediaClient() && video_codec != kUnknownVideoCodec &&
       !GetMediaClient()->IsSupportedVideoConfig(
-          {video_codec, video_profile, video_level, eotf})) {
+          {video_codec, video_profile, video_level, color_space})) {
     return IsNotSupported;
   }
 
 #if defined(OS_ANDROID)
   // TODO(chcunningham): Delete this. Android platform support should be
   // handled by (android specific) MediaClient.
   if (!IsCodecSupportedOnAndroid(codec, mime_type_lower_case, is_encrypted,
                                  platform_info_)) {
     return IsNotSupported;
   }
@@ skipping 52 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