/* This file is part of Xmms2-libvisual.
*
* Xmms2-libvisual 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 3 of the License, or
* (at your option) any later version.
*
* Xmms2-libvisual 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 Xmms2-libvisual. If not, see .
*/
#include
#include
#include
#include
VISUAL_PLUGIN_API_VERSION_VALIDATOR
#define SAMPLE_RATE 44100
#define SAMPLE_RATE_TYPE_LV VISUAL_AUDIO_SAMPLE_RATE_44100
#define CHANNELS 2
#define CHANNELS_TYPE_LV VISUAL_AUDIO_SAMPLE_CHANNEL_STEREO
#define SAMPLE_TYPE int16_t
#define SAMPLE_FORMAT_PA PA_SAMPLE_S16LE
#define SAMPLE_FORMAT_LV VISUAL_AUDIO_SAMPLE_FORMAT_S16
#define FRAMES 512
#define CHUNK_SIZE_BYTES (FRAMES * CHANNELS * sizeof(SAMPLE_TYPE))
#define CHUNKS (2 * SAMPLE_RATE / FRAMES + 1) // i.e. 2+ seconds of audio
#if defined(__clang__) || defined(__GNUC__)
# define ATOMIC_CONSUMER_LOAD_64(source, target) __atomic_load(&source, &target, __ATOMIC_ACQUIRE)
# define ATOMIC_PRODUCER_STORE_64(target, source) __atomic_store(&target, &source, __ATOMIC_RELEASE)
#else
# error We need GCC or Clang for __atomic_load and __atomic_store
#endif
pa_sample_spec sample_spec = {
.format = SAMPLE_FORMAT_PA,
.rate = SAMPLE_RATE,
.channels = CHANNELS
};
typedef struct {
pa_threaded_mainloop * mainloop;
pa_context * context;
pa_stream * input_stream;
SAMPLE_TYPE pcm_data[CHUNKS][FRAMES * CHANNELS]; // ringbuffer of chunks
uint64_t chunks_written;
uint64_t chunk_write_offset_bytes;
uint64_t chunks_read;
} pulseaudio_priv_t;
static int inp_pulseaudio_init (VisPluginData *plugin);
static int inp_pulseaudio_cleanup (VisPluginData *plugin);
static int inp_pulseaudio_upload (VisPluginData *plugin, VisAudio *audio);
static void on_input_stream_data (pa_stream *p, size_t nbytes, void *userdata);
const VisPluginInfo *get_plugin_info( void ) {
static VisInputPlugin input = {
.upload = inp_pulseaudio_upload
};
static VisPluginInfo info = {
.type = VISUAL_PLUGIN_TYPE_INPUT,
.plugname = "pulseaudio",
.name = "Pulseaudio input plugin",
.author = "Scott Sibley "
", "
"Sebastian Pipping ",
.version = "2.0",
.about = "Use input data from pulseaudio",
.help = "",
.license = VISUAL_PLUGIN_LICENSE_GPL, // v3 or later, see header
.init = inp_pulseaudio_init,
.cleanup = inp_pulseaudio_cleanup,
.plugin = VISUAL_OBJECT (&input)
};
return &info;
}
static int inp_pulseaudio_init( VisPluginData *plugin ) {
pulseaudio_priv_t *priv = visual_mem_new0(pulseaudio_priv_t, 1);
visual_object_set_private(VISUAL_OBJECT (plugin), priv);
priv->mainloop = pa_threaded_mainloop_new();
visual_log_return_val_if_fail( priv->mainloop != NULL, -1 );
pa_mainloop_api *const mainloop_api = pa_threaded_mainloop_get_api(priv->mainloop);
visual_log_return_val_if_fail( mainloop_api != NULL, -2 );
priv->context = pa_context_new(mainloop_api, "lv-pulseaudio");
visual_log_return_val_if_fail( priv->context != NULL, -3 );
const int connect_res =
pa_context_connect(priv->context, NULL, PA_CONTEXT_NOFLAGS, NULL);
visual_log_return_val_if_fail( connect_res == 0, -4 );
// NOTE: Starting the main loop prior to pa_context_connect would get us into
// this situation:
// Assertion 'c->callback' failed at
// ../pulseaudio-16.1/src/pulsecore/socket-client.c:126, function
// do_call(). Aborting.
// https://gitlab.freedesktop.org/pulseaudio/pulseaudio/-/issues/991
const int mainloop_start_ret = pa_threaded_mainloop_start(priv->mainloop);
visual_log_return_val_if_fail( mainloop_start_ret == 0, -5 );
while (pa_context_get_state(priv->context) < PA_CONTEXT_READY) {
visual_time_usleep(1000);
}
priv->input_stream = pa_stream_new(priv->context, "Recording", &sample_spec, NULL);
visual_log_return_val_if_fail( priv->input_stream != NULL, -6 );
pa_stream_set_read_callback(priv->input_stream, on_input_stream_data, priv);
const pa_buffer_attr input_buffer_attr = {
.fragsize = CHUNK_SIZE_BYTES,
.maxlength = CHUNK_SIZE_BYTES,
};
const int input_connect_res = pa_stream_connect_record(
priv->input_stream, NULL, &input_buffer_attr, PA_STREAM_ADJUST_LATENCY);
visual_log_return_val_if_fail( input_connect_res == 0, -7 );
return 0;
}
static int inp_pulseaudio_cleanup( VisPluginData *plugin )
{
pulseaudio_priv_t *priv = visual_object_get_private(VISUAL_OBJECT (plugin));
visual_log_return_val_if_fail( priv != NULL, -1 );
pa_stream_disconnect(priv->input_stream);
pa_stream_unref(priv->input_stream);
pa_context_disconnect(priv->context);
pa_context_unref(priv->context);
pa_threaded_mainloop_stop(priv->mainloop);
pa_threaded_mainloop_free(priv->mainloop);
visual_mem_free (priv);
return 0;
}
static int inp_pulseaudio_upload( VisPluginData *plugin, VisAudio *audio )
{
pulseaudio_priv_t *priv = visual_object_get_private(VISUAL_OBJECT (plugin));
visual_log_return_val_if_fail( priv != NULL, -1 );
// `priv->chunks_written` is monotonically increasing in another thread in parallel,
// so we make a snapshot to work with a single consistent value below.
// Also, plain reads to 64bit are not atomic on 32bit platforms, so we add protection.
// This is attomic `priv->chunks_written = frozen_chunks_written`.
uint64_t frozen_chunks_written;
ATOMIC_CONSUMER_LOAD_64(priv->chunks_written, frozen_chunks_written);
assert(priv->chunks_read <= frozen_chunks_written);
if (priv->chunks_read == frozen_chunks_written) {
return 0;
}
// The writing head keeps moving "in parallel" in another thread
// and without locking. So if the reader get too far behind, the writer
// overtakes the reader, in theory. It is not likely to happen because
// (1) the reader drains all available bytes at once, (2) the buffer
// is large enough to protect against temporary jittering, and (3)
// because `.upload` is guaranteed to be called at least at rendering
// FPS frequency.
const uint64_t tolerable_behind_by = CHUNKS / 2;
uint64_t behind_by = frozen_chunks_written - priv->chunks_read;
if (behind_by > tolerable_behind_by) {
priv->chunks_read = frozen_chunks_written - tolerable_behind_by;
behind_by = tolerable_behind_by;
}
const uint64_t target_chunks_read = priv->chunks_read + behind_by;
while (priv->chunks_read < target_chunks_read) {
void *const data = priv->pcm_data[priv->chunks_read % CHUNKS];
VisBuffer visbuffer;
visual_buffer_init(&visbuffer, data, CHUNK_SIZE_BYTES, NULL);
visual_audio_samplepool_input(audio->samplepool, &visbuffer, SAMPLE_RATE_TYPE_LV,
SAMPLE_FORMAT_LV, CHANNELS_TYPE_LV);
priv->chunks_read++;
}
return 0;
}
static void on_input_stream_data(pa_stream *p, size_t nbytes, void *userdata) {
pulseaudio_priv_t * const priv = (pulseaudio_priv_t *)userdata;
visual_log_return_if_fail( priv != NULL );
const void *source = NULL;
const int peek_res = pa_stream_peek(p, &source, &nbytes);
visual_log_return_if_fail( peek_res == 0 );
visual_log_return_if_fail( source != 0 );
const int drop_res = pa_stream_drop(p);
visual_log_return_if_fail( drop_res == 0 );
// Copy all readable bytes from `source` to the right place in `priv->pcm_data`.
while (nbytes > 0) {
void *const target = (void *)priv->pcm_data[priv->chunks_written % CHUNKS] + priv->chunk_write_offset_bytes;
size_t round_nbytes = nbytes;
// Would a full write overflow the current chunk?
if (priv->chunk_write_offset_bytes + round_nbytes > CHUNK_SIZE_BYTES) {
// Cut down to fit the chunk
round_nbytes = CHUNK_SIZE_BYTES - priv->chunk_write_offset_bytes;
}
visual_mem_copy(target, source, round_nbytes);
// Figure out write offset location for the next round
if (priv->chunk_write_offset_bytes + round_nbytes < CHUNK_SIZE_BYTES) {
// Same chunk but further behind
priv->chunk_write_offset_bytes += round_nbytes;
} else {
// Start of the next chunk
priv->chunk_write_offset_bytes = 0;
// This is atomic `priv->chunks_written++`
const uint64_t new_chunks_written = priv->chunks_written + 1;
ATOMIC_PRODUCER_STORE_64(priv->chunks_written, new_chunks_written);
}
nbytes -= round_nbytes;
}
}