jeka/utun2
1
0 Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
abe3d4bc89abc3e0cf700ce51f29781a961f5b37
utun2/src/stream/stream_playback_audio.cpp
T

323 lines
18 KiB
C++
Raw Blame History

#include "stream_playback_audio.h"
#include "soundtouch/SoundTouch.h"
#include <algorithm>
#include <atomic>
#include <cmath>
#include <cstring>
#include <new>
extern "C" {
#include "../../lib/debug_config.h"
#include "../../lib/mem.h"
#include "../../lib/opus_codec.h"
}
namespace {
constexpr unsigned rate = 48000, framesPerPacket = 960, maxFrames = 8192, mapCapacity = 1024, pcmCapacity = 128;
struct Span {
double first, last, ptsFirst, ptsLast;
Span(double begin = 0, double end = 0, double ptsBegin = 0, double ptsEnd = 0)
: first(begin), last(end), ptsFirst(ptsBegin), ptsLast(ptsEnd) {}
};
double mapped(const Span& span, double position) {
if (span.last <= span.first) return span.ptsLast;
double fraction = std::max(0.0, std::min(1.0, (position - span.first) / (span.last - span.first)));
return span.ptsFirst + fraction * (span.ptsLast - span.ptsFirst);
}
}
struct stream_playback_audio {
struct Pcm {
int16_t samples[framesPerPacket * 2];
Span spans[8];
unsigned frames = 0, count = 0;
} ready[pcmCapacity];
std::atomic<uint64_t> readyWrite{0}, readyRead{0}, preparedFrames{0}, consumedFrames{0};
std::atomic<double> consumedGain{0};
unsigned readyOffset = 0; // Только consumer; producer переиспользует слот после readyRead.store(release).
double preparedOutput = 0, preparedGain = 0; // Только producer.
opus_codec_decoder_t* opus = nullptr;
soundtouch::SoundTouch stretch;
Span input[mapCapacity], output[mapCapacity];
unsigned inputHead = 0, inputCount = 0, outputHead = 0, outputCount = 0;
unsigned bufferFrames = 0;
int tempo = 1000;
int64_t startPts = 0, expectedPts = -1, endPts = 0; // endPts публикуется через preparedEnd.
double expectedOutput = 0, producedOutput = 0, lastPts = 0;
uint64_t written = 0, lastAudioFrame = 0; // Consumer: граница последнего PCM до возможной тишины.
std::atomic<bool> finished{false}, failed{false}, preparedEnd{false};
int16_t pcm[framesPerPacket * 2];
float samples[maxFrames * 2];
};
/* Между сменами темпа соответствие линейно; точки сохраняют старый темп уже поставленного PCM. */
static bool appendOutput(stream_playback_audio* a, const Span& span) {
if (a->outputCount) {
auto& previous = a->output[(a->outputHead + a->outputCount - 1) % mapCapacity];
double previousSlope = (previous.ptsLast - previous.ptsFirst) / (previous.last - previous.first);
double slope = (span.ptsLast - span.ptsFirst) / (span.last - span.first);
if (std::abs(previous.last - span.first) < 0.000001 && std::abs(previous.ptsLast - span.ptsFirst) < 0.001
&& std::abs(previousSlope - slope) < 0.000001) {
previous.last = span.last; previous.ptsLast = span.ptsLast; return true;
}
}
if (a->outputCount == mapCapacity) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback audio output map overflow written=%llu", (unsigned long long)a->written);
a->failed = true; return false;
}
a->output[(a->outputHead + a->outputCount++) % mapCapacity] = span;
return true;
}
/* Прогрев перед точкой старта не создаёт слышимый PCM; частично перекрытый пакет обрезается по кадрам. */
static int feedPcm(stream_playback_audio* a, int64_t pts, const uint8_t* packet, int length) {
int count = opus_codec_decode(a->opus, packet, length, a->pcm, framesPerPacket);
if (count != (int)framesPerPacket) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback Opus decode failed pts=%lld result=%d", (long long)pts, count); return -1;
}
if (pts + 20000 <= a->startPts) return 0;
unsigned skip = pts < a->startPts ? (unsigned)((a->startPts - pts) * rate + 999999) / 1000000 : 0;
if (skip >= framesPerPacket) return 0;
unsigned frames = framesPerPacket - skip;
while (a->inputCount && a->input[a->inputHead].last <= a->preparedOutput) {
a->inputHead = (a->inputHead + 1) % mapCapacity; a->inputCount--;
}
if (a->inputCount == mapCapacity) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback audio input map overflow pts=%lld", (long long)pts); return -1;
}
double end = a->expectedOutput + frames * 1000.0 / a->tempo;
a->input[(a->inputHead + a->inputCount++) % mapCapacity] =
{a->expectedOutput, end, pts + skip * 1000000.0 / rate, pts + 20000.0};
a->expectedOutput = end;
for (unsigned i = 0; i < frames * 2; i++) a->samples[i] = a->pcm[skip * 2 + i] / 32768.0f;
a->stretch.putSamples(a->samples, frames);
return 0;
}
extern "C" {
struct stream_playback_audio* stream_playback_audio_create(int64_t start, unsigned bufferMs) {
if (start < 0) { DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback audio invalid start=%lld", (long long)start); return nullptr; }
if (!bufferMs || bufferMs > 1000) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback audio invalid PCM buffer=%ums range=1..1000ms", bufferMs); return nullptr;
}
void* memory = u_malloc(sizeof(stream_playback_audio));
if (!memory) { DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback audio allocation failed"); return nullptr; }
auto* a = new (memory) stream_playback_audio;
a->startPts = start; a->lastPts = (double)start; a->bufferFrames = rate * bufferMs / 1000;
a->opus = opus_codec_decoder_create(rate, 2);
if (!a->opus) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback audio Opus initialization failed"); stream_playback_audio_destroy(a); return nullptr;
}
a->stretch.setSampleRate(rate); a->stretch.setChannels(2); a->stretch.setTempo(1.0);
a->stretch.setSetting(SETTING_USE_QUICKSEEK, 1);
a->stretch.setSetting(SETTING_SEQUENCE_MS, 20); a->stretch.setSetting(SETTING_SEEKWINDOW_MS, 10);
a->stretch.setSetting(SETTING_OVERLAP_MS, 4); a->stretch.setSetting(SETTING_USE_AA_FILTER, 0);
DEBUG_INFO(DEBUG_CATEGORY_STREAM,
"playback audio created start=%lld stereo=1 tempo=1.0..1.6 PCM_buffer=%ums/%u_frames DSP_latency_us=%lld output=SPSC",
(long long)start, bufferMs, a->bufferFrames, (long long)stream_playback_audio_latency_us(a));
return a;
}
void stream_playback_audio_destroy(struct stream_playback_audio* a) {
if (!a) return;
DEBUG_INFO(DEBUG_CATEGORY_STREAM, "playback audio destroy written=%llu produced=%.0f pts=%.0f failed=%d",
(unsigned long long)a->written, a->producedOutput, a->lastPts, (int)a->failed.load());
opus_codec_decoder_destroy(a->opus); a->~stream_playback_audio(); u_free(a);
}
int stream_playback_audio_feed(struct stream_playback_audio* a, int64_t pts, const uint8_t* packet, size_t length) {
if (!a || !packet || !length || length > 1275 || pts < 0 || pts > INT64_MAX - 20000 || a->finished || a->failed) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback audio invalid feed pts=%lld length=%zu", (long long)pts, length); return -1;
}
if (a->expectedPts >= 0 && pts < a->expectedPts - 10000) {
DEBUG_WARN(DEBUG_CATEGORY_STREAM, "playback audio late packet pts=%lld expected=%lld", (long long)pts, (long long)a->expectedPts);
return 1;
}
int64_t difference = a->expectedPts < 0 ? 0 : pts - a->expectedPts;
if (difference >= 110000) {
DEBUG_WARN(DEBUG_CATEGORY_STREAM, "playback audio discontinuity pts=%lld expected=%lld gap_us=%lld",
(long long)pts, (long long)a->expectedPts, (long long)difference); return -2;
}
int missing = a->expectedPts < 0 ? 0 : (int)((difference + 10000) / 20000);
int64_t effectivePts = a->expectedPts < 0 ? pts : a->expectedPts + missing * 20000;
if (effectivePts > INT64_MAX - 20000) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback audio normalized PTS overflow pts=%lld", (long long)effectivePts); return -1;
}
for (int i = 0; i < missing; i++) if (feedPcm(a, a->expectedPts + i * 20000, nullptr, 0) < 0) return -1;
if (feedPcm(a, effectivePts, packet, (int)length) < 0) return -1;
a->expectedPts = effectivePts + 20000;
return stream_playback_audio_prepare(a);
}
void stream_playback_audio_set_tempo(struct stream_playback_audio* a, int tempo) {
if (!a || tempo < 1000 || tempo > 1600) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback audio invalid tempo=%d", tempo); return;
}
if (tempo == a->tempo) return;
a->tempo = tempo; a->stretch.setTempo(tempo / 1000.0);
}
int stream_playback_audio_needs_input(const struct stream_playback_audio* a) {
return a && !a->finished && !a->failed && stream_playback_audio_buffered(a) < a->bufferFrames;
}
unsigned stream_playback_audio_buffered(const struct stream_playback_audio* a) {
if (!a) return 0;
uint64_t consumed = a->consumedFrames.load(std::memory_order_acquire);
uint64_t prepared = a->preparedFrames.load(std::memory_order_acquire);
return (unsigned)(prepared > consumed ? prepared - consumed : 0);
}
int64_t stream_playback_audio_latency_us(struct stream_playback_audio* a) {
return a ? ((int64_t)a->stretch.getSetting(SETTING_INITIAL_LATENCY) * 1000000 + rate - 1) / rate : 0;
}
/* DSP принадлежит producer. Каждый слот содержит PCM и его исходные PTS, включая смены темпа. */
int stream_playback_audio_prepare(struct stream_playback_audio* a) {
if (!a || a->failed) { DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback PCM prepare invalid state"); return -1; }
uint64_t write = a->readyWrite.load(std::memory_order_relaxed);
while (write - a->readyRead.load(std::memory_order_acquire) < pcmCapacity) {
double end = a->finished ? std::round(a->expectedOutput) : std::floor(a->expectedOutput);
unsigned count = (unsigned)std::max(0.0, std::min<double>(framesPerPacket, end - a->preparedOutput));
count = std::min(count, a->stretch.numSamples());
if (!count) break;
auto& slot = a->ready[write % pcmCapacity]; slot.count = 0;
slot.frames = a->stretch.receiveSamples(a->samples, count);
for (unsigned i = 0; i < slot.frames * 2; i++)
slot.samples[i] = (int16_t)std::lrint(std::max(-32768.0f, std::min(32767.0f, a->samples[i] * 32767.0f)));
double position = a->preparedOutput, until = position + slot.frames;
for (unsigned i = 0; i < a->inputCount && position < until; i++) {
const auto& span = a->input[(a->inputHead + i) % mapCapacity];
if (span.last <= position) continue;
double next = std::min(until, span.last);
// EOF округляется до целого выходного frame, последний PTS остаётся концом материала.
if (a->finished && i + 1 == a->inputCount && until <= std::round(a->expectedOutput)) next = until;
if (slot.count == 8) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback PCM source map overflow frames=%u", slot.frames);
a->failed = true; return -1;
}
double firstPts = mapped(span, position), lastPts = mapped(span, next);
if (a->finished && i + 1 == a->inputCount && next == std::round(a->expectedOutput)) lastPts = span.ptsLast;
slot.spans[slot.count++] = {position, next, firstPts, lastPts};
a->preparedGain += std::max(0.0, lastPts - firstPts - (next - position) * 1000000.0 / rate);
position = next;
}
if (position != until || !slot.frames) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback PCM source map missing begin=%.0f end=%.0f mapped=%.0f",
a->preparedOutput, until, position);
a->failed = true; return -1;
}
a->preparedOutput = until;
a->preparedFrames.store((uint64_t)until, std::memory_order_release);
a->readyWrite.store(++write, std::memory_order_release);
}
if (a->finished && a->preparedOutput >= std::round(a->expectedOutput)) a->preparedEnd.store(true, std::memory_order_release);
return 0;
}
/* Consumer копирует только готовый PCM. Ни Opus, ни SoundTouch, ни producer-lock здесь нет. */
int stream_playback_audio_pull(struct stream_playback_audio* a, int16_t* pcm, unsigned frames, int64_t limit) {
if (!a || !pcm || frames > maxFrames || a->failed || limit < 0) {
DEBUG_ERROR(DEBUG_CATEGORY_STREAM, "playback audio invalid pull frames=%u limit=%lld", frames, (long long)limit); return -1;
}
unsigned done = 0;
uint64_t read = a->readyRead.load(std::memory_order_relaxed);
double consumedGain = a->consumedGain.load(std::memory_order_relaxed);
while (done < frames && read != a->readyWrite.load(std::memory_order_acquire)) {
const auto& slot = a->ready[read % pcmCapacity];
double until = a->producedOutput;
for (unsigned i = 0; i < slot.count; i++) {
const auto& span = slot.spans[i];
if (span.last <= a->producedOutput) continue;
if (limit >= span.ptsLast) until = span.last;
else if (limit > span.ptsFirst) {
until = span.first + (limit - span.ptsFirst) * (span.last - span.first) / (span.ptsLast - span.ptsFirst); break;
} else break;
}
unsigned got = std::min(frames - done, (unsigned)std::max(0.0, std::floor(until - a->producedOutput)));
if (!got) break;
std::memcpy(pcm + done * 2, slot.samples + a->readyOffset * 2, got * 2 * sizeof(int16_t));
double position = a->producedOutput, end = position + got;
for (unsigned i = 0; i < slot.count && position < end; i++) {
const auto& span = slot.spans[i];
if (span.last <= position) continue;
double next = std::min(end, span.last), firstPts = mapped(span, position), lastPts = mapped(span, next);
if (!appendOutput(a, {a->written + position - a->producedOutput,
a->written + next - a->producedOutput, firstPts, lastPts})) return -1;
consumedGain += std::max(0.0, lastPts - firstPts - (next - position) * 1000000.0 / rate);
a->lastPts = lastPts; position = next;
}
a->producedOutput = end; a->written += got; done += got; a->readyOffset += got;
a->lastAudioFrame = a->written;
if (a->readyOffset == slot.frames) { a->readyOffset = 0; a->readyRead.store(++read, std::memory_order_release); }
}
a->consumedGain.store(consumedGain, std::memory_order_release);
a->consumedFrames.store((uint64_t)a->producedOutput, std::memory_order_release);
if (stream_playback_audio_empty(a)) a->lastPts = (double)a->endPts;
return (int)done;
}
void stream_playback_audio_silence(struct stream_playback_audio* a, unsigned frames) {
if (!a || !frames) return;
if (!appendOutput(a, {(double)a->written, (double)(a->written + frames), a->lastPts, a->lastPts})) return;
a->written += frames;
}
int64_t stream_playback_audio_position(struct stream_playback_audio* a, uint64_t played) {
if (!a) return -1;
if (played > a->written) played = a->written;
while (a->outputCount > 1 && a->output[a->outputHead].last <= played) {
a->outputHead = (a->outputHead + 1) % mapCapacity; a->outputCount--;
}
// Округлённый PCM мог быть опубликован до finish; точный EOF передаётся отдельной immutable границей.
if (stream_playback_audio_empty(a) && played >= a->lastAudioFrame) return a->endPts;
if (!a->outputCount) return a->startPts;
return (int64_t)std::llround(mapped(a->output[a->outputHead], (double)played));
}
int64_t stream_playback_audio_pending_gain(struct stream_playback_audio* a, uint64_t played) {
if (!a) return 0;
if (stream_playback_audio_empty(a) && played >= a->lastAudioFrame) return 0;
double gain = std::max(0.0, a->preparedGain - a->consumedGain.load(std::memory_order_acquire));
for (unsigned i = 0; i < a->outputCount; i++) {
const auto& span = a->output[(a->outputHead + i) % mapCapacity];
double begin = std::max(span.first, (double)played);
if (span.last <= begin) continue;
gain += std::max(0.0, span.ptsLast - mapped(span, begin) - (span.last - begin) * 1000000.0 / rate);
}
for (unsigned i = 0; !a->preparedEnd.load(std::memory_order_relaxed) && i < a->inputCount; i++) {
const auto& span = a->input[(a->inputHead + i) % mapCapacity];
double begin = std::max(span.first, a->preparedOutput);
if (span.last <= begin) continue;
gain += std::max(0.0, span.ptsLast - mapped(span, begin) - (span.last - begin) * 1000000.0 / rate);
}
return (int64_t)std::ceil(gain);
}
uint64_t stream_playback_audio_written(const struct stream_playback_audio* a) { return a ? a->written : 0; }
int stream_playback_audio_starved(const struct stream_playback_audio* a, uint64_t played) {
if (!a || a->finished) return 0;
if (played >= a->written || !a->outputCount) return 1;
for (unsigned i = 0; i < a->outputCount; i++) {
const auto& span = a->output[(a->outputHead + i) % mapCapacity];
if (span.last <= played) continue;
return span.ptsLast == span.ptsFirst;
}
return 1;
}
void stream_playback_audio_finish(struct stream_playback_audio* a) {
if (!a || a->finished) return;
a->endPts = std::max(a->startPts, a->expectedPts);
DEBUG_DEBUG(DEBUG_CATEGORY_DEBUG, "playback audio finish pts=%lld expected_frames=%.6f prepared_frames=%.0f",
(long long)a->endPts, a->expectedOutput, a->preparedOutput);
a->stretch.flush(); a->finished = true; stream_playback_audio_prepare(a);
}
int stream_playback_audio_empty(const struct stream_playback_audio* a) {
return !a || (a->preparedEnd.load(std::memory_order_acquire) && !stream_playback_audio_buffered(a));
}
}
Reference in new issue View Git Blame Copy Permalink