2 * Copyright (C) 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 #include "MediaPlayer.h"
31 #include "ContentType.h"
34 #include "FrameView.h"
37 #include "MIMETypeRegistry.h"
38 #include "MediaPlayerPrivate.h"
40 #include "TimeRanges.h"
47 #include "MediaPlayerPrivateGStreamer.h"
50 #if PLATFORM(MAC) || (PLATFORM(QT) && USE(QTKIT))
51 #include "MediaPlayerPrivateQTKit.h"
53 #include "MediaPlayerPrivateAVFoundationObjC.h"
55 #define PlatformMediaEngineClassName MediaPlayerPrivateQTKit
56 #elif OS(WINCE) && !PLATFORM(QT)
57 #include "MediaPlayerPrivateWinCE.h"
58 #define PlatformMediaEngineClassName MediaPlayerPrivate
60 #include "MediaPlayerPrivateQuickTimeVisualContext.h"
61 #define PlatformMediaEngineClassName MediaPlayerPrivateQuickTimeVisualContext
63 #include "MediaPlayerPrivateAVFoundationCF.h"
66 #if USE(QT_MULTIMEDIA) && !USE(GSTREAMER)
67 #include "MediaPlayerPrivateQt.h"
68 #define PlatformMediaEngineClassName MediaPlayerPrivateQt
70 #elif PLATFORM(CHROMIUM)
71 #include "MediaPlayerPrivateChromium.h"
72 #define PlatformMediaEngineClassName MediaPlayerPrivate
73 #elif PLATFORM(EFL) && ENABLE(TIZEN_MM_PLAYER)
74 #include "MediaPlayerPrivateMMFW.h"
79 const PlatformMedia NoPlatformMedia = { PlatformMedia::None, {0} };
81 // a null player to make MediaPlayer logic simpler
83 class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {
85 NullMediaPlayerPrivate(MediaPlayer*) { }
87 #if ENABLE(TIZEN_MM_PLAYER)
88 virtual void load(const WTF::String&) { }
90 virtual void load(const String&) { }
92 virtual void cancelLoad() { }
94 virtual void prepareToPlay() { }
95 virtual void play() { }
96 virtual void pause() { }
98 virtual PlatformMedia platformMedia() const { return NoPlatformMedia; }
99 #if USE(ACCELERATED_COMPOSITING)
100 virtual PlatformLayer* platformLayer() const { return 0; }
103 virtual IntSize naturalSize() const { return IntSize(0, 0); }
105 virtual bool hasVideo() const { return false; }
106 virtual bool hasAudio() const { return false; }
108 // justine.bang@samsung.com
109 #if ENABLE(TIZEN_MM_PLAYER)
110 virtual void stop() { }
111 virtual void smartCalculate() { }
112 virtual void setZoomWeak(void *data) { }
113 virtual void setZoom(void *data) { }
114 virtual void pauseOrResume(bool b) { }
115 virtual void catchMouseDown(){}
116 virtual void catchMouseUp(){}
119 virtual void setVisible(bool) { }
121 virtual float duration() const { return 0; }
123 virtual float currentTime() const { return 0; }
124 virtual void seek(float) { }
125 virtual bool seeking() const { return false; }
127 virtual void setRate(float) { }
128 virtual void setPreservesPitch(bool) { }
129 virtual bool paused() const { return false; }
131 virtual void setVolume(float) { }
133 virtual bool supportsMuting() const { return false; }
134 virtual void setMuted(bool) { }
136 virtual bool hasClosedCaptions() const { return false; }
137 virtual void setClosedCaptionsVisible(bool) { };
139 virtual MediaPlayer::NetworkState networkState() const { return MediaPlayer::Empty; }
140 virtual MediaPlayer::ReadyState readyState() const { return MediaPlayer::HaveNothing; }
142 virtual float maxTimeSeekable() const { return 0; }
143 virtual PassRefPtr<TimeRanges> buffered() const { return TimeRanges::create(); }
145 virtual unsigned totalBytes() const { return 0; }
146 virtual unsigned bytesLoaded() const { return 0; }
148 virtual void setSize(const IntSize&) { }
150 virtual void paint(GraphicsContext*, const IntRect&) { }
152 virtual bool canLoadPoster() const { return false; }
153 virtual void setPoster(const String&) { }
155 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
156 virtual void deliverNotification(MediaPlayerProxyNotificationType) { }
157 virtual void setMediaPlayerProxy(WebMediaPlayerProxy*) { }
158 virtual void setControls(bool) { }
161 virtual bool hasSingleSecurityOrigin() const { return true; }
163 #if ENABLE(MEDIA_SOURCE)
164 virtual bool sourceAppend(const unsigned char*, unsigned) { return false; }
165 virtual void sourceEndOfStream(MediaPlayer::EndOfStreamStatus status) { }
169 static PassOwnPtr<MediaPlayerPrivateInterface> createNullMediaPlayer(MediaPlayer* player)
171 return adoptPtr(new NullMediaPlayerPrivate(player));
177 struct MediaPlayerFactory {
178 WTF_MAKE_NONCOPYABLE(MediaPlayerFactory); WTF_MAKE_FAST_ALLOCATED;
180 MediaPlayerFactory(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsTypeAndCodecs,
181 MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite)
182 : constructor(constructor)
183 , getSupportedTypes(getSupportedTypes)
184 , supportsTypeAndCodecs(supportsTypeAndCodecs)
185 , getSitesInMediaCache(getSitesInMediaCache)
186 , clearMediaCache(clearMediaCache)
187 , clearMediaCacheForSite(clearMediaCacheForSite)
192 CreateMediaEnginePlayer constructor;
193 MediaEngineSupportedTypes getSupportedTypes;
194 MediaEngineSupportsType supportsTypeAndCodecs;
195 MediaEngineGetSitesInMediaCache getSitesInMediaCache;
196 MediaEngineClearMediaCache clearMediaCache;
197 MediaEngineClearMediaCacheForSite clearMediaCacheForSite;
200 static void addMediaEngine(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite);
201 static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, MediaPlayerFactory* current = 0);
202 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current);
204 static Vector<MediaPlayerFactory*>& installedMediaEngines()
206 DEFINE_STATIC_LOCAL(Vector<MediaPlayerFactory*>, installedEngines, ());
207 static bool enginesQueried = false;
209 if (!enginesQueried) {
210 enginesQueried = true;
213 MediaPlayerPrivateGStreamer::registerMediaEngine(addMediaEngine);
216 #if USE(AVFOUNDATION)
217 if (Settings::isAVFoundationEnabled()) {
219 MediaPlayerPrivateAVFoundationObjC::registerMediaEngine(addMediaEngine);
221 MediaPlayerPrivateAVFoundationCF::registerMediaEngine(addMediaEngine);
226 //WebKit EFL trunk uses gstreamer for multimedia backend as well as gtk
227 //port. However, TIZEN webkit doesn't use gstreamer for multimedia. Instead,
228 //it uses slp multimedia player. So, I comment below preprocessor out for
229 //TIZEN WebKit. - Gyuyoung Kim.
230 #if !PLATFORM(GTK) && !PLATFORM(EFL) && !(PLATFORM(QT) && USE(GSTREAMER))
231 PlatformMediaEngineClassName::registerMediaEngine(addMediaEngine);
234 #if ENABLE(TIZEN_MM_PLAYER)
235 // TIZEN WebKit uses mm_player multimedia backend to play video and audio.
236 MediaPlayerPrivate::registerMediaEngine(addMediaEngine);
240 return installedEngines;
243 static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
244 MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite)
247 ASSERT(getSupportedTypes);
248 ASSERT(supportsType);
250 installedMediaEngines().append(new MediaPlayerFactory(constructor, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite));
253 static const AtomicString& applicationOctetStream()
255 DEFINE_STATIC_LOCAL(const AtomicString, applicationOctetStream, ("application/octet-stream"));
256 return applicationOctetStream;
259 static const AtomicString& textPlain()
261 DEFINE_STATIC_LOCAL(const AtomicString, textPlain, ("text/plain"));
265 static const AtomicString& codecs()
267 DEFINE_STATIC_LOCAL(const AtomicString, codecs, ("codecs"));
271 static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, MediaPlayerFactory* current)
276 Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
277 if (engines.isEmpty())
280 // 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream"
281 // when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows
283 if (type == applicationOctetStream()) {
284 if (!codecs.isEmpty())
288 MediaPlayerFactory* engine = 0;
289 MediaPlayer::SupportsType supported = MediaPlayer::IsNotSupported;
290 unsigned count = engines.size();
291 for (unsigned ndx = 0; ndx < count; ndx++) {
293 if (current == engines[ndx])
297 MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(type, codecs);
298 if (engineSupport > supported) {
299 supported = engineSupport;
300 engine = engines[ndx];
307 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current)
309 Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
310 if (engines.isEmpty())
314 return engines.first();
316 size_t currentIndex = engines.find(current);
317 if (currentIndex == WTF::notFound || currentIndex + 1 >= engines.size())
320 return engines[currentIndex + 1];
325 MediaPlayer::MediaPlayer(MediaPlayerClient* client)
326 : m_mediaPlayerClient(client)
327 , m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
328 , m_private(createNullMediaPlayer(this))
329 , m_currentMediaEngine(0)
336 , m_preservesPitch(true)
337 , m_privateBrowsing(false)
338 , m_shouldPrepareToRender(false)
339 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
343 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
344 Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
345 if (!engines.isEmpty()) {
346 m_currentMediaEngine = engines[0];
347 m_private = engines[0]->constructor(this);
348 if (m_mediaPlayerClient)
349 m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
354 MediaPlayer::~MediaPlayer()
356 m_mediaPlayerClient = 0;
359 bool MediaPlayer::load(const String& url, const ContentType& contentType)
361 String type = contentType.type().lower();
362 String typeCodecs = contentType.parameter(codecs());
364 // If the MIME type is missing or is not meaningful, try to figure it out from the URL.
365 if (type.isEmpty() || type == applicationOctetStream() || type == textPlain()) {
366 if (protocolIs(url, "data"))
367 type = mimeTypeFromDataURL(url);
369 size_t pos = url.reverseFind('.');
370 if (pos != notFound) {
371 String extension = url.substring(pos + 1);
372 String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
373 if (!mediaType.isEmpty())
380 m_contentMIMEType = type;
381 m_contentTypeCodecs = typeCodecs;
382 loadWithNextMediaEngine(0);
383 return m_currentMediaEngine;
386 void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current)
388 MediaPlayerFactory* engine;
390 // If no MIME type is specified, just use the next engine.
391 if (m_contentMIMEType.isEmpty())
392 engine = nextMediaEngine(current);
394 engine = bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, current);
396 // Don't delete and recreate the player unless it comes from a different engine.
398 LOG(Media, "MediaPlayer::loadWithNextMediaEngine - no media engine found for type \"%s\"", m_contentMIMEType.utf8().data());
399 m_currentMediaEngine = engine;
401 } else if (m_currentMediaEngine != engine) {
402 m_currentMediaEngine = engine;
403 m_private = engine->constructor(this);
404 if (m_mediaPlayerClient)
405 m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
406 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
407 m_private->setMediaPlayerProxy(m_playerProxy);
409 m_private->setPrivateBrowsingMode(m_privateBrowsing);
410 m_private->setPreload(m_preload);
411 m_private->setPreservesPitch(preservesPitch());
412 if (m_shouldPrepareToRender)
413 m_private->prepareForRendering();
417 m_private->load(m_url);
419 m_private = createNullMediaPlayer(this);
420 if (m_mediaPlayerClient)
421 m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
425 bool MediaPlayer::hasAvailableVideoFrame() const
427 return m_private->hasAvailableVideoFrame();
430 void MediaPlayer::prepareForRendering()
432 m_shouldPrepareToRender = true;
433 m_private->prepareForRendering();
436 bool MediaPlayer::canLoadPoster() const
438 return m_private->canLoadPoster();
441 void MediaPlayer::setPoster(const String& url)
443 m_private->setPoster(url);
446 void MediaPlayer::cancelLoad()
448 m_private->cancelLoad();
451 void MediaPlayer::prepareToPlay()
453 m_private->prepareToPlay();
456 void MediaPlayer::play()
461 void MediaPlayer::pause()
466 #if ENABLE(MEDIA_SOURCE)
467 bool MediaPlayer::sourceAppend(const unsigned char* data, unsigned length)
469 return m_private->sourceAppend(data, length);
472 void MediaPlayer::sourceEndOfStream(MediaPlayer::EndOfStreamStatus status)
474 return m_private->sourceEndOfStream(status);
478 float MediaPlayer::duration() const
480 return m_private->duration();
483 float MediaPlayer::startTime() const
485 return m_private->startTime();
488 double MediaPlayer::initialTime() const
490 return m_private->initialTime();
493 float MediaPlayer::currentTime() const
495 return m_private->currentTime();
498 void MediaPlayer::seek(float time)
500 m_private->seek(time);
503 bool MediaPlayer::paused() const
505 return m_private->paused();
508 bool MediaPlayer::seeking() const
510 return m_private->seeking();
513 bool MediaPlayer::supportsFullscreen() const
515 return m_private->supportsFullscreen();
518 bool MediaPlayer::supportsSave() const
520 return m_private->supportsSave();
523 bool MediaPlayer::supportsScanning() const
525 return m_private->supportsScanning();
528 IntSize MediaPlayer::naturalSize()
530 return m_private->naturalSize();
533 bool MediaPlayer::hasVideo() const
535 return m_private->hasVideo();
538 bool MediaPlayer::hasAudio() const
540 return m_private->hasAudio();
543 bool MediaPlayer::inMediaDocument()
545 Frame* frame = m_frameView ? m_frameView->frame() : 0;
546 Document* document = frame ? frame->document() : 0;
548 return document && document->isMediaDocument();
551 PlatformMedia MediaPlayer::platformMedia() const
553 return m_private->platformMedia();
556 #if USE(ACCELERATED_COMPOSITING)
557 PlatformLayer* MediaPlayer::platformLayer() const
559 return m_private->platformLayer();
563 MediaPlayer::NetworkState MediaPlayer::networkState()
565 return m_private->networkState();
568 MediaPlayer::ReadyState MediaPlayer::readyState()
570 return m_private->readyState();
573 float MediaPlayer::volume() const
578 void MediaPlayer::setVolume(float volume)
582 if (m_private->supportsMuting() || !m_muted)
583 m_private->setVolume(volume);
586 bool MediaPlayer::muted() const
591 void MediaPlayer::setMuted(bool muted)
595 if (m_private->supportsMuting())
596 m_private->setMuted(muted);
598 m_private->setVolume(muted ? 0 : m_volume);
601 bool MediaPlayer::hasClosedCaptions() const
603 return m_private->hasClosedCaptions();
606 void MediaPlayer::setClosedCaptionsVisible(bool closedCaptionsVisible)
608 m_private->setClosedCaptionsVisible(closedCaptionsVisible);
611 float MediaPlayer::rate() const
616 void MediaPlayer::setRate(float rate)
619 m_private->setRate(rate);
622 bool MediaPlayer::preservesPitch() const
624 return m_preservesPitch;
627 void MediaPlayer::setPreservesPitch(bool preservesPitch)
629 m_preservesPitch = preservesPitch;
630 m_private->setPreservesPitch(preservesPitch);
633 PassRefPtr<TimeRanges> MediaPlayer::buffered()
635 return m_private->buffered();
638 float MediaPlayer::maxTimeSeekable()
640 return m_private->maxTimeSeekable();
643 unsigned MediaPlayer::bytesLoaded()
645 return m_private->bytesLoaded();
648 void MediaPlayer::setSize(const IntSize& size)
651 m_private->setSize(size);
654 // justine.bang@samsung.com
655 #if ENABLE(TIZEN_MM_PLAYER)
656 void MediaPlayer::stop( )
661 void MediaPlayer::smartCalculate()
663 m_private->smartCalculate();
666 void MediaPlayer::setZoomWeak(void* data)
668 m_private->setZoomWeak(data);
671 void MediaPlayer::setZoom(void* data)
673 m_private->setZoom(data);
676 void MediaPlayer::pauseOrResume(bool b)
678 m_private->pauseOrResume(b);
681 void MediaPlayer::catchMouseDown()
683 m_private->catchMouseDown();
686 void MediaPlayer::catchMouseUp()
688 m_private->catchMouseUp();
691 #if !ENABLE(PLUGIN_PROXY_FOR_VIDEO)
692 void MediaPlayer::enterFullscreen()
694 m_private->enterFullscreen();
697 void MediaPlayer::exitFullscreen()
699 m_private->exitFullscreen();
704 bool MediaPlayer::visible() const
709 void MediaPlayer::setVisible(bool b)
712 m_private->setVisible(b);
715 MediaPlayer::Preload MediaPlayer::preload() const
720 void MediaPlayer::setPreload(MediaPlayer::Preload preload)
723 m_private->setPreload(preload);
726 void MediaPlayer::paint(GraphicsContext* p, const IntRect& r)
728 m_private->paint(p, r);
731 void MediaPlayer::paintCurrentFrameInContext(GraphicsContext* p, const IntRect& r)
733 m_private->paintCurrentFrameInContext(p, r);
736 MediaPlayer::SupportsType MediaPlayer::supportsType(const ContentType& contentType)
738 String type = contentType.type().lower();
739 String typeCodecs = contentType.parameter(codecs());
741 // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the
742 // user agent knows it cannot render or is the type "application/octet-stream"
743 if (type == applicationOctetStream())
744 return IsNotSupported;
746 MediaPlayerFactory* engine = bestMediaEngineForTypeAndCodecs(type, typeCodecs);
748 return IsNotSupported;
750 return engine->supportsTypeAndCodecs(type, typeCodecs);
753 void MediaPlayer::getSupportedTypes(HashSet<String>& types)
755 Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
756 if (engines.isEmpty())
759 unsigned count = engines.size();
760 for (unsigned ndx = 0; ndx < count; ndx++)
761 engines[ndx]->getSupportedTypes(types);
764 bool MediaPlayer::isAvailable()
766 return !installedMediaEngines().isEmpty();
769 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
770 void MediaPlayer::deliverNotification(MediaPlayerProxyNotificationType notification)
772 m_private->deliverNotification(notification);
775 void MediaPlayer::setMediaPlayerProxy(WebMediaPlayerProxy* proxy)
777 m_playerProxy = proxy;
778 m_private->setMediaPlayerProxy(proxy);
781 void MediaPlayer::setControls(bool controls)
783 m_private->setControls(controls);
786 void MediaPlayer::enterFullscreen()
788 m_private->enterFullscreen();
791 void MediaPlayer::exitFullscreen()
793 m_private->exitFullscreen();
797 #if USE(ACCELERATED_COMPOSITING)
798 void MediaPlayer::acceleratedRenderingStateChanged()
800 m_private->acceleratedRenderingStateChanged();
803 bool MediaPlayer::supportsAcceleratedRendering() const
805 return m_private->supportsAcceleratedRendering();
807 #endif // USE(ACCELERATED_COMPOSITING)
809 bool MediaPlayer::hasSingleSecurityOrigin() const
811 return m_private->hasSingleSecurityOrigin();
814 MediaPlayer::MovieLoadType MediaPlayer::movieLoadType() const
816 return m_private->movieLoadType();
819 float MediaPlayer::mediaTimeForTimeValue(float timeValue) const
821 return m_private->mediaTimeForTimeValue(timeValue);
824 double MediaPlayer::maximumDurationToCacheMediaTime() const
826 return m_private->maximumDurationToCacheMediaTime();
829 unsigned MediaPlayer::decodedFrameCount() const
831 return m_private->decodedFrameCount();
834 unsigned MediaPlayer::droppedFrameCount() const
836 return m_private->droppedFrameCount();
839 unsigned MediaPlayer::audioDecodedByteCount() const
841 return m_private->audioDecodedByteCount();
844 unsigned MediaPlayer::videoDecodedByteCount() const
846 return m_private->videoDecodedByteCount();
849 void MediaPlayer::reloadTimerFired(Timer<MediaPlayer>*)
851 m_private->cancelLoad();
852 loadWithNextMediaEngine(m_currentMediaEngine);
855 void MediaPlayer::getSitesInMediaCache(Vector<String>& sites)
857 Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
858 unsigned size = engines.size();
859 for (unsigned i = 0; i < size; i++) {
860 if (!engines[i]->getSitesInMediaCache)
862 Vector<String> engineSites;
863 engines[i]->getSitesInMediaCache(engineSites);
864 sites.append(engineSites);
868 void MediaPlayer::clearMediaCache()
870 Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
871 unsigned size = engines.size();
872 for (unsigned i = 0; i < size; i++) {
873 if (engines[i]->clearMediaCache)
874 engines[i]->clearMediaCache();
878 void MediaPlayer::clearMediaCacheForSite(const String& site)
880 Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
881 unsigned size = engines.size();
882 for (unsigned i = 0; i < size; i++) {
883 if (engines[i]->clearMediaCacheForSite)
884 engines[i]->clearMediaCacheForSite(site);
888 void MediaPlayer::setPrivateBrowsingMode(bool privateBrowsingMode)
890 m_privateBrowsing = privateBrowsingMode;
891 m_private->setPrivateBrowsingMode(m_privateBrowsing);
894 #if ENABLE(MEDIA_SOURCE)
895 void MediaPlayer::sourceOpened()
897 if (m_mediaPlayerClient)
898 m_mediaPlayerClient->mediaPlayerSourceOpened();
901 String MediaPlayer::sourceURL() const
903 if (m_mediaPlayerClient)
904 return m_mediaPlayerClient->mediaPlayerSourceURL();
910 void MediaPlayer::networkStateChanged()
912 // If more than one media engine is installed and this one failed before finding metadata,
913 // let the next engine try.
914 if (m_private->networkState() >= FormatError
915 && m_private->readyState() < HaveMetadata
916 && installedMediaEngines().size() > 1) {
917 if ( m_contentMIMEType.isEmpty() || bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, m_currentMediaEngine)) {
918 m_reloadTimer.startOneShot(0);
922 if (m_mediaPlayerClient)
923 m_mediaPlayerClient->mediaPlayerNetworkStateChanged(this);
926 void MediaPlayer::readyStateChanged()
928 if (m_mediaPlayerClient)
929 m_mediaPlayerClient->mediaPlayerReadyStateChanged(this);
932 void MediaPlayer::volumeChanged(float newVolume)
934 m_volume = newVolume;
935 if (m_mediaPlayerClient)
936 m_mediaPlayerClient->mediaPlayerVolumeChanged(this);
939 void MediaPlayer::muteChanged(bool newMuted)
942 if (m_mediaPlayerClient)
943 m_mediaPlayerClient->mediaPlayerMuteChanged(this);
946 void MediaPlayer::timeChanged()
948 if (m_mediaPlayerClient)
949 m_mediaPlayerClient->mediaPlayerTimeChanged(this);
952 void MediaPlayer::sizeChanged()
954 if (m_mediaPlayerClient)
955 m_mediaPlayerClient->mediaPlayerSizeChanged(this);
958 void MediaPlayer::repaint()
960 if (m_mediaPlayerClient)
961 m_mediaPlayerClient->mediaPlayerRepaint(this);
964 void MediaPlayer::durationChanged()
966 if (m_mediaPlayerClient)
967 m_mediaPlayerClient->mediaPlayerDurationChanged(this);
970 void MediaPlayer::rateChanged()
972 if (m_mediaPlayerClient)
973 m_mediaPlayerClient->mediaPlayerRateChanged(this);
976 void MediaPlayer::playbackStateChanged()
978 if (m_mediaPlayerClient)
979 m_mediaPlayerClient->mediaPlayerPlaybackStateChanged(this);
982 void MediaPlayer::firstVideoFrameAvailable()
984 if (m_mediaPlayerClient)
985 m_mediaPlayerClient->mediaPlayerFirstVideoFrameAvailable(this);
988 void MediaPlayer::characteristicChanged()
990 if (m_mediaPlayerClient)
991 m_mediaPlayerClient->mediaPlayerCharacteristicChanged(this);
994 #if ENABLE(WEB_AUDIO)
995 AudioSourceProvider* MediaPlayer::audioSourceProvider()
997 return m_private->audioSourceProvider();