| // Copyright 2016 The Cobalt Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "starboard/media.h" |
| |
| #include "starboard/character.h" |
| #include "starboard/log.h" |
| #include "starboard/shared/starboard/media/codec_util.h" |
| #include "starboard/shared/starboard/media/media_support_internal.h" |
| #include "starboard/shared/starboard/media/media_util.h" |
| #include "starboard/shared/starboard/media/mime_type.h" |
| #include "starboard/string.h" |
| |
| using starboard::shared::starboard::media::GetAudioCodecFromString; |
| using starboard::shared::starboard::media::GetTransferIdFromString; |
| using starboard::shared::starboard::media::GetVideoCodecFromString; |
| using starboard::shared::starboard::media::IsAudioOutputSupported; |
| using starboard::shared::starboard::media::MimeType; |
| using starboard::shared::starboard::media::ParseH264Info; |
| |
| namespace { |
| |
| const int64_t kDefaultBitRate = 0; |
| const int64_t kDefaultAudioChannels = 2; |
| |
| // A progressive video contains both audio and video data. The JS app uses |
| // canPlayType() like "canPlayType(video/mp4; codecs="avc1.42001E, mp4a.40.2",)" |
| // to query for support on both the audio and video codecs, which is being |
| // forwarded to here. |
| // |
| // Note that canPlayType() doesn't support extra parameters like width, height |
| // and channels. |
| SbMediaSupportType CanPlayProgressiveVideo(const MimeType& mime_type, |
| bool decode_to_texture_required) { |
| #if SB_API_VERSION < 10 |
| SB_UNREFERENCED_PARAMETER(decode_to_texture_required); |
| #endif // SB_API_VERSION < 10 |
| |
| const std::vector<std::string>& codecs = mime_type.GetCodecs(); |
| |
| SB_DCHECK(codecs.size() == 2) << codecs.size(); |
| |
| bool has_audio_codec = false; |
| bool has_video_codec = false; |
| for (size_t i = 0; i < codecs.size(); ++i) { |
| SbMediaAudioCodec audio_codec = GetAudioCodecFromString(codecs[i].c_str()); |
| if (audio_codec != kSbMediaAudioCodecNone) { |
| if (!SbMediaIsAudioSupported(audio_codec, kDefaultBitRate)) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| has_audio_codec = true; |
| continue; |
| } |
| SbMediaVideoCodec video_codec = GetVideoCodecFromString(codecs[i].c_str()); |
| if (video_codec == kSbMediaVideoCodecNone) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| has_video_codec = true; |
| |
| int width = 0; |
| int height = 0; |
| int fps = 0; |
| |
| if (video_codec == kSbMediaVideoCodecH264) { |
| if (!ParseH264Info(codecs[i].c_str(), &width, &height, &fps)) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| } |
| if (!SbMediaIsVideoSupported(video_codec, width, height, kDefaultBitRate, |
| fps |
| #if SB_API_VERSION >= 10 |
| , |
| decode_to_texture_required |
| #endif // SB_API_VERSION >= 10 |
| #if SB_HAS(MEDIA_EOTF_CHECK_SUPPORT) |
| , |
| kSbMediaTransferIdUnspecified |
| #endif // SB_HAS(MEDIA_EOTF_CHECK_SUPPORT) |
| )) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| } |
| |
| if (has_audio_codec && has_video_codec) { |
| return kSbMediaSupportTypeProbably; |
| } |
| |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| // Calls to isTypeSupported() are redirected to this function. Following are |
| // some example inputs: |
| // isTypeSupported(video/webm; codecs="vp9") |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; width=640) |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; width=99999) |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; height=360) |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; height=99999) |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; framerate=30) |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; framerate=9999) |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; bitrate=300000) |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; bitrate=2000000000) |
| // isTypeSupported(audio/mp4; codecs="mp4a.40.2") |
| // isTypeSupported(audio/webm; codecs="vorbis") |
| // isTypeSupported(video/webm; codecs="vp9") |
| // isTypeSupported(video/webm; codecs="vp9") |
| // isTypeSupported(audio/webm; codecs="opus") |
| // isTypeSupported(audio/mp4; codecs="mp4a.40.2"; channels=2) |
| // isTypeSupported(audio/mp4; codecs="mp4a.40.2"; channels=99) |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; decode-to-texture=true) |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; decode-to-texture=false) |
| // isTypeSupported(video/mp4; codecs="avc1.4d401e"; decode-to-texture=invalid) |
| SbMediaSupportType CanPlayMimeAndKeySystem(const MimeType& mime_type, |
| const char* key_system) { |
| SB_DCHECK(mime_type.is_valid()); |
| |
| const std::vector<std::string>& codecs = mime_type.GetCodecs(); |
| |
| // Pre-filter for |key_system|. |
| if (SbStringGetLength(key_system) != 0) { |
| if (!SbMediaIsSupported(kSbMediaVideoCodecNone, kSbMediaAudioCodecNone, |
| key_system)) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| } |
| |
| bool decode_to_texture_required = false; |
| #if SB_API_VERSION >= 10 |
| std::string decode_to_texture_value = |
| mime_type.GetParamStringValue("decode-to-texture", "false"); |
| if (decode_to_texture_value == "true") { |
| decode_to_texture_required = true; |
| } else if (decode_to_texture_value != "false") { |
| // If an invalid value (e.g. not "true" or "false") is passed in for |
| // decode-to-texture, trivially reject. |
| return kSbMediaSupportTypeNotSupported; |
| } |
| #endif // SB_API_VERSION >= 10 |
| |
| if (codecs.size() == 0) { |
| // When there is no codecs listed, returns |kSbMediaSupportTypeMaybe| and |
| // reject unsupported formats when query again with valid "codecs". |
| return kSbMediaSupportTypeMaybe; |
| } |
| |
| if (codecs.size() > 2) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| if (codecs.size() == 2) { |
| SB_DCHECK(SbStringGetLength(key_system) == 0); |
| return CanPlayProgressiveVideo(mime_type, decode_to_texture_required); |
| } |
| |
| SB_DCHECK(codecs.size() == 1); |
| |
| if (mime_type.type() == "audio") { |
| SbMediaAudioCodec audio_codec = GetAudioCodecFromString(codecs[0].c_str()); |
| if (audio_codec == kSbMediaAudioCodecNone) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| if (SbStringGetLength(key_system) != 0) { |
| if (!SbMediaIsSupported(kSbMediaVideoCodecNone, audio_codec, |
| key_system)) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| } |
| |
| int channels = |
| mime_type.GetParamIntValue("channels", kDefaultAudioChannels); |
| if (!IsAudioOutputSupported(kSbMediaAudioCodingTypePcm, channels)) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| int bitrate = mime_type.GetParamIntValue("bitrate", kDefaultBitRate); |
| |
| if (SbMediaIsAudioSupported(audio_codec, bitrate)) { |
| return kSbMediaSupportTypeProbably; |
| } |
| |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| if (mime_type.type() == "video") { |
| SbMediaVideoCodec video_codec = GetVideoCodecFromString(codecs[0].c_str()); |
| if (video_codec == kSbMediaVideoCodecNone) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| if (SbStringGetLength(key_system) != 0) { |
| if (!SbMediaIsSupported(video_codec, kSbMediaAudioCodecNone, |
| key_system)) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| } |
| |
| std::string eotf = mime_type.GetParamStringValue("eotf", ""); |
| SbMediaTransferId transfer_id = kSbMediaTransferIdUnspecified; |
| if (!eotf.empty()) { |
| transfer_id = GetTransferIdFromString(eotf); |
| // If the eotf is not known, reject immediately - without checking with |
| // the platform. |
| if (transfer_id == kSbMediaTransferIdUnknown) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| } |
| |
| std::string cryptoblockformat = |
| mime_type.GetParamStringValue("cryptoblockformat", ""); |
| if (!cryptoblockformat.empty()) { |
| if (mime_type.subtype() != "webm" || cryptoblockformat != "subsample") { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| } |
| |
| int width = 0; |
| int height = 0; |
| int fps = 0; |
| |
| if (video_codec == kSbMediaVideoCodecH264) { |
| if (!ParseH264Info(codecs[0].c_str(), &width, &height, &fps)) { |
| return kSbMediaSupportTypeNotSupported; |
| } |
| } |
| |
| width = mime_type.GetParamIntValue("width", width); |
| height = mime_type.GetParamIntValue("height", height); |
| fps = mime_type.GetParamIntValue("framerate", fps); |
| |
| int bitrate = mime_type.GetParamIntValue("bitrate", kDefaultBitRate); |
| |
| if (SbMediaIsVideoSupported(video_codec, width, height, bitrate, fps |
| #if SB_API_VERSION >= 10 |
| , |
| decode_to_texture_required |
| #endif // SB_API_VERSION >= 10 |
| #if SB_HAS(MEDIA_EOTF_CHECK_SUPPORT) |
| , |
| transfer_id |
| #endif // SB_HAS(MEDIA_EOTF_CHECK_SUPPORT) |
| )) { |
| return kSbMediaSupportTypeProbably; |
| } |
| |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| } // namespace |
| |
| SbMediaSupportType SbMediaCanPlayMimeAndKeySystem(const char* mime, |
| const char* key_system) { |
| if (mime == NULL) { |
| SB_DLOG(WARNING) << "mime cannot be NULL"; |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| if (key_system == NULL) { |
| SB_DLOG(WARNING) << "key_system cannot be NULL"; |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| MimeType mime_type(mime); |
| if (!mime_type.is_valid()) { |
| SB_DLOG(WARNING) << mime << " is not a valid mime type"; |
| return kSbMediaSupportTypeNotSupported; |
| } |
| |
| return CanPlayMimeAndKeySystem(mime_type, key_system); |
| } |
