Add VP9 to canPlayType on Android

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>
 
+#if defined(OS_ANDROID)
+#include "base/android/build_info.h"

[scherkus (not reviewing), 2013/11/09 00:20:05]

typically #if #includes are put after the first block of #includes (i.e,.
starting on line 23)

[vignesh, 2013/11/11 19:55:34]

Done.

+#endif
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/mime_util.h"
 #include "net/base/platform_mime_util.h"
 
@@ skipping 266 matching lines @@
   "video/x-m4v",
   "audio/mp4",
   "audio/x-m4a",
 
   // MP3.
   "audio/mp3",
   "audio/x-mp3",
   "audio/mpeg",
 };
 
+struct CommonMediaCodec {
+  const char* codec;
+#if defined(OS_ANDROID)
+  const int min_api_level;
+#endif
+};
+
 // List of supported codecs when passed in with <source type="...">.
 // This set of codecs is supported by all variations of Chromium.
+// For android this also lists the minimum API level from which the codec is
+// supported.
 //
 // 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",
-  "vp9",  // TODO(tomfinegan): Move vp9 back down with vp8 once VP9 is supported
-          // on Android. https://crbug.com/285016
+static const CommonMediaCodec common_media_codecs[] = {
+#if !defined(OS_ANDROID)
+  { "theora" },
+  { "vorbis" },
+  { "vp8" },
+  { "vp9" },
+  { "1" }  // WAVE_FORMAT_PCM.
+#else
+  { "vorbis", 0 },
+  { "vp8", 0 },
+  { "vp9", 19 },  // VP9 supported only in Kitkat+.

[scherkus (not reviewing), 2013/11/09 00:20:05]

it seems unfortunate to duplicate both lists and minimum API levels for codecs

what about something like the following:

struct AndroidCodecRequirements {
  const char* codec;
  const int minimum_api_level;
};

// If codec not present then there are no requirements.
static const AndroidCodecRequirements android_codec_requirements[] = {
  { "vp9", 19 }
};

then when filtering through the common_media_codecs and format_codec_mappings,
we check for the presence and passing of the requirements

[vignesh, 2013/11/11 16:07:10]

if duplication is your only concern, then how about getting rid of it this way?

I leave the struct as it is now in my CL. The initialization can be done like
this:

// if there are no requirements, min_api_level is left uninitialized (thereby
automatically initializing them to zero).
...
{ "vorbis" },
{ "vp8" },
{ "vp9" #if defined(OS_ANDROID) , 19 #endif }
...

[vignesh, 2013/11/11 19:55:34]

Hardcoding this as discussed on other comments.

+  { "1", 0 }  // WAVE_FORMAT_PCM.
 #endif
-  "vorbis",
-  "vp8",
-  "1"  // WAVE_FORMAT_PCM.
 };
 
 // List of proprietary codecs only supported by Google Chrome.
 static const char* const proprietary_media_codecs[] = {
   "avc1",
   "avc3",
   "mp4a"
 };
 
 // Note: does not include javascript types list (see supported_javascript_types)
@@ skipping 82 matching lines @@
   "text/javascript1.1",
   "text/javascript1.2",
   "text/javascript1.3",
   "text/jscript",
   "text/livescript"
 };
 
 struct MediaFormatStrict {
   const char* mime_type;
   const char* codecs_list;
+#if defined(OS_ANDROID)
+  const int* min_api_levels;
+#endif
 };
 
 static const MediaFormatStrict format_codec_mappings[] = {
-  // TODO(tomfinegan): Remove this if/else when VP9 is supported on Android.
-  // https://crbug.com/285016
 #if !defined(OS_ANDROID)
   { "video/webm", "vorbis,vp8,vp8.0,vp9,vp9.0" },
-#else
-  { "video/webm", "vorbis,vp8,vp8.0" },
-#endif
   { "audio/webm", "vorbis" },
   { "audio/wav", "1" }
+#else
+  { "video/webm", "vorbis,vp8,vp8.0,vp9,vp9.0", (int[]) { 0, 0, 0, 19, 19 } },
+  { "audio/webm", "vorbis", (int[]) { 0 } },
+  { "audio/wav", "1", (int[]) { 0 } }
+#endif
 };
 
 MimeUtil::MimeUtil() {
   InitializeMimeTypeMaps();
 }
 
 // static
 bool MimeUtil::AreSupportedCodecs(const MimeMappings& supported_codecs,
                                   const std::vector<std::string>& codecs) {
   for (size_t i = 0; i < codecs.size(); ++i) {
@@ skipping 27 matching lines @@
   for (size_t i = 0; i < arraysize(common_media_types); ++i)
     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(common_media_codecs); ++i)

[scherkus (not reviewing), 2013/11/09 00:31:00]

we'll also need { }s for this for loop and one below

[vignesh, 2013/11/11 19:55:34]

Done.

-    codecs_map_.insert(common_media_codecs[i]);
+#if defined(OS_ANDROID)
+    if (base::android::BuildInfo::GetInstance()->sdk_int() >=
+        common_media_codecs[i].min_api_level)
+#endif
+    codecs_map_.insert(common_media_codecs[i].codec);
 #if defined(USE_PROPRIETARY_CODECS)
   for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i)
     codecs_map_.insert(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;
     for (size_t j = 0; j < mime_type_codecs.size(); ++j)
+#if defined(OS_ANDROID)
+      if (base::android::BuildInfo::GetInstance()->sdk_int() >=
+          format_codec_mappings[i].min_api_levels[j])
+#endif
       codecs.insert(mime_type_codecs[j]);
     strict_format_map_[format_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 {
@@ skipping 500 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