MediaPlayer::MediaPlayer(MediaPlayerClient* client)
: m_mediaPlayerClient(client)
, m_private(createNullMediaPlayer(this))
, m_currentMediaEngine(0)
, m_frameView(0)
, m_visible(false)
, m_rate(1.0f)
, m_volume(1.0f)
, m_muted(false)
, m_preservesPitch(true)
, m_autobuffer(false)
#if PLATFORM(ANDROID)
, m_mediaElementType(Video)
#endif
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
, m_playerProxy(0)
#endif
{
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
if (!engines.isEmpty()) {
m_currentMediaEngine = engines[0];
m_private.clear();
m_private.set(engines[0]->constructor(this));
}
#endif
}
void MediaPlayer::clearMediaCacheForSite(const String& site)
{
for (auto& engine : installedMediaEngines()) {
if (engine.clearMediaCacheForSite)
engine.clearMediaCacheForSite(site);
}
}
MediaPlayer::MediaPlayer(MediaPlayerClient* client)
: m_mediaPlayerClient(client)
, m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
, m_private(createNullMediaPlayer(this))
, m_currentMediaEngine(0)
, m_frameView(0)
, m_preload(Auto)
, m_visible(false)
, m_rate(1.0f)
, m_volume(1.0f)
, m_muted(false)
, m_preservesPitch(true)
, m_privateBrowsing(false)
, m_shouldPrepareToRender(false)
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
, m_playerProxy(0)
#endif
#if PLATFORM(ANDROID)
, m_mediaElementType(Video)
#endif
{
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
if (!engines.isEmpty()) {
m_currentMediaEngine = engines[0];
m_private.clear();
m_private.set(engines[0]->constructor(this));
if (m_mediaPlayerClient)
m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
}
#endif
}
void MediaPlayer::clearMediaCache(const String& path, std::chrono::system_clock::time_point modifiedSince)
{
for (auto& engine : installedMediaEngines()) {
if (engine.clearMediaCache)
engine.clearMediaCache(path, modifiedSince);
}
}
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;
}
void MediaPlayer::clearMediaCacheForOrigins(const String& path, const HashSet<RefPtr<SecurityOrigin>>& origins)
{
for (auto& engine : installedMediaEngines()) {
if (engine.clearMediaCacheForOrigins)
engine.clearMediaCacheForOrigins(path, origins);
}
}
MediaPlayer::MediaPlayer(MediaPlayerClient* client)
: m_mediaPlayerClient(client)
, m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
, m_private(createNullMediaPlayer(this))
, m_currentMediaEngine(0)
, m_frameView(0)
, m_preload(Auto)
, m_visible(false)
, m_rate(1.0f)
, m_volume(1.0f)
, m_muted(false)
, m_preservesPitch(true)
, m_privateBrowsing(false)
, m_shouldPrepareToRender(false)
, m_contentMIMETypeWasInferredFromExtension(false)
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
, m_playerProxy(0)
#endif
{
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
if (Settings::isVideoPluginProxyEnabled() && !engines.isEmpty()) {
m_currentMediaEngine = engines[0];
m_private = engines[0]->constructor(this);
if (m_mediaPlayerClient)
m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
}
#endif
}
void MediaPlayer::clearMediaCache()
{
for (auto& engine : installedMediaEngines()) {
if (engine.clearMediaCache)
engine.clearMediaCache();
}
}
static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType)
{
ASSERT(constructor);
ASSERT(getSupportedTypes);
ASSERT(supportsType);
installedMediaEngines().append(new MediaPlayerFactory(constructor, getSupportedTypes, supportsType));
}
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;
}
bool MediaPlayer::supportsKeySystem(const String& keySystem, const String& mimeType)
{
for (auto& engine : installedMediaEngines()) {
if (engine.supportsKeySystem && engine.supportsKeySystem(keySystem, mimeType))
return true;
}
return false;
}
void MediaPlayer::getSupportedTypes(HashSet<String>& types)
{
for (auto& engine : installedMediaEngines()) {
HashSet<String> engineTypes;
engine.getSupportedTypes(engineTypes);
types.add(engineTypes.begin(), engineTypes.end());
}
}
static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite)
{
ASSERT(constructor);
ASSERT(getSupportedTypes);
ASSERT(supportsType);
installedMediaEngines().append(new MediaPlayerFactory(constructor, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite));
}
void MediaPlayer::clearMediaCacheForSite(const String& site)
{
Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
unsigned size = engines.size();
for (unsigned i = 0; i < size; i++) {
if (engines[i]->clearMediaCacheForSite)
engines[i]->clearMediaCacheForSite(site);
}
}
void MediaPlayer::getSitesInMediaCache(Vector<String>& sites)
{
for (auto& engine : installedMediaEngines()) {
if (!engine.getSitesInMediaCache)
continue;
Vector<String> engineSites;
engine.getSitesInMediaCache(engineSites);
sites.appendVector(engineSites);
}
}
void MediaPlayer::getSupportedTypes(HashSet<String>& types)
{
Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
if (engines.isEmpty())
return;
unsigned count = engines.size();
for (unsigned ndx = 0; ndx < count; ndx++)
engines[ndx]->getSupportedTypes(types);
}
HashSet<RefPtr<SecurityOrigin>> MediaPlayer::originsInMediaCache(const String& path)
{
HashSet<RefPtr<SecurityOrigin>> origins;
for (auto& engine : installedMediaEngines()) {
if (!engine.originsInMediaCache)
continue;
addToHash(origins, engine.originsInMediaCache(path));
}
return origins;
}
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::getSitesInMediaCache(Vector<String>& sites)
{
Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
unsigned size = engines.size();
for (unsigned i = 0; i < size; i++) {
if (!engines[i]->getSitesInMediaCache)
continue;
Vector<String> engineSites;
engines[i]->getSitesInMediaCache(engineSites);
sites.append(engineSites);
}
}
// Client callbacks.
void MediaPlayer::networkStateChanged()
{
// If more than one media engine is installed and this one failed before finding metadata,
// let the next engine try.
if (m_private->networkState() >= FormatError && m_private->readyState() < HaveMetadata) {
m_client.mediaPlayerEngineFailedToLoad();
if (installedMediaEngines().size() > 1 && (m_contentMIMEType.isEmpty() || nextBestMediaEngine(m_currentMediaEngine))) {
m_reloadTimer.startOneShot(0);
return;
}
}
m_client.mediaPlayerNetworkStateChanged(this);
}
// Client callbacks.
void MediaPlayer::networkStateChanged()
{
// If more than one media engine is installed and this one failed before finding metadata,
// let the next engine try.
if (m_private->networkState() >= FormatError
&& m_private->readyState() < HaveMetadata
&& installedMediaEngines().size() > 1) {
if ( m_contentMIMEType.isEmpty() || bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, m_currentMediaEngine)) {
m_reloadTimer.startOneShot(0);
return;
}
}
if (m_mediaPlayerClient)
m_mediaPlayerClient->mediaPlayerNetworkStateChanged(this);
}
static const MediaPlayerFactory* nextMediaEngine(const MediaPlayerFactory* current)
{
auto& engines = installedMediaEngines();
if (engines.isEmpty())
return nullptr;
if (!current)
return &engines.first();
size_t currentIndex = current - &engines.first();
if (currentIndex + 1 >= engines.size())
return nullptr;
return &engines[currentIndex + 1];
}
static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current)
{
Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
if (engines.isEmpty())
return 0;
if (!current)
return engines.first();
size_t currentIndex = engines.find(current);
if (currentIndex == WTF::notFound || currentIndex == engines.size())
return 0;
return engines[currentIndex + 1];
}
static MediaPlayerFactory* chooseBestEngineForTypeAndCodecs(const String& type, const String& codecs)
{
Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
if (engines.isEmpty())
return 0;
MediaPlayerFactory* engine = 0;
MediaPlayer::SupportsType supported = MediaPlayer::IsNotSupported;
unsigned count = engines.size();
for (unsigned ndx = 0; ndx < count; ndx++) {
MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(type, codecs);
if (engineSupport > supported) {
supported = engineSupport;
engine = engines[ndx];
}
}
return engine;
}
void MediaPlayer::resetMediaEngines()
{
installedMediaEngines(ResetEngines);
}
bool MediaPlayer::isAvailable()
{
return !installedMediaEngines().isEmpty();
}
void MediaPlayer::getSupportedTypes(HashSet<String>& types)
{
for (auto& engine : installedMediaEngines())
engine.getSupportedTypes(types);
}