WIP: allow to play Youtube if use_proprieraty_codecs=1 and ffmpeg_branding=Chromium

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 66 matching lines @@
   // Returns true if this method was able to map |codec_id| to a specific
   // Codec enum value. |codec| and |is_ambiguous| are only valid if true
   // is returned. Otherwise their value is undefined after the call.
   // |is_ambiguous| is true if |codec_id| did not have enough information to
   // unambiguously determine the proper Codec enum value. If |is_ambiguous|
   // is true |codec| contains the best guess for the intended Codec enum value.
   bool StringToCodec(const std::string& codec_id,
                      Codec* codec,
                      bool* is_ambiguous) const;
 
+  media::AudioCodec MediaCodecToAudioCodec(Codec codec) const;
+  media::VideoCodec MediaCodecToVideoCodec(Codec codec) const;
+
   // Returns true if |codec| is supported by the platform.
   // Note: This method will return false if the platform supports proprietary
   // codecs but |allow_proprietary_codecs_| is set to false.
   bool IsCodecSupported(Codec codec) const;
 
   // Returns true if |codec| refers to a proprietary codec.
   bool IsCodecProprietary(Codec codec) const;
 
   // Returns true and sets |*default_codec| if |mime_type| has a  default codec
   // associated with it. Returns false otherwise and the value of
@@ skipping 372 matching lines @@
 
 SupportsType MimeUtil::IsSupportedMediaFormat(
     const std::string& mime_type,
     const std::vector<std::string>& codecs) 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;
 
+  // TODO: implement and use media::IsMediaContainerSupported
+  // similar to IsVideoCodecSupported
+
   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))
                ? IsSupported
                : IsNotSupported;
   }
 
   if (codecs.empty()) {
     // We get here if the mimetype expects to get a codecs parameter,
@@ skipping 143 matching lines @@
   // either 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 parsing.
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecID(codec_id, codec, is_ambiguous)) {
     return true;
   }
 #endif
   return ParseH264CodecID(codec_id, codec, is_ambiguous);
 }
 
+media::AudioCodec MimeUtil::MediaCodecToAudioCodec(Codec codec) const {
+  switch (codec) {
+    case PCM:
+      return kCodecPCM_S16BE;  // kCodecPCM_S24BE
+    case MP3:
+      return kCodecMP3;
+    case AC3:
+      return kCodecAC3;
+    case EAC3:
+      return kCodecEAC3;
+    case MPEG2_AAC_LC:
+    case MPEG2_AAC_MAIN:
+    case MPEG2_AAC_SSR:
+    case MPEG4_AAC_LC:
+    case MPEG4_AAC_SBR_v1:
+    case MPEG4_AAC_SBR_PS_v2:
+      return kCodecAAC;
+    case VORBIS:
+      return kCodecVorbis;
+    case OPUS:
+      return kCodecOpus;
+    /*
+        case ?
+          return kCodecFLAC;
+        case ?
+          return kCodecAMR_NB;
+        case ?
+          return kCodecAMR_WB;
+        case ?
+          return kCodecPCM_ALAW;
+          return kCodecPCM_MULAW;
+        case ?
+          return kCodecGSM_MS;
+        case ?
+          return kCodecALAC;;
+    */
+
+    default:
+      DVLOG(1) << "Unknown Codec: " << codec;
+  }
+  return kUnknownAudioCodec;
+}
+
+VideoCodec MimeUtil::MediaCodecToVideoCodec(Codec codec) const {
+  switch (codec) {
+    case H264_BASELINE:
+    case H264_MAIN:
+    case H264_HIGH:
+      return kCodecH264;
+    case HEVC_MAIN:
+      return kCodecHEVC;
+    case VP8:
+      return kCodecVP8;
+    case VP9:
+      return kCodecVP9;
+    case THEORA:
+      return kCodecTheora;
+    /*
+        case ?:
+          return kCodecVC1;
+        case ?:
+          return kCodecMPEG2;
+        case ?:
+          return kCodecMPEG4;
+    */
+    default:
+      DVLOG(1) << "Unknown Codec: " << codec;
+  }
+  return kUnknownVideoCodec;
+}
+
 bool MimeUtil::IsCodecSupported(Codec codec) const {
   DCHECK_NE(codec, INVALID_CODEC);
 
 #if defined(OS_ANDROID)
   if (!IsCodecSupportedOnAndroid(codec))
     return false;
 #endif
 
-  return allow_proprietary_codecs_ || !IsCodecProprietary(codec);
+  bool allow = allow_proprietary_codecs_ || !IsCodecProprietary(codec);
+
+  // Not allowed because of build configuration.
+  if (!allow)
+    return false;
+
+  // Check if the underlying media library actually supports the codec. Useful
+  // when the build configuration allows proprietary codecs but not the
+  // underlying media library.
+
+  AudioCodec audio_codec = MediaCodecToAudioCodec(codec);
+  if (audio_codec != kUnknownAudioCodec &&
+      media::IsAudioCodecSupported(audio_codec))
+    return true;
+
+  media::VideoCodec video_codec = MediaCodecToVideoCodec(codec);
+  if (video_codec != kUnknownVideoCodec &&
+      media::IsVideoCodecSupported(video_codec))
+    return true;
+
+  return false;
 }
 
 bool MimeUtil::IsCodecProprietary(Codec codec) const {
   switch (codec) {
     case INVALID_CODEC:
     case AC3:
     case EAC3:
     case MP3:
     case MPEG2_AAC_LC:
     case MPEG2_AAC_MAIN:
@@ skipping 57 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