Finish file playback only after video presentation and PCM drain

This commit is contained in:
evgeny committed 2026-10-28 00:58:59 +01:00
1 parent 18d80fd019
commit 98e0a67aa2
2 files changed
+96 -53

No files matched your search

+82 -45
View File
@@ -6,6 +6,8 @@
#include <QThread>
#include <QDateTime>
#include <QPointer>
#include <algorithm>
#ifdef HAVE_FFMPEG
extern "C" {
@@ -30,7 +32,6 @@ public:
QString path;
QAtomicInt* abort = nullptr;
QAtomicInt* paused = nullptr;
QAtomicInt* seekReq = nullptr;
QAtomicInteger<qint64>* seekTargetMs = nullptr;
QAtomicInt* buffered = nullptr;
QAtomicInt* epoch = nullptr;
@@ -38,9 +39,9 @@ public:
signals:
void opened(int width, int height, qint64 durationMs, bool hasAudio);
void audioDecoded(std::shared_ptr<std::vector<int16_t>> pcm, int sampleRate, int channels, qint64 durationMs);
void frameDecoded(const QImage& image, qint64 ptsMs, int epoch);
void frameDecoded(const QImage& image, qint64 ptsMs, qint64 endMs, int epoch);
void error(const QString& msg);
void finished();
void decodeFinished(int epoch);
public slots:
void run();
@@ -199,7 +200,10 @@ void Worker::run() {
if (sws_getColorspaceDetails(sws, &invTbl, &sr, &tbl, &dr, &br, &ct, &st) >= 0)
sws_setColorspaceDetails(sws, invTbl, srcRange, tbl, 1 /* RGB full-range */, br, ct, st);
int gen = epoch->loadRelaxed();
int gen = 0; // Новый open начинает с 0; ранний seek должен быть обработан до выдачи его кадров.
const AVRational rate = av_guess_frame_rate(fmt, vst, nullptr);
const qint64 estimatedDuration = rate.num > 0 && rate.den > 0 ?
std::max<qint64>(1, av_rescale_q(1, av_inv_q(rate), AVRational{1, 1000})) : 40;
auto emitFrame = [&](AVFrame* fr) {
if (fr->pts == AV_NOPTS_VALUE) return true; /* кадр без pts ломает очередь */
QImage img = video_frame_image(vw, vh);
@@ -212,25 +216,33 @@ void Worker::run() {
worker_fail(this, QCoreApplication::translate("ChatGui", "Video frame conversion failed")); return false;
}
qint64 ptsMs = av_rescale_q(fr->pts, vst->time_base, AVRational{1, 1000});
#if LIBAVUTIL_VERSION_MAJOR >= 58
const int64_t duration = fr->duration;
#else
const int64_t duration = fr->pkt_duration;
#endif
const qint64 durationMs = duration > 0 ?
std::max<qint64>(1, av_rescale_q(duration, vst->time_base, AVRational{1, 1000})) : estimatedDuration;
buffered->fetchAndAddRelaxed(1);
emit frameDecoded(img, ptsMs, gen);
emit frameDecoded(img, ptsMs, ptsMs + durationMs, gen);
return true;
};
bool eof = false;
while (!abort->loadRelaxed()) {
if (seekReq->loadRelaxed()) {
const int requested = epoch->loadAcquire();
if (requested != gen) {
qint64 targetMs = seekTargetMs->loadRelaxed();
int sret = av_seek_frame(fmt, -1, targetMs * 1000, AVSEEK_FLAG_BACKWARD);
if (sret < 0)
if (sret < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_VIDEO, "VideoEngine: seek to %lldms failed ret=%d",
(long long)targetMs, sret);
else
DEBUG_TRACE(DEBUG_CATEGORY_VIDEO, "VideoEngine: seek to %lldms", (long long)targetMs);
worker_fail(this, QCoreApplication::translate("ChatGui", "Cannot seek video")); cleanup(); return;
}
DEBUG_DEBUG(DEBUG_CATEGORY_VIDEO, "VideoEngine: seek epoch=%d target=%lldms", requested, (long long)targetMs);
avcodec_flush_buffers(vdec);
gen = epoch->loadRelaxed();
gen = requested;
eof = false;
seekReq->storeRelaxed(0);
}
if (paused->loadRelaxed()) { QThread::msleep(10); continue; }
if (eof) { QThread::msleep(10); continue; } /* ждём seek или abort */
@@ -241,8 +253,8 @@ void Worker::run() {
avcodec_send_packet(vdec, nullptr);
while (avcodec_receive_frame(vdec, frame) == 0) if (!emitFrame(frame)) { cleanup(); return; }
eof = true;
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "VideoEngine: decode finished");
emit finished();
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "VideoEngine: decode EOF epoch=%d buffered=%d", gen, buffered->loadRelaxed());
emit decodeFinished(gen);
continue;
}
if (pkt->stream_index == vidx) {
@@ -283,7 +295,8 @@ void VideoPlayerEngine::open(const QString& path) {
m_path = path;
m_abort.storeRelaxed(0);
m_paused.storeRelaxed(0);
m_seekReq.storeRelaxed(0);
m_epoch.storeRelaxed(0); m_seekTargetMs.storeRelaxed(0);
m_decodeEof = false; m_videoEndMs = 0; m_audioFrames = 0; m_audioClock = false;
m_buffered.storeRelaxed(0);
clearPending();
m_renderFrame = QImage();
@@ -296,7 +309,6 @@ void VideoPlayerEngine::open(const QString& path) {
m_worker->path = path;
m_worker->abort = &m_abort;
m_worker->paused = &m_paused;
m_worker->seekReq = &m_seekReq;
m_worker->seekTargetMs = &m_seekTargetMs;
m_worker->buffered = &m_buffered;
m_worker->epoch = &m_epoch;
@@ -310,14 +322,14 @@ void VideoPlayerEngine::open(const QString& path) {
connect(m_worker, &Worker::audioDecoded, this, [this, generation](auto pcm, int rate, int channels, qint64 duration) {
if (generation == m_openGeneration) onAudioDecoded(pcm, rate, channels, duration);
});
connect(m_worker, &Worker::frameDecoded, this, [this, generation](const QImage& frame, qint64 pts, int epoch) {
if (generation == m_openGeneration) onFrameDecoded(frame, pts, epoch);
connect(m_worker, &Worker::frameDecoded, this, [this, generation](const QImage& frame, qint64 pts, qint64 end, int epoch) {
if (generation == m_openGeneration) onFrameDecoded(frame, pts, end, epoch);
});
connect(m_worker, &Worker::error, this, [this, generation](const QString& error) {
if (generation == m_openGeneration) onWorkerError(error);
});
connect(m_worker, &Worker::finished, this, [this, generation]() {
if (generation == m_openGeneration) onWorkerFinished();
connect(m_worker, &Worker::decodeFinished, this, [this, generation](int epoch) {
if (generation == m_openGeneration) onDecodeFinished(epoch);
});
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "VideoEngine: open %s", qPrintable(path));
@@ -328,7 +340,7 @@ void VideoPlayerEngine::play() {
if (m_state != Paused && m_state != Playing) return;
m_paused.storeRelaxed(0);
if (m_hasAudio) SoundManager::instance()->resumePcm(m_audioPlayback);
else { m_elapsedBaseMs = m_positionMs; m_elapsed.restart(); }
if (!m_audioClock) { m_elapsedBaseMs = m_positionMs; m_elapsed.restart(); }
setState(Playing);
m_presentTimer.start();
}
@@ -350,17 +362,20 @@ void VideoPlayerEngine::togglePlayPause() {
void VideoPlayerEngine::seekMs(qint64 ms) {
if (ms < 0) ms = 0;
if (m_durationMs > 0 && ms > m_durationMs) ms = m_durationMs;
m_epoch.fetchAndAddRelaxed(1);
m_seekTargetMs.storeRelaxed(ms);
m_seekReq.storeRelaxed(1);
m_epoch.fetchAndAddRelease(1);
m_decodeEof = false; m_videoEndMs = 0;
clearPending();
if (m_hasAudio) {
int sr = SoundManager::instance()->pcmSampleRate(m_audioPlayback);
if (sr > 0) SoundManager::instance()->seekPcm(m_audioPlayback, (unsigned long long)(ms * sr / 1000));
} else {
m_elapsedBaseMs = ms;
m_elapsed.restart();
if (sr > 0) {
if (!SoundManager::instance()->seekPcm(m_audioPlayback, (unsigned long long)(ms * sr / 1000))) {
onWorkerError(QCoreApplication::translate("ChatGui", "Cannot seek video")); return;
}
m_audioClock = (uint64_t)(ms * sr / 1000) < m_audioFrames;
}
}
m_elapsedBaseMs = ms; m_elapsed.restart();
m_positionMs = ms;
if (m_state == Finished) setState(Paused);
emit positionChanged(ms);
@@ -369,6 +384,7 @@ void VideoPlayerEngine::seekMs(qint64 ms) {
void VideoPlayerEngine::stop() {
++m_openGeneration;
m_abort.storeRelaxed(1);
m_decodeEof = false; m_videoEndMs = 0; m_audioClock = false; m_audioFrames = 0;
m_presentTimer.stop();
clearPending();
m_renderFrame = QImage();
@@ -391,12 +407,16 @@ void VideoPlayerEngine::close() {
}
}
qint64 VideoPlayerEngine::clockMs() const {
if (m_hasAudio && m_audioSampleRate > 0) {
if (m_state == Finished && !SoundManager::instance()->isPcmPlaying(m_audioPlayback))
return m_durationMs; /* аудио закончилось — часы в конец */
unsigned long long cur = SoundManager::instance()->pcmCursor(m_audioPlayback);
return (qint64)(cur * 1000 / (unsigned long long)m_audioSampleRate);
qint64 VideoPlayerEngine::clockMs() {
if (m_audioClock) {
auto* sound = SoundManager::instance();
const uint64_t cursor = sound->pcmCursor(m_audioPlayback);
if (cursor < m_audioFrames || sound->isPcmPlaying(m_audioPlayback))
return (qint64)(cursor * 1000 / (uint64_t)m_audioSampleRate);
m_audioClock = false;
m_elapsedBaseMs = std::max(m_positionMs, (qint64)((m_audioFrames * 1000 + m_audioSampleRate - 1) / m_audioSampleRate));
m_elapsed.restart();
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "VideoEngine: audio ended, timer continues from=%lldms", (long long)m_elapsedBaseMs);
}
return m_elapsedBaseMs + m_elapsed.elapsed();
}
@@ -430,6 +450,7 @@ void VideoPlayerEngine::onAudioDecoded(std::shared_ptr<std::vector<int16_t>> pcm
int sampleRate, int channels, qint64 durationMs) {
if (pcm && !pcm->empty() && channels > 0) {
m_audioSampleRate = sampleRate;
m_audioFrames = pcm->size() / (size_t)channels;
SoundManager::instance()->stopPcm(m_audioPlayback);
m_audioPlayback = SoundManager::instance()->playRawPcm(pcm->data(), (int)(pcm->size() / (size_t)channels),
sampleRate, channels, pcm);
@@ -437,25 +458,29 @@ void VideoPlayerEngine::onAudioDecoded(std::shared_ptr<std::vector<int16_t>> pcm
/* аудио-устройство недоступно — переходим на системные часы */
m_hasAudio = false;
m_audioSampleRate = 0;
m_audioFrames = 0; m_audioClock = false;
DEBUG_WARN(DEBUG_CATEGORY_VIDEO, "VideoEngine: audio not playing, fallback to system clock");
} else {
DEBUG_TRACE(DEBUG_CATEGORY_VIDEO, "VideoEngine: audio started %dHz %dch", sampleRate, channels, pcm);
m_audioClock = true;
DEBUG_DEBUG(DEBUG_CATEGORY_VIDEO, "VideoEngine: audio started rate=%d channels=%d frames=%llu",
sampleRate, channels, (unsigned long long)m_audioFrames);
}
} else {
m_hasAudio = false;
DEBUG_WARN(DEBUG_CATEGORY_VIDEO, "VideoEngine: no audio data, video only");
}
m_elapsedBaseMs = 0;
m_elapsedBaseMs = m_positionMs;
m_elapsed.restart();
setState(Playing);
m_presentTimer.start();
}
void VideoPlayerEngine::onFrameDecoded(const QImage& image, qint64 ptsMs, int epoch) {
void VideoPlayerEngine::onFrameDecoded(const QImage& image, qint64 ptsMs, qint64 endMs, int epoch) {
if (epoch != m_epoch.loadRelaxed()) {
m_buffered.fetchAndSubRelaxed(1); /* устаревший кадр после seek — не будет показан */
return;
}
m_videoEndMs = std::max(m_videoEndMs, endMs);
m_pending.push_back({ image, ptsMs });
}
@@ -466,16 +491,20 @@ void VideoPlayerEngine::onWorkerError(const QString& msg) {
emit error(msg);
}
void VideoPlayerEngine::onWorkerFinished() {
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "VideoEngine: worker finished");
/* дождёмся, пока отрисуются оставшиеся кадры в presentTick, потом Finished */
setState(Finished);
emit finished();
void VideoPlayerEngine::onDecodeFinished(int epoch) {
if (epoch != m_epoch.loadRelaxed()) {
DEBUG_DEBUG(DEBUG_CATEGORY_VIDEO, "VideoEngine: stale EOF ignored epoch=%d current=%d", epoch, m_epoch.loadRelaxed()); return;
}
m_decodeEof = true;
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "VideoEngine: draining epoch=%d pending=%zu video_end=%lldms position=%lldms state=%d",
epoch, m_pending.size(), (long long)m_videoEndMs, (long long)m_positionMs, (int)m_state);
}
void VideoPlayerEngine::presentTick() {
if (m_state != Playing) return;
const uint64_t generation = m_openGeneration; const int epoch = m_epoch.loadRelaxed();
QPointer<VideoPlayerEngine> guard(this);
qint64 clk = clockMs();
if (m_durationMs > 0 && clk > m_durationMs) clk = m_durationMs;
QImage show;
bool have = false;
@@ -485,14 +514,22 @@ void VideoPlayerEngine::presentTick() {
m_buffered.fetchAndSubRelaxed(1);
have = true;
}
if (have) { m_renderFrame = show; emit framePresented(); }
m_positionMs = clk;
if (have) {
m_renderFrame = show; emit framePresented();
if (!guard || generation != m_openGeneration || epoch != m_epoch.loadRelaxed() || m_state != Playing) return;
}
emit positionChanged(m_positionMs);
if (!guard || generation != m_openGeneration || epoch != m_epoch.loadRelaxed() || m_state != Playing) return;
if (m_state == Finished && m_pending.empty()) {
const bool audioDone = !m_hasAudio || (!SoundManager::instance()->isPcmPlaying(m_audioPlayback) &&
SoundManager::instance()->pcmCursor(m_audioPlayback) >= m_audioFrames);
if (m_decodeEof && m_pending.empty() && clk >= m_videoEndMs && audioDone) {
m_presentTimer.stop();
if (m_hasAudio) SoundManager::instance()->stopPcm(m_audioPlayback);
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "VideoEngine: playback finished epoch=%d position=%lldms video_end=%lldms audio_done=%d",
epoch, (long long)m_positionMs, (long long)m_videoEndMs, audioDone);
setState(Finished);
if (guard && generation == m_openGeneration && epoch == m_epoch.loadRelaxed() && m_state == Finished) emit finished();
}
}
+14 -8
View File
@@ -17,8 +17,11 @@ class QThread;
Q_DECLARE_METATYPE(std::shared_ptr<std::vector<int16_t>>)
/* Плеер видео на FFmpeg (GUI-процесс). Декод в отдельном потоке,
* отрисовка кадров по мастер-часам (аудио-курсор или системный таймер). */
/* Файловый FFmpeg-плеер: публичные методы/сигналы — GUI, декодирование — отдельный поток.
* open запускает воспроизведение асинхронно; close останавливает и ждёт worker.
* EOF декодера относится к эпохе seek и лишь завершает вход. Playing/Paused сохраняются до показа последнего
* кадра на полную длительность и окончания PCM; после этого Finished/finished приходят один раз.
* Аудио-курсор задаёт часы до конца PCM, далее работает монотонный таймер. Seek/open сбрасывают EOF. */
class VideoPlayerEngine : public QObject {
Q_OBJECT
public:
@@ -48,21 +51,21 @@ signals:
void opened(int width, int height, qint64 durationMs, bool hasAudio);
void positionChanged(qint64 ms);
void stateChanged(int state);
void finished();
void finished(); // Текущее воспроизведение завершено; все поля обновлены до сигнала, можно close/open/seek.
void error(const QString& msg);
void framePresented();
private slots:
void onWorkerOpened(int width, int height, qint64 durationMs, bool hasAudio);
void onAudioDecoded(std::shared_ptr<std::vector<int16_t>> pcm, int sampleRate, int channels, qint64 durationMs);
void onFrameDecoded(const QImage& image, qint64 ptsMs, int epoch);
void onFrameDecoded(const QImage& image, qint64 ptsMs, qint64 endMs, int epoch);
void onWorkerError(const QString& msg);
void onWorkerFinished();
void onDecodeFinished(int epoch);
void presentTick();
private:
void setState(State s);
qint64 clockMs() const;
qint64 clockMs(); // PCM, затем непрерывный монотонный таймер после окончания аудио.
void clearPending();
uint64_t m_openGeneration = 0;
@@ -80,17 +83,20 @@ private:
/* управление worker'ом (атомики, доступны из обоих потоков) */
QAtomicInt m_abort{0};
QAtomicInt m_paused{0};
QAtomicInt m_seekReq{0};
QAtomicInteger<qint64> m_seekTargetMs{0};
QAtomicInt m_buffered{0};
QAtomicInt m_epoch{0};
QAtomicInt m_epoch{0}; // GUI публикует новый target до release-инкремента; worker обрабатывает каждую последнюю эпоху.
/* презентация (только GUI-поток) */
std::deque<std::pair<QImage, qint64>> m_pending;
QImage m_renderFrame;
bool m_decodeEof = false; // EOF только текущей эпохи; не меняет состояние/возможность паузы.
qint64 m_videoEndMs = 0; // Максимальный конец принятого кадра: PTS + его длительность.
QTimer m_presentTimer;
uint64_t m_audioPlayback = 0;
int m_audioSampleRate = 0;
uint64_t m_audioFrames = 0; // Полная длина PCM на канал; сессия сохраняется после Finished для replay/seek.
bool m_audioClock = false; // Часы ещё следуют PCM; после его конца продолжаются через m_elapsed.
QElapsedTimer m_elapsed;
qint64 m_elapsedBaseMs = 0;
};