jeka
/
utun2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Раздели PCM-сессии и исправь частоту и перемотку звука

master
evgeny 1 day ago
parent
40b974b29c
commit
217e5795bf
13 changed files with 225 additions and 133 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      tools/chatgui/src/audiodevicesettingspage.cpp
  2. 10
      tools/chatgui/src/mainwindow.cpp
  3. 36
      tools/chatgui/src/messagedelegate.cpp
  4. 3
      tools/chatgui/src/messagedelegate.h
  5. 2
      tools/chatgui/src/messagelist.cpp
  6. 155
      tools/chatgui/src/sound_manager.cpp
  7. 40
      tools/chatgui/src/sound_manager.h
  8. 47
      tools/chatgui/src/videoplayer_engine.cpp
  9. 2
      tools/chatgui/src/videoplayer_engine.h
  10. 18
      tools/chatgui/src/voiceplayback.cpp
  11. 5
      tools/chatgui/src/voiceplayback.h
  12. 36
      tools/chatgui/tests/test_audio_recovery.cpp
  13. 2
      tools/chatgui/tests/test_voice_file.cpp

2
tools/chatgui/src/audiodevicesettingspage.cpp
Unescape View File

@ -411,7 +411,7 @@ void AudioDeviceSettingsPage::onTestSpeaker() {
std::vector<int16_t> pcm(samples); std::vector<int16_t> pcm(samples);
for (int i = 0; i < samples; i++) for (int i = 0; i < samples; i++)
pcm[i] = (int16_t)(12000.0 * sin(2.0 * M_PI * 440.0 * i / sampleRate)); pcm[i] = (int16_t)(12000.0 * sin(2.0 * M_PI * 440.0 * i / sampleRate));
SoundManager::instance()->playRawPcm(pcm.data(), samples, sampleRate, 1); SoundManager::instance()->playRawPcm(pcm.data(), samples, sampleRate, 1, {}, true);
} }
void AudioDeviceSettingsPage::buildCompressorUI(QVBoxLayout* layout) { void AudioDeviceSettingsPage::buildCompressorUI(QVBoxLayout* layout) {

10
tools/chatgui/src/mainwindow.cpp
Unescape View File

@ -947,7 +947,7 @@ void MainWindow::autoPlayCheckNewMessage(const QString& channelId) {
qPrintable(channelId), (long long)msg.id, qPrintable(fullPath)); qPrintable(channelId), (long long)msg.id, qPrintable(fullPath));
if (!m_autoPlayTimer->isActive()) if (!m_autoPlayTimer->isActive())
m_autoPlayTimer->start(200); m_autoPlayTimer->start(200);
if (!SoundManager::instance()->isCurrentPcmPlaying()) if (!VoicePlayer::isPlaying())
autoPlayTimerTick(); autoPlayTimerTick();
return; return;
} }
@ -972,7 +972,7 @@ void MainWindow::autoPlayCheckNewMessage(const QString& channelId) {
} }
void MainWindow::autoPlayTimerTick() { void MainWindow::autoPlayTimerTick() {
if (VoicePlayer::isPreparing() || SoundManager::instance()->isCurrentPcmPlaying()) if (VoicePlayer::isPreparing() || VoicePlayer::isPlaying())
return; return;
while (!m_autoPlayQueue.isEmpty()) { while (!m_autoPlayQueue.isEmpty()) {
@ -1000,8 +1000,8 @@ void MainWindow::autoPlayTimerTick() {
DEBUG_DEBUG(DEBUG_CATEGORY_DEBUG, "auto-play: playing ch=%s msg=%lld file=%s dur=%.1fs", DEBUG_DEBUG(DEBUG_CATEGORY_DEBUG, "auto-play: playing ch=%s msg=%lld file=%s dur=%.1fs",
qPrintable(chId), (long long)msgId, qPrintable(fullPath), (double)dur); qPrintable(chId), (long long)msgId, qPrintable(fullPath), (double)dur);
MessageDelegate::stopAllAutoPlay(); MessageDelegate::stopAllAutoPlay();
VoicePlayer::playOpusFile(fullPath, this, [fullPath](float actualDur) { VoicePlayer::playOpusFile(fullPath, this, [fullPath](float actualDur, uint64_t playbackId) {
MessageDelegate::startAutoPlay(fullPath, actualDur); MessageDelegate::startAutoPlay(fullPath, actualDur, playbackId);
}); });
return; return;
} }
@ -1033,6 +1033,6 @@ void MainWindow::onAttachmentDownloadedForAutoPlay(const QString& chId, int64_t
return; return;
if (!m_autoPlayTimer->isActive()) if (!m_autoPlayTimer->isActive())
m_autoPlayTimer->start(200); m_autoPlayTimer->start(200);
if (!SoundManager::instance()->isCurrentPcmPlaying()) if (!VoicePlayer::isPlaying())
autoPlayTimerTick(); autoPlayTimerTick();
} }

36
tools/chatgui/src/messagedelegate.cpp
Unescape View File

@ -29,6 +29,7 @@ MessageDelegate::MessageDelegate(QObject *parent)
: QStyledItemDelegate(parent) {} : QStyledItemDelegate(parent) {}
struct VoicePlayState { struct VoicePlayState {
uint64_t playbackId = 0;
bool loading = false; bool loading = false;
bool playing = false; bool playing = false;
bool paused = false; bool paused = false;
@ -56,7 +57,7 @@ static void ensureVoiceTimer() {
continue; continue;
} }
if (it->paused) { anyActive = true; continue; } if (it->paused) { anyActive = true; continue; }
if (!sm->isCurrentPcmPlaying()) { if (!sm->isPcmPlaying(it->playbackId)) {
it->playing = false; it->playing = false;
it->paused = false; it->paused = false;
anyActive = true; anyActive = true;
@ -177,16 +178,16 @@ bool MessageDelegate::editorEvent(QEvent *event, QAbstractItemModel *model,
/* Start playback then seek */ /* Start playback then seek */
st.loading = true; st.loading = true;
QPersistentModelIndex persistent(index); QPersistentModelIndex persistent(index);
VoicePlayer::playOpusFile(filePath, this, [filePath, clickFrac, persistent](float actualDur) { VoicePlayer::playOpusFile(filePath, this, [filePath, clickFrac, persistent](float actualDur, uint64_t playbackId) {
s_voiceStates[filePath].loading = false; s_voiceStates[filePath].loading = false;
if (actualDur <= 0) return; if (actualDur <= 0) return;
MessageDelegate::startAutoPlay(filePath, actualDur); MessageDelegate::startAutoPlay(filePath, actualDur, playbackId);
float position = clickFrac * actualDur; float position = clickFrac * actualDur;
auto& state = s_voiceStates[filePath]; auto& state = s_voiceStates[filePath];
state.startMs -= (qint64)(position * 1000); state.pausedPosSec = position; state.startMs -= (qint64)(position * 1000); state.pausedPosSec = position;
state.displayFrac = clickFrac; state.displayElapsed = position; state.displayFrac = clickFrac; state.displayElapsed = position;
int rate = SoundManager::instance()->currentPcmSampleRate(); int rate = SoundManager::instance()->pcmSampleRate(playbackId);
if (rate > 0) SoundManager::instance()->seekCurrentPcm((unsigned long long)(position * rate)); if (rate > 0) SoundManager::instance()->seekPcm(playbackId, (unsigned long long)(position * rate));
if (persistent.isValid()) const_cast<QAbstractItemModel*>(persistent.model())->setData(persistent, 1, MsgVoicePlayStateRole); if (persistent.isValid()) const_cast<QAbstractItemModel*>(persistent.model())->setData(persistent, 1, MsgVoicePlayStateRole);
}); });
s_voiceTimer->start(); s_voiceTimer->start();
@ -199,9 +200,9 @@ bool MessageDelegate::editorEvent(QEvent *event, QAbstractItemModel *model,
{ st.playing = true; s_voiceTimer->start(); } { st.playing = true; s_voiceTimer->start(); }
st.displayFrac = (targetSec > 0 && dur > 0) ? (targetSec / dur) : 0; st.displayFrac = (targetSec > 0 && dur > 0) ? (targetSec / dur) : 0;
st.displayElapsed = targetSec; st.displayElapsed = targetSec;
int sr = SoundManager::instance()->currentPcmSampleRate(); int sr = SoundManager::instance()->pcmSampleRate(st.playbackId);
if (sr > 0) if (sr > 0)
SoundManager::instance()->seekCurrentPcm((unsigned long long)(targetSec * sr)); SoundManager::instance()->seekPcm(st.playbackId, (unsigned long long)(targetSec * sr));
} }
return true; return true;
} }
@ -219,7 +220,7 @@ bool MessageDelegate::editorEvent(QEvent *event, QAbstractItemModel *model,
st.pausedPosSec = (now - st.startMs) / 1000.0f; st.pausedPosSec = (now - st.startMs) / 1000.0f;
st.playing = false; st.playing = false;
st.paused = true; st.paused = true;
SoundManager::instance()->pauseCurrentPcm(); SoundManager::instance()->pausePcm(st.playbackId);
model->setData(index, 2, MsgVoicePlayStateRole); model->setData(index, 2, MsgVoicePlayStateRole);
return true; return true;
} }
@ -232,7 +233,7 @@ bool MessageDelegate::editorEvent(QEvent *event, QAbstractItemModel *model,
st.startMs = now - (qint64)(st.pausedPosSec * 1000.0); st.startMs = now - (qint64)(st.pausedPosSec * 1000.0);
st.displayFrac = (dur > 0) ? (st.pausedPosSec / dur) : 0; st.displayFrac = (dur > 0) ? (st.pausedPosSec / dur) : 0;
st.displayElapsed = st.pausedPosSec; st.displayElapsed = st.pausedPosSec;
SoundManager::instance()->resumeCurrentPcm(); SoundManager::instance()->resumePcm(st.playbackId);
s_voiceTimer->start(); s_voiceTimer->start();
model->setData(index, 1, MsgVoicePlayStateRole); model->setData(index, 1, MsgVoicePlayStateRole);
return true; return true;
@ -243,15 +244,15 @@ bool MessageDelegate::editorEvent(QEvent *event, QAbstractItemModel *model,
for (auto it = s_voiceStates.begin(); it != s_voiceStates.end(); ++it) { for (auto it = s_voiceStates.begin(); it != s_voiceStates.end(); ++it) {
it->playing = false; it->paused = false; it->playing = false; it->paused = false;
} }
SoundManager::instance()->stopCurrentPcm(); VoicePlayer::stop();
} }
st.loading = true; st.loading = true;
QPersistentModelIndex persistent(index); QPersistentModelIndex persistent(index);
VoicePlayer::playOpusFile(filePath, this, [filePath, persistent](float actualDur) { VoicePlayer::playOpusFile(filePath, this, [filePath, persistent](float actualDur, uint64_t playbackId) {
s_voiceStates[filePath].loading = false; s_voiceStates[filePath].loading = false;
if (actualDur <= 0) return; if (actualDur <= 0) return;
MessageDelegate::startAutoPlay(filePath, actualDur); MessageDelegate::startAutoPlay(filePath, actualDur, playbackId);
if (persistent.isValid()) const_cast<QAbstractItemModel*>(persistent.model())->setData(persistent, 1, MsgVoicePlayStateRole); if (persistent.isValid()) const_cast<QAbstractItemModel*>(persistent.model())->setData(persistent, 1, MsgVoicePlayStateRole);
}); });
s_voiceTimer->start(); s_voiceTimer->start();
@ -913,9 +914,9 @@ void MessageDelegate::paint(QPainter *painter, const QStyleOptionViewItem &optio
elapsed = st->pausedPosSec; elapsed = st->pausedPosSec;
} else if (isPlaying) { } else if (isPlaying) {
SoundManager* sm = SoundManager::instance(); SoundManager* sm = SoundManager::instance();
if (sm->isCurrentPcmPlaying()) { if (sm->isPcmPlaying(st->playbackId)) {
int sr = sm->currentPcmSampleRate(); int sr = sm->pcmSampleRate(st->playbackId);
if (sr > 0) elapsed = (float)((double)sm->currentPcmCursor() / sr); if (sr > 0) elapsed = (float)((double)sm->pcmCursor(st->playbackId) / sr);
} }
if (elapsed <= 0) { if (elapsed <= 0) {
qint64 now = QDateTime::currentMSecsSinceEpoch(); qint64 now = QDateTime::currentMSecsSinceEpoch();
@ -1504,10 +1505,11 @@ void MessageDelegate::drawAvatar(QPainter *p, const Layout &L,
p->restore(); p->restore();
} }
void MessageDelegate::startAutoPlay(const QString& filePath, float actualDurationSec) { void MessageDelegate::startAutoPlay(const QString& filePath, float actualDurationSec, uint64_t playbackId) {
if (actualDurationSec <= 0) return; if (actualDurationSec <= 0) return;
ensureVoiceTimer(); ensureVoiceTimer();
VoicePlayState& st = s_voiceStates[filePath]; VoicePlayState& st = s_voiceStates[filePath];
st.playbackId = playbackId;
st.playing = true; st.playing = true;
st.paused = false; st.paused = false;
st.durationSec = (actualDurationSec > 0) ? actualDurationSec : 1.0f; st.durationSec = (actualDurationSec > 0) ? actualDurationSec : 1.0f;
@ -1520,7 +1522,7 @@ void MessageDelegate::startAutoPlay(const QString& filePath, float actualDuratio
} }
void MessageDelegate::stopAllAutoPlay() { void MessageDelegate::stopAllAutoPlay() {
VoicePlayer::cancelPending(); VoicePlayer::stop();
for (auto it = s_voiceStates.begin(); it != s_voiceStates.end(); ++it) { for (auto it = s_voiceStates.begin(); it != s_voiceStates.end(); ++it) {
it->playing = false; it->paused = false; it->loading = false; it->playing = false; it->paused = false; it->loading = false;
} }

3
tools/chatgui/src/messagedelegate.h
Unescape View File

@ -1,4 +1,5 @@
#pragma once #pragma once
#include <cstdint>
#include <QStyledItemDelegate> #include <QStyledItemDelegate>
#include <functional> #include <functional>
@ -55,7 +56,7 @@ public:
const QStyleOptionViewItem &option, const QStyleOptionViewItem &option,
const QModelIndex &index) override; const QModelIndex &index) override;
static void startAutoPlay(const QString& filePath, float actualDurationSec); static void startAutoPlay(const QString& filePath, float actualDurationSec, uint64_t playbackId);
static void stopAllAutoPlay(); static void stopAllAutoPlay();
void setVideoOpenCallback(std::function<void(const QString&)> cb) { m_videoOpenCb = std::move(cb); } void setVideoOpenCallback(std::function<void(const QString&)> cb) { m_videoOpenCb = std::move(cb); }

2
tools/chatgui/src/messagelist.cpp
Unescape View File

@ -960,7 +960,7 @@ void MessageList::onAttachmentDownloaded(const QString& chId, int64_t msgId) {
if (!fp.isEmpty() && QFile::exists(fp)) { if (!fp.isEmpty() && QFile::exists(fp)) {
QTimer::singleShot(500, this, [this, fp]() { QTimer::singleShot(500, this, [this, fp]() {
MessageDelegate::stopAllAutoPlay(); MessageDelegate::stopAllAutoPlay();
VoicePlayer::playOpusFile(fp, this, [fp](float actualDur) { MessageDelegate::startAutoPlay(fp, actualDur); }); VoicePlayer::playOpusFile(fp, this, [fp](float actualDur, uint64_t playbackId) { MessageDelegate::startAutoPlay(fp, actualDur, playbackId); });
}); });
} }
} }

155
tools/chatgui/src/sound_manager.cpp
Unescape View File

@ -89,6 +89,10 @@ void SoundManager::openOutput() {
void SoundManager::recoverAudio() { void SoundManager::recoverAudio() {
if (!m_initialized) return; if (!m_initialized) return;
for (auto it = m_pcmSessions.begin(); it != m_pcmSessions.end();) {
if (it->second->transient && !isPcmPlaying(it->first)) it = m_pcmSessions.erase(it);
else ++it;
}
if (m_context && audio_context_failed(m_context)) { if (m_context && audio_context_failed(m_context)) {
DEBUG_ERROR(DEBUG_CATEGORY_CALL, "SoundManager: context failed, closing dependent devices"); DEBUG_ERROR(DEBUG_CATEGORY_CALL, "SoundManager: context failed, closing dependent devices");
emit contextAboutToReset(); emit contextAboutToReset();
@ -112,14 +116,34 @@ void SoundManager::setDevices(const QString& output, const QString& input) {
recoverAudio(); recoverAudio();
} }
void SoundManager::clearCurrentPcm() { /* Detach ждёт читателя графа; владелец PCM освобождается последним. */
if (m_currentPcmSound) { ma_sound_uninit(m_currentPcmSound); delete m_currentPcmSound; m_currentPcmSound = nullptr; } SoundManager::PcmSession::~PcmSession() {
if (m_currentPcmBuffer) { if (sound) { ma_sound_uninit(sound); delete sound; }
ma_audio_buffer* buf = (ma_audio_buffer*)m_currentPcmBuffer; if (buffer) { ma_audio_buffer_uninit(buffer); delete buffer; }
ma_audio_buffer_uninit(buf); delete buf; m_currentPcmBuffer = nullptr; }
SoundManager::PcmSession* SoundManager::pcmSession(PlaybackId id) const {
auto it = m_pcmSessions.find(id);
return it == m_pcmSessions.end() ? nullptr : it->second.get();
}
/* Новый узел имеет пустой read/resampler cache; общий PCM и handle сохраняются. */
bool SoundManager::createPcmNode(PcmSession& session, bool playing) {
auto* sound = new ma_sound{};
ma_result result = ma_sound_init_from_data_source(m_engine, (ma_data_source*)session.buffer, 0, nullptr, sound);
if (result != MA_SUCCESS) {
delete sound;
DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "playback: node init failed result=%d", result);
return false;
} }
m_currentPcmSampleRate = 0; session.sound = sound;
m_currentPcmOwner.reset(); ma_sound_set_volume(sound, m_volume);
if (playing && ma_sound_start(sound) != MA_SUCCESS) {
DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "playback: node start failed");
ma_sound_uninit(sound); delete sound; session.sound = nullptr;
return false;
}
return true;
} }
void SoundManager::shutdown() { void SoundManager::shutdown() {
@ -128,7 +152,7 @@ void SoundManager::shutdown() {
m_initialized = false; m_initialized = false;
emit contextAboutToReset(); emit contextAboutToReset();
m_output.close(); m_output.close();
clearCurrentPcm(); m_pcmSessions.clear();
for (auto it = m_sounds.begin(); it != m_sounds.end(); ++it) { for (auto it = m_sounds.begin(); it != m_sounds.end(); ++it) {
if (it->sound) { ma_sound_uninit(it->sound); delete it->sound; } if (it->sound) { ma_sound_uninit(it->sound); delete it->sound; }
@ -278,75 +302,84 @@ ma_context* SoundManager::context() {
return m_context; return m_context;
} }
void SoundManager::playRawPcm(const int16_t* pcm, int sampleCount, int sampleRate, int channels, SoundManager::PlaybackId SoundManager::playRawPcm(const int16_t* pcm, int frameCount, int sampleRate, int channels,
std::shared_ptr<std::vector<int16_t>> owner) { std::shared_ptr<std::vector<int16_t>> owner, bool transient) {
if (!m_engine || !m_initialized) { if (!m_engine || !m_initialized || !pcm || frameCount <= 0 || sampleRate <= 0 || channels < 1 || channels > 2) {
DEBUG_WARN(DEBUG_CATEGORY_GENERAL, "SoundManager::playRawPcm: not initialized (engine=%p init=%d)", DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "playback: invalid PCM frames=%d rate=%d ch=%d ready=%d",
(void*)m_engine, (int)m_initialized); frameCount, sampleRate, channels, m_initialized);
return; return 0;
} }
clearCurrentPcm(); if (owner && (pcm != owner->data() || (size_t)frameCount > owner->size() / channels)) {
m_currentPcmOwner = std::move(owner); DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "playback: PCM owner does not contain requested frames");
m_currentPcmSampleRate = sampleRate; return 0;
DEBUG_DEBUG(DEBUG_CATEGORY_DEBUG, "SoundManager::playRawPcm: %d samples %dHz %dch volume=%.2f",
sampleCount, sampleRate, channels, m_volume);
ma_audio_buffer_config bufCfg = ma_audio_buffer_config_init(
ma_format_s16, (ma_uint32)channels, (ma_uint64)sampleCount, pcm, NULL);
ma_audio_buffer* buf = new ma_audio_buffer;
m_currentPcmBuffer = buf;
ma_result r = m_currentPcmOwner ? ma_audio_buffer_init(&bufCfg, buf) : ma_audio_buffer_init_copy(&bufCfg, buf);
if (r != MA_SUCCESS) {
DEBUG_WARN(DEBUG_CATEGORY_GENERAL, "SoundManager: audio_buffer_init_copy failed (%d)", r);
delete buf; m_currentPcmBuffer = nullptr;
return;
} }
auto session = std::make_unique<PcmSession>();
m_currentPcmSound = new ma_sound; session->owner = std::move(owner);
r = ma_sound_init_from_data_source(m_engine, (ma_data_source*)buf, 0, nullptr, m_currentPcmSound); session->frames = frameCount; session->rate = sampleRate; session->transient = transient;
if (r != MA_SUCCESS) { ma_audio_buffer_config config = ma_audio_buffer_config_init(ma_format_s16, channels, frameCount, pcm, nullptr);
DEBUG_WARN(DEBUG_CATEGORY_GENERAL, "SoundManager: PCM sound init failed (%d)", r); config.sampleRate = sampleRate;
ma_audio_buffer_uninit(buf); delete buf; m_currentPcmBuffer = nullptr; auto* buffer = new ma_audio_buffer{};
delete m_currentPcmSound; m_currentPcmSound = nullptr; ma_result result = session->owner ? ma_audio_buffer_init(&config, buffer) : ma_audio_buffer_init_copy(&config, buffer);
return; if (result != MA_SUCCESS) {
delete buffer;
DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "playback: PCM buffer init failed result=%d", result);
return 0;
} }
session->buffer = buffer;
if (!createPcmNode(*session, true)) return 0;
PlaybackId id = ++m_nextPlaybackId;
m_pcmSessions.emplace(id, std::move(session));
DEBUG_INFO(DEBUG_CATEGORY_MEDIA, "playback: started id=%llu frames=%d rate=%d ch=%d transient=%d",
(unsigned long long)id, frameCount, sampleRate, channels, transient);
return id;
}
ma_sound_set_volume(m_currentPcmSound, m_volume); void SoundManager::pausePcm(PlaybackId id) {
r = ma_sound_start(m_currentPcmSound); auto* session = pcmSession(id);
ma_uint64 cursor = 0; if (session && session->sound) ma_sound_stop(session->sound);
ma_sound_get_cursor_in_pcm_frames(m_currentPcmSound, &cursor);
DEBUG_INFO(DEBUG_CATEGORY_GENERAL,
"SoundManager::playRawPcm: started rc=%d is_playing=%d cursor=%llu/%d",
(int)r, (int)ma_sound_is_playing(m_currentPcmSound),
(unsigned long long)cursor, sampleCount);
} }
void SoundManager::pauseCurrentPcm() { void SoundManager::resumePcm(PlaybackId id) {
if (m_currentPcmSound) ma_sound_stop(m_currentPcmSound); auto* session = pcmSession(id);
if (session && session->sound && ma_sound_start(session->sound) != MA_SUCCESS)
DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "playback: resume failed id=%llu", (unsigned long long)id);
} }
void SoundManager::resumeCurrentPcm() { void SoundManager::stopPcm(PlaybackId id) {
if (m_currentPcmSound) ma_sound_start(m_currentPcmSound); if (m_pcmSessions.erase(id)) DEBUG_INFO(DEBUG_CATEGORY_MEDIA, "playback: stopped id=%llu", (unsigned long long)id);
} }
void SoundManager::stopCurrentPcm() { uint64_t SoundManager::pcmCursor(PlaybackId id) const {
clearCurrentPcm(); auto* session = pcmSession(id);
if (!session || !session->sound) return 0;
uint64_t rendered = ma_sound_get_time_in_pcm_frames(session->sound);
return std::min(session->frames, session->origin + rendered * (uint64_t)session->rate / 48000);
} }
unsigned long long SoundManager::currentPcmCursor() const { bool SoundManager::isPcmPlaying(PlaybackId id) const {
if (!m_currentPcmSound) return 0; auto* session = pcmSession(id);
ma_uint64 cursor = 0; return session && session->sound && ma_sound_is_playing(session->sound);
ma_sound_get_cursor_in_pcm_frames(m_currentPcmSound, &cursor);
return (unsigned long long)cursor;
} }
bool SoundManager::isCurrentPcmPlaying() const { int SoundManager::pcmSampleRate(PlaybackId id) const {
if (!m_currentPcmSound) return false; auto* session = pcmSession(id);
return ma_sound_is_playing(m_currentPcmSound) != MA_FALSE; return session ? session->rate : 0;
} }
void SoundManager::seekCurrentPcm(unsigned long long pcmFrame) { bool SoundManager::seekPcm(PlaybackId id, uint64_t frame) {
if (m_currentPcmSound) ma_sound_seek_to_pcm_frame(m_currentPcmSound, pcmFrame); auto* session = pcmSession(id);
if (!session || !session->sound) { DEBUG_WARN(DEBUG_CATEGORY_MEDIA, "playback: seek missing id=%llu", (unsigned long long)id); return false; }
bool playing = ma_sound_is_playing(session->sound);
ma_sound_uninit(session->sound); delete session->sound; session->sound = nullptr;
session->origin = std::min(frame, session->frames);
ma_result result = ma_audio_buffer_seek_to_pcm_frame(session->buffer, session->origin);
if (result != MA_SUCCESS || !createPcmNode(*session, playing)) {
DEBUG_ERROR(DEBUG_CATEGORY_MEDIA, "playback: seek failed id=%llu frame=%llu result=%d",
(unsigned long long)id, (unsigned long long)frame, result);
return false;
}
DEBUG_DEBUG(DEBUG_CATEGORY_MEDIA, "playback: seek id=%llu frame=%llu", (unsigned long long)id, (unsigned long long)session->origin);
return true;
} }
static QString decodeDeviceName(const char* name) { static QString decodeDeviceName(const char* name) {

40
tools/chatgui/src/sound_manager.h
Unescape View File

@ -6,6 +6,7 @@
#include <QByteArray> #include <QByteArray>
#include <vector> #include <vector>
#include <memory> #include <memory>
#include <map>
#include <cstdint> #include <cstdint>
#include <QTimer> #include <QTimer>
#include "audio_device.h" #include "audio_device.h"
@ -47,16 +48,17 @@ public:
QString playbackDevice() const { return m_playbackId; } QString playbackDevice() const { return m_playbackId; }
QString captureDevice() const { return m_captureId; } QString captureDevice() const { return m_captureId; }
/* owner удерживает готовый PCM без копии в GUI; без owner короткие буферы копируются. */ using PlaybackId = uint64_t;
void playRawPcm(const int16_t* pcm, int sampleCount, int sampleRate, int channels, /* GUI: независимая сессия. owner удерживает PCM до detach; без owner данные копируются. */
std::shared_ptr<std::vector<int16_t>> owner = {}); PlaybackId playRawPcm(const int16_t* pcm, int frameCount, int sampleRate, int channels,
void pauseCurrentPcm(); std::shared_ptr<std::vector<int16_t>> owner = {}, bool transient = false);
void resumeCurrentPcm(); void pausePcm(PlaybackId id);
void stopCurrentPcm(); void resumePcm(PlaybackId id);
void seekCurrentPcm(unsigned long long pcmFrame); void stopPcm(PlaybackId id);
unsigned long long currentPcmCursor() const; bool seekPcm(PlaybackId id, uint64_t frame);
bool isCurrentPcmPlaying() const; uint64_t pcmCursor(PlaybackId id) const;
int currentPcmSampleRate() const { return m_currentPcmSampleRate; } bool isPcmPlaying(PlaybackId id) const;
int pcmSampleRate(PlaybackId id) const;
struct DeviceInfo { struct DeviceInfo {
QString name; QString name;
@ -75,7 +77,17 @@ private:
SoundManager(); SoundManager();
~SoundManager(); ~SoundManager();
void clearCurrentPcm(); struct PcmSession {
ma_sound* sound = nullptr;
ma_audio_buffer* buffer = nullptr;
std::shared_ptr<std::vector<int16_t>> owner;
uint64_t frames = 0, origin = 0;
int rate = 0;
bool transient = false;
~PcmSession();
};
PcmSession* pcmSession(PlaybackId id) const;
bool createPcmNode(PcmSession& session, bool playing);
void recoverAudio(); void recoverAudio();
bool openContext(); bool openContext();
void openOutput(); void openOutput();
@ -96,10 +108,8 @@ private:
QString m_playbackId, m_captureId; QString m_playbackId, m_captureId;
ma_backend m_backend = ma_backend_null; ma_backend m_backend = ma_backend_null;
bool m_backendSelected = false; bool m_backendSelected = false;
ma_sound* m_currentPcmSound = nullptr; std::map<PlaybackId, std::unique_ptr<PcmSession>> m_pcmSessions;
void* m_currentPcmBuffer = nullptr; PlaybackId m_nextPlaybackId = 0;
int m_currentPcmSampleRate = 0;
std::shared_ptr<std::vector<int16_t>> m_currentPcmOwner;
bool m_initialized = false; bool m_initialized = false;
bool m_enabled = true; bool m_enabled = true;
float m_volume = 0.8f; float m_volume = 0.8f;

47
tools/chatgui/src/videoplayer_engine.cpp
Unescape View File

@ -295,11 +295,22 @@ void VideoPlayerEngine::open(const QString& path) {
m_worker->moveToThread(m_thread); m_worker->moveToThread(m_thread);
connect(m_thread, &QThread::started, m_worker, &Worker::run); connect(m_thread, &QThread::started, m_worker, &Worker::run);
connect(m_worker, &Worker::opened, this, &VideoPlayerEngine::onWorkerOpened); uint64_t generation = ++m_openGeneration;
connect(m_worker, &Worker::audioDecoded, this, &VideoPlayerEngine::onAudioDecoded); connect(m_worker, &Worker::opened, this, [this, generation](int w, int h, qint64 duration, bool audio) {
connect(m_worker, &Worker::frameDecoded, this, &VideoPlayerEngine::onFrameDecoded); if (generation == m_openGeneration) onWorkerOpened(w, h, duration, audio);
connect(m_worker, &Worker::error, this, &VideoPlayerEngine::onWorkerError); });
connect(m_worker, &Worker::finished, this, &VideoPlayerEngine::onWorkerFinished); 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::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();
});
DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "VideoEngine: open %s", qPrintable(path)); DEBUG_INFO(DEBUG_CATEGORY_VIDEO, "VideoEngine: open %s", qPrintable(path));
m_thread->start(); m_thread->start();
@ -308,7 +319,7 @@ void VideoPlayerEngine::open(const QString& path) {
void VideoPlayerEngine::play() { void VideoPlayerEngine::play() {
if (m_state != Paused && m_state != Playing) return; if (m_state != Paused && m_state != Playing) return;
m_paused.storeRelaxed(0); m_paused.storeRelaxed(0);
if (m_hasAudio) SoundManager::instance()->resumeCurrentPcm(); if (m_hasAudio) SoundManager::instance()->resumePcm(m_audioPlayback);
else { m_elapsedBaseMs = m_positionMs; m_elapsed.restart(); } else { m_elapsedBaseMs = m_positionMs; m_elapsed.restart(); }
setState(Playing); setState(Playing);
m_presentTimer.start(); m_presentTimer.start();
@ -317,7 +328,7 @@ void VideoPlayerEngine::play() {
void VideoPlayerEngine::pause() { void VideoPlayerEngine::pause() {
if (m_state != Playing) return; if (m_state != Playing) return;
m_paused.storeRelaxed(1); m_paused.storeRelaxed(1);
if (m_hasAudio) SoundManager::instance()->pauseCurrentPcm(); if (m_hasAudio) SoundManager::instance()->pausePcm(m_audioPlayback);
setState(Paused); setState(Paused);
m_presentTimer.stop(); m_presentTimer.stop();
} }
@ -336,8 +347,8 @@ void VideoPlayerEngine::seekMs(qint64 ms) {
m_seekReq.storeRelaxed(1); m_seekReq.storeRelaxed(1);
clearPending(); clearPending();
if (m_hasAudio) { if (m_hasAudio) {
int sr = SoundManager::instance()->currentPcmSampleRate(); int sr = SoundManager::instance()->pcmSampleRate(m_audioPlayback);
if (sr > 0) SoundManager::instance()->seekCurrentPcm((unsigned long long)(ms * sr / 1000)); if (sr > 0) SoundManager::instance()->seekPcm(m_audioPlayback, (unsigned long long)(ms * sr / 1000));
} else { } else {
m_elapsedBaseMs = ms; m_elapsedBaseMs = ms;
m_elapsed.restart(); m_elapsed.restart();
@ -348,11 +359,12 @@ void VideoPlayerEngine::seekMs(qint64 ms) {
} }
void VideoPlayerEngine::stop() { void VideoPlayerEngine::stop() {
++m_openGeneration;
m_abort.storeRelaxed(1); m_abort.storeRelaxed(1);
m_presentTimer.stop(); m_presentTimer.stop();
clearPending(); clearPending();
m_renderFrame = QImage(); m_renderFrame = QImage();
if (m_hasAudio) SoundManager::instance()->stopCurrentPcm(); if (m_hasAudio) SoundManager::instance()->stopPcm(m_audioPlayback);
setState(Stopped); setState(Stopped);
m_positionMs = 0; m_positionMs = 0;
m_durationMs = 0; m_durationMs = 0;
@ -373,9 +385,9 @@ void VideoPlayerEngine::close() {
qint64 VideoPlayerEngine::clockMs() const { qint64 VideoPlayerEngine::clockMs() const {
if (m_hasAudio && m_audioSampleRate > 0) { if (m_hasAudio && m_audioSampleRate > 0) {
if (m_state == Finished && !SoundManager::instance()->isCurrentPcmPlaying()) if (m_state == Finished && !SoundManager::instance()->isPcmPlaying(m_audioPlayback))
return m_durationMs; /* аудио закончилось — часы в конец */ return m_durationMs; /* аудио закончилось — часы в конец */
unsigned long long cur = SoundManager::instance()->currentPcmCursor(); unsigned long long cur = SoundManager::instance()->pcmCursor(m_audioPlayback);
return (qint64)(cur * 1000 / (unsigned long long)m_audioSampleRate); return (qint64)(cur * 1000 / (unsigned long long)m_audioSampleRate);
} }
return m_elapsedBaseMs + m_elapsed.elapsed(); return m_elapsedBaseMs + m_elapsed.elapsed();
@ -410,15 +422,16 @@ void VideoPlayerEngine::onAudioDecoded(std::shared_ptr<std::vector<int16_t>> pcm
int sampleRate, int channels, qint64 durationMs) { int sampleRate, int channels, qint64 durationMs) {
if (pcm && !pcm->empty() && channels > 0) { if (pcm && !pcm->empty() && channels > 0) {
m_audioSampleRate = sampleRate; m_audioSampleRate = sampleRate;
SoundManager::instance()->playRawPcm(pcm->data(), (int)(pcm->size() / (size_t)channels), SoundManager::instance()->stopPcm(m_audioPlayback);
sampleRate, channels); m_audioPlayback = SoundManager::instance()->playRawPcm(pcm->data(), (int)(pcm->size() / (size_t)channels),
if (!SoundManager::instance()->isCurrentPcmPlaying()) { sampleRate, channels, pcm);
if (!SoundManager::instance()->isPcmPlaying(m_audioPlayback)) {
/* аудио-устройство недоступно — переходим на системные часы */ /* аудио-устройство недоступно — переходим на системные часы */
m_hasAudio = false; m_hasAudio = false;
m_audioSampleRate = 0; m_audioSampleRate = 0;
DEBUG_WARN(DEBUG_CATEGORY_VIDEO, "VideoEngine: audio not playing, fallback to system clock"); DEBUG_WARN(DEBUG_CATEGORY_VIDEO, "VideoEngine: audio not playing, fallback to system clock");
} else { } else {
DEBUG_DEBUG(DEBUG_CATEGORY_VIDEO, "VideoEngine: audio started %dHz %dch", sampleRate, channels); DEBUG_DEBUG(DEBUG_CATEGORY_VIDEO, "VideoEngine: audio started %dHz %dch", sampleRate, channels, pcm);
} }
} else { } else {
m_hasAudio = false; m_hasAudio = false;
@ -471,7 +484,7 @@ void VideoPlayerEngine::presentTick() {
if (m_state == Finished && m_pending.empty()) { if (m_state == Finished && m_pending.empty()) {
m_presentTimer.stop(); m_presentTimer.stop();
if (m_hasAudio) SoundManager::instance()->stopCurrentPcm(); if (m_hasAudio) SoundManager::instance()->stopPcm(m_audioPlayback);
} }
} }

2
tools/chatgui/src/videoplayer_engine.h
Unescape View File

@ -65,6 +65,7 @@ private:
qint64 clockMs() const; qint64 clockMs() const;
void clearPending(); void clearPending();
uint64_t m_openGeneration = 0;
QString m_path; QString m_path;
QThread* m_thread = nullptr; QThread* m_thread = nullptr;
class Worker* m_worker = nullptr; class Worker* m_worker = nullptr;
@ -88,6 +89,7 @@ private:
std::deque<std::pair<QImage, qint64>> m_pending; std::deque<std::pair<QImage, qint64>> m_pending;
QImage m_renderFrame; QImage m_renderFrame;
QTimer m_presentTimer; QTimer m_presentTimer;
uint64_t m_audioPlayback = 0;
int m_audioSampleRate = 0; int m_audioSampleRate = 0;
QElapsedTimer m_elapsed; QElapsedTimer m_elapsed;
qint64 m_elapsedBaseMs = 0; qint64 m_elapsedBaseMs = 0;

18
tools/chatgui/src/voiceplayback.cpp
Unescape View File

@ -73,13 +73,17 @@ int VoicePlayer::decodeOpusFile(const QString& filePath, std::vector<int16_t>& o
static unsigned s_decodeGeneration = 0; /* Только GUI-поток. */ static unsigned s_decodeGeneration = 0; /* Только GUI-поток. */
static bool s_decoding = false; static bool s_decoding = false;
static uint64_t s_playbackId = 0;
void VoicePlayer::cancelPending() { s_decodeGeneration++; } void VoicePlayer::cancelPending() { s_decodeGeneration++; }
void VoicePlayer::stop() { cancelPending(); SoundManager::instance()->stopPcm(s_playbackId); s_playbackId = 0; }
bool VoicePlayer::isPlaying() { return SoundManager::instance()->isPcmPlaying(s_playbackId); }
uint64_t VoicePlayer::playbackId() { return s_playbackId; }
bool VoicePlayer::isPreparing() { return s_decoding; } bool VoicePlayer::isPreparing() { return s_decoding; }
/* Декодирование и выделение PCM выполняются в worker; GUI принимает готовый буфер. */ /* Декодирование и выделение PCM выполняются в worker; GUI принимает готовый буфер. */
void VoicePlayer::playOpusFile(const QString& filePath, QObject* context, std::function<void(float)> ready) { void VoicePlayer::playOpusFile(const QString& filePath, QObject* context, std::function<void(float, uint64_t)> ready) {
if (s_decoding) { DEBUG_WARN(DEBUG_CATEGORY_MEDIA, "voice: decoder busy"); ready(0); return; } if (s_decoding) { DEBUG_WARN(DEBUG_CATEGORY_MEDIA, "voice: decoder busy"); ready(0, 0); return; }
struct Result { struct Result {
std::shared_ptr<std::vector<int16_t>> pcm = std::make_shared<std::vector<int16_t>>(); std::shared_ptr<std::vector<int16_t>> pcm = std::make_shared<std::vector<int16_t>>();
int rate = 0, channels = 0; int rate = 0, channels = 0;
@ -101,9 +105,13 @@ void VoicePlayer::playOpusFile(const QString& filePath, QObject* context, std::f
QObject::connect(thread, &QThread::finished, QCoreApplication::instance(), [result, receiver, ready, generation]() { QObject::connect(thread, &QThread::finished, QCoreApplication::instance(), [result, receiver, ready, generation]() {
s_decoding = false; s_decoding = false;
if (!receiver || generation != s_decodeGeneration) return; if (!receiver || generation != s_decodeGeneration) return;
if (result->duration > 0) SoundManager::instance()->playRawPcm(result->pcm->data(), if (result->duration > 0) {
(int)(result->pcm->size() / result->channels), result->rate, result->channels, result->pcm); SoundManager::instance()->stopPcm(s_playbackId);
ready(result->duration); s_playbackId = SoundManager::instance()->playRawPcm(result->pcm->data(),
(int)(result->pcm->size() / result->channels), result->rate, result->channels, result->pcm);
if (!s_playbackId) result->duration = 0;
}
ready(result->duration, s_playbackId);
}); });
QObject::connect(thread, &QThread::finished, thread, &QObject::deleteLater); QObject::connect(thread, &QThread::finished, thread, &QObject::deleteLater);
thread->start(); thread->start();

5
tools/chatgui/src/voiceplayback.h
Unescape View File

@ -9,8 +9,11 @@ class QObject;
class VoicePlayer { class VoicePlayer {
public: public:
static void playOpusFile(const QString& filePath, QObject* context, std::function<void(float)> ready); static void playOpusFile(const QString& filePath, QObject* context, std::function<void(float, uint64_t)> ready);
static void cancelPending(); static void cancelPending();
static void stop();
static bool isPlaying();
static uint64_t playbackId();
static bool isPreparing(); static bool isPreparing();
static int decodeOpusFile(const QString& filePath, std::vector<int16_t>& outPcm, static int decodeOpusFile(const QString& filePath, std::vector<int16_t>& outPcm,
int& outSampleRate, int& outChannels, float& outDurationSec); int& outSampleRate, int& outChannels, float& outDurationSec);

36
tools/chatgui/tests/test_audio_recovery.cpp
Unescape View File

@ -84,19 +84,19 @@ static void pulse_recovery(SoundManager* manager, const QString& control) {
REQUIRE(manager->context()->backend == ma_backend_pulseaudio); REQUIRE(manager->context()->backend == ma_backend_pulseaudio);
AudioRecorder recorder; recorder.init(); recorder.startRecording(); AudioRecorder recorder; recorder.init(); recorder.startRecording();
std::vector<int16_t> pcm(48000 * 20, 1000); std::vector<int16_t> pcm(48000 * 20, 1000);
manager->playRawPcm(pcm.data(), (int)pcm.size(), 48000, 1); auto pcmId = manager->playRawPcm(pcm.data(), (int)pcm.size(), 48000, 1);
for (int i = 0; i < 100 && recorder.durationMs() < 300; ++i) pump(50); for (int i = 0; i < 100 && recorder.durationMs() < 300; ++i) pump(50);
REQUIRE(recorder.durationMs() >= 300 && manager->currentPcmCursor() > 0); REQUIRE(recorder.durationMs() >= 300 && manager->pcmCursor(pcmId) > 0);
int duration = recorder.durationMs(); int duration = recorder.durationMs();
auto cursor = manager->currentPcmCursor(); auto cursor = manager->pcmCursor(pcmId);
QFile ready(control + "/ready"); REQUIRE(ready.open(QIODevice::WriteOnly)); ready.close(); QFile ready(control + "/ready"); REQUIRE(ready.open(QIODevice::WriteOnly)); ready.close();
for (int i = 0; i < 100 && manager->context(); ++i) pump(50); for (int i = 0; i < 100 && manager->context(); ++i) pump(50);
REQUIRE(!manager->context()); REQUIRE(!manager->context());
QFile closed(control + "/closed"); REQUIRE(closed.open(QIODevice::WriteOnly)); closed.close(); QFile closed(control + "/closed"); REQUIRE(closed.open(QIODevice::WriteOnly)); closed.close();
for (int i = 0; i < 150 && (!manager->context() || recorder.durationMs() <= duration + 200); ++i) pump(50); for (int i = 0; i < 150 && (!manager->context() || recorder.durationMs() <= duration + 200); ++i) pump(50);
REQUIRE(manager->context() && recorder.durationMs() > duration + 200 && manager->currentPcmCursor() > cursor); REQUIRE(manager->context() && recorder.durationMs() > duration + 200 && manager->pcmCursor(pcmId) > cursor);
qInfo("PulseAudio progress: capture=%d -> %dms playback=%llu -> %llu frames", duration, recorder.durationMs(), qInfo("PulseAudio progress: capture=%d -> %dms playback=%llu -> %llu frames", duration, recorder.durationMs(),
(unsigned long long)cursor, manager->currentPcmCursor()); (unsigned long long)cursor, (unsigned long long)manager->pcmCursor(pcmId));
recorder.stopRecording(); manager->shutdown(); recorder.stopRecording(); manager->shutdown();
REQUIRE(devices.empty()); REQUIRE(devices.empty());
qInfo("real PulseAudio: capture/playback progress restored after server restart PASS"); qInfo("real PulseAudio: capture/playback progress restored after server restart PASS");
@ -163,16 +163,16 @@ int main(int argc, char** argv) {
REQUIRE(radio->start(7) == 0); REQUIRE(radio->start(7) == 0);
AudioRecorder recorder; recorder.init(); recorder.startRecording(); AudioRecorder recorder; recorder.init(); recorder.startRecording();
std::vector<int16_t> notification(48000 * 10, 1000); std::vector<int16_t> notification(48000 * 10, 1000);
manager->playRawPcm(notification.data(), (int)notification.size(), 48000, 1); auto pcmId = manager->playRawPcm(notification.data(), (int)notification.size(), 48000, 1);
pump(60); pump(60);
auto cursor = manager->currentPcmCursor(); auto cursor = manager->pcmCursor(pcmId);
REQUIRE(cursor > 0); REQUIRE(cursor > 0);
int previousContext = contextStarts; int previousContext = contextStarts;
failContext = true; failContexts = 2; failContext = true; failContexts = 2;
pump(1800); pump(1800);
REQUIRE(contextStarts >= previousContext + 3 && manager->context()); REQUIRE(contextStarts >= previousContext + 3 && manager->context());
REQUIRE(call->callId() == 42 && radio->groupId() == 7 && recorder.isRecording()); REQUIRE(call->callId() == 42 && radio->groupId() == 7 && recorder.isRecording());
REQUIRE(manager->currentPcmCursor() > cursor && manager->isCurrentPcmPlaying()); REQUIRE(manager->pcmCursor(pcmId) > cursor && manager->isPcmPlaying(pcmId));
call->stop(); radio->stop(); recorder.stopRecording(); call->stop(); radio->stop(); recorder.stopRecording();
int previousStarts = starts; int previousStarts = starts;
pump(600); pump(600);
@ -192,6 +192,26 @@ int main(int argc, char** argv) {
pump(1000); pump(1000);
REQUIRE(manager->context() && captureStarts == previousCapture); REQUIRE(manager->context() && captureStarts == previousCapture);
// Частота источника и управление сессией независимы от соседнего проигрывателя.
std::vector<int16_t> pcm24(24000 * 2, 2000), pcm48(48000 * 2, -1000);
auto player24 = manager->playRawPcm(pcm24.data(), 48000, 24000, 1);
auto player48 = manager->playRawPcm(pcm48.data(), 96000, 48000, 1);
REQUIRE(player24 && player48 && player24 != player48);
pump(150);
uint64_t cursor24 = manager->pcmCursor(player24), cursor48 = manager->pcmCursor(player48);
REQUIRE(cursor24 > 1000 && cursor24 < 6000 && cursor48 > cursor24 * 1.8 && cursor48 < cursor24 * 2.2);
manager->pausePcm(player24);
cursor24 = manager->pcmCursor(player24);
pump(80);
REQUIRE(manager->pcmCursor(player24) == cursor24 && manager->pcmCursor(player48) > cursor48);
REQUIRE(manager->seekPcm(player24, 12000));
REQUIRE(manager->pcmCursor(player24) == 12000 && !manager->isPcmPlaying(player24));
manager->resumePcm(player24);
manager->stopPcm(player48);
pump(60);
REQUIRE(manager->pcmCursor(player24) > 12000 && manager->pcmCursor(player48) == 0);
manager->stopPcm(player24);
// Предел TX действует до помещения задачи в uasync; старое поколение не отправляется после stop/start. // Предел TX действует до помещения задачи в uasync; старое поколение не отправляется после stop/start.
uasync_poll(instance.ua, 0); uasync_poll(instance.ua, 0);
REQUIRE(call_audio_start(99) == 0); REQUIRE(call_audio_start(99) == 0);

2
tools/chatgui/tests/test_voice_file.cpp
Unescape View File

@ -35,7 +35,7 @@ int main(int argc, char** argv) {
reject(valid.left(14)); // Обрезанный пакет. reject(valid.left(14)); // Обрезанный пакет.
REQUIRE(file.open(QIODevice::WriteOnly | QIODevice::Truncate)); REQUIRE(file.write(valid) == valid.size()); file.close(); REQUIRE(file.open(QIODevice::WriteOnly | QIODevice::Truncate)); REQUIRE(file.write(valid) == valid.size()); file.close();
bool called = false; bool called = false;
VoicePlayer::playOpusFile(path, &app, [&](float) { called = true; }); VoicePlayer::playOpusFile(path, &app, [&](float, uint64_t) { called = true; });
REQUIRE(VoicePlayer::isPreparing()); VoicePlayer::cancelPending(); REQUIRE(VoicePlayer::isPreparing()); VoicePlayer::cancelPending();
QElapsedTimer deadline; deadline.start(); QElapsedTimer deadline; deadline.start();
while (VoicePlayer::isPreparing() && deadline.elapsed() < 5000) { app.processEvents(); QThread::msleep(1); } while (VoicePlayer::isPreparing() && deadline.elapsed() < 5000) { app.processEvents(); QThread::msleep(1); }

Write Preview
Loading…
Cancel
Save