Fix mime type mappings when the unified media pipeline is enabled.

media/base/mime_util.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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/macros.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/mime_util.h"
 #include "media/media_features.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 namespace media {
 
 // Singleton utility class for mime types.
@@ skipping 117 matching lines @@
 
     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::VORBIS:
     case MimeUtil::H264_BASELINE:
     case MimeUtil::H264_MAIN:
     case MimeUtil::H264_HIGH:
     case MimeUtil::VP8:

[ddorwin, 2016/02/12 18:45:12]

There is also the codec-specific blacklist
(https://code.google.com/p/chromium/issues/detail?id=582548). Currently, this
only affects VP8. Do we use and/or fallback to libvpx?

(If we only use libvpx, perhaps we should make that blacklist NOTREACHED().)

[DaleCurtis, 2016/02/13 02:01:43]

Fixed. For now I've just added an IsVp8Blacklisted() since that's the only codec
with a big warning that anyone who adds more codecs to the blacklist will need
to update mime util. I don't want to expose the general purpose method since it
uses its own strings.

       return true;
 
     case MimeUtil::AC3:
     case MimeUtil::EAC3:
       // TODO(servolk): Revisit this for AC3/EAC3 support on AndroidTV
       return false;
 
     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;
+      return IsUnifiedMediaPipelineEnabled();

[ddorwin, 2016/02/12 18:45:12]

As mentioned previously, we need to know that it can be used (is not
blacklisted) too.

[DaleCurtis, 2016/02/13 02:01:43]

We'll either be using MediaPlayer or the unified media pipeline w/ software
codecs here so the blacklist doesn't apply to this case; though |is_encrypted|
does.

 
     case MimeUtil::OPUS:
       // Opus is supported only in Lollipop+ (API Level 21).
-      return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
+      return base::android::BuildInfo::GetInstance()->sdk_int() >= 21 ||
+             IsUnifiedMediaPipelineEnabled();
 
     case MimeUtil::HEVC_MAIN:
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
       // HEVC/H.265 is supported in Lollipop+ (API Level 21), according to
       // http://developer.android.com/reference/android/media/MediaFormat.html
       return base::android::BuildInfo::GetInstance()->sdk_int() >= 21;
 #else
       return false;
 #endif
 
     case MimeUtil::VP9:
       // VP9 is supported only in KitKat+ (API Level 19).
-      return base::android::BuildInfo::GetInstance()->sdk_int() >= 19;
+      return base::android::BuildInfo::GetInstance()->sdk_int() >= 19 ||
+             IsUnifiedMediaPipelineEnabled();

[ddorwin, 2016/02/12 18:45:12]

This one may not be affected by the blacklist (based on comments about libvpx in
render_frame_impl.cc. Another reason to make sure all this logic is together and
consistent.

[DaleCurtis, 2016/02/13 02:01:43]

The blacklist doesn't matter here (currently), so I've just expanded this check
to include |is_encrypted|.

 
     case MimeUtil::THEORA:
       return false;
   }
 
   return false;
 }
+
+static bool IsMimeTypeAndCodecSupportedOnAndroid(const std::string& mime_type,
+                                                 MimeUtil::Codec codec) {
+  // Opus in ogg is not allowed on Android unless the unified media pipeline is
+  // available.
+  if (base::EndsWith(mime_type, "ogg", base::CompareCase::INSENSITIVE_ASCII) &&

[ddorwin, 2016/02/12 18:45:12]

Minor: Since this comes from our code, the check can be case case sensitive.

[DaleCurtis, 2016/02/13 02:01:43]

Done.

+      codec == MimeUtil::OPUS) {
+    return IsUnifiedMediaPipelineEnabled();

[ddorwin, 2016/02/12 18:45:12]

Ditto on the blacklist.

(As long as we support WMPA for such devices, we'll need to keep this function.)

[DaleCurtis, 2016/02/13 02:01:43]

Blacklist doesn't matter here since either the pipeline is enabled and we're
using software codecs or its not and we don't use MediaCodec. 

|is_encrypted| would matter, but we don't support encrypted ogg files, so I
think this is fine.

+  }
+
+  return true;

[ddorwin, 2016/02/12 18:45:12]

As mentioned below, we might want to call IsCodecSupportedOnAndroid() here.

[DaleCurtis, 2016/02/13 02:01:43]

Done.

+}
+
 #endif
 
 enum MediaFormatType { COMMON, PROPRIETARY };
 
 struct MediaFormat {
   const char* const mime_type;
   MediaFormatType format_type;
   const char* const codecs_list;
 };
 
@@ skipping 46 matching lines @@
 
 // A list of media types (https://en.wikipedia.org/wiki/Media_type) and
 // corresponding media codecs supported by these types/containers.
 // Media formats marked as PROPRIETARY are not supported by Chromium, only
 // Google Chrome browser supports them.
 static const MediaFormat kFormatCodecMappings[] = {
     {"video/webm", COMMON, "opus,vorbis,vp8,vp8.0,vp9,vp9.0"},
     {"audio/webm", COMMON, "opus,vorbis"},
     {"audio/wav", COMMON, "1"},
     {"audio/x-wav", COMMON, "1"},
-#if defined(OS_ANDROID)
-    // Android does not support Opus in Ogg container.
-    // Android does not support Theora and thus video/ogg.
-    {"audio/ogg", COMMON, "vorbis"},
-    {"application/ogg", COMMON, "vorbis"},
-#else
+#if !defined(OS_ANDROID)

[ddorwin, 2016/02/12 18:45:12]

Should we retain this comment?
// Android does not support Theora and thus video/ogg.

[DaleCurtis, 2016/02/13 02:01:43]

Done.

     {"video/ogg", COMMON, "opus,theora,vorbis"},
+#endif
     {"audio/ogg", COMMON, "opus,vorbis"},
+    // Note: Theora is not supported on Android and will be rejected during the
+    // call to IsCodecSupportedOnAndroid().
     {"application/ogg", COMMON, "opus,theora,vorbis"},
-#endif
 #if defined(USE_PROPRIETARY_CODECS)
     {"audio/mpeg", PROPRIETARY, "mp3"},
     {"audio/mp3", PROPRIETARY, ""},
     {"audio/x-mp3", PROPRIETARY, ""},
     {"audio/aac", PROPRIETARY, ""},  // AAC / ADTS
     {"audio/mp4", PROPRIETARY, kMP4AudioCodecsExpression},
     {"audio/x-m4a", PROPRIETARY, kMP4AudioCodecsExpression},
     {"video/mp4", PROPRIETARY, kMP4VideoCodecsExpression},
     {"video/x-m4v", PROPRIETARY, kMP4VideoCodecsExpression},
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
@@ skipping 163 matching lines @@
     std::vector<std::string> mime_type_codecs;
     ParseCodecString(kFormatCodecMappings[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);
+
+#if defined(OS_ANDROID)
+      // Android has container retrictions on codecs which may vary at runtime,
+      // filter out container and codec combinations which are disallowed.
+      if (!IsMimeTypeAndCodecSupportedOnAndroid(
+              kFormatCodecMappings[i].mime_type, codec)) {
+        continue;
+      }
+#endif
+
       codecs.insert(codec);
     }
 
     media_format_map_[kFormatCodecMappings[i].mime_type] = codecs;
   }
 }
 
 bool MimeUtil::IsSupportedMediaMimeType(const std::string& mime_type) const {
   return media_format_map_.find(base::ToLowerASCII(mime_type)) !=
          media_format_map_.end();
@@ skipping 192 matching lines @@
     return true;
   }
 #endif
   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))

[ddorwin, 2016/02/12 18:45:12]

We check unsupported codecs for each call but container-codec combinations when
we build the list. It seems we should be consistent.

[DaleCurtis, 2016/02/13 02:01:43]

Done.

     return false;
 #endif
 
   return allow_proprietary_codecs_ || !IsCodecProprietary(codec);
 }
 
 bool MimeUtil::IsCodecProprietary(Codec codec) const {
   switch (codec) {
     case INVALID_CODEC:
     case AC3:
@@ skipping 61 matching lines @@
                       std::vector<std::string>* codecs_out,
                       const bool strip) {
   g_media_mime_util.Get().ParseCodecString(codecs, codecs_out, strip);
 }
 
 void RemoveProprietaryMediaTypesAndCodecsForTests() {
   g_media_mime_util.Get().RemoveProprietaryMediaTypesAndCodecsForTests();
 }
 
 }  // namespace media