Make video codec support logic overridable via MediaClient

media/base/mime_util_internal.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 "media/base/mime_util_internal.h"
 
 #include "base/command_line.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/media_client.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_codecs.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #include "media/base/android/media_codec_util.h"
 #endif
 
 namespace media {
 namespace internal {
@@ skipping 232 matching lines @@
   platform_info_.has_platform_vp9_decoder =
       MediaCodecUtil::IsVp9DecoderAvailable();
   platform_info_.supports_opus = PlatformHasOpusSupport();
 #endif
 
   InitializeMimeTypeMaps();
 }
 
 MimeUtil::~MimeUtil() {}
 
+VideoCodec MimeUtilToVideoCodec(MimeUtil::Codec codec) {
+  switch (codec) {
+    case MimeUtil::H264:
+      return kCodecH264;
+    case MimeUtil::HEVC:
+      return kCodecHEVC;
+    case MimeUtil::VP8:
+      return kCodecVP8;
+    case MimeUtil::VP9:
+      return kCodecVP9;
+    case MimeUtil::THEORA:
+      return kCodecTheora;
+    default:
+      break;
+  }
+  return kUnknownVideoCodec;
+}
+
 SupportsType MimeUtil::AreSupportedCodecs(
     const CodecSet& supported_codecs,
     const std::vector<std::string>& codecs,
     const std::string& mime_type_lower_case,
     bool is_encrypted) const {
   DCHECK(!supported_codecs.empty());
   DCHECK(!codecs.empty());
 
   SupportsType result = IsSupported;
   for (size_t i = 0; i < codecs.size(); ++i) {
     bool is_ambiguous = true;
     Codec codec = INVALID_CODEC;
+    VideoCodecProfile video_profile = VIDEO_CODEC_PROFILE_UNKNOWN;
+    uint8_t video_level = 0;
     if (!StringToCodec(mime_type_lower_case, codecs[i], &codec, &is_ambiguous,
-                       is_encrypted)) {
+                       &video_profile, &video_level, is_encrypted)) {
       return IsNotSupported;
     }
 
+    VideoCodec video_codec = MimeUtilToVideoCodec(codec);
+
+    if (GetMediaClient() && video_codec != kUnknownVideoCodec &&
+        !GetMediaClient()->IsSupportedVideoConfig(video_codec, video_profile,
+                                                  video_level)) {
+      return IsNotSupported;
+    }
+
     if (!IsCodecSupported(codec, mime_type_lower_case, is_encrypted) ||
         supported_codecs.find(codec) == supported_codecs.end()) {
       return IsNotSupported;
     }
 
     if (is_ambiguous)
       result = MayBeSupported;
   }
 
   return result;
@@ skipping 340 matching lines @@
     }
   }
 
   return false;
 }
 
 bool MimeUtil::StringToCodec(const std::string& mime_type_lower_case,
                              const std::string& codec_id,
                              Codec* codec,
                              bool* is_ambiguous,
+                             VideoCodecProfile* out_profile,
+                             uint8_t* out_level,
                              bool is_encrypted) const {
+  DCHECK(out_profile);
+  DCHECK(out_level);
+  *out_profile = VIDEO_CODEC_PROFILE_UNKNOWN;
+  *out_level = 0;
+
   StringToCodecMappings::const_iterator itr =
       string_to_codec_map_.find(codec_id);
   if (itr != string_to_codec_map_.end()) {
     *codec = itr->second.codec;
     *is_ambiguous = itr->second.is_ambiguous;
     return true;
   }
 
 // If |codec_id| is not in |string_to_codec_map_|, then we assume that it is
 // 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.
-  VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
-  uint8_t level_idc = 0;
-
-  if (ParseAVCCodecId(codec_id, &profile, &level_idc)) {
+  if (ParseAVCCodecId(codec_id, out_profile, out_level)) {
     *codec = MimeUtil::H264;
-    switch (profile) {
+    switch (*out_profile) {
 // HIGH10PROFILE is supported through fallback to the ffmpeg decoder
 // which is not available on Android, or if FFMPEG is not used.
 #if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID)
       case H264PROFILE_HIGH10PROFILE:
         if (is_encrypted) {
           // FFmpeg is not generally used for encrypted videos, so we do not
           // know whether 10-bit is supported.
           *is_ambiguous = true;
           break;
         }
 // Fall through.
 #endif
 
       case H264PROFILE_BASELINE:
       case H264PROFILE_MAIN:
       case H264PROFILE_HIGH:
-        *is_ambiguous = !IsValidH264Level(level_idc);
+        *is_ambiguous = !IsValidH264Level(*out_level);
         break;
       default:
         *is_ambiguous = true;
     }
     return true;
   }
 
-  if (ParseVp9CodecID(mime_type_lower_case, codec_id, &profile)) {
+  if (ParseVp9CodecID(mime_type_lower_case, codec_id, out_profile)) {
     *codec = MimeUtil::VP9;
-    switch (profile) {
+    *out_level = 1;
+    switch (*out_profile) {
       case VP9PROFILE_PROFILE0:
         // Profile 0 should always be supported if VP9 is supported.
         *is_ambiguous = false;
         break;
       default:
         // We don't know if the underlying platform supports these profiles.
         // Need to add platform level querying to get supported profiles
         // (crbug/604566).
         *is_ambiguous = true;
     }
     return true;
   }
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
-  if (ParseHEVCCodecId(codec_id, &profile, &level_idc)) {
-    // TODO(servolk): Set |is_ambiguous| to true for now to make CanPlayType
-    // return 'maybe' for HEVC codec ids, instead of probably. This needs to be
-    // changed to false after adding platform-level HEVC profile and level
-    // checks, see crbug.com/601949.
-    *is_ambiguous = true;
+  if (ParseHEVCCodecId(codec_id, out_profile, out_level)) {
     *codec = MimeUtil::HEVC;
+    *is_ambiguous = false;
     return true;
   }
 #endif
 
   DVLOG(4) << __FUNCTION__ << ": Unrecognized codec id " << codec_id;
   return false;
 }
 
 bool MimeUtil::IsCodecSupported(Codec codec,
                                 const std::string& mime_type_lower_case,
@@ skipping 55 matching lines @@
     const std::string& mime_type_lower_case,
     bool is_encrypted) const {
   Codec default_codec = Codec::INVALID_CODEC;
   if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec))
     return false;
   return IsCodecSupported(default_codec, mime_type_lower_case, is_encrypted);
 }
 
 }  // namespace internal
 }  // namespace media