If stuck wait for three seconds of packets.

Telegram/SourceFiles/data/data_document.cpp

@@ -297,9 +297,10 @@ void StartStreaming(
 		static auto player = std::unique_ptr<Player>();
 		static auto pauseOnSeek = false;
 		static auto position = crl::time(0);
-		static auto preloaded = crl::time(0);
+		static auto preloadedAudio = crl::time(0);
+		static auto preloadedVideo = crl::time(0);
 		static auto duration = crl::time(0);
-		static auto options = Media::Streaming::PlaybackOptions();
+		static auto options = PlaybackOptions();
 		static auto speed = 1.;
 		static auto step = pow(2., 1. / 12);
 		static auto frame = QImage();
@@ -343,10 +344,14 @@ void StartStreaming(
 				if (player->ready()) {
 					frame = player->frame({});
 				}
-				preloaded = position = options.position = std::clamp(
+				preloadedAudio
-					(duration * e->pos().x()) / width(),
+					= preloadedVideo
-					crl::time(0),
+					= position
-					crl::time(duration));
+					= options.position
+					= std::clamp(
+						(duration * e->pos().x()) / width(),
+						crl::time(0),
+						crl::time(duration));
 				player->play(options);
 			}
 
@@ -367,7 +372,7 @@ void StartStreaming(
 
 		options.speed = speed;
 		//options.syncVideoByAudio = false;
-		preloaded = position = options.position = 0;
+		preloadedAudio = preloadedVideo = position = options.position = 0;
 		frame = QImage();
 		player->play(options);
 		player->updates(
@@ -391,7 +396,9 @@ void StartStreaming(
 							? (position * video->width() / duration)
 							: 0;
 						const auto till2 = duration
-							? (preloaded * video->width() / duration)
+							? (std::min(preloadedAudio, preloadedVideo)
+								* video->width()
+								/ duration)
 							: 0;
 						if (player->ready()) {
 							Painter(video.get()).drawImage(
@@ -437,9 +444,11 @@ void StartStreaming(
 					}, video->lifetime());
 				}
 			}, [&](PreloadedVideo &update) {
-				if (preloaded < update.till) {
+				if (preloadedVideo < update.till) {
-					preloaded = update.till;
+					if (preloadedVideo < preloadedAudio) {
-					video->update();
+						video->update();
+					}
+					preloadedVideo = update.till;
 				}
 			}, [&](UpdateVideo &update) {
 				Expects(video != nullptr);
@@ -449,11 +458,11 @@ void StartStreaming(
 				}
 				video->update();
 			}, [&](PreloadedAudio &update) {
-				if (preloaded < update.till) {
+				if (preloadedAudio < update.till) {
-					preloaded = update.till;
+					if (video && preloadedAudio < preloadedVideo) {
-					if (video) {
 						video->update();
 					}
+					preloadedAudio = update.till;
 				}
 			}, [&](UpdateAudio &update) {
 				if (position < update.position) {

Telegram/SourceFiles/history/media/history_media_document.cpp

@@ -645,7 +645,7 @@ bool HistoryDocument::updateStatusText() const {
 
 				statusSize = -1 - (state.position / state.frequency);
 				realDuration = (state.length / state.frequency);
-				showPause = (state.state == State::Playing || state.state == State::Resuming || state.state == State::Starting);
+				showPause = Media::Player::ShowPauseIcon(state.state);
 			} else {
 				if (auto voice = Get<HistoryDocumentVoice>()) {
 					voice->checkPlaybackFinished();
@@ -660,7 +660,7 @@ bool HistoryDocument::updateStatusText() const {
 				&& !Media::Player::IsStoppedOrStopping(state.state)) {
 				statusSize = -1 - (state.position / state.frequency);
 				realDuration = (state.length / state.frequency);
-				showPause = (state.state == State::Playing || state.state == State::Resuming || state.state == State::Starting);
+				showPause = Media::Player::ShowPauseIcon(state.state);
 			} else {
 			}
 			if (!showPause && (state.id == AudioMsgId(_data, _parent->data()->fullId()))) {

Telegram/SourceFiles/inline_bots/inline_bot_layout_internal.cpp

@@ -901,7 +901,7 @@ bool File::updateStatusText() const {
 			if (state.id == AudioMsgId(_document, FullMsgId()) && !Media::Player::IsStoppedOrStopping(state.state)) {
 				statusSize = -1 - (state.position / state.frequency);
 				realDuration = (state.length / state.frequency);
-				showPause = (state.state == State::Playing || state.state == State::Resuming || state.state == State::Starting);
+				showPause = Media::Player::ShowPauseIcon(state.state);
 			}
 		} else if (_document->isAudioFile()) {
 			statusSize = FileStatusSizeLoaded;
@@ -909,7 +909,7 @@ bool File::updateStatusText() const {
 			if (state.id == AudioMsgId(_document, FullMsgId()) && !Media::Player::IsStoppedOrStopping(state.state)) {
 				statusSize = -1 - (state.position / state.frequency);
 				realDuration = (state.length / state.frequency);
-				showPause = (state.state == State::Playing || state.state == State::Resuming || state.state == State::Starting);
+				showPause = Media::Player::ShowPauseIcon(state.state);
 			}
 			if (!showPause && (state.id == AudioMsgId(_document, FullMsgId())) && Media::Player::instance()->isSeeking(AudioMsgId::Type::Song)) {
 				showPause = true;

Telegram/SourceFiles/media/audio/media_audio.cpp

@@ -436,7 +436,9 @@ void Mixer::Track::reattach(AudioMsgId::Type type) {
 	}
 
 	alSourcei(stream.source, AL_SAMPLE_OFFSET, qMax(state.position - bufferedPosition, 0LL));
-	if (!IsStopped(state.state) && state.state != State::PausedAtEnd) {
+	if (!IsStopped(state.state)
+		&& (state.state != State::PausedAtEnd)
+		&& !state.waitingForData) {
 		alSourcef(stream.source, AL_GAIN, ComputeVolume(type));
 		alSourcePlay(stream.source);
 		if (IsPaused(state.state)) {
@@ -449,6 +451,7 @@ void Mixer::Track::reattach(AudioMsgId::Type type) {
 }
 
 void Mixer::Track::detach() {
+	getNotQueuedBufferIndex();
 	resetStream();
 	destroyStream();
 }
@@ -711,20 +714,28 @@ void Mixer::resetFadeStartPosition(AudioMsgId::Type type, int positionInBuffered
 	if (positionInBuffered < 0) {
 		Audio::AttachToDevice();
 		if (track->isStreamCreated()) {
-			ALint currentPosition = 0;
+			ALint alSampleOffset = 0;
-			alGetSourcei(track->stream.source, AL_SAMPLE_OFFSET, &currentPosition);
+			ALint alState = AL_INITIAL;
+			alGetSourcei(track->stream.source, AL_SAMPLE_OFFSET, &alSampleOffset);
+			alGetSourcei(track->stream.source, AL_SOURCE_STATE, &alState);
 			if (Audio::PlaybackErrorHappened()) {
 				setStoppedState(track, State::StoppedAtError);
 				onError(track->state.id);
 				return;
-			}
+			} else if ((alState == AL_STOPPED)
-
+				&& (alSampleOffset == 0)
-			if (currentPosition == 0 && !internal::CheckAudioDeviceConnected()) {
+				&& !internal::CheckAudioDeviceConnected()) {
 				track->fadeStartPosition = track->state.position;
 				return;
 			}
 
-			positionInBuffered = currentPosition;
+			const auto stoppedAtEnd = (alState == AL_STOPPED)
+				&& (!IsStopped(track->state.state)
+					|| IsStoppedAtEnd(track->state.state))
+				|| track->state.waitingForData;
+			positionInBuffered = stoppedAtEnd
+				? track->bufferedLength
+				: alSampleOffset;
 		} else {
 			positionInBuffered = 0;
 		}
@@ -1406,10 +1417,7 @@ void Fader::onTimer() {
 }
 
 int32 Fader::updateOnePlayback(Mixer::Track *track, bool &hasPlaying, bool &hasFading, float64 volumeMultiplier, bool volumeChanged) {
-	auto playing = false;
+	const auto errorHappened = [&] {
-	auto fading = false;
-
-	auto errorHappened = [this, track] {
 		if (Audio::PlaybackErrorHappened()) {
 			setStoppedState(track, State::StoppedAtError);
 			return true;
@@ -1417,32 +1425,34 @@ int32 Fader::updateOnePlayback(Mixer::Track *track, bool &hasPlaying, bool &hasF
 		return false;
 	};
 
-	ALint positionInBuffered = 0;
+	ALint alSampleOffset = 0;
-	ALint state = AL_INITIAL;
+	ALint alState = AL_INITIAL;
-	alGetSourcei(track->stream.source, AL_SAMPLE_OFFSET, &positionInBuffered);
+	alGetSourcei(track->stream.source, AL_SAMPLE_OFFSET, &alSampleOffset);
-	alGetSourcei(track->stream.source, AL_SOURCE_STATE, &state);
+	alGetSourcei(track->stream.source, AL_SOURCE_STATE, &alState);
-	if (errorHappened()) return EmitError;
+	if (errorHappened()) {
+		return EmitError;
+	} else if ((alState == AL_STOPPED)
+		&& (alSampleOffset == 0)
+		&& !internal::CheckAudioDeviceConnected()) {
+		return 0;
+	}
 
 	int32 emitSignals = 0;
+	const auto stoppedAtEnd = (alState == AL_STOPPED)
+		&& (!IsStopped(track->state.state)
+			|| IsStoppedAtEnd(track->state.state))
+		|| track->state.waitingForData;
+	const auto positionInBuffered = stoppedAtEnd
+		? track->bufferedLength
+		: alSampleOffset;
+	const auto waitingForDataOld = track->state.waitingForData;
+	track->state.waitingForData = stoppedAtEnd
+		&& (track->state.state != State::Stopping);
+	const auto fullPosition = track->bufferedPosition + positionInBuffered;
 
-	if (state == AL_STOPPED && positionInBuffered == 0 && !internal::CheckAudioDeviceConnected()) {
+	auto playing = (track->state.state == State::Playing);
-		return emitSignals;
+	auto fading = IsFading(track->state.state);
-	}
+	if (alState != AL_PLAYING && !track->loading) {
-
-	switch (track->state.state) {
-	case State::Stopping:
-	case State::Pausing:
-	case State::Starting:
-	case State::Resuming: {
-		fading = true;
-	} break;
-	case State::Playing: {
-		playing = true;
-	} break;
-	}
-
-	auto fullPosition = track->bufferedPosition + positionInBuffered;
-	if (state != AL_PLAYING && !track->loading) {
 		if (fading || playing) {
 			fading = false;
 			playing = false;
@@ -1456,7 +1466,7 @@ int32 Fader::updateOnePlayback(Mixer::Track *track, bool &hasPlaying, bool &hasF
 			if (errorHappened()) return EmitError;
 			emitSignals |= EmitStopped;
 		}
-	} else if (fading && state == AL_PLAYING) {
+	} else if (fading && alState == AL_PLAYING) {
 		auto fadingForSamplesCount = (fullPosition - track->fadeStartPosition);
 		if (crl::time(1000) * fadingForSamplesCount >= kFadeDuration * track->state.frequency) {
 			fading = false;
@@ -1466,7 +1476,7 @@ int32 Fader::updateOnePlayback(Mixer::Track *track, bool &hasPlaying, bool &hasF
 			switch (track->state.state) {
 			case State::Stopping: {
 				setStoppedState(track);
-				state = AL_STOPPED;
+				alState = AL_STOPPED;
 			} break;
 			case State::Pausing: {
 				alSourcePause(track->stream.source);
@@ -1488,15 +1498,22 @@ int32 Fader::updateOnePlayback(Mixer::Track *track, bool &hasPlaying, bool &hasF
 			alSourcef(track->stream.source, AL_GAIN, newGain * volumeMultiplier);
 			if (errorHappened()) return EmitError;
 		}
-	} else if (playing && state == AL_PLAYING) {
+	} else if (playing && alState == AL_PLAYING) {
 		if (volumeChanged) {
 			alSourcef(track->stream.source, AL_GAIN, 1. * volumeMultiplier);
 			if (errorHappened()) return EmitError;
 		}
 	}
-	if (state == AL_PLAYING && fullPosition >= track->state.position + kCheckPlaybackPositionDelta) {
+	if (alState == AL_PLAYING && fullPosition >= track->state.position + kCheckPlaybackPositionDelta) {
 		track->state.position = fullPosition;
 		emitSignals |= EmitPositionUpdated;
+	} else if (track->state.waitingForData && !waitingForDataOld) {
+		if (fullPosition > track->state.position) {
+			track->state.position = fullPosition;
+		}
+		// When stopped because of insufficient data while streaming,
+		// inform the player about the last position we were at.
+		emitSignals |= EmitPositionUpdated;
 	}
 	if (playing || track->state.state == State::Starting || track->state.state == State::Resuming) {
 		if (!track->loaded && !track->loading) {

Telegram/SourceFiles/media/audio/media_audio.h

@@ -88,6 +88,10 @@ inline bool IsPaused(State state) {
 		|| (state == State::PausedAtEnd);
 }
 
+inline bool IsPausedOrPausing(State state) {
+	return IsPaused(state) || (state == State::Pausing);
+}
+
 inline bool IsFading(State state) {
 	return (state == State::Starting)
 		|| (state == State::Stopping)
@@ -99,12 +103,18 @@ inline bool IsActive(State state) {
 	return !IsStopped(state) && !IsPaused(state);
 }
 
+inline bool ShowPauseIcon(State state) {
+	return !IsStoppedOrStopping(state)
+		&& !IsPausedOrPausing(state);
+}
+
 struct TrackState {
 	AudioMsgId id;
 	State state = State::Stopped;
 	int64 position = 0;
 	int64 length = 0;
 	int frequency = kDefaultFrequency;
+	bool waitingForData = false;
 };
 
 class Mixer : public QObject, private base::Subscriber {

Telegram/SourceFiles/media/audio/media_audio_loaders.cpp

@@ -227,9 +227,10 @@ void Loaders::loadData(AudioMsgId audio, crl::time positionMs) {
 		return;
 	}
 
-	if (started) {
+	if (started || samplesCount) {
 		Audio::AttachToDevice();
-
+	}
+	if (started) {
 		track->started();
 		if (!internal::audioCheckError()) {
 			setStoppedState(track, State::StoppedAtStart);
@@ -263,12 +264,6 @@ void Loaders::loadData(AudioMsgId audio, crl::time positionMs) {
 			l->setForceToBuffer(false);
 		}
 
-		//LOG(("[%4] PUSHING %1 SAMPLES (%2 BYTES) %3ms"
-		//	).arg(samplesCount
-		//	).arg(samples.size()
-		//	).arg((samplesCount * 1000LL) / track->frequency
-		//	).arg(crl::now() % 10000, 4, 10, QChar('0')));
-
 		track->bufferSamples[bufferIndex] = samples;
 		track->samplesCount[bufferIndex] = samplesCount;
 		track->bufferedLength += samplesCount;
@@ -287,6 +282,7 @@ void Loaders::loadData(AudioMsgId audio, crl::time positionMs) {
 		}
 		finished = true;
 	}
+	track->state.waitingForData = false;
 
 	if (finished) {
 		track->loaded = true;
@@ -295,44 +291,47 @@ void Loaders::loadData(AudioMsgId audio, crl::time positionMs) {
 	}
 
 	track->loading = false;
-	if (track->state.state == State::Resuming || track->state.state == State::Playing || track->state.state == State::Starting) {
+	if (IsPausedOrPausing(track->state.state)
-		ALint state = AL_INITIAL;
+		|| IsStoppedOrStopping(track->state.state)) {
-		alGetSourcei(track->stream.source, AL_SOURCE_STATE, &state);
+		return;
-		if (internal::audioCheckError()) {
+	}
-			if (state != AL_PLAYING) {
+	ALint state = AL_INITIAL;
-				if (state == AL_STOPPED && !internal::CheckAudioDeviceConnected()) {
+	alGetSourcei(track->stream.source, AL_SOURCE_STATE, &state);
-					return;
+	if (!internal::audioCheckError()) {
-				}
+		setStoppedState(track, State::StoppedAtError);
+		emitError(type);
+		return;
+	}
 
-				alSourcef(track->stream.source, AL_GAIN, ComputeVolume(type));
+	if (state == AL_PLAYING) {
-				if (!internal::audioCheckError()) {
+		return;
-					setStoppedState(track, State::StoppedAtError);
+	} else if (state == AL_STOPPED && !internal::CheckAudioDeviceConnected()) {
-					emitError(type);
+		return;
-					return;
+	}
-				}
 
-				if (state == AL_STOPPED) {
+	alSourcef(track->stream.source, AL_GAIN, ComputeVolume(type));
-					alSourcei(track->stream.source, AL_SAMPLE_OFFSET, qMax(track->state.position - track->bufferedPosition, 0LL));
+	if (!internal::audioCheckError()) {
-					if (!internal::audioCheckError()) {
+		setStoppedState(track, State::StoppedAtError);
-						setStoppedState(track, State::StoppedAtError);
+		emitError(type);
-						emitError(type);
+		return;
-						return;
+	}
-					}
-				}
-				alSourcePlay(track->stream.source);
-				if (!internal::audioCheckError()) {
-					setStoppedState(track, State::StoppedAtError);
-					emitError(type);
-					return;
-				}
 
-				emit needToCheck();
+	if (state == AL_STOPPED) {
-			}
+		alSourcei(track->stream.source, AL_SAMPLE_OFFSET, qMax(track->state.position - track->bufferedPosition, 0LL));
-		} else {
+		if (!internal::audioCheckError()) {
 			setStoppedState(track, State::StoppedAtError);
 			emitError(type);
+			return;
 		}
 	}
+	alSourcePlay(track->stream.source);
+	if (!internal::audioCheckError()) {
+		setStoppedState(track, State::StoppedAtError);
+		emitError(type);
+		return;
+	}
+
+	emit needToCheck();
 }
 
 AudioPlayerLoader *Loaders::setupLoader(

Telegram/SourceFiles/media/player/media_player_cover.cpp

@@ -246,7 +246,7 @@ void CoverWidget::handleSongUpdate(const TrackState &state) {
 	}
 
 	auto stopped = IsStoppedOrStopping(state.state);
-	auto showPause = !stopped && (state.state == State::Playing || state.state == State::Resuming || state.state == State::Starting);
+	auto showPause = ShowPauseIcon(state.state);
 	if (instance()->isSeeking(AudioMsgId::Type::Song)) {
 		showPause = true;
 	}

Telegram/SourceFiles/media/player/media_player_instance.cpp

@@ -403,7 +403,7 @@ void Instance::playPauseCancelClicked(AudioMsgId::Type type) {
 
 	auto state = mixer()->currentState(type);
 	auto stopped = IsStoppedOrStopping(state.state);
-	auto showPause = !stopped && (state.state == State::Playing || state.state == State::Resuming || state.state == State::Starting);
+	auto showPause = ShowPauseIcon(state.state);
 	auto audio = state.id.audio();
 	if (audio && audio->loading()) {
 		audio->cancel();

Telegram/SourceFiles/media/player/media_player_widget.cpp

@@ -436,7 +436,7 @@ void Widget::handleSongUpdate(const TrackState &state) {
 	}
 
 	auto stopped = IsStoppedOrStopping(state.state);
-	auto showPause = !stopped && (state.state == State::Playing || state.state == State::Resuming || state.state == State::Starting);
+	auto showPause = ShowPauseIcon(state.state);
 	if (instance()->isSeeking(_type)) {
 		showPause = true;
 	}

Telegram/SourceFiles/media/streaming/media_streaming_audio_track.cpp

@@ -164,6 +164,10 @@ void AudioTrack::setSpeed(float64 speed) {
 	Media::Player::mixer()->setSpeedFromVideo(_audioId, speed);
 }
 
+rpl::producer<> AudioTrack::waitingForData() const {
+	return _waitingForData.events();
+}
+
 rpl::producer<crl::time> AudioTrack::playPosition() {
 	Expects(_ready == nullptr);
 
@@ -194,6 +198,9 @@ rpl::producer<crl::time> AudioTrack::playPosition() {
 			case State::Stopping:
 			case State::Pausing:
 			case State::Resuming:
+				if (state.waitingForData) {
+					_waitingForData.fire({});
+				}
 				_playPosition = state.position * 1000 / state.frequency;
 				return;
 			case State::Paused:

Telegram/SourceFiles/media/streaming/media_streaming_audio_track.h

@@ -30,6 +30,7 @@ public:
 
 	// Called from the main thread.
 	void setSpeed(float64 speed);
+	[[nodiscard]] rpl::producer<> waitingForData() const;
 
 	// Called from the main thread.
 	// Non-const, because we subscribe to changes on the first call.
@@ -75,6 +76,7 @@ private:
 
 	// Accessed from the main thread.
 	base::Subscription _subscription;
+	rpl::event_stream<> _waitingForData;
 	// First set from the same unspecified thread before _ready is called.
 	// After that accessed from the main thread.
 	rpl::variable<crl::time> _playPosition;

Telegram/SourceFiles/media/streaming/media_streaming_player.cpp

@@ -17,6 +17,24 @@ namespace Media {
 namespace Streaming {
 namespace {
 
+constexpr auto kReceivedTillEnd = std::numeric_limits<crl::time>::max();
+constexpr auto kBufferFor = crl::time(3000);
+
+[[nodiscard]] crl::time TrackClampReceivedTill(
+		crl::time position,
+		const TrackState &state) {
+	return (state.duration == kTimeUnknown || position == kTimeUnknown)
+		? position
+		: (position == kReceivedTillEnd)
+		? state.duration
+		: std::clamp(position, 0LL, state.duration - 1);
+}
+
+[[nodiscard]] bool FullTrackReceived(const TrackState &state) {
+	return (state.duration != kTimeUnknown)
+		&& (state.receivedTill == state.duration);
+}
+
 void SaveValidStateInformation(TrackState &to, TrackState &&from) {
 	Expects(from.position != kTimeUnknown);
 	Expects(from.receivedTill != kTimeUnknown);
@@ -74,6 +92,7 @@ not_null<FileDelegate*> Player::delegate() {
 
 void Player::checkNextFrame() {
 	Expects(_nextFrameTime != kTimeUnknown);
+	Expects(!_renderFrameTimer.isActive());
 
 	const auto now = crl::now();
 	if (now < _nextFrameTime) {
@@ -85,12 +104,12 @@ void Player::checkNextFrame() {
 }
 
 void Player::renderFrame(crl::time now) {
-	if (_video) {
+	Expects(_video != nullptr);
-		const auto position = _video->markFrameDisplayed(now);
+
-		if (position != kTimeUnknown) {
+	const auto position = _video->markFrameDisplayed(now);
-			videoPlayedTill(position);
+	Assert(position != kTimeUnknown);
-		}
+
-	}
+	videoPlayedTill(position);
 }
 
 template <typename Track>
@@ -104,7 +123,7 @@ void Player::trackReceivedTill(
 		position = std::clamp(position, 0LL, state.duration);
 		if (state.receivedTill < position) {
 			state.receivedTill = position;
-			_updates.fire({ PreloadedUpdate<Track>{ position } });
+			trackSendReceivedTill(track, state);
 		}
 	} else {
 		state.receivedTill = position;
@@ -125,10 +144,22 @@ void Player::trackPlayedTill(
 	}
 }
 
+template <typename Track>
+void Player::trackSendReceivedTill(
+		const Track &track,
+		TrackState &state) {
+	Expects(state.duration != kTimeUnknown);
+	Expects(state.receivedTill != kTimeUnknown);
+
+	_updates.fire({ PreloadedUpdate<Track>{ state.receivedTill } });
+}
+
 void Player::audioReceivedTill(crl::time position) {
 	Expects(_audio != nullptr);
 
+	position = TrackClampReceivedTill(position, _information.audio.state);
 	trackReceivedTill(*_audio, _information.audio.state, position);
+	checkResumeFromWaitingForData();
 }
 
 void Player::audioPlayedTill(crl::time position) {
@@ -140,6 +171,7 @@ void Player::audioPlayedTill(crl::time position) {
 void Player::videoReceivedTill(crl::time position) {
 	Expects(_video != nullptr);
 
+	position = TrackClampReceivedTill(position, _information.video.state);
 	trackReceivedTill(*_video, _information.video.state, position);
 }
 
@@ -298,12 +330,13 @@ void Player::provideStartInformation() {
 
 		if (_stage == Stage::Ready && !_paused) {
 			_paused = true;
-			resume();
+			updatePausedState();
 		}
 	}
 }
 
 void Player::fail() {
+	_sessionLifetime = rpl::lifetime();
 	const auto stopGuarded = crl::guard(&_sessionGuard, [=] { stop(); });
 	_stage = Stage::Failed;
 	_updates.fire_error({});
@@ -326,11 +359,35 @@ void Player::play(const PlaybackOptions &options) {
 void Player::pause() {
 	Expects(valid());
 
-	if (_paused) {
+	_pausedByUser = true;
+	updatePausedState();
+}
+
+void Player::resume() {
+	Expects(valid());
+
+	_pausedByUser = false;
+	updatePausedState();
+}
+
+void Player::updatePausedState() {
+	const auto paused = _pausedByUser || _pausedByWaitingForData;
+	if (_paused == paused) {
 		return;
 	}
-	_paused = true;
+	_paused = paused;
-	if (_stage == Stage::Started) {
+	if (!_paused && _stage == Stage::Ready) {
+		const auto guard = base::make_weak(&_sessionGuard);
+		start();
+		if (!guard) {
+			return;
+		}
+	}
+
+	if (_stage != Stage::Started) {
+		return;
+	}
+	if (_paused) {
 		_pausedTime = crl::now();
 		if (_audio) {
 			_audio->pause(_pausedTime);
@@ -338,20 +395,7 @@ void Player::pause() {
 		if (_video) {
 			_video->pause(_pausedTime);
 		}
-	}
+	} else {
-}
-
-void Player::resume() {
-	Expects(valid());
-
-	if (!_paused) {
-		return;
-	}
-	_paused = false;
-	if (_stage == Stage::Ready) {
-		start();
-	}
-	if (_stage == Stage::Started) {
 		_startedTime = crl::now();
 		if (_audio) {
 			_audio->resume(_startedTime);
@@ -362,48 +406,85 @@ void Player::resume() {
 	}
 }
 
+bool Player::trackReceivedEnough(const TrackState &state) const {
+	return FullTrackReceived(state)
+		|| (state.position + kBufferFor <= state.receivedTill);
+}
+
+void Player::checkResumeFromWaitingForData() {
+	if (_pausedByWaitingForData
+		&& (!_audio || trackReceivedEnough(_information.audio.state))
+		&& (!_video || trackReceivedEnough(_information.video.state))) {
+		_pausedByWaitingForData = false;
+		updatePausedState();
+	}
+}
+
 void Player::start() {
 	Expects(_stage == Stage::Ready);
 
 	_stage = Stage::Started;
-	if (_audio) {
+	const auto guard = base::make_weak(&_sessionGuard);
+
+	rpl::merge(
+		_audio ? _audio->waitingForData() : rpl::never(),
+		_video ? _video->waitingForData() : rpl::never()
+	) | rpl::filter([=] {
+		return !FullTrackReceived(_information.video.state)
+			|| !FullTrackReceived(_information.audio.state);
+	}) | rpl::start_with_next([=] {
+		_pausedByWaitingForData = true;
+		updatePausedState();
+		_updates.fire({ WaitingForData() });
+	}, _sessionLifetime);
+
+	if (guard && _audio) {
 		_audio->playPosition(
 		) | rpl::start_with_next_done([=](crl::time position) {
 			audioPlayedTill(position);
 		}, [=] {
-			if (_stage == Stage::Started) {
+			Expects(_stage == Stage::Started);
-				_audioFinished = true;
+
-				if (!_video || _videoFinished) {
+			_audioFinished = true;
-					_updates.fire({ Finished() });
+			if (!_video || _videoFinished) {
-				}
+				_updates.fire({ Finished() });
 			}
-		}, _lifetime);
+		}, _sessionLifetime);
 	}
-	if (_video) {
+
+	if (guard && _video) {
 		_video->renderNextFrame(
 		) | rpl::start_with_next_done([=](crl::time when) {
 			_nextFrameTime = when;
 			checkNextFrame();
 		}, [=] {
-			if (_stage == Stage::Started) {
+			Expects(_stage == Stage::Started);
-				_videoFinished = true;
-				if (!_audio || _audioFinished) {
-					_updates.fire({ Finished() });
-				}
-			}
-		}, _lifetime);
-	}
 
+			_videoFinished = true;
+			if (!_audio || _audioFinished) {
+				_updates.fire({ Finished() });
+			}
+		}, _sessionLifetime);
+	}
+	if (guard && _audio) {
+		trackSendReceivedTill(*_audio, _information.audio.state);
+	}
+	if (guard && _video) {
+		trackSendReceivedTill(*_video, _information.video.state);
+	}
 }
+
 void Player::stop() {
 	_file->stop();
+	_sessionLifetime = rpl::lifetime();
 	if (_stage != Stage::Failed) {
 		_stage = Stage::Uninitialized;
 	}
 	_audio = nullptr;
 	_video = nullptr;
 	invalidate_weak_ptrs(&_sessionGuard);
-	_paused = false;
+	_pausedByUser = _pausedByWaitingForData = _paused = false;
+	_renderFrameTimer.cancel();
 	_audioFinished = false;
 	_videoFinished = false;
 	_readTillEnd = false;
@@ -418,8 +499,12 @@ bool Player::playing() const {
 	return (_stage == Stage::Started) && !_paused;
 }
 
+bool Player::buffering() const {
+	return _pausedByWaitingForData;
+}
+
 bool Player::paused() const {
-	return _paused;
+	return _pausedByUser;
 }
 
 void Player::setSpeed(float64 speed) {

Telegram/SourceFiles/media/streaming/media_streaming_player.h

@@ -46,6 +46,7 @@ public:
 
 	[[nodiscard]] bool failed() const;
 	[[nodiscard]] bool playing() const;
+	[[nodiscard]] bool buffering() const;
 	[[nodiscard]] bool paused() const;
 
 	[[nodiscard]] rpl::producer<Update, Error> updates() const;
@@ -57,9 +58,6 @@ public:
 	~Player();
 
 private:
-	static constexpr auto kReceivedTillEnd
-		= std::numeric_limits<crl::time>::max();
-
 	enum class Stage {
 		Uninitialized,
 		Initializing,
@@ -91,12 +89,21 @@ private:
 	void videoReceivedTill(crl::time position);
 	void videoPlayedTill(crl::time position);
 
+	void updatePausedState();
+	[[nodiscard]] bool trackReceivedEnough(const TrackState &state) const;
+	void checkResumeFromWaitingForData();
+
 	template <typename Track>
 	void trackReceivedTill(
 		const Track &track,
 		TrackState &state,
 		crl::time position);
 
+	template <typename Track>
+	void trackSendReceivedTill(
+		const Track &track,
+		TrackState &state);
+
 	template <typename Track>
 	void trackPlayedTill(
 		const Track &track,
@@ -121,6 +128,8 @@ private:
 	// Belongs to the main thread.
 	Information _information;
 	Stage _stage = Stage::Uninitialized;
+	bool _pausedByUser = false;
+	bool _pausedByWaitingForData = false;
 	bool _paused = false;
 	bool _audioFinished = false;
 	bool _videoFinished = false;
@@ -130,7 +139,9 @@ private:
 	crl::time _nextFrameTime = kTimeUnknown;
 	base::Timer _renderFrameTimer;
 	rpl::event_stream<Update, Error> _updates;
+
 	rpl::lifetime _lifetime;
+	rpl::lifetime _sessionLifetime;
 
 };
 

Telegram/SourceFiles/media/streaming/media_streaming_video_track.cpp

@@ -36,6 +36,7 @@ public:
 	void process(Packet &&packet);
 
 	[[nodisacrd]] rpl::producer<crl::time> displayFrameAt() const;
+	[[nodisacrd]] rpl::producer<> waitingForData() const;
 
 	void pause(crl::time time);
 	void resume(crl::time time);
@@ -76,6 +77,7 @@ private:
 	mutable TimePoint _syncTimePoint;
 	mutable crl::time _previousFramePosition = kTimeUnknown;
 	rpl::variable<crl::time> _nextFrameDisplayTime = kTimeUnknown;
+	rpl::event_stream<> _waitingForData;
 
 	bool _queued = false;
 	base::ConcurrentTimer _readFramesTimer;
@@ -111,6 +113,10 @@ rpl::producer<crl::time> VideoTrackObject::displayFrameAt() const {
 		: _nextFrameDisplayTime.value();
 }
 
+rpl::producer<> VideoTrackObject::waitingForData() const {
+	return interrupted() ? rpl::never() : _waitingForData.events();
+}
+
 void VideoTrackObject::process(Packet &&packet) {
 	if (interrupted()) {
 		return;
@@ -162,6 +168,8 @@ bool VideoTrackObject::readFrame(not_null<Frame*> frame) {
 		} else if (error.code() != AVERROR(EAGAIN) || _noMoreData) {
 			interrupt();
 			_error();
+		} else if (_stream.queue.empty()) {
+			_waitingForData.fire({});
 		}
 		return false;
 	}
@@ -604,6 +612,12 @@ rpl::producer<crl::time> VideoTrack::renderNextFrame() const {
 	});
 }
 
+rpl::producer<> VideoTrack::waitingForData() const {
+	return _wrapped.producer_on_main([](const Implementation &unwrapped) {
+		return unwrapped.waitingForData();
+	});
+}
+
 VideoTrack::~VideoTrack() {
 	_wrapped.with([shared = std::move(_shared)](Implementation &unwrapped) {
 		unwrapped.interrupt();

Telegram/SourceFiles/media/streaming/media_streaming_video_track.h

@@ -48,6 +48,7 @@ public:
 	[[nodiscard]] crl::time markFrameDisplayed(crl::time now);
 	[[nodiscard]] QImage frame(const FrameRequest &request) const;
 	[[nodiscard]] rpl::producer<crl::time> renderNextFrame() const;
+	[[nodiscard]] rpl::producer<> waitingForData() const;
 
 	// Called from the main thread.
 	~VideoTrack();

Telegram/SourceFiles/media/view/media_clip_controller.cpp

@@ -131,7 +131,7 @@ void Controller::updatePlayback(const Player::TrackState &state) {
 }
 
 void Controller::updatePlayPauseResumeState(const Player::TrackState &state) {
-	auto showPause = (state.state == Player::State::Playing || state.state == Player::State::Resuming || _seekPositionMs >= 0);
+	auto showPause = ShowPauseIcon(state.state) || (_seekPositionMs >= 0);
 	if (showPause != _showPause) {
 		disconnect(_playPauseResume, SIGNAL(clicked()), this, _showPause ? SIGNAL(pausePressed()) : SIGNAL(playPressed()));
 		_showPause = showPause;

Telegram/SourceFiles/overview/overview_layout.cpp

@@ -854,7 +854,7 @@ bool Voice::updateStatusText() {
 		if (state.id == AudioMsgId(_data, parent()->fullId(), state.id.playId()) && !Media::Player::IsStoppedOrStopping(state.state)) {
 			statusSize = -1 - (state.position / state.frequency);
 			realDuration = (state.length / state.frequency);
-			showPause = (state.state == State::Playing || state.state == State::Resuming || state.state == State::Starting);
+			showPause = Media::Player::ShowPauseIcon(state.state);
 		}
 	} else {
 		statusSize = FileStatusSizeReady;
@@ -1225,7 +1225,7 @@ bool Document::updateStatusText() {
 			if (state.id == AudioMsgId(_data, parent()->fullId()) && !Media::Player::IsStoppedOrStopping(state.state)) {
 				statusSize = -1 - (state.position / state.frequency);
 				realDuration = (state.length / state.frequency);
-				showPause = (state.state == State::Playing || state.state == State::Resuming || state.state == State::Starting);
+				showPause = Media::Player::ShowPauseIcon(state.state);
 			}
 			if (!showPause && (state.id == AudioMsgId(_data, parent()->fullId())) && Media::Player::instance()->isSeeking(AudioMsgId::Type::Song)) {
 				showPause = true;