Various MimeUtil cleanups.

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/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 {
 
-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[] = {
+static const std::map<std::string, MimeUtil::Codec> kStringToCodecMap = {

[DaleCurtis, 2017/02/17 23:39:03]

Can't do this since it's a static initializer.

[chcunningham, 2017/02/20 22:25:05]

Fixed! thanks

     {"1", MimeUtil::PCM},  // We only allow this for WAV so it isn't ambiguous.
     // avc1/avc3.XXXXXX may be unambiguous; handled by ParseAVCCodecId().
     // hev1/hvc1.XXXXXX may be unambiguous; handled by ParseHEVCCodecID().
     // vp9, vp9.0, vp09.xx.xx.xx.xx.xx.xx.xx may be unambiguous; handled by
     // ParseVp9CodecID().
     {"mp3", MimeUtil::MP3},
     // Following is the list of RFC 6381 compliant audio codec strings:
     //   mp4a.66     - MPEG-2 AAC MAIN
     //   mp4a.67     - MPEG-2 AAC LC
     //   mp4a.68     - MPEG-2 AAC SSR
@@ skipping 29 matching lines @@
     {"mp4a.a6", MimeUtil::EAC3},
     {"mp4a.A6", MimeUtil::EAC3},
 #endif
     {"vorbis", MimeUtil::VORBIS},
     {"opus", MimeUtil::OPUS},
     {"flac", MimeUtil::FLAC},
     {"vp8", MimeUtil::VP8},
     {"vp8.0", MimeUtil::VP8},
     {"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},
-    {"avc1", MimeUtil::H264},
-    {"avc3", MimeUtil::H264},
-    // avc1/avc3.XXXXXX may be ambiguous; handled by ParseAVCCodecId().
-};
-
 static bool ParseVp9CodecID(const std::string& mime_type_lower_case,
                             const std::string& codec_id,
                             VideoCodecProfile* out_profile,
                             uint8_t* out_level) {
   if (mime_type_lower_case == "video/mp4") {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableVp9InMp4)) {
       return ParseNewStyleVp9CodecID(codec_id, out_profile, out_level);
     }
   } else if (mime_type_lower_case == "video/webm") {
@@ skipping 54 matching lines @@
 SupportsType MimeUtil::AreSupportedCodecs(
     const CodecSet& supported_codecs,
     const std::vector<std::string>& codecs,
     const std::string& mime_type_lower_case,
     bool is_encrypted) const {
   DCHECK(!supported_codecs.empty());
   DCHECK(!codecs.empty());
 
   SupportsType result = IsSupported;
   for (size_t i = 0; i < codecs.size(); ++i) {
-    bool is_ambiguous = true;
+    // Parse the string.
+    bool ambiguous_codec_string = true;
     Codec codec = INVALID_CODEC;
     VideoCodecProfile video_profile = VIDEO_CODEC_PROFILE_UNKNOWN;
     uint8_t video_level = 0;
-    if (!StringToCodec(mime_type_lower_case, codecs[i], &codec, &is_ambiguous,
-                       &video_profile, &video_level, is_encrypted)) {
+    if (!ParseCodecString(mime_type_lower_case, codecs[i], &codec,
+                          &ambiguous_codec_string, &video_profile,
+                          &video_level)) {
       return IsNotSupported;
     }
 
-    VideoCodec video_codec = MimeUtilToVideoCodec(codec);
+    // Bail if codec not in supported list for given container.
+    if (supported_codecs.find(codec) == supported_codecs.end())
+      return IsNotSupported;
 
-    if (GetMediaClient() && video_codec != kUnknownVideoCodec &&
-        !GetMediaClient()->IsSupportedVideoConfig(video_codec, video_profile,
-                                                  video_level)) {
-      return IsNotSupported;
+    // Make conservative guesses to resolve ambiguity before checking platform
+    // support. H264 is 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;
     }
 
-    if (!IsCodecSupported(codec, mime_type_lower_case, is_encrypted) ||
-        supported_codecs.find(codec) == supported_codecs.end()) {
+    // Check platform support.
+    result = IsCodecSupported(mime_type_lower_case, codec, video_profile,
+                              video_level, is_encrypted);
+    if (result == IsNotSupported)
       return IsNotSupported;
-    }
 
-    if (is_ambiguous)
+    // Downgrade to MayBeSupported if we had to guess the meaning of the codec
+    // string.
+    if (result == IsSupported && ambiguous_codec_string)
       result = MayBeSupported;
   }
 
   return result;
 }
 
 void MimeUtil::InitializeMimeTypeMaps() {
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
   allow_proprietary_codecs_ = true;
 #endif
 
-  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);
-  }
-
   AddSupportedMediaFormats();
 }
 
 // Each call to AddContainerWithCodecs() contains a media type
 // (https://en.wikipedia.org/wiki/Media_type) and corresponding media codec(s)
 // supported by these types/containers.
 // TODO(ddorwin): Replace insert() calls with initializer_list when allowed.
 void MimeUtil::AddSupportedMediaFormats() {
   CodecSet implicit_codec;
   CodecSet wav_codecs;
@@ skipping 108 matching lines @@
 
   if (is_proprietary_mime_type)
     proprietary_media_containers_.push_back(mime_type);
 }
 
 bool MimeUtil::IsSupportedMediaMimeType(const std::string& mime_type) const {
   return media_format_map_.find(base::ToLowerASCII(mime_type)) !=
          media_format_map_.end();
 }
 
-void MimeUtil::ParseCodecString(const std::string& codecs,
-                                std::vector<std::string>* codecs_out,
-                                bool strip) {
+void MimeUtil::SplitCodecsToVector(const std::string& codecs,
+                                   std::vector<std::string>* codecs_out,
+                                   bool strip) {
   *codecs_out =
       base::SplitString(base::TrimString(codecs, "\"", base::TRIM_ALL), ",",
                         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   // Convert empty or all-whitespace input to 0 results.
   if (codecs_out->size() == 1 && (*codecs_out)[0].empty())
     codecs_out->clear();
 
   if (!strip)
     return;
@@ skipping 12 matching lines @@
     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())
     return IsNotSupported;
 
   if (it_media_format_map->second.empty()) {
     // We get here if the mimetype does not expect a codecs parameter.
-    return (codecs.empty() && IsDefaultCodecSupportedLowerCase(
-                                  mime_type_lower_case, is_encrypted))
-               ? IsSupported
-               : IsNotSupported;
+    if (codecs.empty()) {
+      return IsDefaultCodecSupportedLowerCase(mime_type_lower_case,
+                                              is_encrypted);
+    } else {
+      return 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, mime_type_lower_case, is_encrypted)
-               ? IsSupported
-               : IsNotSupported;
+    return IsSimpleCodecSupported(mime_type_lower_case, default_codec,
+                                  is_encrypted);
   }
 
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
   if (mime_type_lower_case == "video/mp2t") {
     std::vector<std::string> codecs_to_check;
     for (const auto& codec_id : codecs) {
       codecs_to_check.push_back(TranslateLegacyAvc1CodecIds(codec_id));
     }
     return AreSupportedCodecs(it_media_format_map->second, codecs_to_check,
                               mime_type_lower_case, is_encrypted);
   }
 #endif
 
   return AreSupportedCodecs(it_media_format_map->second, codecs,
                             mime_type_lower_case, is_encrypted);
 }
 
 void MimeUtil::RemoveProprietaryMediaTypesAndCodecs() {
   for (const auto& container : proprietary_media_containers_)
     media_format_map_.erase(container);
   allow_proprietary_codecs_ = false;
 }
 
 // static
-bool MimeUtil::IsCodecSupportedOnPlatform(
+bool MimeUtil::IsCodecSupportedOnAndroid(
     Codec codec,
     const std::string& mime_type_lower_case,
     bool is_encrypted,
     const PlatformInfo& platform_info) {
   DCHECK_NE(mime_type_lower_case, "");
 
   // Encrypted block support is never available without platform decoders.
   if (is_encrypted && !platform_info.has_platform_decoders)
     return false;
 
@@ skipping 105 matching lines @@
         return true;
 
       // MediaPlayer only supports VP9 in WebM.
       return mime_type_lower_case == "video/webm";
     }
   }
 
   return false;
 }
 
-bool MimeUtil::StringToCodec(const std::string& mime_type_lower_case,
-                             const std::string& codec_id,
-                             Codec* codec,
-                             bool* is_ambiguous,
-                             VideoCodecProfile* out_profile,
-                             uint8_t* out_level,
-                             bool is_encrypted) const {
+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) const {
+  DCHECK(codec);
   DCHECK(out_profile);
   DCHECK(out_level);
+
+  *codec = INVALID_CODEC;
+  *ambiguous_codec_string = false;
   *out_profile = VIDEO_CODEC_PROFILE_UNKNOWN;
   *out_level = 0;
 
-  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;
+  std::map<std::string, Codec>::const_iterator itr =
+      kStringToCodecMap.find(codec_id);
+  if (itr != kStringToCodecMap.end()) {
+    *codec = itr->second;
     return true;
   }
 
-  // If |codec_id| is not in |string_to_codec_map_|, then we assume that it is
+  // 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 |string_to_codec_map_| and require
+  // only ones that are not added to the |kStringToCodecMap| and require
   // parsing.
   if (ParseVp9CodecID(mime_type_lower_case, codec_id, out_profile, out_level)) {
     *codec = MimeUtil::VP9;
-    switch (*out_profile) {
-      case VP9PROFILE_PROFILE0:
-        // Profile 0 should always be supported if VP9 is supported.
-        *is_ambiguous = false;
-        break;
-      default:
-        // We don't know if the underlying platform supports these profiles.
-        // Need to add platform level querying to get supported profiles
-        // (crbug/604566).
-        *is_ambiguous = true;
-        break;
-    }
     return true;
   }
 
   if (ParseAVCCodecId(codec_id, out_profile, out_level)) {
     *codec = MimeUtil::H264;
-    switch (*out_profile) {
-// HIGH10PROFILE is supported through fallback to the ffmpeg decoder
-// which is not available on Android, or if FFMPEG is not used.
-#if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID)
-      case H264PROFILE_HIGH10PROFILE:
-        if (is_encrypted) {
-          // FFmpeg is not generally used for encrypted videos, so we do not
-          // know whether 10-bit is supported.
-          *is_ambiguous = true;
-          break;
-        }
-// Fall through.
-#endif
-
-      case H264PROFILE_BASELINE:
-      case H264PROFILE_MAIN:
-      case H264PROFILE_HIGH:
-        *is_ambiguous = !IsValidH264Level(*out_level);
-        break;
-      default:
-        *is_ambiguous = true;
-    }
+    // Allowed string ambiguity since 2014. DO NOT ADD NEW CASES FOR AMBIGUITY.
+    *ambiguous_codec_string = !IsValidH264Level(*out_level);
     return true;
   }
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecId(codec_id, out_profile, out_level)) {
     *codec = MimeUtil::HEVC;
-    *is_ambiguous = false;
     return true;
   }
 #endif
 
-  DVLOG(4) << __func__ << ": Unrecognized codec id " << codec_id;
+  LOG(WARNING) << __func__ << ": Unrecognized codec id " << codec_id;
   return false;
 }
 
-bool MimeUtil::IsCodecSupported(Codec codec,
-                                const std::string& mime_type_lower_case,
-                                bool is_encrypted) const {
+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 */, 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,
+                                        bool is_encrypted) const {
   DCHECK_NE(codec, INVALID_CODEC);
 
+  VideoCodec video_codec = MimeUtilToVideoCodec(codec);
+  if (video_codec != kUnknownVideoCodec) {
+    DCHECK_NE(video_profile, VIDEO_CODEC_PROFILE_UNKNOWN);
+    DCHECK_GT(video_level, 0);
+  }
+
+  // Bail early for disabled proprietary codecs
+  if (!allow_proprietary_codecs_ && IsCodecProprietary(codec)) {
+    return IsNotSupported;
+  }
+
+  // Check for cases of ambiguous platform support.
+  // TODO(chcunningham): DELETE THIS. Platform should know its capabilities.
+  // Answer should come from MediaClient.
+  bool ambiguous_platform_support = false;
+  if (codec == MimeUtil::H264) {
+    switch (video_profile) {
+      // Always supported
+      case H264PROFILE_BASELINE:
+      case H264PROFILE_MAIN:
+      case H264PROFILE_HIGH:
+        break;
+// HIGH10PROFILE is supported through fallback to the ffmpeg decoder
+// which is not available on Android, or if FFMPEG is not used.
+#if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID)
+      case H264PROFILE_HIGH10PROFILE:
+        // FFmpeg is not generally used for encrypted videos, so we do not
+        // know whether 10-bit is supported.
+        ambiguous_platform_support = is_encrypted;
+        break;
+#endif
+      default:
+        ambiguous_platform_support = true;
+    }
+  } 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)) {
+    return IsNotSupported;
+  }
+
 #if defined(OS_ANDROID)
-  if (!IsCodecSupportedOnPlatform(codec, mime_type_lower_case, is_encrypted,
-                                  platform_info_)) {
-    return false;
+  // 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;
   }
 #endif
 
-  return allow_proprietary_codecs_ || !IsCodecProprietary(codec);
+  return ambiguous_platform_support ? MayBeSupported : IsSupported;
 }
 
 bool MimeUtil::IsCodecProprietary(Codec codec) const {
   switch (codec) {
     case INVALID_CODEC:
     case AC3:
     case EAC3:
     case MP3:
     case MPEG2_AAC:
     case MPEG4_AAC:
@@ skipping 29 matching lines @@
   }
 
   if (mime_type_lower_case == "audio/flac") {
     *default_codec = MimeUtil::FLAC;
     return true;
   }
 
   return false;
 }
 
-bool MimeUtil::IsDefaultCodecSupportedLowerCase(
+SupportsType MimeUtil::IsDefaultCodecSupportedLowerCase(
     const std::string& mime_type_lower_case,
     bool is_encrypted) const {
   Codec default_codec = Codec::INVALID_CODEC;
   if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec))
-    return false;
-  return IsCodecSupported(default_codec, mime_type_lower_case, is_encrypted);
+    return IsNotSupported;
+  return IsSimpleCodecSupported(mime_type_lower_case, default_codec,
+                                is_encrypted);
 }
 
 }  // namespace internal
 }  // namespace media