528 lines
14 KiB
C++
528 lines
14 KiB
C++
/*
|
|
* Copyright (C) 2017 Paul Davis <paul@linuxaudiosystems.com>
|
|
* Copyright (C) 2017 Robin Gareus <robin@gareus.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
|
|
#include <cmath>
|
|
#include <glibmm.h>
|
|
|
|
#include "pbd/compose.h"
|
|
#include "pbd/error.h"
|
|
#include "pbd/pthread_utils.h"
|
|
|
|
#include "alsa_slave.h"
|
|
|
|
#include "pbd/i18n.h"
|
|
|
|
using namespace ARDOUR;
|
|
|
|
AlsaAudioSlave::AlsaAudioSlave (
|
|
const char *play_name,
|
|
const char *capt_name,
|
|
unsigned int master_rate,
|
|
unsigned int master_samples_per_period,
|
|
unsigned int slave_rate,
|
|
unsigned int slave_samples_per_period,
|
|
unsigned int periods_per_cycle)
|
|
: _pcmi (play_name, capt_name, 0, slave_rate, slave_samples_per_period, periods_per_cycle, 2, /* Alsa_pcmi::DEBUG_ALL */ 0)
|
|
, _run (false)
|
|
, _active (false)
|
|
, _samples_since_dll_reset (0)
|
|
, _ratio (1.0)
|
|
, _slave_speed (1.0)
|
|
, _draining (1)
|
|
, _rb_capture (4 * /* AlsaAudioBackend::_max_buffer_size */ 8192 * _pcmi.ncapt ())
|
|
, _rb_playback (4 * /* AlsaAudioBackend::_max_buffer_size */ 8192 * _pcmi.nplay ())
|
|
, _samples_per_period (master_samples_per_period)
|
|
, _capt_buff (0)
|
|
, _play_buff (0)
|
|
, _src_buff (0)
|
|
{
|
|
if (0 != _pcmi.state()) {
|
|
return;
|
|
}
|
|
|
|
/* from alsa-slave to master */
|
|
_ratio = (double) master_rate / (double) _pcmi.fsamp();
|
|
|
|
#ifndef NDEBUG
|
|
fprintf (stdout, " --[[ ALSA Slave %s/%s ratio: %.4f\n", play_name, capt_name, _ratio);
|
|
_pcmi.printinfo ();
|
|
fprintf (stdout, " --]]\n");
|
|
#endif
|
|
|
|
_src_capt.setup (_ratio, _pcmi.ncapt (), /*quality*/ 32); // save capture to master
|
|
_src_play.setup (1.0 / _ratio, _pcmi.nplay (), /*quality*/ 32); // master to slave play
|
|
|
|
_src_capt.set_rrfilt (100);
|
|
_src_play.set_rrfilt (100);
|
|
|
|
_capt_buff = (float*) malloc (sizeof(float) * _pcmi.ncapt () * _samples_per_period);
|
|
_play_buff = (float*) malloc (sizeof(float) * _pcmi.nplay () * _samples_per_period);
|
|
_src_buff = (float*) malloc (sizeof(float) * std::max (_pcmi.nplay (), _pcmi.ncapt ()));
|
|
}
|
|
|
|
AlsaAudioSlave::~AlsaAudioSlave ()
|
|
{
|
|
stop ();
|
|
free (_capt_buff);
|
|
free (_play_buff);
|
|
free (_src_buff);
|
|
}
|
|
|
|
void
|
|
AlsaAudioSlave::reset_resampler (ArdourZita::VResampler& src)
|
|
{
|
|
src.reset ();
|
|
src.inp_count = src.inpsize () - 1;
|
|
src.out_count = 200000;
|
|
src.process ();
|
|
}
|
|
|
|
bool
|
|
AlsaAudioSlave::start ()
|
|
{
|
|
if (_run) {
|
|
return false;
|
|
}
|
|
|
|
_run = true;
|
|
if (pbd_realtime_pthread_create (PBD_SCHED_FIFO, -20, 100000,
|
|
&_thread, _process_thread, this))
|
|
{
|
|
if (pthread_create (&_thread, NULL, _process_thread, this)) {
|
|
_run = false;
|
|
PBD::error << _("AlsaAudioBackend: failed to create slave process thread.") << endmsg;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
int timeout = 5000;
|
|
while (!_active && --timeout > 0) { Glib::usleep (1000); }
|
|
|
|
if (timeout == 0 || !_active) {
|
|
_run = false;
|
|
PBD::error << _("AlsaAudioBackend: failed to start slave process thread.") << endmsg;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
AlsaAudioSlave::stop ()
|
|
{
|
|
void *status;
|
|
if (!_run) {
|
|
return;
|
|
}
|
|
|
|
_run = false;
|
|
if (pthread_join (_thread, &status)) {
|
|
PBD::error << _("AlsaAudioBackend: slave failed to terminate properly.") << endmsg;
|
|
}
|
|
_pcmi.pcm_stop ();
|
|
}
|
|
|
|
void*
|
|
AlsaAudioSlave::_process_thread (void* arg)
|
|
{
|
|
AlsaAudioSlave* aas = static_cast<AlsaAudioSlave*> (arg);
|
|
return aas->process_thread ();
|
|
}
|
|
|
|
void*
|
|
AlsaAudioSlave::process_thread ()
|
|
{
|
|
_active = true;
|
|
|
|
bool reset_dll = true;
|
|
int last_n_periods = 0;
|
|
int no_proc_errors = 0;
|
|
const int bailout = 2 * _pcmi.fsamp () / _pcmi.fsize ();
|
|
|
|
double dll_dt = (double) _pcmi.fsize () / (double)_pcmi.fsamp ();
|
|
double dll_w1 = 2 * M_PI * 0.1 * dll_dt;
|
|
double dll_w2 = dll_w1 * dll_w1;
|
|
|
|
const double sr_norm = 1e-6 * (double) _pcmi.fsamp () / (double) _pcmi.fsize ();
|
|
|
|
_pcmi.pcm_start ();
|
|
|
|
while (_run) {
|
|
bool xrun = false;
|
|
long nr = _pcmi.pcm_wait ();
|
|
|
|
/* update DLL */
|
|
uint64_t clock0 = g_get_monotonic_time();
|
|
|
|
if (reset_dll || last_n_periods != 1) {
|
|
reset_dll = false;
|
|
dll_dt = 1e6 * (double) _pcmi.fsize () / (double) _pcmi.fsamp();
|
|
_t0 = clock0;
|
|
_t1 = clock0 + dll_dt;
|
|
_samples_since_dll_reset = 0;
|
|
} else {
|
|
const double er = clock0 - _t1;
|
|
_t0 = _t1;
|
|
_t1 = _t1 + dll_w1 * er + dll_dt;
|
|
dll_dt += dll_w2 * er;
|
|
_samples_since_dll_reset += _pcmi.fsize ();
|
|
}
|
|
|
|
_slave_speed = (_t1 - _t0) * sr_norm; // XXX atomic
|
|
|
|
if (_pcmi.state () > 0) {
|
|
++no_proc_errors;
|
|
xrun = true;
|
|
}
|
|
|
|
if (_pcmi.state () < 0) {
|
|
PBD::error << _("AlsaAudioBackend: Slave I/O error.") << endmsg;
|
|
break;
|
|
}
|
|
|
|
if (no_proc_errors > bailout) {
|
|
PBD::error << _("AlsaAudioBackend: Slave terminated due to continuous x-runs.") << endmsg;
|
|
break;
|
|
}
|
|
|
|
const size_t spp = _pcmi.fsize ();
|
|
const bool drain = g_atomic_int_get (&_draining);
|
|
last_n_periods = 0;
|
|
|
|
while (nr >= (long)spp) {
|
|
no_proc_errors = 0;
|
|
|
|
_pcmi.capt_init (spp);
|
|
if (drain || _pcmi.ncapt () == 0) {
|
|
/* do nothing */
|
|
} else if (_rb_capture.write_space () >= _pcmi.ncapt () * spp) {
|
|
#if 0 // failsafe: write interleave sample by sample
|
|
for (uint32_t s = 0; s < spp; ++s) {
|
|
for (uint32_t c = 0; c < _pcmi.ncapt (); ++c) {
|
|
float d;
|
|
_pcmi.capt_chan (c, &d, 1);
|
|
_rb_capture.write (&d, 1);
|
|
}
|
|
}
|
|
#else
|
|
unsigned int nchn = _pcmi.ncapt ();
|
|
PBD::RingBuffer<float>::rw_vector vec;
|
|
_rb_capture.get_write_vector (&vec);
|
|
if (vec.len[0] >= nchn * spp) {
|
|
for (uint32_t c = 0; c < nchn; ++c) {
|
|
_pcmi.capt_chan (c, vec.buf[0] + c, spp, nchn);
|
|
}
|
|
} else {
|
|
uint32_t c;
|
|
/* first copy continuous area */
|
|
uint32_t k = vec.len[0] / nchn;
|
|
for (c = 0; c < nchn; ++c) {
|
|
_pcmi.capt_chan (c, vec.buf[0] + c, k, nchn);
|
|
}
|
|
|
|
/* possible samples at end of first buffer chunk,
|
|
* incomplete audio-sample */
|
|
uint32_t s = vec.len[0] - k * nchn;
|
|
assert (s < nchn);
|
|
|
|
for (c = 0; c < s; ++c) {
|
|
_pcmi.capt_chan (c, vec.buf[0] + k * nchn + c, 1, nchn);
|
|
}
|
|
/* cont'd audio-sample at second ringbuffer chunk */
|
|
for (; c < nchn; ++c) {
|
|
_pcmi.capt_chan (c, vec.buf[1] + c - s, spp - k, nchn);
|
|
}
|
|
/* remaining data in 2nd area */
|
|
for (c = 0; c < s; ++c) {
|
|
_pcmi.capt_chan (c, vec.buf[1] + c + nchn - s, spp - k, nchn);
|
|
}
|
|
}
|
|
_rb_capture.increment_write_idx (spp * nchn);
|
|
#endif
|
|
} else {
|
|
g_atomic_int_set(&_draining, 1);
|
|
}
|
|
_pcmi.capt_done (spp);
|
|
|
|
|
|
if (drain) {
|
|
_rb_playback.increment_read_idx (_rb_playback.read_space ());
|
|
}
|
|
|
|
_pcmi.play_init (spp);
|
|
if (_pcmi.nplay () == 0) {
|
|
/* relax */
|
|
}
|
|
else if (_rb_playback.read_space () >= _pcmi.nplay () * spp) {
|
|
#if 0 // failsafe: read sample by sample de-interleave
|
|
for (uint32_t s = 0; s < spp; ++s) {
|
|
for (uint32_t c = 0; c < _pcmi.nplay (); ++c) {
|
|
float d;
|
|
_rb_playback.read (&d, 1);
|
|
_pcmi.play_chan (c, (const float*)&d, 1);
|
|
}
|
|
}
|
|
#else
|
|
unsigned int nchn = _pcmi.nplay ();
|
|
PBD::RingBuffer<float>::rw_vector vec;
|
|
_rb_playback.get_read_vector (&vec);
|
|
if (vec.len[0] >= nchn * spp) {
|
|
for (uint32_t c = 0; c < nchn; ++c) {
|
|
_pcmi.play_chan (c, vec.buf[0] + c, spp, nchn);
|
|
}
|
|
} else {
|
|
uint32_t c;
|
|
uint32_t k = vec.len[0] / nchn;
|
|
for (c = 0; c < nchn; ++c) {
|
|
_pcmi.play_chan (c, vec.buf[0] + c, k, nchn);
|
|
}
|
|
|
|
uint32_t s = vec.len[0] - k * nchn;
|
|
assert (s < nchn);
|
|
|
|
for (c = 0; c < s; ++c) {
|
|
_pcmi.play_chan (c, vec.buf[0] + k * nchn + c, 1, nchn);
|
|
}
|
|
|
|
for (; c < nchn; ++c) {
|
|
_pcmi.play_chan (c, vec.buf[1] + c - s, spp - k, nchn);
|
|
}
|
|
for (c = 0; c < s; ++c) {
|
|
_pcmi.play_chan (c, vec.buf[1] + c + nchn - s, spp - k, nchn);
|
|
}
|
|
}
|
|
_rb_playback.increment_read_idx (spp * nchn);
|
|
#endif
|
|
} else {
|
|
if (!drain) {
|
|
printf ("Slave Process: Playback Buffer Underflow, have %u want %lu\n", _rb_playback.read_space (), _pcmi.nplay () * spp); // XXX DEBUG
|
|
_play_latency += spp * _ratio;
|
|
update_latencies (_play_latency, _capt_latency);
|
|
}
|
|
/* silence outputs */
|
|
for (uint32_t c = 0; c < _pcmi.nplay (); ++c) {
|
|
_pcmi.clear_chan (c, spp);
|
|
}
|
|
}
|
|
_pcmi.play_done (spp);
|
|
|
|
nr -= spp;
|
|
++last_n_periods;
|
|
}
|
|
|
|
if (xrun && (_pcmi.capt_xrun() > 0 || _pcmi.play_xrun() > 0)) {
|
|
reset_dll = true;
|
|
_samples_since_dll_reset = 0;
|
|
g_atomic_int_set(&_draining, 1);
|
|
}
|
|
}
|
|
|
|
_pcmi.pcm_stop ();
|
|
_active = false;
|
|
|
|
if (_run) {
|
|
Halted (); /* Emit Signal */
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
AlsaAudioSlave::cycle_start (double tme, double mst_speed, bool drain)
|
|
{
|
|
//printf ("SRC %f / %f = %f\n", mst_speed, _slave_speed, mst_speed / _slave_speed);
|
|
//printf ("DRIFT (mst) %11.1f - (slv) %11.1f = %.1f us = %.1f spl\n", tme, _t0, tme - _t0, (tme - _t0) * _pcmi.fsamp () * 1e-6);
|
|
//printf ("Slave capt: %u play: %u\n", _rb_capture.read_space (), _rb_playback.read_space ());
|
|
|
|
// TODO LPF filter ratios, atomic _slave_speed
|
|
const double slave_speed = _slave_speed;
|
|
|
|
_src_capt.set_rratio (mst_speed / slave_speed);
|
|
_src_play.set_rratio (slave_speed / mst_speed);
|
|
|
|
memset (_capt_buff, 0, sizeof(float) * _pcmi.ncapt () * _samples_per_period);
|
|
|
|
if (drain) {
|
|
g_atomic_int_set(&_draining, 1);
|
|
return;
|
|
}
|
|
|
|
if (g_atomic_int_get (&_draining)) {
|
|
_rb_capture.increment_read_idx (_rb_capture.read_space());
|
|
return;
|
|
}
|
|
|
|
/* resample slave capture data from ringbuffer */
|
|
unsigned int nchn = _pcmi.ncapt ();
|
|
_src_capt.out_count = _samples_per_period;
|
|
_src_capt.out_data = _capt_buff;
|
|
|
|
/* estimate required samples */
|
|
const double rratio = _ratio * mst_speed / slave_speed;
|
|
if (_rb_capture.read_space() < ceil (nchn * _samples_per_period / rratio)) {
|
|
printf ("--- UNDERFLOW --- have %u want %.1f\n", _rb_capture.read_space(), ceil (nchn * _samples_per_period / rratio)); // XXX DEBUG
|
|
_capt_latency += _samples_per_period;
|
|
update_latencies (_play_latency, _capt_latency);
|
|
return;
|
|
}
|
|
|
|
bool underflow = false;
|
|
while (_src_capt.out_count && _active) {
|
|
if (_rb_capture.read_space() < nchn) {
|
|
underflow = true;
|
|
break;
|
|
}
|
|
unsigned int n;
|
|
PBD::RingBuffer<float>::rw_vector vec;
|
|
_rb_capture.get_read_vector (&vec);
|
|
if (vec.len[0] < nchn) {
|
|
_rb_capture.read (_src_buff, nchn);
|
|
_src_capt.inp_count = 1;
|
|
_src_capt.inp_data = _src_buff;
|
|
_src_capt.process ();
|
|
} else {
|
|
_src_capt.inp_count = n = vec.len[0] / nchn;
|
|
_src_capt.inp_data = vec.buf[0];
|
|
_src_capt.process ();
|
|
n -= _src_capt.inp_count;
|
|
_rb_capture.increment_read_idx (n * _pcmi.ncapt ());
|
|
}
|
|
}
|
|
|
|
if (underflow) {
|
|
std::cerr << "ALSA Slave: Capture Ringbuffer Underflow\n"; // XXX
|
|
g_atomic_int_set(&_draining, 1);
|
|
}
|
|
|
|
if (!_active || underflow) {
|
|
memset (_capt_buff, 0, sizeof(float) * _pcmi.ncapt () * _samples_per_period);
|
|
}
|
|
|
|
memset (_play_buff, 0, sizeof(float) * _pcmi.nplay () * _samples_per_period);
|
|
}
|
|
|
|
void
|
|
AlsaAudioSlave::cycle_end ()
|
|
{
|
|
bool drain_done = false;
|
|
bool overflow = false;
|
|
|
|
if (g_atomic_int_get (&_draining)) {
|
|
if (_rb_capture.read_space() == 0 && _rb_playback.read_space() == 0 && _samples_since_dll_reset > _pcmi.fsamp ()) {
|
|
reset_resampler (_src_capt);
|
|
reset_resampler (_src_play);
|
|
memset (_src_buff, 0, sizeof (float) * _pcmi.nplay());
|
|
/* prefill ringbuffers, resampler variance */
|
|
for (int i = 0; i < 16; ++i) {
|
|
_rb_playback.write (_src_buff, _pcmi.nplay());
|
|
}
|
|
memset (_src_buff, 0, sizeof (float) * _pcmi.ncapt());
|
|
// It's safe to write here, process-thread NO-OPs while draining.
|
|
for (int i = 0; i < 16; ++i) {
|
|
_rb_capture.write (_src_buff, _pcmi.ncapt());
|
|
}
|
|
_capt_latency = 16;
|
|
_play_latency = 16 + _ratio * _pcmi.fsize () * (_pcmi.play_nfrag () - 1);
|
|
update_latencies (_play_latency, _capt_latency);
|
|
drain_done = true;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* resample collected playback data into ringbuffer */
|
|
unsigned int nchn = _pcmi.nplay ();
|
|
_src_play.inp_count = _samples_per_period;
|
|
_src_play.inp_data = _play_buff;
|
|
|
|
while (_src_play.inp_count && _active && nchn > 0) {
|
|
unsigned int n;
|
|
PBD::RingBuffer<float>::rw_vector vec;
|
|
_rb_playback.get_write_vector (&vec);
|
|
if (vec.len[0] < nchn) {
|
|
_src_play.out_count = 1;
|
|
_src_play.out_data = _src_buff;
|
|
_src_play.process ();
|
|
if (_rb_playback.write_space() < nchn) {
|
|
overflow = true;
|
|
break;
|
|
} else if (_src_play.out_count == 0) {
|
|
_rb_playback.write (_src_buff, nchn);
|
|
}
|
|
} else {
|
|
_src_play.out_count = n = vec.len[0] / nchn;
|
|
_src_play.out_data = vec.buf[0];
|
|
_src_play.process ();
|
|
n -= _src_play.out_count;
|
|
if (_rb_playback.write_space() < n * nchn) {
|
|
overflow = true;
|
|
break;
|
|
}
|
|
_rb_playback.increment_write_idx (n * nchn);
|
|
}
|
|
}
|
|
|
|
if (overflow) {
|
|
std::cerr << "ALSA Slave: Playback Ringbuffer Overflow\n"; // XXX
|
|
g_atomic_int_set(&_draining, 1);
|
|
return;
|
|
}
|
|
if (drain_done) {
|
|
g_atomic_int_set(&_draining, 0);
|
|
}
|
|
}
|
|
|
|
void
|
|
AlsaAudioSlave::freewheel (bool onoff)
|
|
{
|
|
if (onoff) {
|
|
g_atomic_int_set(&_draining, 1);
|
|
}
|
|
}
|
|
|
|
/* master read slave's capture.
|
|
* resampled at cycle_start, before master can call this
|
|
*/
|
|
uint32_t
|
|
AlsaAudioSlave::capt_chan (uint32_t chn, float* dst, uint32_t n_samples)
|
|
{
|
|
uint32_t nchn = _pcmi.ncapt ();
|
|
assert (chn < nchn && n_samples == _samples_per_period);
|
|
float* src = &_capt_buff[chn];
|
|
for (uint32_t s = 0; s < n_samples; ++s) {
|
|
dst[s] = src[s * nchn];
|
|
}
|
|
return n_samples;
|
|
}
|
|
|
|
/* write from master to slave output,
|
|
* resampled at cycle_end, after master called this.
|
|
*/
|
|
uint32_t
|
|
AlsaAudioSlave::play_chan (uint32_t chn, float* src, uint32_t n_samples)
|
|
{
|
|
uint32_t nchn = _pcmi.nplay ();
|
|
assert (chn < nchn && n_samples == _samples_per_period);
|
|
float* dst = &_play_buff[chn];
|
|
for (uint32_t s = 0; s < n_samples; ++s) {
|
|
dst[s * nchn] = src[s];
|
|
}
|
|
return n_samples;
|
|
}
|