Fix: Changing canPlayType behaviour for MP4 containers

net/base/mime_util.cc

 // Copyright (c) 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 <algorithm>
 #include <iterator>
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
@@ skipping 75 matching lines @@
   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 std::map<std::string, MimeMappings> StrictMappings;
 
   typedef std::vector<std::string> MimeExpressionMappings;
   typedef std::map<std::string, MimeExpressionMappings>
       StrictExpressionMappings;
 
   MimeUtil();
 
   // Returns true if |codecs| is nonempty and all the items in it are present in
   // |supported_codecs|.
-  static bool AreSupportedCodecs(const MimeMappings& supported_codecs,
+  static bool AreSupportedCodecs(const MimeExpressionMappings& supported_codecs,
                                  const std::vector<std::string>& codecs);
-  // Returns true is |codecs| is nonempty and all the items in it match with the
-  // codecs expression in |supported_codecs|.
-  static bool AreSupportedCodecsWithProfile(
-      const MimeExpressionMappings& supported_codecs,
-      const std::vector<std::string>& codecs);
 
   // For faster lookup, keep hash sets.
   void InitializeMimeTypeMaps();
 
   bool GetMimeTypeFromExtensionHelper(const base::FilePath::StringType& ext,
                                       bool include_platform_types,
                                       std::string* mime_type) const;
 
   MimeMappings image_map_;
   MimeMappings media_map_;
   MimeMappings non_image_map_;
   MimeMappings unsupported_text_map_;
   MimeMappings javascript_map_;
-  MimeMappings codecs_map_;
+  MimeExpressionMappings codecs_map_;
 
   // A map of mime_types and hash map of the supported codecs for the mime_type.
-  StrictMappings strict_format_map_;
-  // A map of MP4 mime_types which expect codecs with profile parameter and
-  // vector of supported codecs expressions for the mime_type.
-  StrictExpressionMappings strict_mp4_format_map_;
+  StrictExpressionMappings strict_format_map_;
+  // A map of mime_types, which expect codecs which are RFC compliant but do not
+  // have sufficient informatation whether they are supported or not, and vector
+  // of supported codecs expressions for the mime_type.
+  StrictExpressionMappings inconclusive_format_map_;
 };  // class MimeUtil
 
 // This variable is Leaky because we need to access it from WorkerPool threads.
 static base::LazyInstance<MimeUtil>::Leaky g_mime_util =
     LAZY_INSTANCE_INITIALIZER;
 
 struct MimeInfo {
   const char* mime_type;
   const char* extensions;  // comma separated list
 };
@@ skipping 140 matching lines @@
   "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",

[Ryan Sleevi, 2014/07/09 23:56:13]

This is no longer consistent with the comment on line 283, as evidenced by line
455.

-#endif
 
   // WebM.
   "video/webm",
   "audio/webm",
 
   // Wav.
   "audio/wav",
   "audio/x-wav",
 
 #if defined(OS_ANDROID)
@@ skipping 11 matching lines @@
   "audio/mp4",
   "audio/x-m4a",
 
   // MP3.
   "audio/mp3",
   "audio/x-mp3",
   "audio/mpeg",
 };
 
 // List of supported codecs when passed in with <source type="...">.
 // This set of codecs is supported by all variations of Chromium.

[Ryan Sleevi, 2014/07/09 23:56:13]

This comment is no longer true for line 328.

 //
 // Refer to http://wiki.whatwg.org/wiki/Video_type_parameters#Browser_Support
 // for more information.
 //
 // The codecs for WAV are integers as defined in Appendix A of RFC2361:
 // http://tools.ietf.org/html/rfc2361
 static const char* const common_media_codecs[] = {
-#if !defined(OS_ANDROID)  // Android doesn't support Ogg Theora.
   "theora",
-#endif
   "opus",
   "vorbis",
   "vp8",
   "vp9",
   "1"  // WAVE_FORMAT_PCM.
 };
 
 // List of proprietary codecs only supported by Google Chrome.
 static const char* const proprietary_media_codecs[] = {
   "avc1",
@@ skipping 88 matching lines @@
     return false;
 
   // VP9 is supported only in KitKat+ (API Level 19).
   if ((!codec.compare("vp9") || !codec.compare("vp9.0")) &&
       base::android::BuildInfo::GetInstance()->sdk_int() < 19) {
     return false;
   }
 
   // TODO(vigneshv): Change this similar to the VP9 check once Opus is
   // supported on Android (http://crbug.com/318436).
-  if (!codec.compare("opus")) {
+  if (!codec.compare("opus"))
+    return false;
+
+  // MPEG-2 AAC is not supported on Android
+  if (!codec.compare("mp4a.67"))
+    return false;
+
+  // H.264 Main and High profiles are not supported on Android
+  if (!codec.compare("avc1.4d40??") || !codec.compare("avc3.4d40??") ||
+      !codec.compare("avc1.4D40??") || !codec.compare("avc3.4D40??") ||
+      !codec.compare("avc1.6400??") || !codec.compare("avc3.6400??")) {
     return false;
   }
+
   return true;
 }
 
 static bool IsMimeTypeSupportedOnAndroid(const std::string& mimeType) {
+  // Ogg Theora is not supported on Android
+  if (!mimeType.compare("video/ogg"))
+    return false;
+
   // 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* mime_type;
   const char* codecs_list;
 };
 
-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" },
-  { "video/ogg", "opus,theora,vorbis" },
-  { "audio/ogg", "opus,vorbis" },
-  { "application/ogg", "opus,theora,vorbis" },
-  { "audio/mpeg", "" },
-  { "audio/mp3", "" },
-  { "audio/x-mp3", "" }
-};
-
 // Following is the list of RFC 6381 compliant codecs:
 //   mp4a.6B     - MPEG-1 audio
 //   mp4a.69     - MPEG-2 extension to MPEG-1
 //   mp4a.67     - MPEG-2 AAC
 //   mp4a.40.2   - MPEG-4 AAC
-//   mp4a.40.5   - MPEG-4 HE-AAC
+//   mp4a.40.5   - MPEG-4 HE-AACv1
 //
 //   avc1.42E0xx - H.264 Baseline
 //   avc1.4D40xx - H.264 Main
 //   avc1.6400xx - H.264 High
+static const char kProprietaryAudioCodecsExpression[] =
+    "mp4a.6B,mp4a.69,mp4a.67,mp4a.40.2,mp4a.40.5";
+static const char kProprietaryCodecsExpression[] =
+    "avc1.42E0??,avc1.42e0??,avc1.4D40??,avc1.4d40??,avc1.6400??,"
+    "avc3.42E0??,avc3.42e0??,avc3.4D40??,avc3.4d40??,avc3.6400??,"
+    "mp4a.6B,mp4a.69,mp4a.67,mp4a.40.2,mp4a.40.5";
+
+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"},
+    {"video/ogg", "opus,theora,vorbis"},
+    {"audio/ogg", "opus,vorbis"},
+    {"application/ogg", "opus,theora,vorbis"},
+    {"audio/mpeg", ""},
+    {"audio/mp3", ""},
+    {"audio/x-mp3", ""},
+    {"audio/mp4", kProprietaryAudioCodecsExpression},
+    {"audio/x-m4a", kProprietaryAudioCodecsExpression},
+    {"video/mp4", kProprietaryCodecsExpression},
+    {"video/x-m4v", kProprietaryCodecsExpression},
+    {"application/x-mpegurl", kProprietaryCodecsExpression},
+    {"application/vnd.apple.mpegurl", kProprietaryCodecsExpression}
+};
+
+// Following is the list of codecs that are RFC 6381 compliant but browser
+// cannot be sure whether the platform supports them or not

[Ryan Sleevi, 2014/07/09 23:56:13]

grammar rewrite:

// The following is the list of codecs that are RFC 6381 compliant, but
// which support for varies by platform and cannot be determined
// beforehand.

(Context: "browser" concepts should not exist in //net)

+//   mp4a.40
+//   avc1
+//   avc3
 //
 // Additionally, several non-RFC compliant codecs are allowed, due to their
 // existing use on web.
-//   mp4a.40
 //   avc1.xxxxxx
 //   avc3.xxxxxx
-//   mp4a.6x
-static const char kProprietaryAudioCodecsExpression[] =
-    "mp4a.6?,mp4a.40,mp4a.40.?";
-static const char kProprietaryCodecsExpression[] =
-    "avc1,avc3,avc1.??????,avc3.??????,mp4a.6?,mp4a.40,mp4a.40.?";
+static const char kInconclusiveProprietaryAudioCodecsExpression[] =
+    "mp4a.40,mp4a.66,mp4a.68";
+static const char kInconclusiveProprietaryCodecsExpression[] =
+    "avc1,avc1.??????,avc3,avc3.??????,mp4a.40,mp4a.66,mp4a.68";
 
-static const MediaFormatStrict format_mp4_codec_mappings[] = {
-  { "audio/mp4", kProprietaryAudioCodecsExpression },
-  { "audio/x-m4a", kProprietaryAudioCodecsExpression },
-  { "video/mp4", kProprietaryCodecsExpression },
-  { "video/x-m4v", kProprietaryCodecsExpression },
-  { "application/x-mpegurl", kProprietaryCodecsExpression },
-  { "application/vnd.apple.mpegurl", kProprietaryCodecsExpression }
+static const MediaFormatStrict format_inconclusive_codec_mappings[] = {
+    {"audio/mp4", kInconclusiveProprietaryAudioCodecsExpression},
+    {"audio/x-m4a", kInconclusiveProprietaryAudioCodecsExpression},
+    {"video/mp4", kInconclusiveProprietaryCodecsExpression},
+    {"video/x-m4v", kInconclusiveProprietaryCodecsExpression},
+    {"application/x-mpegurl", kInconclusiveProprietaryCodecsExpression},
+    {"application/vnd.apple.mpegurl", kInconclusiveProprietaryCodecsExpression}
 };
 
 MimeUtil::MimeUtil() {
   InitializeMimeTypeMaps();
 }
 
 // static
-bool MimeUtil::AreSupportedCodecs(const MimeMappings& supported_codecs,
-                                  const std::vector<std::string>& codecs) {
+// Checks all the codecs present in the |codecs| against the entries in
+// |supported_codecs|. Returns true only if |codecs| is non-empty and all the
+// codecs match |supported_codecs| expressions.
+bool MimeUtil::AreSupportedCodecs(
+    const MimeExpressionMappings& supported_codecs,
+    const std::vector<std::string>& codecs) {
   if (supported_codecs.empty())
     return codecs.empty();
 
   for (size_t i = 0; i < codecs.size(); ++i) {
-    if (supported_codecs.find(codecs[i]) == supported_codecs.end())
-      return false;
-  }
-  return !codecs.empty();
-}
-
-// Checks all the codecs present in the |codecs| against the entries in
-// |supported_codecs|. Returns true only if |codecs| is non-empty and all the
-// codecs match |supported_codecs| expressions.
-bool MimeUtil::AreSupportedCodecsWithProfile(
-    const MimeExpressionMappings& supported_codecs,
-    const std::vector<std::string>& codecs) {
-  DCHECK(!supported_codecs.empty());
-  for (size_t i = 0; i < codecs.size(); ++i) {
     bool codec_matched = false;
     for (size_t j = 0; j < supported_codecs.size(); ++j) {
       if (!MatchPattern(base::StringPiece(codecs[i]),
                         base::StringPiece(supported_codecs[j]))) {
         continue;
       }
       // If suffix exists, check whether it is hexadecimal.
       for (size_t wildcard_pos = supported_codecs[j].find('?');
            wildcard_pos != std::string::npos &&
            wildcard_pos < supported_codecs[j].length();
            wildcard_pos = supported_codecs[j].find('?', wildcard_pos + 1)) {
         // Don't enforce case sensitivity, even though it's called for, as it
         // would break some websites.
         if (wildcard_pos >= codecs[i].length() ||
             !IsHexDigit(codecs[i].at(wildcard_pos))) {
           return false;
         }
       }
       codec_matched = true;
       break;
     }
     if (!codec_matched)
       return false;
   }
+
   return !codecs.empty();
 }
 
 void MimeUtil::InitializeMimeTypeMaps() {
   for (size_t i = 0; i < arraysize(supported_image_types); ++i)
     image_map_.insert(supported_image_types[i]);
 
   // Initialize the supported non-image types.
   for (size_t i = 0; i < arraysize(supported_non_image_types); ++i)
     non_image_map_.insert(supported_non_image_types[i]);
@@ skipping 29 matching lines @@
 #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(common_media_codecs); ++i) {
 #if defined(OS_ANDROID)
     if (!IsCodecSupportedOnAndroid(common_media_codecs[i]))
       continue;
 #endif
-    codecs_map_.insert(common_media_codecs[i]);
+    codecs_map_.push_back(common_media_codecs[i]);
   }
 #if defined(USE_PROPRIETARY_CODECS)
   for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i)
-    codecs_map_.insert(proprietary_media_codecs[i]);
+    codecs_map_.push_back(proprietary_media_codecs[i]);
 #endif
 
   // 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);
 
-    MimeMappings codecs;
+    MimeExpressionMappings codecs;
     for (size_t j = 0; j < mime_type_codecs.size(); ++j) {
 #if defined(OS_ANDROID)
       if (!IsCodecSupportedOnAndroid(mime_type_codecs[j]))
         continue;
 #endif
-      codecs.insert(mime_type_codecs[j]);
+      codecs.push_back(mime_type_codecs[j]);
     }
     strict_format_map_[format_codec_mappings[i].mime_type] = codecs;
   }
-  for (size_t i = 0; i < arraysize(format_mp4_codec_mappings); ++i) {
+  for (size_t i = 0; i < arraysize(format_inconclusive_codec_mappings); ++i) {
     std::vector<std::string> mime_type_codecs;
     ParseCodecString(
-        format_mp4_codec_mappings[i].codecs_list, &mime_type_codecs, false);
+        format_inconclusive_codec_mappings[i].codecs_list, &mime_type_codecs,
+        false);
 
     MimeExpressionMappings codecs;
-    for (size_t j = 0; j < mime_type_codecs.size(); ++j)
+    for (size_t j = 0; j < mime_type_codecs.size(); ++j) {
+#if defined(OS_ANDROID)
+      if (!IsCodecSupportedOnAndroid(mime_type_codecs[j]))
+        continue;
+#endif
       codecs.push_back(mime_type_codecs[j]);
-    strict_mp4_format_map_[format_mp4_codec_mappings[i].mime_type] = codecs;
+    }
+    // Merge codecs from conclusive list into inconclusive list so that querries
+    // with one conclusive and one inconclusive codec do not get an empty
+    // string in reply.

[Ryan Sleevi, 2014/07/09 23:56:13]

This comment needs rewording, but unfortunately, it's confusing enough that I'm
not sure what to suggest here, as I'm not clear why you merge the two.

[amogh.bihani, 2014/07/10 04:02:49]

Here is the scenario... "type=video/mp4; codecs= avc1.64001F, mp4a.40"
in this case, avc1.64001F is in the conclusive list but mp4a.40 is in
inconclusive list, so if we do not merge the two list, we will give "" in reply
instead of "maybe".

Another aproach could have been that I rewrite all the entries of conclusive
list in inconclusive list... but then to make it robust we need to have a check
that - if in the future any new entry is added in conclusive list, then it has
to be added in both.

[Ryan Sleevi, 2014/07/10 20:58:44]

Both of the solutions you've describe involve significant copying.

What's not clear is why you can't break apart the codecs parameter, and test if
it's in either list, and make an appropriate decision from that?

This accomplishes the same thing (AFAICT), but without having to copy these
strings around and reparse them. Have I missed something?

+    StrictExpressionMappings::const_iterator it = strict_format_map_.find(
+        format_inconclusive_codec_mappings[i].mime_type);
+    if (it != strict_format_map_.end())
+      codecs.insert(codecs.end(), it->second.begin(), it->second.end());
+    inconclusive_format_map_[format_inconclusive_codec_mappings[i].mime_type] =
+        codecs;
   }
 }
 
 bool MimeUtil::IsSupportedImageMimeType(const std::string& mime_type) const {
   return image_map_.find(mime_type) != image_map_.end();
 }
 
 bool MimeUtil::IsSupportedMediaMimeType(const std::string& mime_type) const {
   return media_map_.find(mime_type) != media_map_.end();
 }
@@ skipping 161 matching lines @@
   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 {
-  if (strict_format_map_.find(mime_type) == strict_format_map_.end() &&
-      strict_mp4_format_map_.find(mime_type) == strict_mp4_format_map_.end())
+  if (strict_format_map_.find(mime_type) == strict_format_map_.end())
     return false;
   return true;
 }
 
 SupportsType MimeUtil::IsSupportedStrictMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs) const {
-  StrictMappings::const_iterator it_strict_map =
+  StrictExpressionMappings::const_iterator it_strict_map =
       strict_format_map_.find(mime_type);
   if ((it_strict_map != strict_format_map_.end()) &&
       AreSupportedCodecs(it_strict_map->second, codecs)) {
     return IsSupported;
   }
 
   StrictExpressionMappings::const_iterator it_expression_map =
-      strict_mp4_format_map_.find(mime_type);
-  if ((it_expression_map != strict_mp4_format_map_.end()) &&
-      AreSupportedCodecsWithProfile(it_expression_map->second, codecs)) {
+      inconclusive_format_map_.find(mime_type);
+  if ((it_expression_map != inconclusive_format_map_.end()) &&
+      AreSupportedCodecs(it_expression_map->second, codecs)) {
     return MayBeSupported;
   }
 
   if (codecs.empty())
     return MayBeSupported;
 
   return IsNotSupported;
 }
 
 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]);
   }
-  for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i)
-    codecs_map_.erase(proprietary_media_codecs[i]);
+  for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i) {
+    codecs_map_.erase(std::remove(codecs_map_.begin(),
+                                  codecs_map_.end(),
+                                  proprietary_media_codecs[i]),
+                      codecs_map_.end());
+  }
 }
 
 //----------------------------------------------------------------------------
 // Wrappers for the singleton
 //----------------------------------------------------------------------------
 
 bool GetMimeTypeFromExtension(const base::FilePath::StringType& ext,
                               std::string* mime_type) {
   return g_mime_util.Get().GetMimeTypeFromExtension(ext, mime_type);
 }
@@ skipping 305 matching lines @@
   post_data->append("\r\n" + value + "\r\n");
 }
 
 void AddMultipartFinalDelimiterForUpload(const std::string& mime_boundary,
                                          std::string* post_data) {
   DCHECK(post_data);
   post_data->append("--" + mime_boundary + "--\r\n");
 }
 
 }  // namespace net