device: Introduce Drain()

- force draining the videoReassemblyBuffer
- pop the drm buffer from the queue AFTER setting the new PTS
- video buffers are empty, when the drm buffer queue is empty AND
  when the current drm buffer was displayed long enough in trickspeed mode
  (though it is displayed one more time due to m_displayOneFrameThenPause

Author: rellla

audio.cpp

@@ -1057,7 +1057,8 @@ bool cSoftHdAudio::CyclicCall(void)
 	if (err < 0) {
 		if (m_alsa.HandleError(err)) {
 			std::lock_guard<std::mutex> lock(m_queueMutex);
-			m_eventQueue.push_back(BufferUnderrunEvent{AUDIO});
+			if (!m_pDevice->IsDraining())
+				m_eventQueue.push_back(BufferUnderrunEvent{AUDIO});
 		}
 		return false;
 	} else if (err == 0) {

audio.h

@@ -60,6 +60,7 @@ class cSoftHdAudio : public cThread {
 	void Filter(AVFrame *, AVCodecContext *);
 	void EnqueueSpdif(const uint16_t *, int, int64_t pts);
 	bool IsBufferFull(void) { return m_pRingbuffer.FreeBytes() <= AUDIO_MIN_BUFFER_FREE; };
+	bool IsBufferEmpty(void) { return m_pRingbuffer.UsedBytes() == 0 && m_alsa.GetHwDelayFrames() == 0; };
 
 	void FlushBuffers(void);
 	int GetUsedRingbufferBytes(void);

softhddevice.cpp

@@ -649,6 +649,8 @@ bool cSoftHdDevice::SetPlayMode(ePlayMode play_mode)
 		m_externalPlayerActive = false;
 	}
 
+	m_draining = false;
+
 	switch (play_mode) {
 	case pmNone:
 		OnEventReceived(StopEvent{});
@@ -810,6 +812,8 @@ void cSoftHdDevice::Clear(void)
 	m_pAudio->ResetHwDelayBaseline();
 	FlushAudio();
 
+	m_draining = false;
+
 	SetState(BUFFERING);
 
 	m_pRender->Resume();
@@ -888,7 +892,7 @@ void cSoftHdDevice::HandleStillPicture(const uchar *data, int size)
 
 	m_pVideoStream->PushAvPacket(m_videoReassemblyBuffer.PopAvPacket());
 	m_pVideoStream->ResetInputPts(); // stillpicture shouldn't trigger having video data
-	m_pVideoStream->Flush();
+	m_pVideoStream->Drain();
 }
 
 /**
@@ -918,25 +922,76 @@ bool cSoftHdDevice::Poll(__attribute__ ((unused)) cPoller & poller, int timeoutM
 }
 
 /**
- * Flush the device output buffers.
+ * Return true, if the output buffers are empty, false otherwise.
+ * Wait max. up to timeoutMs in case the buffers are not empty.
+ *
+ * This function does not initiate a decoder drain like Drain()
+ * so some data may stay unprocessed in the decoder, while the other
+ * buffers are already emtpy. Therefore, players should use the
+ * new Drain() function instead.
  *
  * @param timeoutMs        timeout in ms to become ready
+ *
+ * @return true, if the buffers are empty, false otherwise
+ *
+ * @note Flush() is marked DEPRECATED since APIVERSION 14
  */
 bool cSoftHdDevice::Flush(int timeoutMs)
 {
 	if (IsDetached())
 		return true;
 
-	LOGDEBUG("device: %s: timeout %d ms", __FUNCTION__, timeoutMs);
-	if (m_pVideoStream->GetAvPacketsFilled()) {
-		if (timeoutMs) {			// let display thread work
-			usleep(timeoutMs * 1000);
-		}
-		return !m_pVideoStream->GetAvPacketsFilled();
+	LOGDEBUG("device: %s: timeout % ms", __FUNCTION__, timeoutMs);
+
+	const auto buffersEmpty = [&]() {
+		return m_playbackMode == AUDIO_ONLY
+			? m_pAudio->IsBufferEmpty()
+			: m_pVideoStream->BuffersEmpty();
+	};
+
+	const cTimeMs timeout(timeoutMs);
+	while (!buffersEmpty() && !timeout.TimedOut())
+		cCondWait::SleepMs(std::min(5, timeoutMs));
+
+	return buffersEmpty();
+}
+
+
+#if APIVERSNUM >= 30014
+/**
+ * Force a decoder drain and return true, if all buffers have been played out
+ *
+ * @return true, if the buffers are empty, false otherwise
+ */
+bool cSoftHdDevice::Drain(void)
+{
+	if (IsDetached())
+		return true;
+
+	// enter drain mode once
+	if (!m_draining) {
+		LOGDEBUG("device: %s: start draining", __FUNCTION__);
+		m_draining = true;
+		if (!m_videoReassemblyBuffer.IsEmpty())
+			m_pVideoStream->PushAvPacket(m_videoReassemblyBuffer.PopAvPacket());
+		m_pVideoStream->Drain();
 	}
 
+	const auto buffersEmpty = [&]() {
+		return m_playbackMode == AUDIO_ONLY
+			? m_pAudio->IsBufferEmpty()
+			: m_pVideoStream->BuffersEmpty();
+	};
+
+	if (!buffersEmpty())
+		return false;
+
+	LOGDEBUG("device: %s: drained, buffers are empty", __FUNCTION__);
+	m_draining = false;
+
 	return true;
 }
+#endif
 
 /**
  * Sets the video display format

softhddevice.h

@@ -169,7 +169,9 @@ class cSoftHdDevice : public cDevice, public IEventReceiver, public cStatus {
 	virtual void StillPicture(const uchar *, int);
 	virtual bool Poll(cPoller &, int = 0);
 	virtual bool Flush(int = 0);
-
+#if APIVERSNUM >= 30014
+	virtual bool Drain(void);
+#endif
 	// Image Grab facilities
 	virtual uchar *GrabImage(int &, bool, int, int, int);
 
@@ -246,6 +248,7 @@ class cSoftHdDevice : public cDevice, public IEventReceiver, public cStatus {
 	void ResetOsdProvider(void) { m_pOsdProvider = nullptr; }
 	bool IsOsdProviderSet(void) const { return m_pOsdProvider != nullptr; }
 	void SetStartDetached(void) { m_forceDetached = true; };
+	bool IsDraining(void) { return m_draining; };
 
 	bool IsBufferingThresholdReached(void);
 	bool IsVideoOnlyPlayback(void) { return m_playbackMode == VIDEO_ONLY; };
@@ -274,6 +277,7 @@ class cSoftHdDevice : public cDevice, public IEventReceiver, public cStatus {
 	static constexpr int MIN_BUFFER_FILL_LEVEL_THRESHOLD_MS = 450; ///< min buffering threshold in ms
 
 	bool m_initialized = false;                     ///< true, if the plugin had a successful Initialize()
+	std::atomic<bool> m_draining = false;           ///< true, if the device is in draining mode (waiting for empty buffers)
 	std::atomic<State> m_state = DETACHED;          ///< current plugin state, normal plugin start sets detached state
 	std::mutex m_eventMutex;                        ///< mutex to protect event queue
 	bool m_needsMakePrimary = false;                ///< true, if device should be made a primary device after attach

videofilter.h

@@ -45,6 +45,7 @@ class cVideoFilter : public cThread {
 	void Stop(void);
 	void PushFrame(AVFrame *);
 	bool IsInputBufferFull(void) { return m_frames.IsFull(); };
+	bool IsInputBufferEmpty(void) { return m_frames.IsEmpty(); };
 	int GetNumFramesToFilter(void) { return m_numFramesToFilter; };
 
 private:

videorender.cpp

@@ -725,13 +725,14 @@ bool cVideoRender::DisplayFrame(void)
 	                               m_pDevice->IsVideoOnlyPlayback() ||
 	                               IsTrickSpeed() ||
 	                               IsStillpicture() ||
+	                               m_pDevice->IsDraining() ||
 	                               m_schedulePlaybackStartAtPtsMs != AV_NOPTS_VALUE;
 	if (m_pDevice->VideoStream()->GetAvPacketsFilled() == 0 && !skipBufferUnderrunCheck)
 		m_eventQueue.push_back(BufferUnderrunEvent{VIDEO});
 
 	cDrmBuffer *drmBuffer = nullptr;
 	if ((!m_videoPlaybackPaused || m_schedulePlaybackStartAtPtsMs != AV_NOPTS_VALUE) && m_framePresentationCounter == 0 && frameTick)
-		drmBuffer = m_drmBufferQueue.Pop();
+		drmBuffer = m_drmBufferQueue.Peek();
 
 	cDrmBuffer *pipBuffer = m_pipDrmBufferQueue.Pop();
 
@@ -749,6 +750,7 @@ bool cVideoRender::DisplayFrame(void)
 			// check if playback shall start
 			if (PtsToMs(drmBuffer->frame->pts) < m_schedulePlaybackStartAtPtsMs) {
 				drmBuffer->PresentationFinished();
+				m_drmBufferQueue.Pop();
 				return true;
 			} else {
 				m_schedulePlaybackStartAtPtsMs = AV_NOPTS_VALUE;
@@ -763,6 +765,7 @@ bool cVideoRender::DisplayFrame(void)
 				drmBuffer->PresentationFinished();
 				if (pipBuffer)
 					pipBuffer->PresentationFinished();
+				m_drmBufferQueue.Pop();
 				return true;
 			}
 
@@ -790,7 +793,9 @@ bool cVideoRender::DisplayFrame(void)
 
 		m_lastFrameWasDropped = false;
 		m_pCurrentlyDisplayed = drmBuffer;
-	} else if (m_pCurrentlyDisplayed && !m_drmBufferQueue.IsEmpty() && !m_videoPlaybackPaused) {
+
+		m_drmBufferQueue.Pop();
+	} else if (m_pCurrentlyDisplayed && !m_videoPlaybackPaused) {
 		// display the current frame again in trick speed mode or for A/V syncing
 		pageFlipDone = PageFlip(m_pCurrentlyDisplayed, pipBuffer);
 	} else if ((m_pBufOsd && m_pBufOsd->IsDirty()) || pipBuffer) {

videorender.h

@@ -242,6 +242,8 @@ class cVideoRender : public cThread {
 	void ClearPipDecoderToDisplayQueue(void);
 	void SetPipSize(bool);
 
+	bool PresentationPending(void) { return m_framePresentationCounter != 0 || !m_drmBufferQueue.IsEmpty(); };
+
 protected:
 	virtual void Action(void);
 

videostream.cpp

@@ -73,12 +73,12 @@ cVideoStream::~cVideoStream(void)
 }
 
 /**
- * Flushes the video stream by finalizing any pending data.
+ * Drains the video stream by finalizing any pending data.
  *
  * This function completes processing of any remaining PES fragments in the fragmentation
  * buffer, then pushes a nullptr packet to the queue to signal a flush operation to the decoder.
  */
-void cVideoStream::Flush(void)
+void cVideoStream::Drain(void)
 {
 	m_packets.Push(nullptr);
 }
@@ -98,6 +98,8 @@ bool cVideoStream::PushAvPacket(AVPacket *avpkt)
 	if (avpkt->pts != AV_NOPTS_VALUE)
 		m_inputPts = avpkt->pts;
 
+	LOGDEBUG2(L_PACKET, "videostream: %s: push PTS %s", __FUNCTION__, Timestamp2String(avpkt->pts, 90));
+
 	return m_packets.Push(avpkt);
 }
 
@@ -409,14 +411,18 @@ void cVideoStream::DecodeInput(void)
 	// send packet to decoder
 	} else if (!PacketDropNeeded(avpkt)) {
 		ret = m_pDecoder->SendPacket(avpkt);
+		m_isResend = false;
 
 		if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
 			avpkt = m_packets.Pop();
 			if (avpkt && avpkt->pts != AV_NOPTS_VALUE)
 				m_lastDecodedPts = avpkt->pts;
 			av_packet_free(&avpkt);
-			m_isResend = false;
+		// a repeated decoder drain was requested, drop the nullptr-packet from the queue
+		} else if (ret == AVERROR_EOF && !avpkt) {
+			m_packets.Pop();
 		} else {
+			// PacketDropNeeded() is skipped next time, because this packet needs to be resent to the decoder
 			m_isResend = true;
 		}
 
@@ -650,3 +656,11 @@ void cVideoStream::RenderFrame(AVFrame * frame)
 			m_frameOutput(frame);
 	}
 }
+
+/**
+ * Return true, if the input AVPacket, videofilter and drm output buffer queues are empty.
+ */
+bool cVideoStream::BuffersEmpty(void)
+{
+	return m_packets.IsEmpty() && !m_pRender->PresentationPending() && m_videoFilter.IsInputBufferEmpty();
+}

videostream.h

@@ -57,7 +57,7 @@ class cVideoStream : public cThread {
 	void FlushDecoder(void);
 	void CloseDecoder(void);
 	bool PushAvPacket(AVPacket *avpkt);
-	void Flush(void);
+	void Drain(void);
 
 	// decoding thread
 	void Stop(void);
@@ -69,6 +69,7 @@ class cVideoStream : public cThread {
 	void StartDecoder();
 	size_t GetAvPacketsFilled(void) { return m_packets.Size(); };
 	bool IsInputBufferFull(void) { return m_packets.Size() >= VIDEO_PACKET_MAX; };
+	bool BuffersEmpty(void);
 	enum AVCodecID GetCodecId(void) { return m_codecId; };
 	void ResetTrickSpeedFramesSentCounter(void) { m_sentTrickPkts = 0; };
 	bool HasInputPts(void) { return m_inputPts != AV_NOPTS_VALUE; }