1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
|
/*
* Copyright (C) 2011 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef MediaPlayerPrivateAVFoundation_h
#define MediaPlayerPrivateAVFoundation_h
#if ENABLE(VIDEO) && USE(AVFOUNDATION)
#include "FloatSize.h"
#include "MediaPlayerPrivate.h"
#include "Timer.h"
#include <wtf/RetainPtr.h>
namespace WebCore {
class ApplicationCacheResource;
class MediaPlayerPrivateAVFoundation : public MediaPlayerPrivateInterface {
public:
virtual void repaint();
virtual void metadataLoaded();
virtual void playabilityKnown();
virtual void rateChanged();
virtual void loadedTimeRangesChanged();
virtual void seekableTimeRangesChanged();
virtual void timeChanged(double);
virtual void seekCompleted(bool);
virtual void didEnd();
class Notification {
public:
enum Type {
None,
ItemDidPlayToEndTime,
ItemTracksChanged,
ItemStatusChanged,
ItemSeekableTimeRangesChanged,
ItemLoadedTimeRangesChanged,
ItemPresentationSizeChanged,
ItemIsPlaybackLikelyToKeepUpChanged,
ItemIsPlaybackBufferEmptyChanged,
ItemIsPlaybackBufferFullChanged,
AssetMetadataLoaded,
AssetPlayabilityKnown,
PlayerRateChanged,
PlayerTimeChanged,
SeekCompleted,
};
Notification()
: m_type(None)
, m_time(0)
, m_finished(false)
{
}
Notification(Type type, double time)
: m_type(type)
, m_time(time)
, m_finished(false)
{
}
Notification(Type type, bool finished)
: m_type(type)
, m_time(0)
, m_finished(finished)
{
}
Type type() { return m_type; }
bool isValid() { return m_type != None; }
double time() { return m_time; }
bool finished() { return m_finished; }
private:
Type m_type;
double m_time;
bool m_finished;
};
void scheduleMainThreadNotification(Notification);
void scheduleMainThreadNotification(Notification::Type, double time = 0);
void scheduleMainThreadNotification(Notification::Type, bool completed);
void dispatchNotification();
void clearMainThreadPendingFlag();
protected:
MediaPlayerPrivateAVFoundation(MediaPlayer*);
virtual ~MediaPlayerPrivateAVFoundation();
// MediaPlayerPrivatePrivateInterface overrides.
virtual void load(const String& url);
virtual void cancelLoad() = 0;
virtual void prepareToPlay();
virtual PlatformMedia platformMedia() const = 0;
virtual void play();
virtual void pause();
virtual IntSize naturalSize() const;
virtual bool hasVideo() const { return m_cachedHasVideo; }
virtual bool hasAudio() const { return m_cachedHasAudio; }
virtual void setVisible(bool);
virtual float duration() const;
virtual float currentTime() const = 0;
virtual void seek(float);
virtual bool seeking() const;
virtual void setRate(float);
virtual bool paused() const;
virtual void setVolume(float) = 0;
virtual bool hasClosedCaptions() const { return m_cachedHasCaptions; }
virtual void setClosedCaptionsVisible(bool) = 0;
virtual MediaPlayer::NetworkState networkState() const { return m_networkState; }
virtual MediaPlayer::ReadyState readyState() const { return m_readyState; }
virtual float maxTimeSeekable() const;
virtual PassRefPtr<TimeRanges> buffered() const;
virtual unsigned bytesLoaded() const;
virtual void setSize(const IntSize&);
virtual void paint(GraphicsContext*, const IntRect&) = 0;
virtual void paintCurrentFrameInContext(GraphicsContext*, const IntRect&) = 0;
virtual void setPreload(MediaPlayer::Preload);
#if USE(ACCELERATED_COMPOSITING)
virtual PlatformLayer* platformLayer() const { return 0; }
virtual bool supportsAcceleratedRendering() const = 0;
virtual void acceleratedRenderingStateChanged();
#endif
virtual MediaPlayer::MovieLoadType movieLoadType() const;
virtual void prepareForRendering();
virtual float mediaTimeForTimeValue(float) const = 0;
virtual bool supportsFullscreen() const;
// Required interfaces for concrete derived classes.
virtual void createAVAssetForURL(const String&) = 0;
virtual void createAVPlayer() = 0;
virtual void createAVPlayerItem() = 0;
#if ENABLE(OFFLINE_WEB_APPLICATIONS)
virtual void createAVAssetForCacheResource(ApplicationCacheResource*) = 0;
#endif
enum ItemStatus {
MediaPlayerAVPlayerItemStatusDoesNotExist,
MediaPlayerAVPlayerItemStatusUnknown,
MediaPlayerAVPlayerItemStatusFailed,
MediaPlayerAVPlayerItemStatusReadyToPlay,
MediaPlayerAVPlayerItemStatusPlaybackBufferEmpty,
MediaPlayerAVPlayerItemStatusPlaybackBufferFull,
MediaPlayerAVPlayerItemStatusPlaybackLikelyToKeepUp,
};
virtual ItemStatus playerItemStatus() const = 0;
enum AssetStatus {
MediaPlayerAVAssetStatusDoesNotExist,
MediaPlayerAVAssetStatusUnknown,
MediaPlayerAVAssetStatusLoading,
MediaPlayerAVAssetStatusFailed,
MediaPlayerAVAssetStatusCancelled,
MediaPlayerAVAssetStatusLoaded,
MediaPlayerAVAssetStatusPlayable,
};
virtual AssetStatus assetStatus() const = 0;
virtual void platformSetVisible(bool) = 0;
virtual void platformPlay() = 0;
virtual void platformPause() = 0;
virtual void checkPlayability() = 0;
virtual void updateRate() = 0;
virtual float rate() const = 0;
virtual void seekToTime(float time) = 0;
virtual unsigned totalBytes() const = 0;
virtual PassRefPtr<TimeRanges> platformBufferedTimeRanges() const = 0;
virtual float platformMaxTimeSeekable() const = 0;
virtual float platformMaxTimeLoaded() const = 0;
virtual float platformDuration() const = 0;
virtual void beginLoadingMetadata() = 0;
virtual void tracksChanged() = 0;
virtual void sizeChanged() = 0;
virtual void createContextVideoRenderer() = 0;
virtual void destroyContextVideoRenderer() = 0;
virtual void createVideoLayer() = 0;
virtual void destroyVideoLayer() = 0;
virtual bool hasAvailableVideoFrame() const = 0;
virtual bool hasContextRenderer() const = 0;
virtual bool hasLayerRenderer() const = 0;
protected:
void updateStates();
void setHasVideo(bool b) { m_cachedHasVideo = b; };
void setHasAudio(bool b) { m_cachedHasAudio = b; }
void setHasClosedCaptions(bool b) { m_cachedHasCaptions = b; }
void setDelayCallbacks(bool);
void setIgnoreLoadStateChanges(bool delay) { m_ignoreLoadStateChanges = delay; }
void setNaturalSize(IntSize);
bool isLiveStream() const { return isinf(duration()); }
enum MediaRenderingMode { MediaRenderingNone, MediaRenderingToContext, MediaRenderingToLayer };
MediaRenderingMode currentRenderingMode() const;
MediaRenderingMode preferredRenderingMode() const;
bool metaDataAvailable() const { return m_readyState >= MediaPlayer::HaveMetadata; }
float requestedRate() const { return m_requestedRate; }
float maxTimeLoaded() const;
bool isReadyForVideoSetup() const;
virtual void setUpVideoRendering();
virtual void tearDownVideoRendering();
bool hasSetUpVideoRendering() const;
static void mainThreadCallback(void*);
float invalidTime() const { return -1.0f; }
const String& assetURL() const { return m_assetURL; }
private:
MediaPlayer* m_player;
Vector<Notification> m_queuedNotifications;
Mutex m_queueMutex;
mutable RefPtr<TimeRanges> m_cachedLoadedTimeRanges;
MediaPlayer::NetworkState m_networkState;
MediaPlayer::ReadyState m_readyState;
String m_assetURL;
MediaPlayer::Preload m_preload;
FloatSize m_scaleFactor;
IntSize m_cachedNaturalSize;
mutable float m_cachedMaxTimeLoaded;
mutable float m_cachedMaxTimeSeekable;
mutable float m_cachedDuration;
float m_reportedDuration;
float m_seekTo;
float m_requestedRate;
int m_delayCallbacks;
bool m_mainThreadCallPending;
bool m_assetIsPlayable;
bool m_visible;
bool m_loadingMetadata;
bool m_isAllowedToRender;
bool m_cachedHasAudio;
bool m_cachedHasVideo;
bool m_cachedHasCaptions;
bool m_ignoreLoadStateChanges;
bool m_haveReportedFirstVideoFrame;
bool m_playWhenFramesAvailable;
};
}
#endif
#endif
|
