void MediaPlayer::loadWithNextMediaEngine(const MediaPlayerFactory* current)
{
#if ENABLE(MEDIA_SOURCE)
#define MEDIASOURCE m_mediaSource
#else
#define MEDIASOURCE 0
#endif
#if ENABLE(MEDIA_STREAM)
#define MEDIASTREAM m_mediaStream
#else
#define MEDIASTREAM 0
#endif
const MediaPlayerFactory* engine = nullptr;
if (!m_contentMIMEType.isEmpty() || MEDIASTREAM || MEDIASOURCE)
engine = nextBestMediaEngine(current);
// If no MIME type is specified or the type was inferred from the file extension, just use the next engine.
if (!engine && (m_contentMIMEType.isEmpty() || m_contentMIMETypeWasInferredFromExtension))
engine = nextMediaEngine(current);
// Don't delete and recreate the player unless it comes from a different engine.
if (!engine) {
LOG(Media, "MediaPlayer::loadWithNextMediaEngine - no media engine found for type \"%s\"", m_contentMIMEType.utf8().data());
m_currentMediaEngine = engine;
m_private = nullptr;
} else if (m_currentMediaEngine != engine) {
m_currentMediaEngine = engine;
m_private = engine->constructor(this);
m_client.mediaPlayerEngineUpdated(this);
m_private->setPrivateBrowsingMode(m_privateBrowsing);
m_private->setPreload(m_preload);
m_private->setPreservesPitch(preservesPitch());
if (m_shouldPrepareToRender)
m_private->prepareForRendering();
}
if (m_private) {
#if ENABLE(MEDIA_SOURCE)
if (m_mediaSource)
m_private->load(m_url.string(), m_mediaSource.get());
else
#endif
#if ENABLE(MEDIA_STREAM)
if (m_mediaStream)
m_private->load(*m_mediaStream);
else
#endif
m_private->load(m_url.string());
} else {
m_private = std::make_unique<NullMediaPlayerPrivate>(this);
m_client.mediaPlayerEngineUpdated(this);
m_client.mediaPlayerResourceNotSupported(this);
}
}
void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current)
{
MediaPlayerFactory* engine = 0;
if (!m_contentMIMEType.isEmpty())
engine = nextBestMediaEngine(current);
// If no MIME type is specified or the type was inferred from the file extension, just use the next engine.
if (!engine && (m_contentMIMEType.isEmpty() || m_contentMIMETypeWasInferredFromExtension))
engine = nextMediaEngine(current);
// Don't delete and recreate the player unless it comes from a different engine.
if (!engine) {
LOG(Media, "MediaPlayer::loadWithNextMediaEngine - no media engine found for type \"%s\"", m_contentMIMEType.utf8().data());
m_currentMediaEngine = engine;
m_private = nullptr;
} else if (m_currentMediaEngine != engine) {
m_currentMediaEngine = engine;
m_private = engine->constructor(this);
if (m_mediaPlayerClient)
m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
m_private->setMediaPlayerProxy(m_playerProxy);
#endif
m_private->setPrivateBrowsingMode(m_privateBrowsing);
m_private->setPreload(m_preload);
m_private->setPreservesPitch(preservesPitch());
if (m_shouldPrepareToRender)
m_private->prepareForRendering();
}
if (m_private) {
#if ENABLE(MEDIA_SOURCE)
if (m_mediaSource)
m_private->load(m_url.string(), m_mediaSource.get());
else
#endif
m_private->load(m_url.string());
} else {
m_private = createNullMediaPlayer(this);
if (m_mediaPlayerClient) {
m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
m_mediaPlayerClient->mediaPlayerResourceNotSupported(this);
}
}
}
void MediaPlayer::load(const String& url, const ContentType& contentType)
{
String type = contentType.type();
String codecs = contentType.parameter("codecs");
// if we don't know the MIME type, see if the extension can help
if (type.isEmpty() || type == "application/octet-stream" || type == "text/plain") {
int pos = url.reverseFind('.');
if (pos >= 0) {
String extension = url.substring(pos + 1);
String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
if (!mediaType.isEmpty())
type = mediaType;
}
}
MediaPlayerFactory* engine = 0;
if (!type.isEmpty())
engine = chooseBestEngineForTypeAndCodecs(type, codecs);
// if we didn't find an engine that claims the MIME type, just use the first engine
if (!engine && !installedMediaEngines().isEmpty())
engine = installedMediaEngines()[0];
// don't delete and recreate the player unless it comes from a different engine
if (engine && m_currentMediaEngine != engine) {
m_currentMediaEngine = engine;
m_private.clear();
m_private.set(engine->constructor(this));
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
m_private->setMediaPlayerProxy(m_playerProxy);
#endif
m_private->setAutobuffer(autobuffer());
m_private->setPreservesPitch(preservesPitch());
}
if (m_private)
m_private->load(url);
else
m_private.set(createNullMediaPlayer(this));
}
void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current)
{
MediaPlayerFactory* engine;
// If no MIME type is specified, just use the next engine.
if (m_contentMIMEType.isEmpty())
engine = nextMediaEngine(current);
else
engine = bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, current);
// Don't delete and recreate the player unless it comes from a different engine.
if (!engine) {
LOG(Media, "MediaPlayer::loadWithNextMediaEngine - no media engine found for type \"%s\"", m_contentMIMEType.utf8().data());
m_currentMediaEngine = engine;
m_private = nullptr;
} else if (m_currentMediaEngine != engine) {
m_currentMediaEngine = engine;
m_private = engine->constructor(this);
if (m_mediaPlayerClient)
m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
m_private->setMediaPlayerProxy(m_playerProxy);
#endif
m_private->setPrivateBrowsingMode(m_privateBrowsing);
m_private->setPreload(m_preload);
m_private->setPreservesPitch(preservesPitch());
if (m_shouldPrepareToRender)
m_private->prepareForRendering();
}
if (m_private)
m_private->load(m_url);
else {
m_private = createNullMediaPlayer(this);
if (m_mediaPlayerClient) {
m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
m_mediaPlayerClient->mediaPlayerResourceNotSupported(this);
}
}
}
