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 (video_codec == kCodecH264) {

[chcunningham, 2016/07/22 20:11:25]

Did you mean to move this stuff out too? I feel like its pretty at home in the
StringToCodec function. Its fine with me if that method decides whats ambiguous
but still emits the profile/level as out params for us to use with
IsSupportedVideoConfig. Maybe I'm missing some reason why this had to come out

[miu, 2016/07/22 20:58:16]

Agreed. For example, Chromecast currently doesn't support 10-bit profiles, so
we'll want to be sure to return IsNotSupported in that case.

[servolk, 2016/07/23 01:10:35]

Yes, Yuri, this is exactly why I've created this change - we want to be able to
express different media capabilities of the different generations of chromecast
devices, but still use the same cast_shell binary on all of them. FYI the next
generation of chromecast is actually going to support 10-bit profiles.

[servolk, 2016/07/23 01:10:35]

Chris, yes, I moved it here intentionally, since strictly speaking this is also
logic for deciding whether a codec is supported or not, and has nothing to do
with parsing the codec id per se. I'd prefer all such logic to be concentrated
here is AreSupportedCodecs, rather than spread across different functions.
I hope to get rid of it completely and switch over to relying solely on the
MediaClient API. Since with the current state of things even if media client API
says that codec is supported (returns true), we don't touch the is_ambiguous
value, which means that, for example, the final outcome for VP9 profile 2 is
still going to be 'maybe' for now, instead of 'probably', even if the
MediaClient supports it. Perhaps we should move this logic that analyzes
profiles into the RenderMediaClient implementation? WDYT?

[chcunningham, 2016/07/25 17:56:16]

I don't follow. This is all about how to set the is_ambiguous flag, which is to
say "I parsed that codec string, and found it to be misssing or partially
invalid". IMHO this does not imply anything about platform support. (Talking
only about lines 303 - 342; I think 344 - 349 are rightly placed in
AreSupportedCodecs)

[servolk, 2016/07/25 18:42:53]

This is true only to some extent. The current logic uses the is_ambiguous flag
in some cases as an indication that codec id doesn't have enough information (in
cases like 'avc1' or 'vp9'), but in other cases we do have a codec id that has
all the necessary information (video profile, level), and yet is_ambiguous is
still set to true so that the final outcome of MimeUtil::AreSupportedCodecs is
'maybe'. I think we shouldn't use the is_ambiguous flag in the latter case, and
instead should always return a definitive answer (either '' or 'probably', but
not 'maybe') based on whether the platform actually supports the given
codec/profile or not. But for the sake of moving this CL forward, I can move
this logic back into StringToCodec for now. And then we can change that later in
a separate CL.

+      switch (video_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(video_level);
+          break;
+        default:
+          is_ambiguous = true;
+      }
+    }
+
+    if (video_codec == kCodecVP9) {
+      switch (video_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;
+      }
+    }
+
+    if (GetMediaClient() && video_codec != kUnknownVideoCodec &&

[chcunningham, 2016/07/22 20:11:25]

Nice

[miu, 2016/07/22 20:58:16]

Is GetMediaClient() global for the whole render process? For media remoting,
it's possible only a subset of render frames within the process are candidates
for remoting (i.e., not including render frames for other browser tabs).

[servolk, 2016/07/23 01:10:35]

Yes, GetMediaClient is global. But my understanding is that media capabilities
are also always global on any given platform (I realize that there might be
other constraints, e.g. chromecast hardware decoder pipeline supports decoding
only one stream at a time, so it's going to be problematic if you create
multiple  HTMLMediaElements/MediaPlayers, but we have other means to deal with
that). How would we need to change this design to accomodate remoting needs
better?

[servolk, 2016/07/23 01:10:35]

Acknowledged.

[miu, 2016/07/25 19:29:55]

Yes media capabilities are static (since you either have support compiled-in or
not). However, what I'm talking about here is the case of dynamically switching
out that set of media capabilities to reflect what is supported by the platform
that will actually be decoding/rendering the media. In the case of remoting, for
example, we might want to respond to canPlayType() in terms of what a Chromecast
supports, not Chrome; or, maybe we should respond using the intersection of the
capabilities of the two platforms so the video would work on either.

+        !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) {
-// 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);
-        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) {
-      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;
-    }
+    *out_level = 1;
     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