Unreviewed, rolling out r245857.
[WebKit-https.git] / Source / WebCore / platform / graphics / avfoundation / objc / MediaPlayerPrivateMediaSourceAVFObjC.h
1 /*
2  * Copyright (C) 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 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 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 MediaPlayerPrivateMediaSourceAVFObjC_h
27 #define MediaPlayerPrivateMediaSourceAVFObjC_h
28
29 #if ENABLE(MEDIA_SOURCE) && USE(AVFOUNDATION)
30
31 #include "MediaPlayerPrivate.h"
32 #include "SourceBufferPrivateClient.h"
33 #include <wtf/Function.h>
34 #include <wtf/HashMap.h>
35 #include <wtf/LoggerHelper.h>
36 #include <wtf/MediaTime.h>
37 #include <wtf/WeakPtr.h>
38
39 OBJC_CLASS AVAsset;
40 OBJC_CLASS AVSampleBufferAudioRenderer;
41 OBJC_CLASS AVSampleBufferDisplayLayer;
42 OBJC_CLASS AVSampleBufferRenderSynchronizer;
43 OBJC_CLASS AVStreamSession;
44
45 typedef struct OpaqueCMTimebase* CMTimebaseRef;
46 typedef struct __CVBuffer *CVPixelBufferRef;
47 typedef struct __CVBuffer *CVOpenGLTextureRef;
48
49 namespace WebCore {
50
51 class CDMSessionMediaSourceAVFObjC;
52 class MediaSourcePrivateAVFObjC;
53 class PixelBufferConformerCV;
54 class PlatformClockCM;
55 class TextureCacheCV;
56 class VideoFullscreenLayerManagerObjC;
57 class VideoTextureCopierCV;
58 class WebCoreDecompressionSession;
59
60
61 class MediaPlayerPrivateMediaSourceAVFObjC
62     : public MediaPlayerPrivateInterface
63 #if !RELEASE_LOG_DISABLED
64     , private LoggerHelper
65 #endif
66 {
67 public:
68     explicit MediaPlayerPrivateMediaSourceAVFObjC(MediaPlayer*);
69     virtual ~MediaPlayerPrivateMediaSourceAVFObjC();
70
71     static void registerMediaEngine(MediaEngineRegistrar);
72
73     // MediaPlayer Factory Methods
74     static bool isAvailable();
75     static void getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>& types);
76     static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
77
78     ALLOW_NEW_API_WITHOUT_GUARDS_BEGIN
79     void addAudioRenderer(AVSampleBufferAudioRenderer*);
80     void removeAudioRenderer(AVSampleBufferAudioRenderer*);
81     ALLOW_NEW_API_WITHOUT_GUARDS_END
82
83     MediaPlayer::NetworkState networkState() const override;
84     MediaPlayer::ReadyState readyState() const override;
85     void setReadyState(MediaPlayer::ReadyState);
86     void setNetworkState(MediaPlayer::NetworkState);
87
88     void seekInternal();
89     void waitForSeekCompleted();
90     void seekCompleted();
91     void setLoadingProgresssed(bool flag) { m_loadingProgressed = flag; }
92     void setHasAvailableVideoFrame(bool);
93     bool hasAvailableVideoFrame() const override;
94     ALLOW_NEW_API_WITHOUT_GUARDS_BEGIN
95     void setHasAvailableAudioSample(AVSampleBufferAudioRenderer*, bool);
96     ALLOW_NEW_API_WITHOUT_GUARDS_END
97     bool allRenderersHaveAvailableSamples() const { return m_allRenderersHaveAvailableSamples; }
98     void updateAllRenderersHaveAvailableSamples();
99     void durationChanged();
100
101     void effectiveRateChanged();
102     void sizeWillChangeAtTime(const MediaTime&, const FloatSize&);
103     void setNaturalSize(const FloatSize&);
104     void flushPendingSizeChanges();
105     void characteristicsChanged();
106
107     MediaTime currentMediaTime() const override;
108     AVSampleBufferDisplayLayer* sampleBufferDisplayLayer() const { return m_sampleBufferDisplayLayer.get(); }
109     WebCoreDecompressionSession* decompressionSession() const { return m_decompressionSession.get(); }
110
111     void setVideoFullscreenLayer(PlatformLayer*, WTF::Function<void()>&& completionHandler) override;
112     void setVideoFullscreenFrame(FloatRect) override;
113
114     bool requiresTextTrackRepresentation() const override;
115     void setTextTrackRepresentation(TextTrackRepresentation*) override;
116     void syncTextTrackBounds() override;
117     
118 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
119 #if HAVE(AVSTREAMSESSION)
120     bool hasStreamSession() { return m_streamSession; }
121     AVStreamSession *streamSession();
122 #endif
123     void setCDMSession(LegacyCDMSession*) override;
124     CDMSessionMediaSourceAVFObjC* cdmSession() const { return m_session.get(); }
125 #endif
126
127 #if ENABLE(ENCRYPTED_MEDIA)
128     void cdmInstanceAttached(CDMInstance&) final;
129     void cdmInstanceDetached(CDMInstance&) final;
130     void attemptToDecryptWithInstance(CDMInstance&) final;
131     bool waitingForKey() const final;
132     void waitingForKeyChanged();
133 #endif
134
135     void outputObscuredDueToInsufficientExternalProtectionChanged(bool);
136     void beginSimulatedHDCPError() override { outputObscuredDueToInsufficientExternalProtectionChanged(true); }
137     void endSimulatedHDCPError() override { outputObscuredDueToInsufficientExternalProtectionChanged(false); }
138
139 #if ENABLE(LEGACY_ENCRYPTED_MEDIA) || ENABLE(ENCRYPTED_MEDIA)
140     void keyNeeded(Uint8Array*);
141 #endif
142
143 #if ENABLE(ENCRYPTED_MEDIA)
144     void initializationDataEncountered(const String&, RefPtr<ArrayBuffer>&&);
145 #endif
146
147     const Vector<ContentType>& mediaContentTypesRequiringHardwareSupport() const;
148     bool shouldCheckHardwareSupport() const;
149
150     WeakPtr<MediaPlayerPrivateMediaSourceAVFObjC> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(*this); }
151
152 #if !RELEASE_LOG_DISABLED
153     const Logger& logger() const final { return m_logger.get(); }
154     const char* logClassName() const override { return "MediaPlayerPrivateMediaSourceAVFObjC"; }
155     const void* logIdentifier() const final { return reinterpret_cast<const void*>(m_logIdentifier); }
156     WTFLogChannel& logChannel() const final;
157
158     const void* mediaPlayerLogIdentifier() { return logIdentifier(); }
159     const Logger& mediaPlayerLogger() { return logger(); }
160 #endif
161
162     enum SeekState {
163         Seeking,
164         WaitingForAvailableFame,
165         SeekCompleted,
166     };
167
168 private:
169     // MediaPlayerPrivateInterface
170     void load(const String& url) override;
171     void load(const String& url, MediaSourcePrivateClient*) override;
172 #if ENABLE(MEDIA_STREAM)
173     void load(MediaStreamPrivate&) override;
174 #endif
175     void cancelLoad() override;
176
177     void prepareToPlay() override;
178     PlatformLayer* platformLayer() const override;
179
180     bool supportsPictureInPicture() const override { return true; }
181     bool supportsFullscreen() const override { return true; }
182
183     void play() override;
184     void playInternal();
185
186     void pause() override;
187     void pauseInternal();
188
189     bool paused() const override;
190
191     void setVolume(float volume) override;
192     bool supportsMuting() const override { return true; }
193     void setMuted(bool) override;
194
195     bool supportsScanning() const override;
196
197     FloatSize naturalSize() const override;
198
199     bool hasVideo() const override;
200     bool hasAudio() const override;
201
202     void setVisible(bool) override;
203
204     MediaTime durationMediaTime() const override;
205     MediaTime startTime() const override;
206     MediaTime initialTime() const override;
207
208     void seekWithTolerance(const MediaTime&, const MediaTime& negativeThreshold, const MediaTime& positiveThreshold) override;
209     bool seeking() const override;
210     void setRateDouble(double) override;
211
212     void setPreservesPitch(bool) override;
213
214     std::unique_ptr<PlatformTimeRanges> seekable() const override;
215     MediaTime maxMediaTimeSeekable() const override;
216     MediaTime minMediaTimeSeekable() const override;
217     std::unique_ptr<PlatformTimeRanges> buffered() const override;
218
219     bool didLoadingProgress() const override;
220
221     void setSize(const IntSize&) override;
222
223     NativeImagePtr nativeImageForCurrentTime() override;
224     bool updateLastPixelBuffer();
225     bool updateLastImage();
226     void paint(GraphicsContext&, const FloatRect&) override;
227     void paintCurrentFrameInContext(GraphicsContext&, const FloatRect&) override;
228     bool copyVideoTextureToPlatformTexture(GraphicsContext3D*, Platform3DObject, GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Denum format, GC3Denum type, bool premultiplyAlpha, bool flipY) override;
229
230     bool supportsAcceleratedRendering() const override;
231     // called when the rendering system flips the into or out of accelerated rendering mode.
232     void acceleratedRenderingStateChanged() override;
233     void notifyActiveSourceBuffersChanged() override;
234
235     // NOTE: Because the only way for MSE to recieve data is through an ArrayBuffer provided by
236     // javascript running in the page, the video will, by necessity, always be CORS correct and
237     // in the page's origin.
238     bool hasSingleSecurityOrigin() const override { return true; }
239     bool didPassCORSAccessCheck() const override { return true; }
240
241     MediaPlayer::MovieLoadType movieLoadType() const override;
242
243     void prepareForRendering() override;
244
245     String engineDescription() const override;
246
247     String languageOfPrimaryAudioTrack() const override;
248
249     size_t extraMemoryCost() const override;
250
251     Optional<VideoPlaybackQualityMetrics> videoPlaybackQualityMetrics() override;
252
253 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
254     bool isCurrentPlaybackTargetWireless() const override;
255     void setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&&) override;
256     void setShouldPlayToPlaybackTarget(bool) override;
257     bool wirelessVideoPlaybackDisabled() const override { return false; }
258 #endif
259
260     bool performTaskAtMediaTime(WTF::Function<void()>&&, MediaTime) final;
261
262     void ensureLayer();
263     void destroyLayer();
264     void ensureDecompressionSession();
265     void destroyDecompressionSession();
266
267     bool shouldBePlaying() const;
268
269     friend class MediaSourcePrivateAVFObjC;
270
271     struct PendingSeek {
272         PendingSeek(const MediaTime& targetTime, const MediaTime& negativeThreshold, const MediaTime& positiveThreshold)
273             : targetTime(targetTime)
274             , negativeThreshold(negativeThreshold)
275             , positiveThreshold(positiveThreshold)
276         {
277         }
278         MediaTime targetTime;
279         MediaTime negativeThreshold;
280         MediaTime positiveThreshold;
281     };
282     std::unique_ptr<PendingSeek> m_pendingSeek;
283
284     MediaPlayer* m_player;
285     WeakPtrFactory<MediaPlayerPrivateMediaSourceAVFObjC> m_weakPtrFactory;
286     WeakPtrFactory<MediaPlayerPrivateMediaSourceAVFObjC> m_sizeChangeObserverWeakPtrFactory;
287     RefPtr<MediaSourcePrivateAVFObjC> m_mediaSourcePrivate;
288     RetainPtr<AVAsset> m_asset;
289     RetainPtr<AVSampleBufferDisplayLayer> m_sampleBufferDisplayLayer;
290
291     struct AudioRendererProperties {
292         bool hasAudibleSample { false };
293     };
294     ALLOW_NEW_API_WITHOUT_GUARDS_BEGIN
295     HashMap<RetainPtr<CFTypeRef>, AudioRendererProperties> m_sampleBufferAudioRendererMap;
296     RetainPtr<AVSampleBufferRenderSynchronizer> m_synchronizer;
297     ALLOW_NEW_API_WITHOUT_GUARDS_END
298     RetainPtr<id> m_timeJumpedObserver;
299     RetainPtr<id> m_durationObserver;
300     RetainPtr<id> m_performTaskObserver;
301     RetainPtr<AVStreamSession> m_streamSession;
302     RetainPtr<CVPixelBufferRef> m_lastPixelBuffer;
303     RetainPtr<CGImageRef> m_lastImage;
304     std::unique_ptr<PixelBufferConformerCV> m_rgbConformer;
305     RefPtr<WebCoreDecompressionSession> m_decompressionSession;
306     Deque<RetainPtr<id>> m_sizeChangeObservers;
307     Timer m_seekTimer;
308 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
309     WeakPtr<CDMSessionMediaSourceAVFObjC> m_session;
310 #endif
311     MediaPlayer::NetworkState m_networkState;
312     MediaPlayer::ReadyState m_readyState;
313     bool m_readyStateIsWaitingForAvailableFrame { false };
314     MediaTime m_lastSeekTime;
315     FloatSize m_naturalSize;
316     double m_rate;
317     bool m_playing;
318     bool m_seeking;
319     SeekState m_seekCompleted { SeekCompleted };
320     mutable bool m_loadingProgressed;
321     bool m_hasBeenAskedToPaintGL { false };
322     bool m_hasAvailableVideoFrame { false };
323     bool m_allRenderersHaveAvailableSamples { false };
324     bool m_visible { false };
325     std::unique_ptr<TextureCacheCV> m_textureCache;
326     std::unique_ptr<VideoTextureCopierCV> m_videoTextureCopier;
327     RetainPtr<CVOpenGLTextureRef> m_lastTexture;
328 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
329     RefPtr<MediaPlaybackTarget> m_playbackTarget;
330     bool m_shouldPlayToTarget { false };
331 #endif
332     std::unique_ptr<VideoFullscreenLayerManagerObjC> m_videoFullscreenLayerManager;
333
334 #if !RELEASE_LOG_DISABLED
335     Ref<const Logger> m_logger;
336     const void* m_logIdentifier;
337 #endif
338 };
339
340 String convertEnumerationToString(MediaPlayerPrivateMediaSourceAVFObjC::SeekState);
341
342 }
343
344 namespace WTF {
345
346 template<typename Type>
347 struct LogArgument;
348
349 template <>
350 struct LogArgument<WebCore::MediaPlayerPrivateMediaSourceAVFObjC::SeekState> {
351     static String toString(const WebCore::MediaPlayerPrivateMediaSourceAVFObjC::SeekState state)
352     {
353         return convertEnumerationToString(state);
354     }
355 };
356
357 } // namespace WTF
358
359 #endif // ENABLE(MEDIA_SOURCE) && USE(AVFOUNDATION)
360
361 #endif // MediaPlayerPrivateMediaSourceAVFObjC_h
362