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 <CoreGraphics/CGAffineTransform.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;
OBJC_CLASS NSNumber;
OBJC_CLASS WebAVSampleBufferStatusChangeListener;
typedef struct opaqueCMSampleBuffer *CMSampleBufferRef;
namespace WebCore {
class AudioTrackPrivateMediaStreamCocoa;
class AVVideoCaptureSource;
class Clock;
class MediaSourcePrivateClient;
class PixelBufferConformerCV;
class VideoTrackPrivateMediaStream;
#if PLATFORM(IOS) || (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 ensureLayers();
void destroyLayers();
void layerStatusDidChange(AVSampleBufferDisplayLayer*);
void layerErrorDidChange(AVSampleBufferDisplayLayer*);
void backgroundLayerBoundsChanged();
PlatformLayer* displayLayer();
PlatformLayer* backgroundLayer();
private:
bool didPassCORSAccessCheck() const final;
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 supportsPictureInPicture() const override;
bool supportsFullscreen() const override { return true; }
void play() override;
void pause() override;
bool paused() const override { return !playing(); }
void setVolume(float) override;
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) final;
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 flushRenderers();
using PendingSampleQueue = Deque<Ref<MediaSample>>;
void addSampleToPendingQueue(PendingSampleQueue&, MediaSample&);
void removeOldSamplesFromPendingQueue(PendingSampleQueue&);
void updateSampleTimes(MediaSample&, const MediaTime&, const char*);
MediaTime calculateTimelineOffset(const MediaSample&, double);
void enqueueVideoSample(MediaStreamTrackPrivate&, MediaSample&);
void flushAndRemoveVideoSampleBuffers();
void requestNotificationWhenReadyForVideoData();
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; }
void setShouldBufferData(bool) override;
MediaPlayer::ReadyState currentReadyState();
void updateReadyState();
void updateTracks();
void updateRenderingMode();
void checkSelectedVideoTrack();
void updateDisplayLayer();
void scheduleDeferredTask(Function<void ()>&&);
enum DisplayMode {
None,
PaintItBlack,
PausedImage,
LivePreview,
};
DisplayMode currentDisplayMode() const;
bool updateDisplayMode();
void updateCurrentFrameImage();
enum class PlaybackState {
None,
Playing,
Paused,
};
bool playing() const { return m_playbackState == PlaybackState::Playing; }
void activeStatusChanged() override;
void characteristicsChanged() override;
void didAddTrack(MediaStreamTrackPrivate&) override;
void didRemoveTrack(MediaStreamTrackPrivate&) override;
void trackStarted(MediaStreamTrackPrivate&) override { };
void trackEnded(MediaStreamTrackPrivate&) override { };
void trackMutedChanged(MediaStreamTrackPrivate&) override { };
void trackSettingsChanged(MediaStreamTrackPrivate&) override { };
void trackEnabledChanged(MediaStreamTrackPrivate&) override { };
void sampleBufferUpdated(MediaStreamTrackPrivate&, MediaSample&) override;
void readyStateChanged(MediaStreamTrackPrivate&) override;
#if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
void setVideoFullscreenLayer(PlatformLayer*, WTF::Function<void()>&& completionHandler) override;
void setVideoFullscreenFrame(FloatRect) override;
#endif
MediaTime streamTime() const;
AudioSourceProvider* audioSourceProvider() final;
CGAffineTransform videoTransformationMatrix(MediaSample&, bool forceUpdate = false);
MediaPlayer* m_player { nullptr };
WeakPtrFactory<MediaPlayerPrivateMediaStreamAVFObjC> m_weakPtrFactory;
RefPtr<MediaStreamPrivate> m_mediaStreamPrivate;
RefPtr<MediaStreamTrackPrivate> m_activeVideoTrack;
RetainPtr<WebAVSampleBufferStatusChangeListener> m_statusChangeListener;
RetainPtr<AVSampleBufferDisplayLayer> m_sampleBufferDisplayLayer;
RetainPtr<PlatformLayer> m_backgroundLayer;
std::unique_ptr<Clock> m_clock;
MediaTime m_pausedTime;
struct CurrentFramePainter {
CurrentFramePainter() = default;
void reset();
RetainPtr<CGImageRef> cgImage;
RefPtr<MediaSample> mediaSample;
std::unique_ptr<PixelBufferConformerCV> pixelBufferConformer;
};
CurrentFramePainter m_imagePainter;
HashMap<String, RefPtr<AudioTrackPrivateMediaStreamCocoa>> m_audioTrackMap;
HashMap<String, RefPtr<VideoTrackPrivateMediaStream>> m_videoTrackMap;
PendingSampleQueue m_pendingVideoSampleQueue;
MediaPlayer::NetworkState m_networkState { MediaPlayer::Empty };
MediaPlayer::ReadyState m_readyState { MediaPlayer::HaveNothing };
FloatSize m_intrinsicSize;
float m_volume { 1 };
DisplayMode m_displayMode { None };
PlaybackState m_playbackState { PlaybackState::None };
MediaSample::VideoRotation m_videoRotation { MediaSample::VideoRotation::None };
CGAffineTransform m_videoTransform;
bool m_videoMirrored { false };
bool m_playing { false };
bool m_muted { false };
bool m_ended { false };
bool m_hasEverEnqueuedVideoFrame { false };
bool m_pendingSelectedTrackCheck { false };
bool m_shouldDisplayFirstVideoFrame { false };
bool m_transformIsValid { false };
bool m_visible { false };
bool m_haveSeenMetadata { false };
#if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
std::unique_ptr<VideoFullscreenLayerManager> m_videoFullscreenLayerManager;
#endif
};
}
#endif // ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
#endif // MediaPlayerPrivateMediaStreamAVFObjC_h