Fix: Adding list of supported codecs 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 63 matching lines @@
   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;
   bool IsSupportedStrictMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs) const;
+  bool IsSupportedStrictMP4MediaMimeType(
+      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;

[Ryan Sleevi, 2014/04/28 22:02:55]

style: Formatting is wrong here. Use git-cl format

+
   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,
                                  const std::vector<std::string>& codecs);
+  static bool AreSupportedCodecsWithProfile(
+                                const MimeExpressionMappings& supported_codecs,
+                                const std::vector<std::string>& codecs);

[Ryan Sleevi, 2014/04/28 22:02:55]

Style: Formatting is wrong here

 
   // 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_;
 
   StrictMappings strict_format_map_;
+  StrictExpressionMappings strict_mp4_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 312 matching lines @@
   { "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", "" }
 };
 
+static const MediaFormatStrict format_mp4_codec_mappings[] = {
+  { "audio/mp4", "mp4a,mp4a.40,mp4a.40.?" },
+  { "audio/x-m4a", "mp4a,mp4a.40,mp4a.40.?" },
+  { "video/mp4", "avc1,avc3,avc1.??????,avc3.??????,mp4a,mp4a.40,mp4a.40.?" },
+  { "video/x-m4v", "avc1,avc3,avc1.??????,avc3.??????,mp4a,mp4a.40,mp4a.40.?" },
+  { "application/x-mpegurl",
+                   "avc1,avc3,avc1.??????,avc3.??????,mp4a,mp4a.40,mp4a.40.?" },
+  { "application/vnd.apple.mpegurl",
+                   "avc1,avc3,avc1.??????,avc3.??????,mp4a,mp4a.40,mp4a.40.?" }

[Ryan Sleevi, 2014/04/28 22:02:55]

Why ? instead of *?

[amogh.bihani, 2014/04/29 03:56:09]

Because '*' wildcard can take any number of characters[1] and we specifically
want 6 digit upper case hexadecimals.
If we use something like avc1.*?, then it will return true even for
"avc1.123456789" or "avc1.12", which would be wrong.

----------
[1]
https://code.google.com/p/chromium/codesearch#chromium/src/base/strings/strin...

+};
+
 MimeUtil::MimeUtil() {
   InitializeMimeTypeMaps();
 }
 
 // static
 bool MimeUtil::AreSupportedCodecs(const MimeMappings& 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();
 }
 
+bool MimeUtil::AreSupportedCodecsWithProfile(
+                              const MimeExpressionMappings& supported_codecs,
+                              const std::vector<std::string>& codecs) {
+  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(static_cast <base::StringPiece> (codecs[i]),
+                       static_cast <base::StringPiece> (supported_codecs[j]))) {
+        codec_matched = true;
+        std::vector<std::string> split_string;
+        base::SplitString(codecs[i], '.', &split_string);
+        if (split_string.size() > 1 &&
+            !IsHigherCaseHexNumber(split_string.back())) {
+          codec_matched = false;
+        }
+        break;
+      }
+    }
+    // Return false if any of the codecs is not matching.
+    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]);
   for (size_t i = 0; i < arraysize(supported_certificate_types); ++i)
     non_image_map_.insert(supported_certificate_types[i].mime_type);
   for (size_t i = 0; i < arraysize(unsupported_text_types); ++i)
@@ skipping 40 matching lines @@
     MimeMappings 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]);
     }
     strict_format_map_[format_codec_mappings[i].mime_type] = codecs;
   }
+  for (size_t i = 0; i < arraysize(format_mp4_codec_mappings); ++i) {
+    std::vector<std::string> mime_type_codecs;
+    ParseCodecString(format_mp4_codec_mappings[i].codecs_list,
+                     &mime_type_codecs,
+                     false);
+
+    MimeExpressionMappings codecs;
+    for (size_t j = 0; j < mime_type_codecs.size(); ++j) {
+      codecs.push_back(mime_type_codecs[j]);
+    }
+    strict_mp4_format_map_[format_mp4_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 162 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())
+  if (strict_format_map_.find(mime_type) == strict_format_map_.end() &&
+      strict_mp4_format_map_.find(mime_type) == strict_mp4_format_map_.end())
     return false;
   return true;
 }
 
 bool MimeUtil::IsSupportedStrictMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs) const {
   StrictMappings::const_iterator it = strict_format_map_.find(mime_type);
   return (it != strict_format_map_.end()) &&
       AreSupportedCodecs(it->second, codecs);
 }
 
+bool MimeUtil::IsSupportedStrictMP4MediaMimeType(
+    const std::string& mime_type,
+    const std::vector<std::string>& codecs) const {
+  StrictExpressionMappings::const_iterator it =
+                                        strict_mp4_format_map_.find(mime_type);
+  return (it != strict_mp4_format_map_.end() &&
+      AreSupportedCodecsWithProfile(it->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]);
   }
   for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i)
     codecs_map_.erase(proprietary_media_codecs[i]);
 }
 
 //----------------------------------------------------------------------------
@@ skipping 60 matching lines @@
 
 bool IsStrictMediaMimeType(const std::string& mime_type) {
   return g_mime_util.Get().IsStrictMediaMimeType(mime_type);
 }
 
 bool IsSupportedStrictMediaMimeType(const std::string& mime_type,
                                     const std::vector<std::string>& codecs) {
   return g_mime_util.Get().IsSupportedStrictMediaMimeType(mime_type, codecs);
 }
 
+bool IsSupportedStrictMP4MediaMimeType(const std::string& mime_type,
+                                      const std::vector<std::string>& codecs) {
+  return g_mime_util.Get().IsSupportedStrictMP4MediaMimeType(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
 // http://plugindoc.mozdev.org/winmime.php
@@ skipping 225 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