init

Telegram/SourceFiles/media/streaming/media_streaming_video_track.h

@@ -0,0 +1,186 @@
+/*
+This file is part of Telegram Desktop,
+the official desktop application for the Telegram messaging service.
+
+For license and copyright information please follow this link:
+https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
+*/
+#pragma once
+
+#include "media/streaming/media_streaming_utility.h"
+
+#include <crl/crl_object_on_queue.h>
+
+namespace Media {
+namespace Streaming {
+
+constexpr auto kFrameDisplayTimeAlreadyDone
+	= std::numeric_limits<crl::time>::max();
+
+class VideoTrackObject;
+class Instance;
+
+class VideoTrack final {
+public:
+	// Called from some unspecified thread.
+	// Callbacks are assumed to be thread-safe.
+	VideoTrack(
+		const PlaybackOptions &options,
+		Stream &&stream,
+		const AudioMsgId &audioId,
+		FnMut<void(const Information &)> ready,
+		Fn<void(Error)> error);
+
+	// Thread-safe.
+	[[nodiscard]] int streamIndex() const;
+	[[nodiscard]] AVRational streamTimeBase() const;
+	[[nodiscard]] crl::time streamDuration() const;
+
+	// Called from the same unspecified thread.
+	void process(std::vector<FFmpeg::Packet> &&packets);
+	void waitForData();
+
+	// Called from the main thread.
+	// Must be called after 'ready' was invoked.
+	void pause(crl::time time);
+	void resume(crl::time time);
+
+	// Called from the main thread.
+	void setSpeed(float64 speed);
+	void setWaitForMarkAsShown(bool wait);
+
+	// Called from the main thread.
+	// Returns the position of the displayed frame.
+	[[nodiscard]] crl::time markFrameDisplayed(crl::time now);
+	void addTimelineDelay(crl::time delayed);
+	bool markFrameShown();
+	[[nodiscard]] crl::time nextFrameDisplayTime() const;
+	[[nodiscard]] QImage frame(
+		const FrameRequest &request,
+		const Instance *instance);
+	[[nodiscard]] FrameWithInfo frameWithInfo(
+		const FrameRequest &request,
+		const Instance *instance);
+	[[nodiscard]] FrameWithInfo frameWithInfo(const Instance *instance);
+	[[nodiscard]] QImage currentFrameImage();
+	void unregisterInstance(not_null<const Instance*> instance);
+	[[nodiscard]] rpl::producer<> checkNextFrame() const;
+	[[nodiscard]] rpl::producer<> waitingForData() const;
+
+	// Called from the main thread.
+	~VideoTrack();
+
+private:
+	friend class VideoTrackObject;
+
+	struct Prepared {
+		Prepared(const FrameRequest &request) : request(request) {
+		}
+
+		FrameRequest request = FrameRequest::NonStrict();
+		QImage image;
+	};
+	struct Frame {
+		FFmpeg::FramePointer decoded = FFmpeg::MakeFramePointer();
+		FFmpeg::FramePointer transferred;
+		QImage original;
+		FrameYUV yuv;
+		crl::time position = kTimeUnknown;
+		crl::time displayed = kTimeUnknown;
+		crl::time display = kTimeUnknown;
+		FrameFormat format = FrameFormat::None;
+
+		base::flat_map<const Instance*, Prepared> prepared;
+
+		int index = 0;
+		bool alpha = false;
+	};
+	struct FrameWithIndex {
+		not_null<Frame*> frame;
+		int index = -1;
+	};
+
+	class Shared {
+	public:
+		using PrepareFrame = not_null<Frame*>;
+		using PrepareNextCheck = crl::time;
+		using PrepareState = std::variant<
+			v::null_t,
+			PrepareFrame,
+			PrepareNextCheck>;
+		struct PresentFrame {
+			crl::time displayPosition = kTimeUnknown;
+			crl::time nextCheckDelay = 0;
+			crl::time addedWorldTimeDelay = 0;
+		};
+
+		// Called from the wrapped object queue.
+		void init(QImage &&cover, bool hasAlpha, crl::time position);
+		[[nodiscard]] bool initialized() const;
+
+		[[nodiscard]] PrepareState prepareState(
+			crl::time trackTime,
+			bool dropStaleFrames);
+
+		[[nodiscard]] PresentFrame presentFrame(
+			not_null<VideoTrackObject*> object,
+			TimePoint trackTime,
+			float64 playbackSpeed,
+			bool dropStaleFrames);
+		[[nodiscard]] bool firstPresentHappened() const;
+
+		// Called from the main thread.
+		// Returns the position of the displayed frame.
+		[[nodiscard]] crl::time markFrameDisplayed(crl::time now);
+		void addTimelineDelay(crl::time delayed);
+		bool markFrameShown();
+		[[nodiscard]] crl::time nextFrameDisplayTime() const;
+		[[nodiscard]] not_null<Frame*> frameForPaint();
+		[[nodiscard]] FrameWithIndex frameForPaintWithIndex();
+
+	private:
+		[[nodiscard]] not_null<Frame*> getFrame(int index);
+		[[nodiscard]] not_null<const Frame*> getFrame(int index) const;
+		[[nodiscard]] int counter() const;
+
+		static constexpr auto kCounterUninitialized = -1;
+		std::atomic<int> _counter = kCounterUninitialized;
+
+		static constexpr auto kFramesCount = 4;
+		std::array<Frame, kFramesCount> _frames;
+
+		// (_counter % 2) == 1 main thread can write _delay.
+		// (_counter % 2) == 0 crl::queue can read _delay.
+		crl::time _delay = kTimeUnknown;
+
+	};
+
+	static void PrepareFrameByRequests(
+		not_null<Frame*> frame,
+		const AVRational &aspect,
+		int rotation);
+	[[nodiscard]] static bool IsDecoded(not_null<const Frame*> frame);
+	[[nodiscard]] static bool IsRasterized(not_null<const Frame*> frame);
+	[[nodiscard]] static bool IsStale(
+		not_null<const Frame*> frame,
+		crl::time trackTime);
+
+	[[nodiscard]] QImage frameImage(
+		not_null<Frame*> frame,
+		const FrameRequest &request,
+		const Instance *instance);
+
+	const int _streamIndex = 0;
+	const AVRational _streamTimeBase;
+	const crl::time _streamDuration = 0;
+	const int _streamRotation = 0;
+	const AVRational _streamAspect = FFmpeg::kNormalAspect;
+	std::unique_ptr<Shared> _shared;
+
+	using Implementation = VideoTrackObject;
+	crl::object_on_queue<Implementation> _wrapped;
+
+};
+
+} // namespace Streaming
+} // namespace Media