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