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