e0067a508589be0a5fb8842c57cd47bd89f93dc2
[WebKit-https.git] / Source / WebCore / platform / graphics / MediaPlayer.h
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 #ifndef MediaPlayer_h
27 #define MediaPlayer_h
28
29 #if ENABLE(VIDEO)
30 #include "GraphicsTypes3D.h"
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 #if USE(PLATFORM_TEXT_TRACK_MENU)
52 #include "PlatformTextTrackMenu.h"
53 #endif
54
55 OBJC_CLASS AVPlayer;
56 OBJC_CLASS QTMovie;
57
58 class AVCFPlayer;
59 class QTMovieGWorld;
60 class QTMovieVisualContext;
61
62 namespace WebCore {
63
64 class AudioSourceProvider;
65 class Document;
66 class GStreamerGWorld;
67 class MediaPlayerPrivateInterface;
68 #if ENABLE(MEDIA_SOURCE)
69 class MediaSource;
70 #endif
71 class TextTrackRepresentation;
72
73 // Structure that will hold every native
74 // types supported by the current media player.
75 // We have to do that has multiple media players
76 // backend can live at runtime.
77 struct PlatformMedia {
78     enum {
79         None,
80         QTMovieType,
81         QTMovieGWorldType,
82         QTMovieVisualContextType,
83         GStreamerGWorldType,
84         ChromiumMediaPlayerType,
85         QtMediaPlayerType,
86         AVFoundationMediaPlayerType,
87         AVFoundationCFMediaPlayerType
88     } type;
89
90     union {
91         QTMovie* qtMovie;
92         QTMovieGWorld* qtMovieGWorld;
93         QTMovieVisualContext* qtMovieVisualContext;
94         GStreamerGWorld* gstreamerGWorld;
95         MediaPlayerPrivateInterface* chromiumMediaPlayer;
96         MediaPlayerPrivateInterface* qtMediaPlayer;
97         AVPlayer* avfMediaPlayer;
98         AVCFPlayer* avcfMediaPlayer;
99     } media;
100 };
101
102 extern const PlatformMedia NoPlatformMedia;
103
104 class CachedResourceLoader;
105 class ContentType;
106 class FrameView;
107 class GraphicsContext;
108 class GraphicsContext3D;
109 class IntRect;
110 class IntSize;
111 class MediaPlayer;
112 struct MediaPlayerFactory;
113 class TimeRanges;
114 class HostWindow;
115
116 #if PLATFORM(WIN) && USE(AVFOUNDATION)
117 struct GraphicsDeviceAdapter;
118 #endif
119
120 class MediaPlayerClient {
121 public:
122     enum CORSMode { Unspecified, Anonymous, UseCredentials };
123
124     virtual ~MediaPlayerClient() { }
125
126     // Get the document which the media player is owned by
127     virtual Document* mediaPlayerOwningDocument() { return 0; }
128
129     // the network state has changed
130     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*) { }
131
132     // the ready state has changed
133     virtual void mediaPlayerReadyStateChanged(MediaPlayer*) { }
134
135     // the volume state has changed
136     virtual void mediaPlayerVolumeChanged(MediaPlayer*) { }
137
138     // the mute state has changed
139     virtual void mediaPlayerMuteChanged(MediaPlayer*) { }
140
141     // time has jumped, eg. not as a result of normal playback
142     virtual void mediaPlayerTimeChanged(MediaPlayer*) { }
143
144     // the media file duration has changed, or is now known
145     virtual void mediaPlayerDurationChanged(MediaPlayer*) { }
146
147     // the playback rate has changed
148     virtual void mediaPlayerRateChanged(MediaPlayer*) { }
149
150     // the play/pause status changed
151     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*) { }
152
153     // The MediaPlayer has found potentially problematic media content.
154     // This is used internally to trigger swapping from a <video>
155     // element to an <embed> in standalone documents
156     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*) { }
157
158     // The MediaPlayer could not discover an engine which supports the requested resource.
159     virtual void mediaPlayerResourceNotSupported(MediaPlayer*) { }
160
161 // Presentation-related methods
162     // a new frame of video is available
163     virtual void mediaPlayerRepaint(MediaPlayer*) { }
164
165     // the movie size has changed
166     virtual void mediaPlayerSizeChanged(MediaPlayer*) { }
167
168     virtual void mediaPlayerEngineUpdated(MediaPlayer*) { }
169
170     // The first frame of video is available to render. A media engine need only make this callback if the
171     // first frame is not available immediately when prepareForRendering is called.
172     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) { }
173
174     // A characteristic of the media file, eg. video, audio, closed captions, etc, has changed.
175     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) { }
176     
177 #if USE(ACCELERATED_COMPOSITING)
178     // whether the rendering system can accelerate the display of this MediaPlayer.
179     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) { return false; }
180
181     // called when the media player's rendering mode changed, which indicates a change in the
182     // availability of the platformLayer().
183     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) { }
184 #endif
185
186 #if PLATFORM(WIN) && USE(AVFOUNDATION)
187     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const { return 0; }
188 #endif
189
190 #if ENABLE(ENCRYPTED_MEDIA)
191     enum MediaKeyErrorCode { UnknownError = 1, ClientError, ServiceError, OutputError, HardwareChangeError, DomainError };
192     virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */) { }
193     virtual void mediaPlayerKeyError(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, MediaKeyErrorCode, unsigned short /* systemCode */) { }
194     virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, const unsigned char* /* message */, unsigned /* messageLength */, const KURL& /* defaultURL */) { }
195     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, const unsigned char* /* initData */, unsigned /* initDataLength */) { return false; }
196 #endif
197
198 #if ENABLE(ENCRYPTED_MEDIA_V2)
199     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) { return false; }
200 #endif
201     
202     virtual String mediaPlayerReferrer() const { return String(); }
203     virtual String mediaPlayerUserAgent() const { return String(); }
204     virtual CORSMode mediaPlayerCORSMode() const { return Unspecified; }
205     virtual void mediaPlayerEnterFullscreen() { }
206     virtual void mediaPlayerExitFullscreen() { }
207     virtual bool mediaPlayerIsFullscreen() const { return false; }
208     virtual bool mediaPlayerIsFullscreenPermitted() const { return false; }
209     virtual bool mediaPlayerIsVideo() const { return false; }
210     virtual LayoutRect mediaPlayerContentBoxRect() const { return LayoutRect(); }
211     virtual void mediaPlayerSetSize(const IntSize&) { }
212     virtual void mediaPlayerPause() { }
213     virtual void mediaPlayerPlay() { }
214     virtual bool mediaPlayerIsPaused() const { return true; }
215     virtual bool mediaPlayerIsLooping() const { return false; }
216     virtual HostWindow* mediaPlayerHostWindow() { return 0; }
217     virtual IntRect mediaPlayerWindowClipRect() { return IntRect(); }
218     virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() { return 0; }
219
220 #if ENABLE(VIDEO_TRACK)
221     virtual void mediaPlayerDidAddTextTrack(PassRefPtr<InbandTextTrackPrivate>) { }
222     virtual void mediaPlayerDidRemoveTextTrack(PassRefPtr<InbandTextTrackPrivate>) { }
223
224     virtual void textTrackRepresentationBoundsChanged(const IntRect&) { }
225     virtual void paintTextTrackRepresentation(GraphicsContext*, const IntRect&) { }
226 #endif
227 };
228
229 class MediaPlayerSupportsTypeClient {
230 public:
231     virtual ~MediaPlayerSupportsTypeClient() { }
232
233     virtual bool mediaPlayerNeedsSiteSpecificHacks() const { return false; }
234     virtual String mediaPlayerDocumentHost() const { return String(); }
235 };
236
237 class MediaPlayer {
238     WTF_MAKE_NONCOPYABLE(MediaPlayer); WTF_MAKE_FAST_ALLOCATED;
239 public:
240
241     static PassOwnPtr<MediaPlayer> create(MediaPlayerClient* client)
242     {
243         return adoptPtr(new MediaPlayer(client));
244     }
245     virtual ~MediaPlayer();
246
247     // Media engine support.
248     enum SupportsType { IsNotSupported, IsSupported, MayBeSupported };
249     static MediaPlayer::SupportsType supportsType(const ContentType&, const String& keySystem, const KURL&, const MediaPlayerSupportsTypeClient*);
250     static void getSupportedTypes(HashSet<String>&);
251     static bool isAvailable();
252     static void getSitesInMediaCache(Vector<String>&);
253     static void clearMediaCache();
254     static void clearMediaCacheForSite(const String&);
255
256     bool supportsFullscreen() const;
257     bool supportsSave() const;
258     bool supportsScanning() const;
259     PlatformMedia platformMedia() const;
260 #if USE(ACCELERATED_COMPOSITING)
261     PlatformLayer* platformLayer() const;
262 #endif
263
264     IntSize naturalSize();
265     bool hasVideo() const;
266     bool hasAudio() const;
267
268     void setFrameView(FrameView* frameView) { m_frameView = frameView; }
269     FrameView* frameView() { return m_frameView; }
270     bool inMediaDocument();
271
272     IntSize size() const { return m_size; }
273     void setSize(const IntSize& size);
274
275     bool load(const KURL&, const ContentType&, const String& keySystem);
276 #if ENABLE(MEDIA_SOURCE)
277     bool load(const KURL&, PassRefPtr<MediaSource>);
278 #endif
279     void cancelLoad();
280
281     bool visible() const;
282     void setVisible(bool);
283
284     void prepareToPlay();
285     void play();
286     void pause();    
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 double invalidTime() { return -1.0;}
302     double duration() const;
303     double currentTime() const;
304     void seek(double time);
305
306     double startTime() const;
307
308     double initialTime() const;
309
310     double rate() const;
311     void setRate(double);
312
313     bool preservesPitch() const;    
314     void setPreservesPitch(bool);
315
316     PassRefPtr<TimeRanges> buffered();
317     PassRefPtr<TimeRanges> seekable();
318     double minTimeSeekable();
319     double maxTimeSeekable();
320
321     bool didLoadingProgress();
322
323     double volume() const;
324     void setVolume(double);
325
326     bool muted() const;
327     void setMuted(bool);
328
329     bool hasClosedCaptions() const;
330     void setClosedCaptionsVisible(bool closedCaptionsVisible);
331
332     bool autoplay() const;    
333     void setAutoplay(bool);
334
335     void paint(GraphicsContext*, const IntRect&);
336     void paintCurrentFrameInContext(GraphicsContext*, const IntRect&);
337
338     // copyVideoTextureToPlatformTexture() is used to do the GPU-GPU textures copy without a readback to system memory.
339     // The first five parameters denote the corresponding GraphicsContext, destination texture, requested level, requested type and the required internalFormat for destination texture.
340     // The last two parameters premultiplyAlpha and flipY denote whether addtional premultiplyAlpha and flip operation are required during the copy.
341     // It returns true on success and false on failure.
342
343     // In the GPU-GPU textures copy, the source texture(Video texture) should have valid target, internalFormat and size, etc.
344     // The destination texture may need to be resized to to the dimensions of the source texture or re-defined to the required internalFormat.
345     // The current restrictions require that format shoud be RGB or RGBA, type should be UNSIGNED_BYTE and level should be 0. It may be lifted in the future.
346
347     // Each platform port can have its own implementation on this function. The default implementation for it is a single "return false" in MediaPlayerPrivate.h.
348     // In chromium, the implementation is based on GL_CHROMIUM_copy_texture extension which is documented at
349     // http://src.chromium.org/viewvc/chrome/trunk/src/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_copy_texture.txt and implemented at
350     // http://src.chromium.org/viewvc/chrome/trunk/src/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.cc via shaders.
351     bool copyVideoTextureToPlatformTexture(GraphicsContext3D*, Platform3DObject texture, GC3Dint level, GC3Denum type, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY);
352
353     enum NetworkState { Empty, Idle, Loading, Loaded, FormatError, NetworkError, DecodeError };
354     NetworkState networkState();
355
356     enum ReadyState  { HaveNothing, HaveMetadata, HaveCurrentData, HaveFutureData, HaveEnoughData };
357     ReadyState readyState();
358
359     enum MovieLoadType { Unknown, Download, StoredStream, LiveStream };
360     MovieLoadType movieLoadType() const;
361
362     enum Preload { None, MetaData, Auto };
363     Preload preload() const;
364     void setPreload(Preload);
365
366     void networkStateChanged();
367     void readyStateChanged();
368     void volumeChanged(double);
369     void muteChanged(bool);
370     void timeChanged();
371     void sizeChanged();
372     void rateChanged();
373     void playbackStateChanged();
374     void durationChanged();
375     void firstVideoFrameAvailable();
376     void characteristicChanged();
377
378     void repaint();
379
380     MediaPlayerClient* mediaPlayerClient() const { return m_mediaPlayerClient; }
381     void clearMediaPlayerClient() { m_mediaPlayerClient = 0; }
382
383     bool hasAvailableVideoFrame() const;
384     void prepareForRendering();
385
386     bool canLoadPoster() const;
387     void setPoster(const String&);
388
389 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
390     void deliverNotification(MediaPlayerProxyNotificationType notification);
391     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
392     void setControls(bool);
393 #endif
394
395 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO) || USE(NATIVE_FULLSCREEN_VIDEO)
396     void enterFullscreen();
397     void exitFullscreen();
398 #endif
399
400 #if USE(NATIVE_FULLSCREEN_VIDEO)
401     bool canEnterFullscreen() const;
402 #endif
403
404 #if USE(ACCELERATED_COMPOSITING)
405     // whether accelerated rendering is supported by the media engine for the current media.
406     bool supportsAcceleratedRendering() const;
407     // called when the rendering system flips the into or out of accelerated rendering mode.
408     void acceleratedRenderingStateChanged();
409 #endif
410
411 #if PLATFORM(WIN) && USE(AVFOUNDATION)
412     GraphicsDeviceAdapter* graphicsDeviceAdapter() const;
413 #endif
414
415     bool hasSingleSecurityOrigin() const;
416
417     bool didPassCORSAccessCheck() const;
418
419     double mediaTimeForTimeValue(double) const;
420
421     double maximumDurationToCacheMediaTime() const;
422
423     unsigned decodedFrameCount() const;
424     unsigned droppedFrameCount() const;
425     unsigned audioDecodedByteCount() const;
426     unsigned videoDecodedByteCount() const;
427
428     void setPrivateBrowsingMode(bool);
429
430 #if ENABLE(WEB_AUDIO)
431     AudioSourceProvider* audioSourceProvider();
432 #endif
433
434 #if ENABLE(ENCRYPTED_MEDIA)
435     void keyAdded(const String& keySystem, const String& sessionId);
436     void keyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode);
437     void keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const KURL& defaultURL);
438     bool keyNeeded(const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength);
439 #endif
440
441 #if ENABLE(ENCRYPTED_MEDIA_V2)
442     bool keyNeeded(Uint8Array* initData);
443 #endif
444
445     String referrer() const;
446     String userAgent() const;
447
448     String engineDescription() const;
449
450     CachedResourceLoader* cachedResourceLoader();
451
452 #if ENABLE(VIDEO_TRACK)
453     void addTextTrack(PassRefPtr<InbandTextTrackPrivate>);
454     void removeTextTrack(PassRefPtr<InbandTextTrackPrivate>);
455
456     bool requiresTextTrackRepresentation() const;
457     void setTextTrackRepresentation(TextTrackRepresentation*);
458 #endif
459
460     static void resetMediaEngines();
461
462 #if USE(PLATFORM_TEXT_TRACK_MENU)
463     bool implementsTextTrackControls() const;
464     PassRefPtr<PlatformTextTrackMenuInterface> textTrackMenu();
465 #endif
466
467 #if USE(GSTREAMER)
468     void simulateAudioInterruption();
469 #endif
470
471     String languageOfPrimaryAudioTrack() const;
472
473 private:
474     MediaPlayer(MediaPlayerClient*);
475     void loadWithNextMediaEngine(MediaPlayerFactory*);
476     void reloadTimerFired(Timer<MediaPlayer>*);
477
478     static void initializeMediaEngines();
479
480     MediaPlayerClient* m_mediaPlayerClient;
481     Timer<MediaPlayer> m_reloadTimer;
482     OwnPtr<MediaPlayerPrivateInterface> m_private;
483     MediaPlayerFactory* m_currentMediaEngine;
484     KURL m_url;
485     String m_contentMIMEType;
486     String m_contentTypeCodecs;
487     String m_keySystem;
488     FrameView* m_frameView;
489     IntSize m_size;
490     Preload m_preload;
491     bool m_visible;
492     double m_rate;
493     double m_volume;
494     bool m_muted;
495     bool m_preservesPitch;
496     bool m_privateBrowsing;
497     bool m_shouldPrepareToRender;
498     bool m_contentMIMETypeWasInferredFromExtension;
499 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
500     WebMediaPlayerProxy* m_playerProxy;    // not owned or used, passed to m_private
501 #endif
502
503 #if ENABLE(MEDIA_SOURCE)
504     RefPtr<MediaSource> m_mediaSource;
505 #endif
506 };
507
508 typedef PassOwnPtr<MediaPlayerPrivateInterface> (*CreateMediaEnginePlayer)(MediaPlayer*);
509 typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);
510 #if ENABLE(ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA_V2)
511 typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const String& type, const String& codecs, const String& keySystem, const KURL& url);
512 #else
513 typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const String& type, const String& codecs, const KURL& url);
514 #endif
515 typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);
516 typedef void (*MediaEngineClearMediaCache)();
517 typedef void (*MediaEngineClearMediaCacheForSite)(const String&);
518
519 typedef void (*MediaEngineRegistrar)(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType,
520     MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite);
521
522 }
523
524 #endif // ENABLE(VIDEO)
525
526 #endif