77619db3a9fc1c003eb37270090e6094b0e05f9b
[WebKit-https.git] / Source / WebCore / platform / graphics / MediaPlayer.h
1 /*
2  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012 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 #ifndef MediaPlayer_h
27 #define MediaPlayer_h
28
29 #if ENABLE(VIDEO)
30
31 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
32 #include "MediaPlayerProxy.h"
33 #endif
34
35 #include "InbandTextTrackPrivate.h"
36 #include "IntRect.h"
37 #include "KURL.h"
38 #include "LayoutRect.h"
39 #include "Timer.h"
40 #include <wtf/Forward.h>
41 #include <wtf/HashSet.h>
42 #include <wtf/OwnPtr.h>
43 #include <wtf/Noncopyable.h>
44 #include <wtf/PassOwnPtr.h>
45 #include <wtf/text/StringHash.h>
46
47 #if USE(ACCELERATED_COMPOSITING)
48 #include "PlatformLayer.h"
49 #endif
50
51 OBJC_CLASS AVPlayer;
52 OBJC_CLASS QTMovie;
53
54 class AVCFPlayer;
55 class QTMovieGWorld;
56 class QTMovieVisualContext;
57
58 namespace WebCore {
59
60 class AudioSourceProvider;
61 class Document;
62 class GStreamerGWorld;
63 class MediaPlayerPrivateInterface;
64 class MediaSource;
65
66 // Structure that will hold every native
67 // types supported by the current media player.
68 // We have to do that has multiple media players
69 // backend can live at runtime.
70 struct PlatformMedia {
71     enum {
72         None,
73         QTMovieType,
74         QTMovieGWorldType,
75         QTMovieVisualContextType,
76         GStreamerGWorldType,
77         ChromiumMediaPlayerType,
78         QtMediaPlayerType,
79         AVFoundationMediaPlayerType,
80         AVFoundationCFMediaPlayerType
81     } type;
82
83     union {
84         QTMovie* qtMovie;
85         QTMovieGWorld* qtMovieGWorld;
86         QTMovieVisualContext* qtMovieVisualContext;
87         GStreamerGWorld* gstreamerGWorld;
88         MediaPlayerPrivateInterface* chromiumMediaPlayer;
89         MediaPlayerPrivateInterface* qtMediaPlayer;
90         AVPlayer* avfMediaPlayer;
91         AVCFPlayer* avcfMediaPlayer;
92     } media;
93 };
94
95 extern const PlatformMedia NoPlatformMedia;
96
97 class CachedResourceLoader;
98 class ContentType;
99 class FrameView;
100 class GraphicsContext;
101 class IntRect;
102 class IntSize;
103 class MediaPlayer;
104 struct MediaPlayerFactory;
105 class TimeRanges;
106 class HostWindow;
107
108 #if PLATFORM(WIN) && USE(AVFOUNDATION)
109 struct GraphicsDeviceAdapter;
110 #endif
111
112 class MediaPlayerClient {
113 public:
114     enum CORSMode { Unspecified, Anonymous, UseCredentials };
115
116     virtual ~MediaPlayerClient() { }
117
118     // Get the document which the media player is owned by
119     virtual Document* mediaPlayerOwningDocument() { return 0; }
120
121     // the network state has changed
122     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*) { }
123
124     // the ready state has changed
125     virtual void mediaPlayerReadyStateChanged(MediaPlayer*) { }
126
127     // the volume state has changed
128     virtual void mediaPlayerVolumeChanged(MediaPlayer*) { }
129
130     // the mute state has changed
131     virtual void mediaPlayerMuteChanged(MediaPlayer*) { }
132
133     // time has jumped, eg. not as a result of normal playback
134     virtual void mediaPlayerTimeChanged(MediaPlayer*) { }
135
136     // the media file duration has changed, or is now known
137     virtual void mediaPlayerDurationChanged(MediaPlayer*) { }
138
139     // the playback rate has changed
140     virtual void mediaPlayerRateChanged(MediaPlayer*) { }
141
142     // the play/pause status changed
143     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*) { }
144
145     // The MediaPlayer has found potentially problematic media content.
146     // This is used internally to trigger swapping from a <video>
147     // element to an <embed> in standalone documents
148     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*) { }
149
150     // The MediaPlayer could not discover an engine which supports the requested resource.
151     virtual void mediaPlayerResourceNotSupported(MediaPlayer*) { }
152
153 // Presentation-related methods
154     // a new frame of video is available
155     virtual void mediaPlayerRepaint(MediaPlayer*) { }
156
157     // the movie size has changed
158     virtual void mediaPlayerSizeChanged(MediaPlayer*) { }
159
160     virtual void mediaPlayerEngineUpdated(MediaPlayer*) { }
161
162     // The first frame of video is available to render. A media engine need only make this callback if the
163     // first frame is not available immediately when prepareForRendering is called.
164     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) { }
165
166     // A characteristic of the media file, eg. video, audio, closed captions, etc, has changed.
167     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) { }
168     
169 #if USE(ACCELERATED_COMPOSITING)
170     // whether the rendering system can accelerate the display of this MediaPlayer.
171     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) { return false; }
172
173     // called when the media player's rendering mode changed, which indicates a change in the
174     // availability of the platformLayer().
175     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) { }
176 #endif
177
178 #if PLATFORM(WIN) && USE(AVFOUNDATION)
179     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const { return 0; }
180 #endif
181
182 #if ENABLE(MEDIA_SOURCE)
183     virtual void mediaPlayerSourceOpened() { }
184     virtual String mediaPlayerSourceURL() const { return "x-media-source-unsupported:"; }
185 #endif
186
187 #if ENABLE(ENCRYPTED_MEDIA)
188     enum MediaKeyErrorCode { UnknownError = 1, ClientError, ServiceError, OutputError, HardwareChangeError, DomainError };
189     virtual void mediaPlayerKeyAdded(MediaPlayer*, const String&, const String&) { }
190     virtual void mediaPlayerKeyError(MediaPlayer*, const String&, const String&, MediaKeyErrorCode, unsigned short) { }
191     virtual void mediaPlayerKeyMessage(MediaPlayer*, const String&, const String&, const unsigned char*, unsigned) { }
192     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String&, const String&, const unsigned char*, unsigned) { return false; }
193 #endif
194
195     virtual String mediaPlayerReferrer() const { return String(); }
196     virtual String mediaPlayerUserAgent() const { return String(); }
197     virtual CORSMode mediaPlayerCORSMode() const { return Unspecified; }
198     virtual void mediaPlayerEnterFullscreen() { }
199     virtual void mediaPlayerExitFullscreen() { }
200     virtual bool mediaPlayerIsFullscreen() const { return false; }
201     virtual bool mediaPlayerIsFullscreenPermitted() const { return false; }
202     virtual bool mediaPlayerIsVideo() const { return false; }
203     virtual LayoutRect mediaPlayerContentBoxRect() const { return LayoutRect(); }
204     virtual void mediaPlayerSetSize(const IntSize&) { }
205     virtual void mediaPlayerPause() { }
206     virtual void mediaPlayerPlay() { }
207     virtual bool mediaPlayerIsPaused() const { return true; }
208     virtual bool mediaPlayerIsLooping() const { return false; }
209     virtual HostWindow* mediaPlayerHostWindow() { return 0; }
210     virtual IntRect mediaPlayerWindowClipRect() { return IntRect(); }
211     virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() { return 0; }
212
213 #if ENABLE(VIDEO_TRACK)
214     virtual void mediaPlayerDidAddTrack(PassRefPtr<InbandTextTrackPrivate>) { }
215     virtual void mediaPlayerDidRemoveTrack(PassRefPtr<InbandTextTrackPrivate>) { }
216 #endif
217 };
218
219 class MediaPlayerSupportsTypeClient {
220 public:
221     virtual ~MediaPlayerSupportsTypeClient() { }
222
223     virtual bool mediaPlayerNeedsSiteSpecificHacks() const { return false; }
224     virtual String mediaPlayerDocumentHost() const { return String(); }
225 };
226
227 class MediaPlayer {
228     WTF_MAKE_NONCOPYABLE(MediaPlayer); WTF_MAKE_FAST_ALLOCATED;
229 public:
230
231     static PassOwnPtr<MediaPlayer> create(MediaPlayerClient* client)
232     {
233         return adoptPtr(new MediaPlayer(client));
234     }
235     virtual ~MediaPlayer();
236
237     // Media engine support.
238     enum SupportsType { IsNotSupported, IsSupported, MayBeSupported };
239     static MediaPlayer::SupportsType supportsType(const ContentType&, const String& keySystem, const KURL&, const MediaPlayerSupportsTypeClient*);
240     static void getSupportedTypes(HashSet<String>&);
241     static bool isAvailable();
242     static void getSitesInMediaCache(Vector<String>&);
243     static void clearMediaCache();
244     static void clearMediaCacheForSite(const String&);
245
246     bool supportsFullscreen() const;
247     bool supportsSave() const;
248     bool supportsScanning() const;
249     PlatformMedia platformMedia() const;
250 #if USE(ACCELERATED_COMPOSITING)
251     PlatformLayer* platformLayer() const;
252 #endif
253
254     IntSize naturalSize();
255     bool hasVideo() const;
256     bool hasAudio() const;
257
258     void setFrameView(FrameView* frameView) { m_frameView = frameView; }
259     FrameView* frameView() { return m_frameView; }
260     bool inMediaDocument();
261
262     IntSize size() const { return m_size; }
263     void setSize(const IntSize& size);
264
265     bool load(const KURL&, const ContentType&, const String& keySystem);
266     void cancelLoad();
267
268     bool visible() const;
269     void setVisible(bool);
270
271     void prepareToPlay();
272     void play();
273     void pause();    
274
275 #if ENABLE(MEDIA_SOURCE)
276     enum AddIdStatus { Ok, NotSupported, ReachedIdLimit };
277     AddIdStatus sourceAddId(const String& id, const String& type, const Vector<String>& codecs);
278     bool sourceRemoveId(const String& id);
279     PassRefPtr<TimeRanges> sourceBuffered(const String& id);
280     bool sourceAppend(const String& id, const unsigned char* data, unsigned length);
281     void sourceSetDuration(double);
282     bool sourceAbort(const String& id);
283     enum EndOfStreamStatus { EosNoError, EosNetworkError, EosDecodeError };
284     void sourceEndOfStream(EndOfStreamStatus);
285     bool sourceSetTimestampOffset(const String& id, double offset);
286 #endif
287
288 #if ENABLE(ENCRYPTED_MEDIA)
289     // Represents synchronous exceptions that can be thrown from the Encrypted Media methods.
290     // This is different from the asynchronous MediaKeyError.
291     enum MediaKeyException { NoError, InvalidPlayerState, KeySystemNotSupported };
292
293     MediaKeyException generateKeyRequest(const String& keySystem, const unsigned char* initData, unsigned initDataLength);
294     MediaKeyException addKey(const String& keySystem, const unsigned char* key, unsigned keyLength, const unsigned char* initData, unsigned initDataLength, const String& sessionId);
295     MediaKeyException cancelKeyRequest(const String& keySystem, const String& sessionId);
296 #endif
297
298     bool paused() const;
299     bool seeking() const;
300
301     static float invalidTime() { return -1.0f;}
302     float duration() const;
303     float currentTime() const;
304     void seek(float time);
305
306     float startTime() const;
307
308     double initialTime() const;
309
310     float rate() const;
311     void setRate(float);
312
313     bool preservesPitch() const;    
314     void setPreservesPitch(bool);
315
316     PassRefPtr<TimeRanges> buffered();
317     PassRefPtr<TimeRanges> seekable();
318     float maxTimeSeekable();
319
320     bool didLoadingProgress();
321
322     float volume() const;
323     void setVolume(float);
324
325     bool muted() const;
326     void setMuted(bool);
327
328     bool hasClosedCaptions() const;
329     void setClosedCaptionsVisible(bool closedCaptionsVisible);
330
331     bool autoplay() const;    
332     void setAutoplay(bool);
333
334     void paint(GraphicsContext*, const IntRect&);
335     void paintCurrentFrameInContext(GraphicsContext*, const IntRect&);
336
337     enum NetworkState { Empty, Idle, Loading, Loaded, FormatError, NetworkError, DecodeError };
338     NetworkState networkState();
339
340     enum ReadyState  { HaveNothing, HaveMetadata, HaveCurrentData, HaveFutureData, HaveEnoughData };
341     ReadyState readyState();
342
343     enum MovieLoadType { Unknown, Download, StoredStream, LiveStream };
344     MovieLoadType movieLoadType() const;
345
346     enum Preload { None, MetaData, Auto };
347     Preload preload() const;
348     void setPreload(Preload);
349
350     void networkStateChanged();
351     void readyStateChanged();
352     void volumeChanged(float);
353     void muteChanged(bool);
354     void timeChanged();
355     void sizeChanged();
356     void rateChanged();
357     void playbackStateChanged();
358     void durationChanged();
359     void firstVideoFrameAvailable();
360     void characteristicChanged();
361
362     void repaint();
363
364     MediaPlayerClient* mediaPlayerClient() const { return m_mediaPlayerClient; }
365
366     bool hasAvailableVideoFrame() const;
367     void prepareForRendering();
368
369     bool canLoadPoster() const;
370     void setPoster(const String&);
371
372 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
373     void deliverNotification(MediaPlayerProxyNotificationType notification);
374     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
375     void setControls(bool);
376 #endif
377
378 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO) || USE(NATIVE_FULLSCREEN_VIDEO)
379     void enterFullscreen();
380     void exitFullscreen();
381 #endif
382
383 #if USE(NATIVE_FULLSCREEN_VIDEO)
384     bool canEnterFullscreen() const;
385 #endif
386
387 #if USE(ACCELERATED_COMPOSITING)
388     // whether accelerated rendering is supported by the media engine for the current media.
389     bool supportsAcceleratedRendering() const;
390     // called when the rendering system flips the into or out of accelerated rendering mode.
391     void acceleratedRenderingStateChanged();
392 #endif
393
394 #if PLATFORM(WIN) && USE(AVFOUNDATION)
395     GraphicsDeviceAdapter* graphicsDeviceAdapter() const;
396 #endif
397
398     bool hasSingleSecurityOrigin() const;
399
400     bool didPassCORSAccessCheck() const;
401
402     float mediaTimeForTimeValue(float) const;
403
404     double maximumDurationToCacheMediaTime() const;
405
406     unsigned decodedFrameCount() const;
407     unsigned droppedFrameCount() const;
408     unsigned audioDecodedByteCount() const;
409     unsigned videoDecodedByteCount() const;
410
411     void setPrivateBrowsingMode(bool);
412
413 #if ENABLE(WEB_AUDIO)
414     AudioSourceProvider* audioSourceProvider();
415 #endif
416
417 #if ENABLE(MEDIA_SOURCE)
418     void sourceOpened();
419     String sourceURL() const;
420 #endif
421
422 #if ENABLE(ENCRYPTED_MEDIA)
423     void keyAdded(const String& keySystem, const String& sessionId);
424     void keyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode);
425     void keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength);
426     bool keyNeeded(const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength);
427 #endif
428
429     String referrer() const;
430     String userAgent() const;
431
432     String engineDescription() const;
433
434     CachedResourceLoader* cachedResourceLoader();
435
436 #if ENABLE(VIDEO_TRACK)
437     void addTextTrack(PassRefPtr<InbandTextTrackPrivate>);
438     void removeTextTrack(PassRefPtr<InbandTextTrackPrivate>);
439 #endif
440
441 private:
442     MediaPlayer(MediaPlayerClient*);
443     void loadWithNextMediaEngine(MediaPlayerFactory*);
444     void reloadTimerFired(Timer<MediaPlayer>*);
445
446     static void initializeMediaEngines();
447
448     MediaPlayerClient* m_mediaPlayerClient;
449     Timer<MediaPlayer> m_reloadTimer;
450     OwnPtr<MediaPlayerPrivateInterface> m_private;
451     MediaPlayerFactory* m_currentMediaEngine;
452     KURL m_url;
453     String m_contentMIMEType;
454     String m_contentTypeCodecs;
455     String m_keySystem;
456     FrameView* m_frameView;
457     IntSize m_size;
458     Preload m_preload;
459     bool m_visible;
460     float m_rate;
461     float m_volume;
462     bool m_muted;
463     bool m_preservesPitch;
464     bool m_privateBrowsing;
465     bool m_shouldPrepareToRender;
466     bool m_contentMIMETypeWasInferredFromExtension;
467 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
468     WebMediaPlayerProxy* m_playerProxy;    // not owned or used, passed to m_private
469 #endif
470 };
471
472 typedef PassOwnPtr<MediaPlayerPrivateInterface> (*CreateMediaEnginePlayer)(MediaPlayer*);
473 typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);
474 #if ENABLE(ENCRYPTED_MEDIA)
475 typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const String& type, const String& codecs, const String& keySystem, const KURL& url);
476 #else
477 typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const String& type, const String& codecs, const KURL& url);
478 #endif
479 typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);
480 typedef void (*MediaEngineClearMediaCache)();
481 typedef void (*MediaEngineClearMediaCacheForSite)(const String&);
482
483 typedef void (*MediaEngineRegistrar)(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType,
484     MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite);
485
486 }
487
488 #endif // ENABLE(VIDEO)
489
490 #endif