Make CanPlayType return "probably" for HI10P h264 videos.

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/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
@@ skipping 263 matching lines @@
     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;
-    if (!StringToCodec(codecs[i], &codec, &is_ambiguous))
+    if (!StringToCodec(codecs[i], &codec, &is_ambiguous, is_encrypted))
       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;
   }
@@ skipping 20 matching lines @@
   // Initialize the supported media formats.
   for (size_t i = 0; i < arraysize(kFormatCodecMappings); ++i) {
     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));
+      CHECK(StringToCodec(mime_type_codecs[j], &codec, &is_ambiguous, false));
       DCHECK(!is_ambiguous);
       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)) !=
@@ skipping 188 matching lines @@
       // Otherwise, platform support is required.
       return platform_info.supports_vp9;
     }
   }
 
   return false;
 }
 
 bool MimeUtil::StringToCodec(const std::string& codec_id,
                              Codec* codec,
-                             bool* is_ambiguous) const {
+                             bool* is_ambiguous,
+                             bool is_encrypted) const {
   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.
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   if (ParseHEVCCodecID(codec_id, codec, is_ambiguous)) {
     return true;
   }
 #endif
 
   VideoCodecProfile profile = VIDEO_CODEC_PROFILE_UNKNOWN;
   uint8_t level_idc = 0;
   if (ParseAVCCodecId(codec_id, &profile, &level_idc)) {
     *codec = MimeUtil::H264;
-    *is_ambiguous =
-        (profile != H264PROFILE_BASELINE && profile != H264PROFILE_MAIN &&
-         profile != H264PROFILE_HIGH) ||
-        !IsValidH264Level(level_idc);
+    switch (profile) {
+// HIGH10PROFILE is supported through fallback to the ffmpeg decoder.

[ddorwin, 2016/03/31 22:31:12]

nit: , which

[hubbe, 2016/04/01 00:20:59]

Done.

+// Which is not available on Android, chromium builds or if

[ddorwin, 2016/03/31 22:31:12]

Chromium is irrelevant to this (that's handled elsewhere) and no different than
the other profiles, so I'd drop that part.

[hubbe, 2016/04/01 00:20:58]

Done.

+// FFMPEG has been disabled.

[ddorwin, 2016/03/31 22:31:12]

nit suggestion: s/has been disabled/is not used/. The former makes it sound like
it's an option.

[hubbe, 2016/04/01 00:20:59]

Done.

+#if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID)

[ddorwin, 2016/03/31 22:31:12]

:) +dalecurtis to confirm this logic.

We should probably make this more obvious when switching to build flags.

[DaleCurtis, 2016/03/31 22:58:44]

this is correct. android doesn't have ff_h264. 

[hubbe, 2016/04/01 00:20:59]

Acknowledged.

[hubbe, 2016/04/01 00:20:59]

Acknowledged.

+      case H264PROFILE_HIGH10PROFILE:

[ddorwin, 2016/03/31 22:31:12]

It might be nicer to always have this case and put the #if inside it. That does
require a #else to break, though.

[hubbe, 2016/04/01 00:20:58]

Tried it, but I didn't like how it turned out.

+        if (is_encrypted) {
+          // Currently we do not support EME on 10-bit videos.

[ddorwin, 2016/03/31 22:31:12]

More accurately, especially since we don't return false:
FFmpeg is not generally used for encrypted videos, so we do not know whether
10-bit is supported.

[hubbe, 2016/04/01 00:20:59]

Done.

+          *is_ambiguous = true;
+          break;
+        }

[ddorwin, 2016/03/31 22:31:12]

Add an explicit comment to "fall through" so it's clear this is not a bug. :)

[hubbe, 2016/04/01 00:20:59]

Done.

+#endif
+
+      case H264PROFILE_BASELINE:
+      case H264PROFILE_MAIN:
+      case H264PROFILE_HIGH:
+
+        *is_ambiguous = !IsValidH264Level(level_idc);
+        break;
+      default:
+        *is_ambiguous = true;
+    }
     return true;
   }
 
   DVLOG(4) << __FUNCTION__ << ": Unrecognized codec id " << codec_id;
   return false;
 }
 
 bool MimeUtil::IsCodecSupported(Codec codec,
                                 const std::string& mime_type_lower_case,
                                 bool is_encrypted) const {
@@ skipping 54 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