Finish file playback only after video presentation and PCM drain
This commit is contained in:
1 parent
18d80fd019
commit
98e0a67aa2
2 files changed
+96
-53
No files matched your search
@@ -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();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
Reference in new issue
Block a user