MediaPlayer::SupportsType MediaPlayer::supportsType(const MediaEngineSupportParameters& parameters, const MediaPlayerSupportsTypeClient* client)
{
// 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the
// user agent knows it cannot render or is the type "application/octet-stream"
if (parameters.type == applicationOctetStream())
return IsNotSupported;
const MediaPlayerFactory* engine = bestMediaEngineForSupportParameters(parameters);
if (!engine)
return IsNotSupported;
#if PLATFORM(COCOA)
// YouTube will ask if the HTMLMediaElement canPlayType video/webm, then
// video/x-flv, then finally video/mp4, and will then load a URL of the first type
// in that list which returns "probably". When Perian is installed,
// MediaPlayerPrivateQTKit claims to support both video/webm and video/x-flv, but
// due to a bug in Perian, loading media in these formats will sometimes fail on
// slow connections. <https://bugs.webkit.org/show_bug.cgi?id=86409>
if (client && client->mediaPlayerNeedsSiteSpecificHacks()) {
String host = client->mediaPlayerDocumentHost();
if ((host.endsWith(".youtube.com", false) || equalIgnoringCase("youtube.com", host))
&& (parameters.type.startsWith("video/webm", false) || parameters.type.startsWith("video/x-flv", false)))
return IsNotSupported;
}
#else
UNUSED_PARAM(client);
#endif
return engine->supportsTypeAndCodecs(parameters);
}
static const MediaPlayerFactory* bestMediaEngineForSupportParameters(const MediaEngineSupportParameters& parameters, const MediaPlayerFactory* current = nullptr)
{
if (parameters.type.isEmpty() && !parameters.isMediaSource && !parameters.isMediaStream)
return nullptr;
// 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream"
// when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows
// it cannot render.
if (parameters.type == applicationOctetStream()) {
if (!parameters.codecs.isEmpty())
return nullptr;
}
const MediaPlayerFactory* foundEngine = nullptr;
MediaPlayer::SupportsType supported = MediaPlayer::IsNotSupported;
for (auto& engine : installedMediaEngines()) {
if (current) {
if (current == &engine)
current = nullptr;
continue;
}
MediaPlayer::SupportsType engineSupport = engine.supportsTypeAndCodecs(parameters);
if (engineSupport > supported) {
supported = engineSupport;
foundEngine = &engine;
}
}
return foundEngine;
}
void MediaPlayer::load(const String& url, const ContentType& contentType)
{
String type = contentType.type().lower();
String typeCodecs = contentType.parameter(codecs());
// If the MIME type is missing or is not meaningful, try to figure it out from the URL.
if (type.isEmpty() || type == applicationOctetStream() || type == textPlain()) {
if (protocolIs(url, "data"))
type = mimeTypeFromDataURL(url);
else {
size_t pos = url.reverseFind('.');
if (pos != notFound) {
String extension = url.substring(pos + 1);
String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
if (!mediaType.isEmpty())
type = mediaType;
}
}
}
m_url = url;
m_contentMIMEType = type;
m_contentTypeCodecs = typeCodecs;
loadWithNextMediaEngine(0);
}
static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, MediaPlayerFactory* current)
{
if (type.isEmpty())
return 0;
Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
if (engines.isEmpty())
return 0;
// 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream"
// when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows
// it cannot render.
if (type == applicationOctetStream()) {
if (!codecs.isEmpty())
return 0;
}
MediaPlayerFactory* engine = 0;
MediaPlayer::SupportsType supported = MediaPlayer::IsNotSupported;
unsigned count = engines.size();
for (unsigned ndx = 0; ndx < count; ndx++) {
if (current) {
if (current == engines[ndx])
current = 0;
continue;
}
MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(type, codecs);
if (engineSupport > supported) {
supported = engineSupport;
engine = engines[ndx];
}
}
return engine;
}
bool MediaPlayer::load(const URL& url, const ContentType& contentType, const String& keySystem)
{
m_contentMIMEType = contentType.type().lower();
m_contentTypeCodecs = contentType.parameter(codecs());
m_url = url;
m_keySystem = keySystem.lower();
m_contentMIMETypeWasInferredFromExtension = false;
#if ENABLE(MEDIA_SOURCE)
m_mediaSource = 0;
#endif
// If the MIME type is missing or is not meaningful, try to figure it out from the URL.
if (m_contentMIMEType.isEmpty() || m_contentMIMEType == applicationOctetStream() || m_contentMIMEType == textPlain()) {
if (m_url.protocolIsData())
m_contentMIMEType = mimeTypeFromDataURL(m_url.string());
else {
String lastPathComponent = url.lastPathComponent();
size_t pos = lastPathComponent.reverseFind('.');
if (pos != notFound) {
String extension = lastPathComponent.substring(pos + 1);
String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
if (!mediaType.isEmpty()) {
m_contentMIMEType = mediaType;
m_contentMIMETypeWasInferredFromExtension = true;
}
}
}
}
loadWithNextMediaEngine(0);
return m_currentMediaEngine;
}
MediaPlayer::SupportsType MediaPlayer::supportsType(const ContentType& contentType)
{
String type = contentType.type().lower();
String typeCodecs = contentType.parameter(codecs());
// 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the
// user agent knows it cannot render or is the type "application/octet-stream"
if (type == applicationOctetStream())
return IsNotSupported;
MediaPlayerFactory* engine = bestMediaEngineForTypeAndCodecs(type, typeCodecs);
if (!engine)
return IsNotSupported;
return engine->supportsTypeAndCodecs(type, typeCodecs);
}