Add MimeUtil::Parse{Audio|Video}CodecString

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"
+#include "media/base/video_color_space.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 19 matching lines @@
   // Platform configuration structure.  Controls which codecs are supported at
   // runtime.  Also used by tests to simulate platform differences.
   struct PlatformInfo {
     bool has_platform_decoders = false;
 
     bool has_platform_vp8_decoder = false;
     bool has_platform_vp9_decoder = false;
     bool supports_opus = false;
   };
 
+  struct ParsedCodecResult {
+    Codec codec;
+    bool is_ambiguous;
+    VideoCodecProfile video_profile;
+    uint8_t video_level;
+    VideoColorSpace video_color_space;
+  };
+
   // See mime_util.h for more information on these methods.
   bool IsSupportedMediaMimeType(const std::string& mime_type) const;
   void SplitCodecsToVector(const std::string& codecs,
                            std::vector<std::string>* codecs_out,
                            bool strip);
+  bool ParseVideoCodecString(const std::string& mime_type,
+                             const std::string& codec_id,
+                             bool* out_is_ambiguous,
+                             VideoCodec* out_codec,
+                             VideoCodecProfile* out_profile,
+                             uint8_t* out_level,
+                             VideoColorSpace* out_color_space);
+  bool ParseAudioCodecString(const std::string& mime_type,
+                             const std::string& codec_id,
+                             bool* out_is_ambiguous,
+                             AudioCodec* out_codec);
   SupportsType IsSupportedMediaFormat(const std::string& mime_type,
                                       const std::vector<std::string>& codecs,
                                       bool is_encrypted) const;
 
   void RemoveProprietaryMediaTypesAndCodecs();
 
   // Checks android platform specific codec restrictions. Returns true if
   // |codec| is supported when contained in |mime_type_lower_case|.
   // |is_encrypted| means the codec will be used with encrypted blocks.
   // |platform_info| describes the availability of various platform features;
@@ skipping 17 matching lines @@
   void AddContainerWithCodecs(const std::string& mime_type,
                               const CodecSet& codecs_list,
                               bool is_proprietary_mime_type);
 
   // Returns IsSupported if all codec IDs in |codecs| are unambiguous and are
   // supported in |mime_type_lower_case|. MayBeSupported is returned if at least
   // one codec ID in |codecs| is ambiguous but all the codecs are supported.
   // IsNotSupported is returned if |mime_type_lower_case| is not supported or at
   // least one is not supported in |mime_type_lower_case|. |is_encrypted| means
   // the codec will be used with encrypted blocks.
-  SupportsType AreSupportedCodecs(const CodecSet& supported_codecs,
-                                  const std::vector<std::string>& codecs,
-                                  const std::string& mime_type_lower_case,
-                                  bool is_encrypted) const;
+  SupportsType AreSupportedCodecs(
+      const std::vector<ParsedCodecResult>& parsed_codecs,
+      const std::string& mime_type_lower_case,
+      bool is_encrypted) const;
 
-  // Converts a codec ID into an Codec enum value and attempts to output the
-  // |out_profile| and |out_level|.
-  // 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_color| is the color space described by the
-  // |codec_id|.
-  bool ParseCodecString(const std::string& mime_type_lower_case,
+  // Parse the combination of |mime_type_lower_case| and |codecs|. Returns true
+  // when parsing succeeds and output is written to |out_results|. Returns false
+  // when parsing fails. Failure may be caused by
+  //  - invalid/unrecognized codec strings and mime_types
+  //  - invalid combinations of codec strings and mime_types (e.g. H264 in WebM)
+  // See comment for ParseCodecHelper().
+  bool ParseCodecStrings(const std::string& mime_type_lower_case,
+                         const std::vector<std::string>& codecs,
+                         std::vector<ParsedCodecResult>* out_results) const;
+
+  // Helper to ParseCodecStrings(). Parses a single |codec_id| with
+  // |mime_type_lower_case| to populate the fields of |out_result|. This helper
+  // method does not validate the combination of |mime_type_lower_case| and
+  // |codec_id|, nor does it handle empty/unprovided codecs; See caller
+  // ParseCodecStrings().
+  //
+  // |out_result| is only valid when this method returns true (parsing success).
+  // |out_result->is_ambiguous| will be set to true when the codec string
+  // matches one of a fixed number of *non-RFC compliant* strings (e.g. "avc").
+  // Ambiguous video codec strings may fail to provide video profile and/or
+  // level info. In these cases, we use the following values to indicate
+  // "unspecified":
+  //  - out_result->video_profile = VIDEO_CODEC_PROFILE_UNKNOWN
+  //  - out_result->video_level = 0
+  //
+  // For unambiguous video codecs, |video_profile| and |video_level| will be
+  // set in |out_result|.
+  //
+  // |out_result|'s |video_color_space| will report the codec strings color
+  // space when provided. Most codec strings do not yet describe color, so this
+  // will often be set to the default of REC709.
+  bool ParseCodecHelper(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,
-                        VideoColorSpace* out_colorspace) const;
+                        ParsedCodecResult* out_result) 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,
@@ skipping 11 matching lines @@
 
   // Returns true if |codec| refers to a proprietary codec.
   bool IsCodecProprietary(Codec codec) const;
 
   // Returns true and sets |*default_codec| if |mime_type_lower_case| has a
   // default codec associated with it. Returns false otherwise and the value of
   // |*default_codec| is undefined.
   bool GetDefaultCodec(const std::string& mime_type_lower_case,
                        Codec* default_codec) const;
 
-  // Returns IsSupported if |mime_type_lower_case| has a default codec
-  // associated with it and IsCodecSupported() returns IsSupported for that
-  // particular codec. |is_encrypted| means the codec will be used with
-  // encrypted blocks.
-  SupportsType IsDefaultCodecSupported(const std::string& mime_type_lower_case,
-                                       bool is_encrypted) const;
-
 #if defined(OS_ANDROID)
   // Indicates the support of various codecs within the platform.
   PlatformInfo platform_info_;
 #endif
 
   // A map of mime_types and hash map of the supported codecs for the mime_type.
   MediaFormatMappings media_format_map_;
 
   // List of proprietary containers in |media_format_map_|.
   std::vector<std::string> proprietary_media_containers_;
   // 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_