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