Index: net/base/mime_util.cc |
diff --git a/net/base/mime_util.cc b/net/base/mime_util.cc |
index e4901277c3f8c12e9207a83deddfeee0fa09ad71..00a1c18b02a3153f623516268de35151d227236e 100644 |
--- a/net/base/mime_util.cc |
+++ b/net/base/mime_util.cc |
@@ -19,10 +19,6 @@ |
#include "net/base/platform_mime_util.h" |
#include "net/http/http_util.h" |
-#if defined(OS_ANDROID) |
-#include "base/android/build_info.h" |
-#endif |
- |
using std::string; |
namespace net { |
@@ -30,26 +26,6 @@ namespace net { |
// Singleton utility class for mime types. |
class MimeUtil : public PlatformMimeUtil { |
public: |
- enum Codec { |
- INVALID_CODEC, |
- PCM, |
- MP3, |
- MPEG2_AAC_LC, |
- MPEG2_AAC_MAIN, |
- MPEG2_AAC_SSR, |
- MPEG4_AAC_LC, |
- MPEG4_AAC_SBR_v1, |
- MPEG4_AAC_SBR_PS_v2, |
- VORBIS, |
- OPUS, |
- H264_BASELINE, |
- H264_MAIN, |
- H264_HIGH, |
- VP8, |
- VP9, |
- THEORA |
- }; |
- |
bool GetMimeTypeFromExtension(const base::FilePath::StringType& ext, |
std::string* mime_type) const; |
@@ -60,7 +36,6 @@ class MimeUtil : public PlatformMimeUtil { |
std::string* mime_type) const; |
bool IsSupportedImageMimeType(const std::string& mime_type) const; |
- bool IsSupportedMediaMimeType(const std::string& mime_type) const; |
bool IsSupportedNonImageMimeType(const std::string& mime_type) const; |
bool IsUnsupportedTextMimeType(const std::string& mime_type) const; |
bool IsSupportedJavascriptMimeType(const std::string& mime_type) const; |
@@ -76,45 +51,13 @@ class MimeUtil : public PlatformMimeUtil { |
bool IsValidTopLevelMimeType(const std::string& type_string) const; |
- bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) const; |
- |
- void ParseCodecString(const std::string& codecs, |
- std::vector<std::string>* codecs_out, |
- bool strip); |
- |
- bool IsStrictMediaMimeType(const std::string& mime_type) const; |
- SupportsType IsSupportedStrictMediaMimeType( |
- const std::string& mime_type, |
- const std::vector<std::string>& codecs) const; |
- |
- void RemoveProprietaryMediaTypesAndCodecsForTests(); |
- |
private: |
friend struct base::DefaultLazyInstanceTraits<MimeUtil>; |
typedef base::hash_set<std::string> MimeMappings; |
- typedef base::hash_set<int> CodecSet; |
- typedef std::map<std::string, CodecSet> StrictMappings; |
- struct CodecEntry { |
- CodecEntry() : codec(INVALID_CODEC), is_ambiguous(true) {} |
- CodecEntry(Codec c, bool ambiguous) : codec(c), is_ambiguous(ambiguous) {} |
- Codec codec; |
- bool is_ambiguous; |
- }; |
- typedef std::map<std::string, CodecEntry> StringToCodecMappings; |
- |
MimeUtil(); |
- // Returns IsSupported if all codec IDs in |codecs| are unambiguous |
- // and are supported by the platform. MayBeSupported is returned if |
- // at least one codec ID in |codecs| is ambiguous but all the codecs |
- // are supported by the platform. IsNotSupported is returned if at |
- // least one codec ID is not supported by the platform. |
- SupportsType AreSupportedCodecs( |
- const CodecSet& supported_codecs, |
- const std::vector<std::string>& codecs) const; |
- |
// For faster lookup, keep hash sets. |
void InitializeMimeTypeMaps(); |
@@ -122,52 +65,10 @@ class MimeUtil : public PlatformMimeUtil { |
bool include_platform_types, |
std::string* mime_type) const; |
- // Converts a codec ID into an Codec enum value and indicates |
- // whether the conversion was ambiguous. |
- // Returns true if this method was able to map |codec_id| to a specific |
- // Codec enum value. |codec| and |is_ambiguous| are only valid if true |
- // is returned. Otherwise their value is undefined after the call. |
- // |is_ambiguous| is true if |codec_id| did not have enough information to |
- // unambiguously determine the proper Codec enum value. If |is_ambiguous| |
- // is true |codec| contains the best guess for the intended Codec enum value. |
- bool StringToCodec(const std::string& codec_id, |
- Codec* codec, |
- bool* is_ambiguous) const; |
- |
- // Returns true if |codec| is supported by the platform. |
- // Note: This method will return false if the platform supports proprietary |
- // codecs but |allow_proprietary_codecs_| is set to false. |
- bool IsCodecSupported(Codec codec) const; |
- |
- // Returns true if |codec| refers to a proprietary codec. |
- bool IsCodecProprietary(Codec codec) const; |
- |
- // Returns true and sets |*default_codec| if |mime_type| has a default codec |
- // associated with it. Returns false otherwise and the value of |
- // |*default_codec| is undefined. |
- bool GetDefaultCodecLowerCase(const std::string& mime_type_lower_case, |
- Codec* default_codec) const; |
- |
- // Returns true if |mime_type_lower_case| has a default codec associated with |
- // it and IsCodecSupported() returns true for that particular codec. |
- bool IsDefaultCodecSupportedLowerCase( |
- const std::string& mime_type_lower_case) const; |
- |
MimeMappings image_map_; |
- MimeMappings media_map_; |
MimeMappings non_image_map_; |
MimeMappings unsupported_text_map_; |
MimeMappings javascript_map_; |
- |
- // A map of mime_types and hash map of the supported codecs for the mime_type. |
- StrictMappings strict_format_map_; |
- |
- // Keeps track of whether proprietary codec support should be |
- // advertised to callers. |
- bool allow_proprietary_codecs_; |
- |
- // Lookup table for string compare based string -> Codec mappings. |
- StringToCodecMappings string_to_codec_map_; |
}; // class MimeUtil |
// This variable is Leaky because we need to access it from WorkerPool threads. |
@@ -322,52 +223,6 @@ static const char* const supported_image_types[] = { |
"image/x-png" |
}; |
-// A list of media types: http://en.wikipedia.org/wiki/Internet_media_type |
-// A comprehensive mime type list: http://plugindoc.mozdev.org/winmime.php |
-// This set of codecs is supported by all variations of Chromium. |
-static const char* const common_media_types[] = { |
- // Ogg. |
- "audio/ogg", |
- "application/ogg", |
-#if !defined(OS_ANDROID) // Android doesn't support Ogg Theora. |
- "video/ogg", |
-#endif |
- |
- // WebM. |
- "video/webm", |
- "audio/webm", |
- |
- // Wav. |
- "audio/wav", |
- "audio/x-wav", |
- |
-#if defined(OS_ANDROID) |
- // HLS. Supported by Android ICS and above. |
- "application/vnd.apple.mpegurl", |
- "application/x-mpegurl", |
-#endif |
-}; |
- |
-// List of proprietary types only supported by Google Chrome. |
-static const char* const proprietary_media_types[] = { |
- // MPEG-4. |
- "video/mp4", |
- "video/x-m4v", |
- "audio/mp4", |
- "audio/x-m4a", |
- |
- // MP3. |
- "audio/mp3", |
- "audio/x-mp3", |
- "audio/mpeg", |
- "audio/aac", |
- |
-#if defined(ENABLE_MPEG2TS_STREAM_PARSER) |
- // MPEG-2 TS. |
- "video/mp2t", |
-#endif |
-}; |
- |
// Note: |
// - does not include javascript types list (see supported_javascript_types) |
// - does not include types starting with "text/" (see |
@@ -448,189 +303,10 @@ static const char* const supported_javascript_types[] = { |
"text/livescript" |
}; |
-#if defined(OS_ANDROID) |
-static bool IsCodecSupportedOnAndroid(MimeUtil::Codec codec) { |
- switch (codec) { |
- case MimeUtil::INVALID_CODEC: |
- return false; |
- |
- case MimeUtil::PCM: |
- case MimeUtil::MP3: |
- case MimeUtil::MPEG4_AAC_LC: |
- case MimeUtil::MPEG4_AAC_SBR_v1: |
- case MimeUtil::MPEG4_AAC_SBR_PS_v2: |
- case MimeUtil::H264_BASELINE: |
- case MimeUtil::H264_MAIN: |
- case MimeUtil::H264_HIGH: |
- case MimeUtil::VP8: |
- case MimeUtil::VORBIS: |
- return true; |
- |
- case MimeUtil::MPEG2_AAC_LC: |
- case MimeUtil::MPEG2_AAC_MAIN: |
- case MimeUtil::MPEG2_AAC_SSR: |
- // MPEG-2 variants of AAC are not supported on Android. |
- return false; |
- |
- case MimeUtil::VP9: |
- // VP9 is supported only in KitKat+ (API Level 19). |
- return base::android::BuildInfo::GetInstance()->sdk_int() >= 19; |
- |
- case MimeUtil::OPUS: |
- // Opus is supported only in Lollipop+ (API Level 21). |
- return base::android::BuildInfo::GetInstance()->sdk_int() >= 21; |
- |
- case MimeUtil::THEORA: |
- return false; |
- } |
- |
- return false; |
-} |
- |
-static bool IsMimeTypeSupportedOnAndroid(const std::string& mimeType) { |
- // HLS codecs are supported in ICS and above (API level 14) |
- if ((!mimeType.compare("application/vnd.apple.mpegurl") || |
- !mimeType.compare("application/x-mpegurl")) && |
- base::android::BuildInfo::GetInstance()->sdk_int() < 14) { |
- return false; |
- } |
- return true; |
-} |
-#endif |
- |
-struct MediaFormatStrict { |
- const char* const mime_type; |
- const char* const codecs_list; |
-}; |
- |
-// Following is the list of RFC 6381 compliant codecs: |
-// mp4a.66 - MPEG-2 AAC MAIN |
-// mp4a.67 - MPEG-2 AAC LC |
-// mp4a.68 - MPEG-2 AAC SSR |
-// mp4a.69 - MPEG-2 extension to MPEG-1 |
-// mp4a.6B - MPEG-1 audio |
-// mp4a.40.2 - MPEG-4 AAC LC |
-// mp4a.40.02 - MPEG-4 AAC LC (leading 0 in aud-oti for compatibility) |
-// mp4a.40.5 - MPEG-4 HE-AAC v1 (AAC LC + SBR) |
-// mp4a.40.05 - MPEG-4 HE-AAC v1 (AAC LC + SBR) (leading 0 in aud-oti for |
-// compatibility) |
-// mp4a.40.29 - MPEG-4 HE-AAC v2 (AAC LC + SBR + PS) |
-// |
-// avc1.42E0xx - H.264 Baseline |
-// avc1.4D40xx - H.264 Main |
-// avc1.6400xx - H.264 High |
-static const char kMP4AudioCodecsExpression[] = |
- "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.02,mp4a.40.5," |
- "mp4a.40.05,mp4a.40.29"; |
-static const char kMP4VideoCodecsExpression[] = |
- // This is not a complete list of supported avc1 codecs. It is simply used |
- // to register support for the corresponding Codec enum. Instead of using |
- // strings in these three arrays, we should use the Codec enum values. |
- // This will avoid confusion and unnecessary parsing at runtime. |
- // kUnambiguousCodecStringMap/kAmbiguousCodecStringMap should be the only |
- // mapping from strings to codecs. See crbug.com/461009. |
- "avc1.42E00A,avc1.4D400A,avc1.64000A," |
- "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.02,mp4a.40.5," |
- "mp4a.40.05,mp4a.40.29"; |
- |
-// These containers are also included in |
-// common_media_types/proprietary_media_types. See crbug.com/461012. |
-static const MediaFormatStrict format_codec_mappings[] = { |
- {"video/webm", "opus,vorbis,vp8,vp8.0,vp9,vp9.0"}, |
- {"audio/webm", "opus,vorbis"}, |
- {"audio/wav", "1"}, |
- {"audio/x-wav", "1"}, |
-// Android does not support Opus in Ogg container. |
-#if defined(OS_ANDROID) |
- {"video/ogg", "theora,vorbis"}, |
- {"audio/ogg", "vorbis"}, |
- {"application/ogg", "theora,vorbis"}, |
-#else |
- {"video/ogg", "opus,theora,vorbis"}, |
- {"audio/ogg", "opus,vorbis"}, |
- {"application/ogg", "opus,theora,vorbis"}, |
-#endif |
- {"audio/mpeg", "mp3"}, |
- {"audio/mp3", ""}, |
- {"audio/x-mp3", ""}, |
- {"audio/mp4", kMP4AudioCodecsExpression}, |
- {"audio/x-m4a", kMP4AudioCodecsExpression}, |
- {"video/mp4", kMP4VideoCodecsExpression}, |
- {"video/x-m4v", kMP4VideoCodecsExpression}, |
- {"application/x-mpegurl", kMP4VideoCodecsExpression}, |
- {"application/vnd.apple.mpegurl", kMP4VideoCodecsExpression}}; |
- |
-struct CodecIDMappings { |
- const char* const codec_id; |
- MimeUtil::Codec codec; |
-}; |
- |
-// List of codec IDs that provide enough information to determine the |
-// codec and profile being requested. |
-// |
-// The "mp4a" strings come from RFC 6381. |
-static const CodecIDMappings kUnambiguousCodecStringMap[] = { |
- {"1", MimeUtil::PCM}, // We only allow this for WAV so it isn't ambiguous. |
- // avc1/avc3.XXXXXX may be unambiguous; handled by ParseH264CodecID(). |
- {"mp3", MimeUtil::MP3}, |
- {"mp4a.66", MimeUtil::MPEG2_AAC_MAIN}, |
- {"mp4a.67", MimeUtil::MPEG2_AAC_LC}, |
- {"mp4a.68", MimeUtil::MPEG2_AAC_SSR}, |
- {"mp4a.69", MimeUtil::MP3}, |
- {"mp4a.6B", MimeUtil::MP3}, |
- {"mp4a.40.2", MimeUtil::MPEG4_AAC_LC}, |
- {"mp4a.40.02", MimeUtil::MPEG4_AAC_LC}, |
- {"mp4a.40.5", MimeUtil::MPEG4_AAC_SBR_v1}, |
- {"mp4a.40.05", MimeUtil::MPEG4_AAC_SBR_v1}, |
- {"mp4a.40.29", MimeUtil::MPEG4_AAC_SBR_PS_v2}, |
- {"vorbis", MimeUtil::VORBIS}, |
- {"opus", MimeUtil::OPUS}, |
- {"vp8", MimeUtil::VP8}, |
- {"vp8.0", MimeUtil::VP8}, |
- {"vp9", MimeUtil::VP9}, |
- {"vp9.0", MimeUtil::VP9}, |
- {"theora", MimeUtil::THEORA}}; |
- |
-// List of codec IDs that are ambiguous and don't provide |
-// enough information to determine the codec and profile. |
-// The codec in these entries indicate the codec and profile |
-// we assume the user is trying to indicate. |
-static const CodecIDMappings kAmbiguousCodecStringMap[] = { |
- {"mp4a.40", MimeUtil::MPEG4_AAC_LC}, |
- {"avc1", MimeUtil::H264_BASELINE}, |
- {"avc3", MimeUtil::H264_BASELINE}, |
- // avc1/avc3.XXXXXX may be ambiguous; handled by ParseH264CodecID(). |
-}; |
- |
-MimeUtil::MimeUtil() : allow_proprietary_codecs_(false) { |
+MimeUtil::MimeUtil() { |
InitializeMimeTypeMaps(); |
} |
-SupportsType MimeUtil::AreSupportedCodecs( |
- const CodecSet& supported_codecs, |
- const std::vector<std::string>& codecs) const { |
- DCHECK(!supported_codecs.empty()); |
- DCHECK(!codecs.empty()); |
- |
- SupportsType result = IsSupported; |
- for (size_t i = 0; i < codecs.size(); ++i) { |
- bool is_ambiguous = true; |
- Codec codec = INVALID_CODEC; |
- if (!StringToCodec(codecs[i], &codec, &is_ambiguous)) |
- return IsNotSupported; |
- |
- if (!IsCodecSupported(codec) || |
- supported_codecs.find(codec) == supported_codecs.end()) { |
- return IsNotSupported; |
- } |
- |
- if (is_ambiguous) |
- result = MayBeSupported; |
- } |
- |
- return result; |
-} |
- |
void MimeUtil::InitializeMimeTypeMaps() { |
for (size_t i = 0; i < arraysize(supported_image_types); ++i) |
image_map_.insert(supported_image_types[i]); |
@@ -644,64 +320,9 @@ void MimeUtil::InitializeMimeTypeMaps() { |
unsupported_text_map_.insert(unsupported_text_types[i]); |
for (size_t i = 0; i < arraysize(supported_javascript_types); ++i) |
non_image_map_.insert(supported_javascript_types[i]); |
- for (size_t i = 0; i < arraysize(common_media_types); ++i) { |
-#if defined(OS_ANDROID) |
- if (!IsMimeTypeSupportedOnAndroid(common_media_types[i])) |
- continue; |
-#endif |
- non_image_map_.insert(common_media_types[i]); |
- } |
-#if defined(USE_PROPRIETARY_CODECS) |
- allow_proprietary_codecs_ = true; |
- |
- for (size_t i = 0; i < arraysize(proprietary_media_types); ++i) |
- non_image_map_.insert(proprietary_media_types[i]); |
-#endif |
- |
- // Initialize the supported media types. |
- for (size_t i = 0; i < arraysize(common_media_types); ++i) { |
-#if defined(OS_ANDROID) |
- if (!IsMimeTypeSupportedOnAndroid(common_media_types[i])) |
- continue; |
-#endif |
- media_map_.insert(common_media_types[i]); |
- } |
-#if defined(USE_PROPRIETARY_CODECS) |
- for (size_t i = 0; i < arraysize(proprietary_media_types); ++i) |
- media_map_.insert(proprietary_media_types[i]); |
-#endif |
for (size_t i = 0; i < arraysize(supported_javascript_types); ++i) |
javascript_map_.insert(supported_javascript_types[i]); |
- |
- for (size_t i = 0; i < arraysize(kUnambiguousCodecStringMap); ++i) { |
- string_to_codec_map_[kUnambiguousCodecStringMap[i].codec_id] = |
- CodecEntry(kUnambiguousCodecStringMap[i].codec, false); |
- } |
- |
- for (size_t i = 0; i < arraysize(kAmbiguousCodecStringMap); ++i) { |
- string_to_codec_map_[kAmbiguousCodecStringMap[i].codec_id] = |
- CodecEntry(kAmbiguousCodecStringMap[i].codec, true); |
- } |
- |
- // Initialize the strict supported media types. |
- for (size_t i = 0; i < arraysize(format_codec_mappings); ++i) { |
- std::vector<std::string> mime_type_codecs; |
- ParseCodecString(format_codec_mappings[i].codecs_list, |
- &mime_type_codecs, |
- false); |
- |
- CodecSet codecs; |
- for (size_t j = 0; j < mime_type_codecs.size(); ++j) { |
- Codec codec = INVALID_CODEC; |
- bool is_ambiguous = true; |
- CHECK(StringToCodec(mime_type_codecs[j], &codec, &is_ambiguous)); |
- DCHECK(!is_ambiguous); |
- codecs.insert(codec); |
- } |
- |
- strict_format_map_[format_codec_mappings[i].mime_type] = codecs; |
- } |
} |
bool MimeUtil::IsSupportedImageMimeType(const std::string& mime_type) const { |
@@ -709,11 +330,6 @@ bool MimeUtil::IsSupportedImageMimeType(const std::string& mime_type) const { |
image_map_.end(); |
} |
-bool MimeUtil::IsSupportedMediaMimeType(const std::string& mime_type) const { |
- return media_map_.find(base::StringToLowerASCII(mime_type)) != |
- media_map_.end(); |
-} |
- |
bool MimeUtil::IsSupportedNonImageMimeType(const std::string& mime_type) const { |
return non_image_map_.find(base::StringToLowerASCII(mime_type)) != |
non_image_map_.end() || |
@@ -881,243 +497,6 @@ bool MimeUtil::IsValidTopLevelMimeType(const std::string& type_string) const { |
return type_string.size() > 2 && StartsWithASCII(type_string, "x-", false); |
} |
-bool MimeUtil::AreSupportedMediaCodecs( |
- const std::vector<std::string>& codecs) const { |
- for (size_t i = 0; i < codecs.size(); ++i) { |
- Codec codec = INVALID_CODEC; |
- bool is_ambiguous = true; |
- if (!StringToCodec(codecs[i], &codec, &is_ambiguous) || |
- !IsCodecSupported(codec)) { |
- return false; |
- } |
- } |
- return true; |
-} |
- |
-void MimeUtil::ParseCodecString(const std::string& codecs, |
- std::vector<std::string>* codecs_out, |
- bool strip) { |
- std::string no_quote_codecs; |
- base::TrimString(codecs, "\"", &no_quote_codecs); |
- base::SplitString(no_quote_codecs, ',', codecs_out); |
- |
- if (!strip) |
- return; |
- |
- // 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::IsStrictMediaMimeType(const std::string& mime_type) const { |
- return strict_format_map_.find(base::StringToLowerASCII(mime_type)) != |
- strict_format_map_.end(); |
-} |
- |
-SupportsType MimeUtil::IsSupportedStrictMediaMimeType( |
- const std::string& mime_type, |
- const std::vector<std::string>& codecs) const { |
- const std::string mime_type_lower_case = base::StringToLowerASCII(mime_type); |
- StrictMappings::const_iterator it_strict_map = |
- strict_format_map_.find(mime_type_lower_case); |
- if (it_strict_map == strict_format_map_.end()) |
- return codecs.empty() ? MayBeSupported : IsNotSupported; |
- |
- if (it_strict_map->second.empty()) { |
- // We get here if the mimetype does not expect a codecs parameter. |
- return (codecs.empty() && |
- IsDefaultCodecSupportedLowerCase(mime_type_lower_case)) |
- ? IsSupported |
- : IsNotSupported; |
- } |
- |
- if (codecs.empty()) { |
- // We get here if the mimetype expects to get a codecs parameter, |
- // but didn't get one. If |mime_type_lower_case| does not have a default |
- // codec the best we can do is say "maybe" because we don't have enough |
- // information. |
- Codec default_codec = INVALID_CODEC; |
- if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec)) |
- return MayBeSupported; |
- |
- return IsCodecSupported(default_codec) ? IsSupported : IsNotSupported; |
- } |
- |
- return AreSupportedCodecs(it_strict_map->second, codecs); |
-} |
- |
-void MimeUtil::RemoveProprietaryMediaTypesAndCodecsForTests() { |
- for (size_t i = 0; i < arraysize(proprietary_media_types); ++i) { |
- non_image_map_.erase(proprietary_media_types[i]); |
- media_map_.erase(proprietary_media_types[i]); |
- } |
- allow_proprietary_codecs_ = false; |
-} |
- |
-// Returns true iff |profile_str| conforms to hex string "42y0", where y is one |
-// of [8..F]. Requiring constraint_set0_flag be set and profile_idc be 0x42 is |
-// taken from ISO-14496-10 7.3.2.1, 7.4.2.1, and Annex A.2.1. |
-// |
-// |profile_str| is the first four characters of the H.264 suffix string |
-// (ignoring the last 2 characters of the full 6 character suffix that are |
-// level_idc). From ISO-14496-10 7.3.2.1, it consists of: |
-// 8 bits: profile_idc: required to be 0x42 here. |
-// 1 bit: constraint_set0_flag : required to be true here. |
-// 1 bit: constraint_set1_flag : ignored here. |
-// 1 bit: constraint_set2_flag : ignored here. |
-// 1 bit: constraint_set3_flag : ignored here. |
-// 4 bits: reserved : required to be 0 here. |
-// |
-// The spec indicates other ways, not implemented here, that a |profile_str| |
-// can indicate a baseline conforming decoder is sufficient for decode in Annex |
-// A.2.1: "[profile_idc not necessarily 0x42] with constraint_set0_flag set and |
-// in which level_idc and constraint_set3_flag represent a level less than or |
-// equal to the specified level." |
-static bool IsValidH264BaselineProfile(const std::string& profile_str) { |
- uint32 constraint_set_bits; |
- if (profile_str.size() != 4 || |
- profile_str[0] != '4' || |
- profile_str[1] != '2' || |
- profile_str[3] != '0' || |
- !base::HexStringToUInt(base::StringPiece(profile_str.c_str() + 2, 1), |
- &constraint_set_bits)) { |
- return false; |
- } |
- |
- return constraint_set_bits >= 8; |
-} |
- |
-static bool IsValidH264Level(const std::string& level_str) { |
- uint32 level; |
- if (level_str.size() != 2 || !base::HexStringToUInt(level_str, &level)) |
- return false; |
- |
- // Valid levels taken from Table A-1 in ISO-14496-10. |
- // Essentially |level_str| is toHex(10 * level). |
- return ((level >= 10 && level <= 13) || |
- (level >= 20 && level <= 22) || |
- (level >= 30 && level <= 32) || |
- (level >= 40 && level <= 42) || |
- (level >= 50 && level <= 51)); |
-} |
- |
-// Handle parsing H.264 codec IDs as outlined in RFC 6381 and ISO-14496-10. |
-// avc1.42y0xx, y >= 8 - H.264 Baseline |
-// avc1.4D40xx - H.264 Main |
-// avc1.6400xx - H.264 High |
-// |
-// avc1.xxxxxx & avc3.xxxxxx are considered ambiguous forms that are trying to |
-// signal H.264 Baseline. For example, the idc_level, profile_idc and |
-// constraint_set3_flag pieces may explicitly require decoder to conform to |
-// baseline profile at the specified level (see Annex A and constraint_set0 in |
-// ISO-14496-10). |
-static bool ParseH264CodecID(const std::string& codec_id, |
- MimeUtil::Codec* codec, |
- bool* is_ambiguous) { |
- // Make sure we have avc1.xxxxxx or avc3.xxxxxx |
- if (codec_id.size() != 11 || |
- (!StartsWithASCII(codec_id, "avc1.", true) && |
- !StartsWithASCII(codec_id, "avc3.", true))) { |
- return false; |
- } |
- |
- std::string profile = StringToUpperASCII(codec_id.substr(5, 4)); |
- if (IsValidH264BaselineProfile(profile)) { |
- *codec = MimeUtil::H264_BASELINE; |
- } else if (profile == "4D40") { |
- *codec = MimeUtil::H264_MAIN; |
- } else if (profile == "6400") { |
- *codec = MimeUtil::H264_HIGH; |
- } else { |
- *codec = MimeUtil::H264_BASELINE; |
- *is_ambiguous = true; |
- return true; |
- } |
- |
- *is_ambiguous = !IsValidH264Level(StringToUpperASCII(codec_id.substr(9))); |
- return true; |
-} |
- |
-bool MimeUtil::StringToCodec(const std::string& codec_id, |
- Codec* codec, |
- bool* is_ambiguous) const { |
- StringToCodecMappings::const_iterator itr = |
- string_to_codec_map_.find(codec_id); |
- if (itr != string_to_codec_map_.end()) { |
- *codec = itr->second.codec; |
- *is_ambiguous = itr->second.is_ambiguous; |
- return true; |
- } |
- |
- // If |codec_id| is not in |string_to_codec_map_|, then we assume that it is |
- // an H.264 codec ID because currently those are the only ones that can't be |
- // stored in the |string_to_codec_map_| and require parsing. |
- return ParseH264CodecID(codec_id, codec, is_ambiguous); |
-} |
- |
-bool MimeUtil::IsCodecSupported(Codec codec) const { |
- DCHECK_NE(codec, INVALID_CODEC); |
- |
-#if defined(OS_ANDROID) |
- if (!IsCodecSupportedOnAndroid(codec)) |
- return false; |
-#endif |
- |
- return allow_proprietary_codecs_ || !IsCodecProprietary(codec); |
-} |
- |
-bool MimeUtil::IsCodecProprietary(Codec codec) const { |
- switch (codec) { |
- case INVALID_CODEC: |
- case MP3: |
- case MPEG2_AAC_LC: |
- case MPEG2_AAC_MAIN: |
- case MPEG2_AAC_SSR: |
- case MPEG4_AAC_LC: |
- case MPEG4_AAC_SBR_v1: |
- case MPEG4_AAC_SBR_PS_v2: |
- case H264_BASELINE: |
- case H264_MAIN: |
- case H264_HIGH: |
- return true; |
- |
- case PCM: |
- case VORBIS: |
- case OPUS: |
- case VP8: |
- case VP9: |
- case THEORA: |
- return false; |
- } |
- |
- return true; |
-} |
- |
-bool MimeUtil::GetDefaultCodecLowerCase(const std::string& mime_type_lower_case, |
- Codec* default_codec) const { |
- if (mime_type_lower_case == "audio/mpeg" || |
- mime_type_lower_case == "audio/mp3" || |
- mime_type_lower_case == "audio/x-mp3") { |
- *default_codec = MimeUtil::MP3; |
- return true; |
- } |
- |
- return false; |
-} |
- |
-bool MimeUtil::IsDefaultCodecSupportedLowerCase( |
- const std::string& mime_type_lower_case) const { |
- Codec default_codec = Codec::INVALID_CODEC; |
- if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec)) |
- return false; |
- return IsCodecSupported(default_codec); |
-} |
- |
//---------------------------------------------------------------------------- |
// Wrappers for the singleton |
//---------------------------------------------------------------------------- |
@@ -1147,10 +526,6 @@ bool IsSupportedImageMimeType(const std::string& mime_type) { |
return g_mime_util.Get().IsSupportedImageMimeType(mime_type); |
} |
-bool IsSupportedMediaMimeType(const std::string& mime_type) { |
- return g_mime_util.Get().IsSupportedMediaMimeType(mime_type); |
-} |
- |
bool IsSupportedNonImageMimeType(const std::string& mime_type) { |
return g_mime_util.Get().IsSupportedNonImageMimeType(mime_type); |
} |
@@ -1183,26 +558,6 @@ bool IsValidTopLevelMimeType(const std::string& type_string) { |
return g_mime_util.Get().IsValidTopLevelMimeType(type_string); |
} |
-bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) { |
- return g_mime_util.Get().AreSupportedMediaCodecs(codecs); |
-} |
- |
-bool IsStrictMediaMimeType(const std::string& mime_type) { |
- return g_mime_util.Get().IsStrictMediaMimeType(mime_type); |
-} |
- |
-SupportsType IsSupportedStrictMediaMimeType( |
- const std::string& mime_type, |
- const std::vector<std::string>& codecs) { |
- return g_mime_util.Get().IsSupportedStrictMediaMimeType(mime_type, codecs); |
-} |
- |
-void ParseCodecString(const std::string& codecs, |
- std::vector<std::string>* codecs_out, |
- const bool strip) { |
- g_mime_util.Get().ParseCodecString(codecs, codecs_out, strip); |
-} |
- |
namespace { |
// From http://www.w3schools.com/media/media_mimeref.asp and |
@@ -1385,10 +740,6 @@ void GetExtensionsForMimeType( |
HashSetToVector(&unique_extensions, extensions); |
} |
-void RemoveProprietaryMediaTypesAndCodecsForTests() { |
- g_mime_util.Get().RemoveProprietaryMediaTypesAndCodecsForTests(); |
-} |
- |
CertificateMimeType GetCertificateMimeTypeForMimeType( |
const std::string& mime_type) { |
// Don't create a map, there is only one entry in the table, |