Add MimeUtil::Parse{Audio|Video}CodecString

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 390 matching lines @@
 
   // Strip everything past the first '.'
   for (std::vector<std::string>::iterator it = codecs_out->begin();
        it != codecs_out->end(); ++it) {
     size_t found = it->find_first_of('.');
     if (found != std::string::npos)
       it->resize(found);
   }
 }
 
+bool MimeUtil::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_colorspace) {
+  DCHECK(out_is_ambiguous);
+  DCHECK(out_codec);
+  DCHECK(out_profile);
+  DCHECK(out_level);
+  DCHECK(out_colorspace);
+
+  Codec mime_internal_codec;
+  bool parsed_ok = ParseCodecString(base::ToLowerASCII(mime_type), codec_id,
+                                    &mime_internal_codec, out_is_ambiguous,
+                                    out_profile, out_level, out_colorspace);
+  if (!parsed_ok)
+    return false;
+
+  *out_codec = MimeUtilToVideoCodec(mime_internal_codec);
+  if (*out_codec == kUnknownVideoCodec)
+    return false;
+
+  return true;
+}
+
+bool MimeUtil::ParseAudioCodecString(const std::string& mime_type,
+                                     const std::string& codec_id,
+                                     bool* out_is_ambiguous,
+                                     AudioCodec* out_codec) {
+  DCHECK(out_is_ambiguous);
+  DCHECK(out_codec);
+
+  Codec mime_internal_codec;
+
+  // Some audio containers unambiguously imply a codec.
+  if (codec_id.empty()) {
+    if (!GetDefaultCodec(mime_type, &mime_internal_codec))
+      return false;
+
+    *out_is_ambiguous = false;
+  } else {
+    // Not part of audio parsing, but its possible users will mistakenly put

[tguilbert, 2017/05/08 23:19:57]

Pure curiosity and not a CL comment: why do we handle when users add video
codecs in the audio config string, but not vice versa?

+    // video codecs in the audio config string, causing the common parsing algo
+    // to set these output values. Passing non-null values avoids issues.
+    VideoCodecProfile out_profile = VIDEO_CODEC_PROFILE_UNKNOWN;
+    uint8_t out_level = 0;
+    VideoColorSpace out_colorspace;
+
+    if (!ParseCodecString(base::ToLowerASCII(mime_type), codec_id,
+                          &mime_internal_codec, out_is_ambiguous, &out_profile,
+                          &out_level, &out_colorspace)) {
+      return false;
+    }
+  }
+
+  *out_codec = MimeUtilToAudioCodec(mime_internal_codec);
+  if (*out_codec == kUnknownAudioCodec)
+    return false;
+
+  return true;
+}
+
 SupportsType MimeUtil::IsSupportedMediaFormat(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     bool is_encrypted) const {
   const std::string mime_type_lower_case = base::ToLowerASCII(mime_type);
   MediaFormatMappings::const_iterator it_media_format_map =
       media_format_map_.find(mime_type_lower_case);
   if (it_media_format_map == media_format_map_.end()) {
     DVLOG(3) << __func__ << " Unrecognized mime type: " << mime_type;
     return IsNotSupported;
@@ skipping 386 matching lines @@
     case VP9:
     case THEORA:
       return false;
   }
 
   return true;
 }
 
 bool MimeUtil::GetDefaultCodec(const std::string& mime_type,
                                Codec* default_codec) const {
+  // Codecs below are unambiguously implied by the mime type string. DO NOT add
+  // default codecs for ambiguous mime types.
+
   if (mime_type == "audio/mpeg" || mime_type == "audio/mp3" ||
       mime_type == "audio/x-mp3") {
     *default_codec = MimeUtil::MP3;
     return true;
   }
 
   if (mime_type == "audio/aac") {
     *default_codec = MimeUtil::MPEG4_AAC;
     return true;
   }
 
   if (mime_type == "audio/flac") {
     *default_codec = MimeUtil::FLAC;
     return true;
   }
 
   return false;
 }
 
 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