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

media/base/mime_util_internal.h

 // 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.
 
 #ifndef MEDIA_BASE_MIME_UTIL_INTERNAL_H_
 #define MEDIA_BASE_MIME_UTIL_INTERNAL_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "media/base/media_export.h"
 #include "media/base/mime_util.h"
 #include "media/base/video_codecs.h"
 
 namespace media {
+
+class VideoColorSpace;
+
 namespace internal {
 
 // Internal utility class for handling mime types.  Should only be invoked by
 // tests and the functions within mime_util.cc -- NOT for direct use by others.
 class MEDIA_EXPORT MimeUtil {
  public:
   MimeUtil();
   ~MimeUtil();
 
   enum Codec {
@@ skipping 78 matching lines @@
   // Returns true if this method was able to map |codec_id| with
   // |mime_type_lower_case| to a specific Codec enum value. |codec| is only
   // valid if true is returned.
   // |ambiguous_codec_string| will be set to true when the codec string matches
   // one of a small number of non-RFC compliant strings (e.g. "avc").
   // |profile| and |level| indicate video codec profile and level (unused for
   // audio codecs). These will be VIDEO_CODEC_PROFILE_UNKNOWN and 0 respectively
   // whenever |codec_id| is incomplete/invalid, or in some cases when
   // |ambiguous_codec_string| is set to true.
   // |is_encrypted| means the codec will be used with encrypted blocks.
-  // |out_eotf| is the electro-optical transfer function described by the
-  // |codec_id|. Will be gfx::ColorSpace::TransferID::INVALID for many codec
-  // strings where EOTF is not described.
+  // |out_color| is the color space described by the
+  // |codec_id|.
   bool 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_colorspace) const;
 
   // Returns IsSupported if |codec| when platform supports codec contained in
   // |mime_type_lower_case|. Returns MayBeSupported when platform support is
   // unclear. Otherwise returns NotSupported. Note: This method will always
   // return NotSupported for proprietary codecs if |allow_proprietary_codecs_|
   // is set to false. |is_encrypted| means the codec will be used with encrypted
   // blocks.
   // TODO(chcunningham): Make this method return a bool. Platform support should
   // always be knowable for a fully specified codec.
   SupportsType IsCodecSupported(const std::string& mime_type_lower_case,
                                 Codec codec,
                                 VideoCodecProfile video_profile,
                                 uint8_t video_level,
-                                gfx::ColorSpace::TransferID eotf,
+                                const VideoColorSpace& eotf,
                                 bool is_encrypted) const;
 
   // Wrapper around IsCodecSupported for simple codecs that are entirely
   // described (or implied) by the container mime-type.
   SupportsType IsSimpleCodecSupported(const std::string& mime_type_lower_case,
                                       Codec codec,
                                       bool is_encrypted) const;
 
   // Returns true if |codec| refers to a proprietary codec.
   bool IsCodecProprietary(Codec codec) const;
@@ skipping 24 matching lines @@
   // Whether proprietary codec support should be advertised to callers.
   bool allow_proprietary_codecs_;
 
   DISALLOW_COPY_AND_ASSIGN(MimeUtil);
 };
 
 }  // namespace internal
 }  // namespace media
 
 #endif  // MEDIA_BASE_MIME_UTIL_INTERNAL_H_