12576fba20b30d2e2a373cbe99a6f78d11972594
[WebKit-https.git] / Source / WebCore / platform / graphics / MediaPlayer.cpp
1 /*
2  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
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.
12  *
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. 
24  */
25
26 #include "config.h"
27
28 #if ENABLE(VIDEO)
29 #include "MediaPlayer.h"
30
31 #include "ContentType.h"
32 #include "Document.h"
33 #include "Frame.h"
34 #include "FrameView.h"
35 #include "IntRect.h"
36 #include "Logging.h"
37 #include "MIMETypeRegistry.h"
38 #include "MediaPlayerPrivate.h"
39 #include "Settings.h"
40 #include "TimeRanges.h"
41 #include <wtf/text/CString.h>
42
43 #if ENABLE(VIDEO_TRACK)
44 #include "InbandTextTrackPrivate.h"
45 #endif
46
47 #if ENABLE(MEDIA_SOURCE)
48 #include "MediaSource.h"
49 #endif
50
51 #if PLATFORM(QT)
52 #include <QtGlobal>
53 #endif
54
55 #if USE(GSTREAMER)
56 #include "MediaPlayerPrivateGStreamer.h"
57 #define PlatformMediaEngineClassName MediaPlayerPrivateGStreamer
58 #endif
59
60 #if PLATFORM(MAC) || (PLATFORM(QT) && USE(QTKIT))
61 #include "MediaPlayerPrivateQTKit.h"
62 #if USE(AVFOUNDATION)
63 #include "MediaPlayerPrivateAVFoundationObjC.h"
64 #endif
65 #elif OS(WINCE) && !PLATFORM(QT)
66 #include "MediaPlayerPrivateWinCE.h"
67 #define PlatformMediaEngineClassName MediaPlayerPrivate
68 #elif PLATFORM(WIN)
69 #include "MediaPlayerPrivateQuickTimeVisualContext.h"
70 #define PlatformMediaEngineClassName MediaPlayerPrivateQuickTimeVisualContext
71 #if USE(AVFOUNDATION)
72 #include "MediaPlayerPrivateAVFoundationCF.h"
73 #endif
74 #elif PLATFORM(QT)
75 #if USE(QT_MULTIMEDIA) && !USE(GSTREAMER)
76 #include "MediaPlayerPrivateQt.h"
77 #define PlatformMediaEngineClassName MediaPlayerPrivateQt
78 #endif
79 #elif PLATFORM(CHROMIUM)
80 #include "MediaPlayerPrivateChromium.h"
81 #define PlatformMediaEngineClassName MediaPlayerPrivate
82 #elif PLATFORM(BLACKBERRY)
83 #include "MediaPlayerPrivateBlackBerry.h"
84 #define PlatformMediaEngineClassName MediaPlayerPrivate
85 #endif
86
87 namespace WebCore {
88
89 const PlatformMedia NoPlatformMedia = { PlatformMedia::None, {0} };
90
91 // a null player to make MediaPlayer logic simpler
92
93 class NullMediaPlayerPrivate : public MediaPlayerPrivateInterface {
94 public:
95     NullMediaPlayerPrivate(MediaPlayer*) { }
96
97     virtual void load(const String&) { }
98 #if ENABLE(MEDIA_SOURCE)
99     virtual void load(const String&, PassRefPtr<MediaSource>) { }
100 #endif
101     virtual void cancelLoad() { }
102
103     virtual void prepareToPlay() { }
104     virtual void play() { }
105     virtual void pause() { }    
106
107     virtual PlatformMedia platformMedia() const { return NoPlatformMedia; }
108 #if USE(ACCELERATED_COMPOSITING)
109     virtual PlatformLayer* platformLayer() const { return 0; }
110 #endif
111
112     virtual IntSize naturalSize() const { return IntSize(0, 0); }
113
114     virtual bool hasVideo() const { return false; }
115     virtual bool hasAudio() const { return false; }
116
117     virtual void setVisible(bool) { }
118
119     virtual float duration() const { return 0; }
120
121     virtual float currentTime() const { return 0; }
122     virtual void seek(float) { }
123     virtual bool seeking() const { return false; }
124
125     virtual void setRate(float) { }
126     virtual void setPreservesPitch(bool) { }
127     virtual bool paused() const { return false; }
128
129     virtual void setVolume(float) { }
130
131     virtual bool supportsMuting() const { return false; }
132     virtual void setMuted(bool) { }
133
134     virtual bool hasClosedCaptions() const { return false; }
135     virtual void setClosedCaptionsVisible(bool) { };
136
137     virtual MediaPlayer::NetworkState networkState() const { return MediaPlayer::Empty; }
138     virtual MediaPlayer::ReadyState readyState() const { return MediaPlayer::HaveNothing; }
139
140     virtual float maxTimeSeekable() const { return 0; }
141     virtual PassRefPtr<TimeRanges> buffered() const { return TimeRanges::create(); }
142
143     virtual unsigned totalBytes() const { return 0; }
144     virtual bool didLoadingProgress() const { return false; }
145
146     virtual void setSize(const IntSize&) { }
147
148     virtual void paint(GraphicsContext*, const IntRect&) { }
149
150     virtual bool canLoadPoster() const { return false; }
151     virtual void setPoster(const String&) { }
152
153 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
154     virtual void deliverNotification(MediaPlayerProxyNotificationType) { }
155     virtual void setMediaPlayerProxy(WebMediaPlayerProxy*) { }
156     virtual void setControls(bool) { }
157 #endif
158
159     virtual bool hasSingleSecurityOrigin() const { return true; }
160
161 #if ENABLE(ENCRYPTED_MEDIA)
162     virtual MediaPlayer::MediaKeyException generateKeyRequest(const String&, const unsigned char*, unsigned) OVERRIDE { return MediaPlayer::InvalidPlayerState; }
163     virtual MediaPlayer::MediaKeyException addKey(const String&, const unsigned char*, unsigned, const unsigned char*, unsigned, const String&) OVERRIDE { return MediaPlayer::InvalidPlayerState; }
164     virtual MediaPlayer::MediaKeyException cancelKeyRequest(const String&, const String&) OVERRIDE { return MediaPlayer::InvalidPlayerState; }
165 #endif
166 };
167
168 static PassOwnPtr<MediaPlayerPrivateInterface> createNullMediaPlayer(MediaPlayer* player) 
169
170     return adoptPtr(new NullMediaPlayerPrivate(player)); 
171 }
172
173
174 // engine support
175
176 struct MediaPlayerFactory {
177     WTF_MAKE_NONCOPYABLE(MediaPlayerFactory); WTF_MAKE_FAST_ALLOCATED;
178 public:
179     MediaPlayerFactory(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsTypeAndCodecs,
180         MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite)
181         : constructor(constructor)
182         , getSupportedTypes(getSupportedTypes)
183         , supportsTypeAndCodecs(supportsTypeAndCodecs)
184         , getSitesInMediaCache(getSitesInMediaCache)
185         , clearMediaCache(clearMediaCache)
186         , clearMediaCacheForSite(clearMediaCacheForSite)
187     {
188     }
189
190     CreateMediaEnginePlayer constructor;
191     MediaEngineSupportedTypes getSupportedTypes;
192     MediaEngineSupportsType supportsTypeAndCodecs;
193     MediaEngineGetSitesInMediaCache getSitesInMediaCache;
194     MediaEngineClearMediaCache clearMediaCache;
195     MediaEngineClearMediaCacheForSite clearMediaCacheForSite;
196 };
197
198 static void addMediaEngine(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite);
199
200 static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, const String& keySystem, const KURL&, MediaPlayerFactory* current = 0);
201 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current);
202
203 enum RequeryEngineOptions { DoNotResetEngines, ResetEngines };
204 static Vector<MediaPlayerFactory*>& installedMediaEngines(RequeryEngineOptions requeryFlags = DoNotResetEngines )
205 {
206     DEFINE_STATIC_LOCAL(Vector<MediaPlayerFactory*>, installedEngines, ());
207     static bool enginesQueried = false;
208
209     if (requeryFlags == ResetEngines) {
210         installedEngines.clear();
211         enginesQueried = false;
212         return installedEngines;
213     }
214
215     if (!enginesQueried) {
216         enginesQueried = true;
217
218 #if USE(AVFOUNDATION)
219         if (Settings::isAVFoundationEnabled()) {
220 #if PLATFORM(MAC)
221             MediaPlayerPrivateAVFoundationObjC::registerMediaEngine(addMediaEngine);
222 #elif PLATFORM(WIN)
223             MediaPlayerPrivateAVFoundationCF::registerMediaEngine(addMediaEngine);
224 #endif
225         }
226 #endif
227
228 #if PLATFORM(MAC) || (PLATFORM(QT) && USE(QTKIT))
229         if (Settings::isQTKitEnabled())
230             MediaPlayerPrivateQTKit::registerMediaEngine(addMediaEngine);
231 #endif
232
233 #if defined(PlatformMediaEngineClassName)
234         PlatformMediaEngineClassName::registerMediaEngine(addMediaEngine);
235 #endif
236     }
237
238     return installedEngines;
239 }
240
241 static void addMediaEngine(CreateMediaEnginePlayer constructor, MediaEngineSupportedTypes getSupportedTypes, MediaEngineSupportsType supportsType,
242     MediaEngineGetSitesInMediaCache getSitesInMediaCache, MediaEngineClearMediaCache clearMediaCache, MediaEngineClearMediaCacheForSite clearMediaCacheForSite)
243 {
244     ASSERT(constructor);
245     ASSERT(getSupportedTypes);
246     ASSERT(supportsType);
247
248     installedMediaEngines().append(new MediaPlayerFactory(constructor, getSupportedTypes, supportsType, getSitesInMediaCache, clearMediaCache, clearMediaCacheForSite));
249 }
250
251 static const AtomicString& applicationOctetStream()
252 {
253     DEFINE_STATIC_LOCAL(const AtomicString, applicationOctetStream, ("application/octet-stream", AtomicString::ConstructFromLiteral));
254     return applicationOctetStream;
255 }
256
257 static const AtomicString& textPlain()
258 {
259     DEFINE_STATIC_LOCAL(const AtomicString, textPlain, ("text/plain", AtomicString::ConstructFromLiteral));
260     return textPlain;
261 }
262
263 static const AtomicString& codecs()
264 {
265     DEFINE_STATIC_LOCAL(const AtomicString, codecs, ("codecs", AtomicString::ConstructFromLiteral));
266     return codecs;
267 }
268
269 static MediaPlayerFactory* bestMediaEngineForTypeAndCodecs(const String& type, const String& codecs, const String& keySystem, const KURL& url, MediaPlayerFactory* current)
270 {
271     if (type.isEmpty())
272         return 0;
273
274     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
275     if (engines.isEmpty())
276         return 0;
277
278     // 4.8.10.3 MIME types - In the absence of a specification to the contrary, the MIME type "application/octet-stream" 
279     // when used with parameters, e.g. "application/octet-stream;codecs=theora", is a type that the user agent knows 
280     // it cannot render.
281     if (type == applicationOctetStream()) {
282         if (!codecs.isEmpty())
283             return 0;
284     }
285
286     MediaPlayerFactory* engine = 0;
287     MediaPlayer::SupportsType supported = MediaPlayer::IsNotSupported;
288     unsigned count = engines.size();
289     for (unsigned ndx = 0; ndx < count; ndx++) {
290         if (current) {
291             if (current == engines[ndx])
292                 current = 0;
293             continue;
294         }
295 #if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
296         MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(type, codecs, keySystem, url);
297 #else
298         UNUSED_PARAM(keySystem);
299         ASSERT(keySystem.isEmpty());
300         MediaPlayer::SupportsType engineSupport = engines[ndx]->supportsTypeAndCodecs(type, codecs, url);
301 #endif
302         if (engineSupport > supported) {
303             supported = engineSupport;
304             engine = engines[ndx];
305         }
306     }
307
308     return engine;
309 }
310
311 static MediaPlayerFactory* nextMediaEngine(MediaPlayerFactory* current)
312 {
313     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
314     if (engines.isEmpty())
315         return 0;
316
317     if (!current) 
318         return engines.first();
319
320     size_t currentIndex = engines.find(current);
321     if (currentIndex == WTF::notFound || currentIndex + 1 >= engines.size()) 
322         return 0;
323
324     return engines[currentIndex + 1];
325 }
326
327 // media player
328
329 MediaPlayer::MediaPlayer(MediaPlayerClient* client)
330     : m_mediaPlayerClient(client)
331     , m_reloadTimer(this, &MediaPlayer::reloadTimerFired)
332     , m_private(createNullMediaPlayer(this))
333     , m_currentMediaEngine(0)
334     , m_frameView(0)
335     , m_preload(Auto)
336     , m_visible(false)
337     , m_rate(1.0f)
338     , m_volume(1.0f)
339     , m_muted(false)
340     , m_preservesPitch(true)
341     , m_privateBrowsing(false)
342     , m_shouldPrepareToRender(false)
343     , m_contentMIMETypeWasInferredFromExtension(false)
344 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
345     , m_playerProxy(0)
346 #endif
347 {
348 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
349     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
350     if (!engines.isEmpty()) {
351         m_currentMediaEngine = engines[0];
352         m_private = engines[0]->constructor(this);
353         if (m_mediaPlayerClient)
354             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
355     }
356 #endif
357 }
358
359 MediaPlayer::~MediaPlayer()
360 {
361     m_mediaPlayerClient = 0;
362 }
363
364 bool MediaPlayer::load(const KURL& url, const ContentType& contentType, const String& keySystem)
365 {
366     m_contentMIMEType = contentType.type().lower();
367     m_contentTypeCodecs = contentType.parameter(codecs());
368     m_url = url;
369     m_keySystem = keySystem.lower();
370     m_contentMIMETypeWasInferredFromExtension = false;
371
372 #if ENABLE(MEDIA_SOURCE)
373     m_mediaSource = 0;
374 #endif
375
376     // If the MIME type is missing or is not meaningful, try to figure it out from the URL.
377     if (m_contentMIMEType.isEmpty() || m_contentMIMEType == applicationOctetStream() || m_contentMIMEType == textPlain()) {
378         if (m_url.protocolIsData())
379             m_contentMIMEType = mimeTypeFromDataURL(m_url.string());
380         else {
381             String lastPathComponent = url.lastPathComponent();
382             size_t pos = lastPathComponent.reverseFind('.');
383             if (pos != notFound) {
384                 String extension = lastPathComponent.substring(pos + 1);
385                 String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
386                 if (!mediaType.isEmpty()) {
387                     m_contentMIMEType = mediaType;
388                     m_contentMIMETypeWasInferredFromExtension = true;
389                 }
390             }
391         }
392     }
393
394     loadWithNextMediaEngine(0);
395     return m_currentMediaEngine;
396 }
397
398 #if ENABLE(MEDIA_SOURCE)
399 bool MediaPlayer::load(const KURL& url, PassRefPtr<MediaSource> mediaSource)
400 {
401     m_mediaSource = mediaSource;
402     m_contentMIMEType = "";
403     m_contentTypeCodecs = "";
404     m_url = url;
405     m_keySystem = "";
406     m_contentMIMETypeWasInferredFromExtension = false;
407     loadWithNextMediaEngine(0);
408     return m_currentMediaEngine;
409 }
410 #endif
411
412 void MediaPlayer::loadWithNextMediaEngine(MediaPlayerFactory* current)
413 {
414     MediaPlayerFactory* engine = 0;
415
416     if (!m_contentMIMEType.isEmpty())
417         engine = bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, m_keySystem, m_url, current);
418
419     // If no MIME type is specified or the type was inferred from the file extension, just use the next engine.
420     if (!engine && (m_contentMIMEType.isEmpty() || m_contentMIMETypeWasInferredFromExtension))
421         engine = nextMediaEngine(current);
422
423     // Don't delete and recreate the player unless it comes from a different engine.
424     if (!engine) {
425         LOG(Media, "MediaPlayer::loadWithNextMediaEngine - no media engine found for type \"%s\"", m_contentMIMEType.utf8().data());
426         m_currentMediaEngine = engine;
427         m_private = nullptr;
428     } else if (m_currentMediaEngine != engine) {
429         m_currentMediaEngine = engine;
430         m_private = engine->constructor(this);
431         if (m_mediaPlayerClient)
432             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
433 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
434         m_private->setMediaPlayerProxy(m_playerProxy);
435 #endif
436         m_private->setPrivateBrowsingMode(m_privateBrowsing);
437         m_private->setPreload(m_preload);
438         m_private->setPreservesPitch(preservesPitch());
439         if (m_shouldPrepareToRender)
440             m_private->prepareForRendering();
441     }
442
443     if (m_private) {
444 #if ENABLE(MEDIA_SOURCE)
445         if (m_mediaSource)
446             m_private->load(m_url.string(), m_mediaSource);
447         else
448 #endif
449         m_private->load(m_url.string());
450     } else {
451         m_private = createNullMediaPlayer(this);
452         if (m_mediaPlayerClient) {
453             m_mediaPlayerClient->mediaPlayerEngineUpdated(this);
454             m_mediaPlayerClient->mediaPlayerResourceNotSupported(this);
455         }
456     }
457 }
458
459 bool MediaPlayer::hasAvailableVideoFrame() const
460 {
461     return m_private->hasAvailableVideoFrame();
462 }
463
464 void MediaPlayer::prepareForRendering()
465 {
466     m_shouldPrepareToRender = true;
467     m_private->prepareForRendering();
468 }
469
470 bool MediaPlayer::canLoadPoster() const
471 {
472     return m_private->canLoadPoster();
473 }
474
475 void MediaPlayer::setPoster(const String& url)
476 {
477     m_private->setPoster(url);
478 }    
479
480 void MediaPlayer::cancelLoad()
481 {
482     m_private->cancelLoad();
483 }    
484
485 void MediaPlayer::prepareToPlay()
486 {
487     m_private->prepareToPlay();
488 }
489
490 void MediaPlayer::play()
491 {
492     m_private->play();
493 }
494
495 void MediaPlayer::pause()
496 {
497     m_private->pause();
498 }
499
500 #if ENABLE(ENCRYPTED_MEDIA)
501 MediaPlayer::MediaKeyException MediaPlayer::generateKeyRequest(const String& keySystem, const unsigned char* initData, unsigned initDataLength)
502 {
503     return m_private->generateKeyRequest(keySystem.lower(), initData, initDataLength);
504 }
505
506 MediaPlayer::MediaKeyException MediaPlayer::addKey(const String& keySystem, const unsigned char* key, unsigned keyLength, const unsigned char* initData, unsigned initDataLength, const String& sessionId)
507 {
508     return m_private->addKey(keySystem.lower(), key, keyLength, initData, initDataLength, sessionId);
509 }
510
511 MediaPlayer::MediaKeyException MediaPlayer::cancelKeyRequest(const String& keySystem, const String& sessionId)
512 {
513     return m_private->cancelKeyRequest(keySystem.lower(), sessionId);
514 }
515 #endif
516
517 float MediaPlayer::duration() const
518 {
519     return m_private->duration();
520 }
521
522 float MediaPlayer::startTime() const
523 {
524     return m_private->startTime();
525 }
526
527 double MediaPlayer::initialTime() const
528 {
529     return m_private->initialTime();
530 }
531
532 float MediaPlayer::currentTime() const
533 {
534     return m_private->currentTime();
535 }
536
537 void MediaPlayer::seek(float time)
538 {
539     m_private->seek(time);
540 }
541
542 bool MediaPlayer::paused() const
543 {
544     return m_private->paused();
545 }
546
547 bool MediaPlayer::seeking() const
548 {
549     return m_private->seeking();
550 }
551
552 bool MediaPlayer::supportsFullscreen() const
553 {
554     return m_private->supportsFullscreen();
555 }
556
557 bool MediaPlayer::supportsSave() const
558 {
559     return m_private->supportsSave();
560 }
561
562 bool MediaPlayer::supportsScanning() const
563 {
564     return m_private->supportsScanning();
565 }
566
567 IntSize MediaPlayer::naturalSize()
568 {
569     return m_private->naturalSize();
570 }
571
572 bool MediaPlayer::hasVideo() const
573 {
574     return m_private->hasVideo();
575 }
576
577 bool MediaPlayer::hasAudio() const
578 {
579     return m_private->hasAudio();
580 }
581
582 bool MediaPlayer::inMediaDocument()
583 {
584     Frame* frame = m_frameView ? m_frameView->frame() : 0;
585     Document* document = frame ? frame->document() : 0;
586
587     return document && document->isMediaDocument();
588 }
589
590 PlatformMedia MediaPlayer::platformMedia() const
591 {
592     return m_private->platformMedia();
593 }
594
595 #if USE(ACCELERATED_COMPOSITING)
596 PlatformLayer* MediaPlayer::platformLayer() const
597 {
598     return m_private->platformLayer();
599 }
600 #endif
601
602 MediaPlayer::NetworkState MediaPlayer::networkState()
603 {
604     return m_private->networkState();
605 }
606
607 MediaPlayer::ReadyState MediaPlayer::readyState()
608 {
609     return m_private->readyState();
610 }
611
612 float MediaPlayer::volume() const
613 {
614     return m_volume;
615 }
616
617 void MediaPlayer::setVolume(float volume)
618 {
619     m_volume = volume;
620
621     if (m_private->supportsMuting() || !m_muted)
622         m_private->setVolume(volume);
623 }
624
625 bool MediaPlayer::muted() const
626 {
627     return m_muted;
628 }
629
630 void MediaPlayer::setMuted(bool muted)
631 {
632     m_muted = muted;
633
634     if (m_private->supportsMuting())
635         m_private->setMuted(muted);
636     else
637         m_private->setVolume(muted ? 0 : m_volume);
638 }
639
640 bool MediaPlayer::hasClosedCaptions() const
641 {
642     return m_private->hasClosedCaptions();
643 }
644
645 void MediaPlayer::setClosedCaptionsVisible(bool closedCaptionsVisible)
646 {
647     m_private->setClosedCaptionsVisible(closedCaptionsVisible);
648 }
649
650 float MediaPlayer::rate() const
651 {
652     return m_rate;
653 }
654
655 void MediaPlayer::setRate(float rate)
656 {
657     m_rate = rate;
658     m_private->setRate(rate);   
659 }
660
661 bool MediaPlayer::preservesPitch() const
662 {
663     return m_preservesPitch;
664 }
665
666 void MediaPlayer::setPreservesPitch(bool preservesPitch)
667 {
668     m_preservesPitch = preservesPitch;
669     m_private->setPreservesPitch(preservesPitch);
670 }
671
672 PassRefPtr<TimeRanges> MediaPlayer::buffered()
673 {
674     return m_private->buffered();
675 }
676
677 PassRefPtr<TimeRanges> MediaPlayer::seekable()
678 {
679     return m_private->seekable();
680 }
681
682 float MediaPlayer::maxTimeSeekable()
683 {
684     return m_private->maxTimeSeekable();
685 }
686
687 bool MediaPlayer::didLoadingProgress()
688 {
689     return m_private->didLoadingProgress();
690 }
691
692 void MediaPlayer::setSize(const IntSize& size)
693
694     m_size = size;
695     m_private->setSize(size);
696 }
697
698 bool MediaPlayer::visible() const
699 {
700     return m_visible;
701 }
702
703 void MediaPlayer::setVisible(bool b)
704 {
705     m_visible = b;
706     m_private->setVisible(b);
707 }
708
709 MediaPlayer::Preload MediaPlayer::preload() const
710 {
711     return m_preload;
712 }
713
714 void MediaPlayer::setPreload(MediaPlayer::Preload preload)
715 {
716     m_preload = preload;
717     m_private->setPreload(preload);
718 }
719
720 void MediaPlayer::paint(GraphicsContext* p, const IntRect& r)
721 {
722     m_private->paint(p, r);
723 }
724
725 void MediaPlayer::paintCurrentFrameInContext(GraphicsContext* p, const IntRect& r)
726 {
727     m_private->paintCurrentFrameInContext(p, r);
728 }
729
730 bool MediaPlayer::copyVideoTextureToPlatformTexture(GraphicsContext3D* context, Platform3DObject texture, GC3Dint level, GC3Denum type, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY)
731 {
732     return m_private->copyVideoTextureToPlatformTexture(context, texture, level, type, internalFormat, premultiplyAlpha, flipY);
733 }
734
735 MediaPlayer::SupportsType MediaPlayer::supportsType(const ContentType& contentType, const String& keySystem, const KURL& url, const MediaPlayerSupportsTypeClient* client)
736 {
737     String type = contentType.type().lower();
738     // The codecs string is not lower-cased because MP4 values are case sensitive
739     // per http://tools.ietf.org/html/rfc4281#page-7.
740     String typeCodecs = contentType.parameter(codecs());
741     String system = keySystem.lower();
742
743     // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the 
744     // user agent knows it cannot render or is the type "application/octet-stream"
745     if (type == applicationOctetStream())
746         return IsNotSupported;
747
748     MediaPlayerFactory* engine = bestMediaEngineForTypeAndCodecs(type, typeCodecs, system, url);
749     if (!engine)
750         return IsNotSupported;
751
752 #if PLATFORM(MAC)
753     // YouTube will ask if the HTMLMediaElement canPlayType video/webm, then
754     // video/x-flv, then finally video/mp4, and will then load a URL of the first type
755     // in that list which returns "probably". When Perian is installed,
756     // MediaPlayerPrivateQTKit claims to support both video/webm and video/x-flv, but
757     // due to a bug in Perian, loading media in these formats will sometimes fail on
758     // slow connections. <https://bugs.webkit.org/show_bug.cgi?id=86409>
759     if (client && client->mediaPlayerNeedsSiteSpecificHacks()) {
760         String host = client->mediaPlayerDocumentHost();
761         if ((host.endsWith(".youtube.com", false) || equalIgnoringCase("youtube.com", host))
762             && (contentType.type().startsWith("video/webm", false) || contentType.type().startsWith("video/x-flv", false)))
763             return IsNotSupported;
764     }
765 #else
766     UNUSED_PARAM(client);
767 #endif
768
769 #if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
770     return engine->supportsTypeAndCodecs(type, typeCodecs, system, url);
771 #else
772     ASSERT(system.isEmpty());
773     return engine->supportsTypeAndCodecs(type, typeCodecs, url);
774 #endif
775 }
776
777 void MediaPlayer::getSupportedTypes(HashSet<String>& types)
778 {
779     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
780     if (engines.isEmpty())
781         return;
782
783     unsigned count = engines.size();
784     for (unsigned ndx = 0; ndx < count; ndx++)
785         engines[ndx]->getSupportedTypes(types);
786
787
788 bool MediaPlayer::isAvailable()
789 {
790     return !installedMediaEngines().isEmpty();
791
792
793 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
794 void MediaPlayer::deliverNotification(MediaPlayerProxyNotificationType notification)
795 {
796     m_private->deliverNotification(notification);
797 }
798
799 void MediaPlayer::setMediaPlayerProxy(WebMediaPlayerProxy* proxy)
800 {
801     m_playerProxy = proxy;
802     m_private->setMediaPlayerProxy(proxy);
803 }
804
805 void MediaPlayer::setControls(bool controls)
806 {
807     m_private->setControls(controls);
808 }
809 #endif
810
811 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO) || USE(NATIVE_FULLSCREEN_VIDEO)
812 void MediaPlayer::enterFullscreen()
813 {
814     m_private->enterFullscreen();
815 }
816
817 void MediaPlayer::exitFullscreen()
818 {
819     m_private->exitFullscreen();
820 }
821 #endif
822
823 #if USE(NATIVE_FULLSCREEN_VIDEO)
824 bool MediaPlayer::canEnterFullscreen() const
825 {
826     return m_private->canEnterFullscreen();
827 }
828 #endif
829
830 #if USE(ACCELERATED_COMPOSITING)
831 void MediaPlayer::acceleratedRenderingStateChanged()
832 {
833     m_private->acceleratedRenderingStateChanged();
834 }
835
836 bool MediaPlayer::supportsAcceleratedRendering() const
837 {
838     return m_private->supportsAcceleratedRendering();
839 }
840 #endif // USE(ACCELERATED_COMPOSITING)
841
842 bool MediaPlayer::hasSingleSecurityOrigin() const
843 {
844     return m_private->hasSingleSecurityOrigin();
845 }
846
847 bool MediaPlayer::didPassCORSAccessCheck() const
848 {
849     return m_private->didPassCORSAccessCheck();
850 }
851
852 MediaPlayer::MovieLoadType MediaPlayer::movieLoadType() const
853 {
854     return m_private->movieLoadType();
855 }
856
857 float MediaPlayer::mediaTimeForTimeValue(float timeValue) const
858 {
859     return m_private->mediaTimeForTimeValue(timeValue);
860 }
861
862 double MediaPlayer::maximumDurationToCacheMediaTime() const
863 {
864     return m_private->maximumDurationToCacheMediaTime();
865 }
866
867 unsigned MediaPlayer::decodedFrameCount() const
868 {
869     return m_private->decodedFrameCount();
870 }
871
872 unsigned MediaPlayer::droppedFrameCount() const
873 {
874     return m_private->droppedFrameCount();
875 }
876
877 unsigned MediaPlayer::audioDecodedByteCount() const
878 {
879     return m_private->audioDecodedByteCount();
880 }
881
882 unsigned MediaPlayer::videoDecodedByteCount() const
883 {
884     return m_private->videoDecodedByteCount();
885 }
886
887 void MediaPlayer::reloadTimerFired(Timer<MediaPlayer>*)
888 {
889     m_private->cancelLoad();
890     loadWithNextMediaEngine(m_currentMediaEngine);
891 }
892
893 void MediaPlayer::getSitesInMediaCache(Vector<String>& sites)
894 {
895     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
896     unsigned size = engines.size();
897     for (unsigned i = 0; i < size; i++) {
898         if (!engines[i]->getSitesInMediaCache)
899             continue;
900         Vector<String> engineSites;
901         engines[i]->getSitesInMediaCache(engineSites);
902         sites.append(engineSites);
903     }
904 }
905
906 void MediaPlayer::clearMediaCache()
907 {
908     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
909     unsigned size = engines.size();
910     for (unsigned i = 0; i < size; i++) {
911         if (engines[i]->clearMediaCache)
912             engines[i]->clearMediaCache();
913     }
914 }
915
916 void MediaPlayer::clearMediaCacheForSite(const String& site)
917 {
918     Vector<MediaPlayerFactory*>& engines = installedMediaEngines();
919     unsigned size = engines.size();
920     for (unsigned i = 0; i < size; i++) {
921         if (engines[i]->clearMediaCacheForSite)
922             engines[i]->clearMediaCacheForSite(site);
923     }
924 }
925
926 void MediaPlayer::setPrivateBrowsingMode(bool privateBrowsingMode)
927 {
928     m_privateBrowsing = privateBrowsingMode;
929     m_private->setPrivateBrowsingMode(m_privateBrowsing);
930 }
931
932 // Client callbacks.
933 void MediaPlayer::networkStateChanged()
934 {
935     // If more than one media engine is installed and this one failed before finding metadata,
936     // let the next engine try.
937     if (m_private->networkState() >= FormatError
938         && m_private->readyState() < HaveMetadata
939         && installedMediaEngines().size() > 1) {
940         if (m_contentMIMEType.isEmpty() || bestMediaEngineForTypeAndCodecs(m_contentMIMEType, m_contentTypeCodecs, m_keySystem, m_url, m_currentMediaEngine)) {
941             m_reloadTimer.startOneShot(0);
942             return;
943         }
944     }
945     if (m_mediaPlayerClient)
946         m_mediaPlayerClient->mediaPlayerNetworkStateChanged(this);
947 }
948
949 void MediaPlayer::readyStateChanged()
950 {
951     if (m_mediaPlayerClient)
952         m_mediaPlayerClient->mediaPlayerReadyStateChanged(this);
953 }
954
955 void MediaPlayer::volumeChanged(float newVolume)
956 {
957     m_volume = newVolume;
958     if (m_mediaPlayerClient)
959         m_mediaPlayerClient->mediaPlayerVolumeChanged(this);
960 }
961
962 void MediaPlayer::muteChanged(bool newMuted)
963 {
964     m_muted = newMuted;
965     if (m_mediaPlayerClient)
966         m_mediaPlayerClient->mediaPlayerMuteChanged(this);
967 }
968
969 void MediaPlayer::timeChanged()
970 {
971     if (m_mediaPlayerClient)
972         m_mediaPlayerClient->mediaPlayerTimeChanged(this);
973 }
974
975 void MediaPlayer::sizeChanged()
976 {
977     if (m_mediaPlayerClient)
978         m_mediaPlayerClient->mediaPlayerSizeChanged(this);
979 }
980
981 void MediaPlayer::repaint()
982 {
983     if (m_mediaPlayerClient)
984         m_mediaPlayerClient->mediaPlayerRepaint(this);
985 }
986
987 void MediaPlayer::durationChanged()
988 {
989     if (m_mediaPlayerClient)
990         m_mediaPlayerClient->mediaPlayerDurationChanged(this);
991 }
992
993 void MediaPlayer::rateChanged()
994 {
995     if (m_mediaPlayerClient)
996         m_mediaPlayerClient->mediaPlayerRateChanged(this);
997 }
998
999 void MediaPlayer::playbackStateChanged()
1000 {
1001     if (m_mediaPlayerClient)
1002         m_mediaPlayerClient->mediaPlayerPlaybackStateChanged(this);
1003 }
1004
1005 void MediaPlayer::firstVideoFrameAvailable()
1006 {
1007     if (m_mediaPlayerClient)
1008         m_mediaPlayerClient->mediaPlayerFirstVideoFrameAvailable(this);
1009 }
1010
1011 void MediaPlayer::characteristicChanged()
1012 {
1013     if (m_mediaPlayerClient)
1014         m_mediaPlayerClient->mediaPlayerCharacteristicChanged(this);
1015 }
1016
1017 #if ENABLE(WEB_AUDIO)
1018 AudioSourceProvider* MediaPlayer::audioSourceProvider()
1019 {
1020     return m_private->audioSourceProvider();
1021 }
1022 #endif // WEB_AUDIO
1023
1024 #if ENABLE(ENCRYPTED_MEDIA)
1025 void MediaPlayer::keyAdded(const String& keySystem, const String& sessionId)
1026 {
1027     if (m_mediaPlayerClient)
1028         m_mediaPlayerClient->mediaPlayerKeyAdded(this, keySystem, sessionId);
1029 }
1030
1031 void MediaPlayer::keyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode errorCode, unsigned short systemCode)
1032 {
1033     if (m_mediaPlayerClient)
1034         m_mediaPlayerClient->mediaPlayerKeyError(this, keySystem, sessionId, errorCode, systemCode);
1035 }
1036
1037 void MediaPlayer::keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const KURL& defaultURL)
1038 {
1039     if (m_mediaPlayerClient)
1040         m_mediaPlayerClient->mediaPlayerKeyMessage(this, keySystem, sessionId, message, messageLength, defaultURL);
1041 }
1042
1043 bool MediaPlayer::keyNeeded(const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength)
1044 {
1045     if (m_mediaPlayerClient)
1046         return m_mediaPlayerClient->mediaPlayerKeyNeeded(this, keySystem, sessionId, initData, initDataLength);
1047     return false;
1048 }
1049 #endif
1050
1051 #if ENABLE(ENCRYPTED_MEDIA_V2)
1052 bool MediaPlayer::keyNeeded(Uint8Array* initData)
1053 {
1054     if (m_mediaPlayerClient)
1055         return m_mediaPlayerClient->mediaPlayerKeyNeeded(this, initData);
1056     return false;
1057 }
1058 #endif
1059
1060 String MediaPlayer::referrer() const
1061 {
1062     if (!m_mediaPlayerClient)
1063         return String();
1064
1065     return m_mediaPlayerClient->mediaPlayerReferrer();
1066 }
1067
1068 String MediaPlayer::userAgent() const
1069 {
1070     if (!m_mediaPlayerClient)
1071         return String();
1072     
1073     return m_mediaPlayerClient->mediaPlayerUserAgent();
1074 }
1075
1076 String MediaPlayer::engineDescription() const
1077 {
1078     if (!m_private)
1079         return String();
1080
1081     return m_private->engineDescription();
1082 }
1083
1084 #if PLATFORM(WIN) && USE(AVFOUNDATION)
1085 GraphicsDeviceAdapter* MediaPlayer::graphicsDeviceAdapter() const
1086 {
1087     if (!m_mediaPlayerClient)
1088         return 0;
1089     
1090     return m_mediaPlayerClient->mediaPlayerGraphicsDeviceAdapter(this);
1091 }
1092 #endif
1093
1094 CachedResourceLoader* MediaPlayer::cachedResourceLoader()
1095 {
1096     if (!m_mediaPlayerClient)
1097         return 0;
1098
1099     return m_mediaPlayerClient->mediaPlayerCachedResourceLoader();
1100 }
1101
1102 #if ENABLE(VIDEO_TRACK)
1103 void MediaPlayer::addTextTrack(PassRefPtr<InbandTextTrackPrivate> track)
1104 {
1105     if (!m_mediaPlayerClient)
1106         return;
1107
1108     m_mediaPlayerClient->mediaPlayerDidAddTrack(track);
1109 }
1110
1111 void MediaPlayer::removeTextTrack(PassRefPtr<InbandTextTrackPrivate> track)
1112 {
1113     if (!m_mediaPlayerClient)
1114         return;
1115
1116     m_mediaPlayerClient->mediaPlayerDidRemoveTrack(track);
1117 }
1118
1119 bool MediaPlayer::requiresTextTrackRepresentation() const
1120 {
1121     return m_private->requiresTextTrackRepresentation();
1122 }
1123
1124 void MediaPlayer::setTextTrackRepresentation(TextTrackRepresentation* representation)
1125 {
1126     m_private->setTextTrackRepresentation(representation);
1127 }
1128 #endif // ENABLE(VIDEO_TRACK)
1129
1130 #if USE(PLATFORM_TEXT_TRACK_MENU)
1131 bool MediaPlayer::implementsTextTrackControls() const
1132 {
1133     return m_private->implementsTextTrackControls();
1134 }
1135
1136 PassRefPtr<PlatformTextTrackMenuInterface> MediaPlayer::textTrackMenu()
1137 {
1138     return m_private->textTrackMenu();
1139 }
1140 #endif // USE(PLATFORM_TEXT_TRACK_MENU)
1141
1142 void MediaPlayer::resetMediaEngines()
1143 {
1144     installedMediaEngines(ResetEngines);
1145 }
1146
1147 #if USE(GSTREAMER)
1148 void MediaPlayer::simulateAudioInterruption()
1149 {
1150     if (!m_private)
1151         return;
1152
1153     m_private->simulateAudioInterruption();
1154 }
1155 #endif
1156
1157 String MediaPlayer::languageOfPrimaryAudioTrack() const
1158 {
1159     if (!m_private)
1160         return emptyString();
1161     
1162     return m_private->languageOfPrimaryAudioTrack();
1163 }
1164 }
1165
1166 #endif