429e5fcf558dc230b4c033d6f1a61e7fcb8d9516
[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 MediaPlayer {
184     WTF_MAKE_NONCOPYABLE(MediaPlayer); WTF_MAKE_FAST_ALLOCATED;
185 public:
186
187     static PassOwnPtr<MediaPlayer> create(MediaPlayerClient* client)
188     {
189         return adoptPtr(new MediaPlayer(client));
190     }
191     virtual ~MediaPlayer();
192
193     // Media engine support.
194     enum SupportsType { IsNotSupported, IsSupported, MayBeSupported };
195     static MediaPlayer::SupportsType supportsType(const ContentType&, const String& keySystem);
196     static void getSupportedTypes(HashSet<String>&);
197     static bool isAvailable();
198     static void getSitesInMediaCache(Vector<String>&);
199     static void clearMediaCache();
200     static void clearMediaCacheForSite(const String&);
201
202     bool supportsFullscreen() const;
203     bool supportsSave() const;
204     bool supportsScanning() const;
205     PlatformMedia platformMedia() const;
206 #if USE(ACCELERATED_COMPOSITING)
207     PlatformLayer* platformLayer() const;
208 #endif
209
210     IntSize naturalSize();
211     bool hasVideo() const;
212     bool hasAudio() const;
213
214     void setFrameView(FrameView* frameView) { m_frameView = frameView; }
215     FrameView* frameView() { return m_frameView; }
216     bool inMediaDocument();
217
218     IntSize size() const { return m_size; }
219     void setSize(const IntSize& size);
220
221     bool load(const KURL&, const ContentType&, const String& keySystem);
222     void cancelLoad();
223
224     bool visible() const;
225     void setVisible(bool);
226
227     void prepareToPlay();
228     void play();
229     void pause();    
230
231 #if ENABLE(MEDIA_SOURCE)
232     enum AddIdStatus { Ok, NotSupported, ReachedIdLimit };
233     AddIdStatus sourceAddId(const String& id, const String& type);
234     bool sourceRemoveId(const String& id);
235     bool sourceAppend(const unsigned char* data, unsigned length);
236     enum EndOfStreamStatus { EosNoError, EosNetworkError, EosDecodeError };
237     void sourceEndOfStream(EndOfStreamStatus);
238 #endif
239
240 #if ENABLE(ENCRYPTED_MEDIA)
241     // Represents synchronous exceptions that can be thrown from the Encrypted Media methods.
242     // This is different from the asynchronous MediaKeyError.
243     enum MediaKeyException { NoError, InvalidPlayerState, KeySystemNotSupported };
244
245     MediaKeyException generateKeyRequest(const String& keySystem, const unsigned char* initData, unsigned initDataLength);
246     MediaKeyException addKey(const String& keySystem, const unsigned char* key, unsigned keyLength, const unsigned char* initData, unsigned initDataLength, const String& sessionId);
247     MediaKeyException cancelKeyRequest(const String& keySystem, const String& sessionId);
248 #endif
249
250     bool paused() const;
251     bool seeking() const;
252
253     float duration() const;
254     float currentTime() const;
255     void seek(float time);
256
257     float startTime() const;
258
259     double initialTime() const;
260
261     float rate() const;
262     void setRate(float);
263
264     bool preservesPitch() const;    
265     void setPreservesPitch(bool);
266
267     PassRefPtr<TimeRanges> buffered();
268     PassRefPtr<TimeRanges> seekable();
269     float maxTimeSeekable();
270
271     unsigned bytesLoaded();
272
273     float volume() const;
274     void setVolume(float);
275
276     bool muted() const;
277     void setMuted(bool);
278
279     bool hasClosedCaptions() const;
280     void setClosedCaptionsVisible(bool closedCaptionsVisible);
281
282     bool autoplay() const;    
283     void setAutoplay(bool);
284
285     void paint(GraphicsContext*, const IntRect&);
286     void paintCurrentFrameInContext(GraphicsContext*, const IntRect&);
287
288     enum NetworkState { Empty, Idle, Loading, Loaded, FormatError, NetworkError, DecodeError };
289     NetworkState networkState();
290
291     enum ReadyState  { HaveNothing, HaveMetadata, HaveCurrentData, HaveFutureData, HaveEnoughData };
292     ReadyState readyState();
293
294     enum MovieLoadType { Unknown, Download, StoredStream, LiveStream };
295     MovieLoadType movieLoadType() const;
296
297     enum Preload { None, MetaData, Auto };
298     Preload preload() const;
299     void setPreload(Preload);
300
301     void networkStateChanged();
302     void readyStateChanged();
303     void volumeChanged(float);
304     void muteChanged(bool);
305     void timeChanged();
306     void sizeChanged();
307     void rateChanged();
308     void playbackStateChanged();
309     void durationChanged();
310     void firstVideoFrameAvailable();
311     void characteristicChanged();
312
313     void repaint();
314
315     MediaPlayerClient* mediaPlayerClient() const { return m_mediaPlayerClient; }
316
317     bool hasAvailableVideoFrame() const;
318     void prepareForRendering();
319
320     bool canLoadPoster() const;
321     void setPoster(const String&);
322
323 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
324     void deliverNotification(MediaPlayerProxyNotificationType notification);
325     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
326     void setControls(bool);
327     void enterFullscreen();
328     void exitFullscreen();
329 #endif
330
331 #if USE(ACCELERATED_COMPOSITING)
332     // whether accelerated rendering is supported by the media engine for the current media.
333     bool supportsAcceleratedRendering() const;
334     // called when the rendering system flips the into or out of accelerated rendering mode.
335     void acceleratedRenderingStateChanged();
336 #endif
337
338     bool hasSingleSecurityOrigin() const;
339
340     float mediaTimeForTimeValue(float) const;
341
342     double maximumDurationToCacheMediaTime() const;
343
344     unsigned decodedFrameCount() const;
345     unsigned droppedFrameCount() const;
346     unsigned audioDecodedByteCount() const;
347     unsigned videoDecodedByteCount() const;
348
349     void setPrivateBrowsingMode(bool);
350
351 #if ENABLE(WEB_AUDIO)
352     AudioSourceProvider* audioSourceProvider();
353 #endif
354
355 #if ENABLE(MEDIA_SOURCE)
356     void sourceOpened();
357     String sourceURL() const;
358 #endif
359
360 #if ENABLE(ENCRYPTED_MEDIA)
361     void keyAdded(const String& keySystem, const String& sessionId);
362     void keyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode);
363     void keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength);
364     void keyNeeded(const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength);
365 #endif
366
367     String referrer() const;
368     String userAgent() const;
369
370 private:
371     MediaPlayer(MediaPlayerClient*);
372     void loadWithNextMediaEngine(MediaPlayerFactory*);
373     void reloadTimerFired(Timer<MediaPlayer>*);
374
375     static void initializeMediaEngines();
376
377     MediaPlayerClient* m_mediaPlayerClient;
378     Timer<MediaPlayer> m_reloadTimer;
379     OwnPtr<MediaPlayerPrivateInterface> m_private;
380     MediaPlayerFactory* m_currentMediaEngine;
381     String m_url;
382     String m_contentMIMEType;
383     String m_contentTypeCodecs;
384     String m_keySystem;
385     FrameView* m_frameView;
386     IntSize m_size;
387     Preload m_preload;
388     bool m_visible;
389     float m_rate;
390     float m_volume;
391     bool m_muted;
392     bool m_preservesPitch;
393     bool m_privateBrowsing;
394     bool m_shouldPrepareToRender;
395 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
396     WebMediaPlayerProxy* m_playerProxy;    // not owned or used, passed to m_private
397 #endif
398 };
399
400 typedef PassOwnPtr<MediaPlayerPrivateInterface> (*CreateMediaEnginePlayer)(MediaPlayer*);
401 typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);
402 #if ENABLE(ENCRYPTED_MEDIA)
403 typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const String& type, const String& codecs, const String& keySystem);
404 #else
405 typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const String& type, const String& codecs);
406 #endif
407 typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);
408 typedef void (*MediaEngineClearMediaCache)();
409 typedef void (*MediaEngineClearMediaCacheForSite)(const String&);
410
411 typedef void (*MediaEngineRegistrar)(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType, 
412     MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite); 
413
414
415 }
416
417 #endif // ENABLE(VIDEO)
418
419 #endif