MediaPlayerPrivateMediaStreamAVFObjC.h [plain text]
#ifndef MediaPlayerPrivateMediaStreamAVFObjC_h
#define MediaPlayerPrivateMediaStreamAVFObjC_h
#if ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
#include "MediaPlayerPrivate.h"
#include "MediaSample.h"
#include "MediaStreamPrivate.h"
#include <wtf/Function.h>
#include <wtf/MediaTime.h>
#include <wtf/WeakPtr.h>
OBJC_CLASS AVSampleBufferAudioRenderer;
OBJC_CLASS AVSampleBufferDisplayLayer;
OBJC_CLASS AVSampleBufferRenderSynchronizer;
OBJC_CLASS AVStreamSession;
typedef struct opaqueCMSampleBuffer *CMSampleBufferRef;
namespace WebCore {
class AudioTrackPrivateMediaStream;
class AVVideoCaptureSource;
class Clock;
class MediaSourcePrivateClient;
class VideoTrackPrivateMediaStream;
#if PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE)
class VideoFullscreenLayerManager;
#endif
class MediaPlayerPrivateMediaStreamAVFObjC final : public MediaPlayerPrivateInterface, private MediaStreamPrivate::Observer, private MediaStreamTrackPrivate::Observer {
public:
explicit MediaPlayerPrivateMediaStreamAVFObjC(MediaPlayer*);
virtual ~MediaPlayerPrivateMediaStreamAVFObjC();
static void registerMediaEngine(MediaEngineRegistrar);
static bool isAvailable();
static void getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>& types);
static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
MediaPlayer::NetworkState networkState() const override;
void setNetworkState(MediaPlayer::NetworkState);
MediaPlayer::ReadyState readyState() const override;
void setReadyState(MediaPlayer::ReadyState);
WeakPtr<MediaPlayerPrivateMediaStreamAVFObjC> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }
void ensureLayer();
void destroyLayer();
private:
void load(const String&) override;
#if ENABLE(MEDIA_SOURCE)
void load(const String&, MediaSourcePrivateClient*) override;
#endif
void load(MediaStreamPrivate&) override;
void cancelLoad() override;
void prepareToPlay() override;
PlatformLayer* platformLayer() const override;
bool supportsFullscreen() const override { return true; }
void play() override;
void pause() override;
bool paused() const override;
void setVolume(float) override;
void internalSetVolume(float, bool);
void setMuted(bool) override;
bool supportsMuting() const override { return true; }
bool supportsScanning() const override { return false; }
FloatSize naturalSize() const override { return m_intrinsicSize; }
bool hasVideo() const override;
bool hasAudio() const override;
void setVisible(bool) override { }
MediaTime durationMediaTime() const override;
MediaTime currentMediaTime() const override;
bool seeking() const override { return false; }
std::unique_ptr<PlatformTimeRanges> seekable() const override;
std::unique_ptr<PlatformTimeRanges> buffered() const override;
bool didLoadingProgress() const override { return m_playing; }
void setSize(const IntSize&) override { }
void enqueueAudioSampleBufferFromTrack(MediaStreamTrackPrivate&, MediaSample&);
void prepareVideoSampleBufferFromTrack(MediaStreamTrackPrivate&, MediaSample&);
void enqueueVideoSampleBuffer(MediaSample&);
bool shouldEnqueueVideoSampleBuffer() const;
void flushAndRemoveVideoSampleBuffers();
void requestNotificationWhenReadyForMediaData();
void paint(GraphicsContext&, const FloatRect&) override;
void paintCurrentFrameInContext(GraphicsContext&, const FloatRect&) override;
bool metaDataAvailable() const { return m_mediaStreamPrivate && m_readyState >= MediaPlayer::HaveMetadata; }
void acceleratedRenderingStateChanged() override;
bool supportsAcceleratedRendering() const override { return true; }
bool hasSingleSecurityOrigin() const override { return true; }
MediaPlayer::MovieLoadType movieLoadType() const override { return MediaPlayer::LiveStream; }
String engineDescription() const override;
size_t extraMemoryCost() const override { return 0; }
bool ended() const override { return m_ended; }
bool shouldBePlaying() const;
MediaPlayer::ReadyState currentReadyState();
void updateReadyState();
void updateIntrinsicSize(const FloatSize&);
void updateTracks();
void renderingModeChanged();
void scheduleDeferredTask(Function<void ()>&&);
enum DisplayMode {
None,
PaintItBlack,
PausedImage,
LivePreview,
};
DisplayMode currentDisplayMode() const;
void updateDisplayMode();
void updatePausedImage();
void activeStatusChanged() override;
void characteristicsChanged() override;
void didAddTrack(MediaStreamTrackPrivate&) override;
void didRemoveTrack(MediaStreamTrackPrivate&) override;
void trackEnded(MediaStreamTrackPrivate&) override { };
void trackMutedChanged(MediaStreamTrackPrivate&) override { };
void trackSettingsChanged(MediaStreamTrackPrivate&) override { };
void trackEnabledChanged(MediaStreamTrackPrivate&) override { };
void sampleBufferUpdated(MediaStreamTrackPrivate&, MediaSample&) override;
#if PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE)
void setVideoFullscreenLayer(PlatformLayer*, std::function<void()> completionHandler) override;
void setVideoFullscreenFrame(FloatRect) override;
#endif
bool haveVideoLayer() const { return m_sampleBufferDisplayLayer || m_videoPreviewPlayer; }
MediaPlayer* m_player { nullptr };
WeakPtrFactory<MediaPlayerPrivateMediaStreamAVFObjC> m_weakPtrFactory;
RefPtr<MediaStreamPrivate> m_mediaStreamPrivate;
RefPtr<RealtimeMediaSourcePreview> m_videoPreviewPlayer;
RefPtr<MediaStreamTrackPrivate> m_videoTrack;
RetainPtr<AVSampleBufferDisplayLayer> m_sampleBufferDisplayLayer;
#if PLATFORM(MAC)
RetainPtr<AVSampleBufferRenderSynchronizer> m_synchronizer;
#endif
RetainPtr<CGImageRef> m_pausedImage;
double m_pausedTime { 0 };
std::unique_ptr<Clock> m_clock;
HashMap<String, RefPtr<AudioTrackPrivateMediaStream>> m_audioTrackMap;
HashMap<String, RefPtr<VideoTrackPrivateMediaStream>> m_videoTrackMap;
Deque<Ref<MediaSample>> m_sampleQueue;
MediaPlayer::NetworkState m_networkState { MediaPlayer::Empty };
MediaPlayer::ReadyState m_readyState { MediaPlayer::HaveNothing };
FloatSize m_intrinsicSize;
float m_volume { 1 };
DisplayMode m_displayMode { None };
bool m_playing { false };
bool m_muted { false };
bool m_haveEverPlayed { false };
bool m_ended { false };
bool m_hasEverEnqueuedVideoFrame { false };
bool m_hasReceivedMedia { false };
bool m_isFrameDisplayed { false };
#if PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE)
std::unique_ptr<VideoFullscreenLayerManager> m_videoFullscreenLayerManager;
#endif
};
}
#endif // ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
#endif // MediaPlayerPrivateMediaStreamAVFObjC_h