diff options
Diffstat (limited to 'src/portaudio.c')
| -rw-r--r-- | src/portaudio.c | 413 |
1 files changed, 221 insertions, 192 deletions
diff --git a/src/portaudio.c b/src/portaudio.c index bbcf008..8ce1945 100644 --- a/src/portaudio.c +++ b/src/portaudio.c @@ -1,223 +1,252 @@ -/* - Copyright 2007-2016 David Robillard <http://drobilla.net> +// Copyright 2007-2024 David Robillard <d@drobilla.net> +// SPDX-License-Identifier: ISC + +#include "backend.h" +#include "comm.h" +#include "log.h" +#include "lv2_evbuf.h" +#include "process.h" +#include "settings.h" +#include "types.h" +#include "urids.h" + +#include <lilv/lilv.h> +#include <zix/attributes.h> +#include <zix/sem.h> - Permission to use, copy, modify, and/or distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "jalv_internal.h" -#include "worker.h" - -#include <stdio.h> -#include <math.h> #include <portaudio.h> +#include <stdbool.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> -struct JalvBackend { - PaStream* stream; +struct JalvBackendImpl { + PaStream* stream; }; static int -pa_process_cb(const void* inputs, - void* outputs, - unsigned long nframes, - const PaStreamCallbackTimeInfo* time, - PaStreamCallbackFlags flags, - void* handle) +process_silent(JalvProcess* const proc, + void* const outputs, + const unsigned long nframes) { - Jalv* jalv = (Jalv*)handle; - - /* Prepare port buffers */ - uint32_t in_index = 0; - uint32_t out_index = 0; - for (uint32_t i = 0; i < jalv->num_ports; ++i) { - struct Port* port = &jalv->ports[i]; - if (port->type == TYPE_AUDIO) { - if (port->flow == FLOW_INPUT) { - lilv_instance_connect_port(jalv->instance, i, ((float**)inputs)[in_index++]); - } else if (port->flow == FLOW_OUTPUT) { - lilv_instance_connect_port(jalv->instance, i, ((float**)outputs)[out_index++]); - } - } else if (port->type == TYPE_EVENT && port->flow == FLOW_INPUT) { - lv2_evbuf_reset(port->evbuf, true); - - if (jalv->request_update) { - /* Plugin state has changed, request an update */ - const LV2_Atom_Object get = { - { sizeof(LV2_Atom_Object_Body), jalv->urids.atom_Object }, - { 0, jalv->urids.patch_Get } }; - LV2_Evbuf_Iterator iter = lv2_evbuf_begin(port->evbuf); - lv2_evbuf_write(&iter, 0, 0, - get.atom.type, get.atom.size, - (const uint8_t*)LV2_ATOM_BODY(&get)); - } - } else if (port->type == TYPE_EVENT) { - /* Clear event output for plugin to write to */ - lv2_evbuf_reset(port->evbuf, false); - } - } - jalv->request_update = false; - - /* Run plugin for this cycle */ - const bool send_ui_updates = jalv_run(jalv, nframes); - - /* Deliver UI events */ - for (uint32_t p = 0; p < jalv->num_ports; ++p) { - struct Port* const port = &jalv->ports[p]; - if (port->flow == FLOW_OUTPUT && port->type == TYPE_EVENT) { - for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(port->evbuf); - lv2_evbuf_is_valid(i); - i = lv2_evbuf_next(i)) { - // Get event from LV2 buffer - uint32_t frames, subframes, type, size; - uint8_t* body; - lv2_evbuf_get(i, &frames, &subframes, &type, &size, &body); - - if (jalv->has_ui) { - // Forward event to UI - jalv_send_to_ui(jalv, p, type, size, body); - } - } - } else if (send_ui_updates && - port->flow == FLOW_OUTPUT && port->type == TYPE_CONTROL) { - char buf[sizeof(ControlChange) + sizeof(float)]; - ControlChange* ev = (ControlChange*)buf; - ev->index = p; - ev->protocol = 0; - ev->size = sizeof(float); - *(float*)ev->body = port->control; - if (zix_ring_write(jalv->plugin_events, buf, sizeof(buf)) - < sizeof(buf)) { - fprintf(stderr, "Plugin => UI buffer overflow!\n"); - } - } - } - - return paContinue; + for (uint32_t i = 0; i < proc->num_ports; ++i) { + memset(((float**)outputs)[i], '\0', nframes * sizeof(float)); + } + + return jalv_bypass(proc, nframes); } -static JalvBackend* -pa_error(const char* msg, PaError err) +static int +process_cb(const void* inputs, + void* outputs, + unsigned long nframes, + const PaStreamCallbackTimeInfo* time, + PaStreamCallbackFlags flags, + void* handle) +{ + (void)time; + (void)flags; + + JalvProcess* const proc = (JalvProcess*)handle; + + // If execution is paused, emit silence and return + if (proc->run_state == JALV_PAUSED) { + return process_silent(proc, outputs, nframes); + } + + // Prepare port buffers + uint32_t in_index = 0; + uint32_t out_index = 0; + for (uint32_t i = 0; i < proc->num_ports; ++i) { + JalvProcessPort* const port = &proc->ports[i]; + if (port->type == TYPE_AUDIO) { + if (port->flow == FLOW_INPUT) { + lilv_instance_connect_port( + proc->instance, i, ((float**)inputs)[in_index++]); + } else if (port->flow == FLOW_OUTPUT) { + lilv_instance_connect_port( + proc->instance, i, ((float**)outputs)[out_index++]); + } + } else if (port->type == TYPE_EVENT) { + lv2_evbuf_reset(port->evbuf, port->flow == FLOW_INPUT); + } + } + + // Run plugin for this cycle + const bool send_ui_updates = jalv_run(proc, nframes); + + // Deliver UI events + for (uint32_t p = 0; p < proc->num_ports; ++p) { + JalvProcessPort* const port = &proc->ports[p]; + if (port->flow == FLOW_OUTPUT && port->type == TYPE_EVENT) { + for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(port->evbuf); + lv2_evbuf_is_valid(i); + i = lv2_evbuf_next(i)) { + // Get event from LV2 buffer + uint32_t frames = 0U; + uint32_t subframes = 0U; + uint32_t type = 0U; + uint32_t size = 0U; + void* body = NULL; + lv2_evbuf_get(i, &frames, &subframes, &type, &size, &body); + + if (proc->has_ui) { + // Forward event to UI + jalv_write_event(proc->plugin_to_ui, p, size, type, body); + } + } + } else if (send_ui_updates && port->flow == FLOW_OUTPUT && + port->type == TYPE_CONTROL) { + jalv_write_control(proc->plugin_to_ui, p, proc->controls_buf[p]); + } + } + + return paContinue; +} + +static int +setup_error(const char* msg, PaError err) { - fprintf(stderr, "error: %s (%s)\n", msg, Pa_GetErrorText(err)); - Pa_Terminate(); - return NULL; + jalv_log(JALV_LOG_ERR, "%s (%s)\n", msg, Pa_GetErrorText(err)); + Pa_Terminate(); + return 1; } JalvBackend* -jalv_backend_init(Jalv* jalv) +jalv_backend_allocate(void) { - PaStreamParameters inputParameters; - PaStreamParameters outputParameters; - PaStream* stream = NULL; - PaError st = paNoError; - - if ((st = Pa_Initialize())) { - return pa_error("Failed to initialize audio system", st); - } - - // Get default input and output devices - inputParameters.device = Pa_GetDefaultInputDevice(); - outputParameters.device = Pa_GetDefaultOutputDevice(); - if (inputParameters.device == paNoDevice) { - return pa_error("No default input device", paDeviceUnavailable); - } else if (outputParameters.device == paNoDevice) { - return pa_error("No default output device", paDeviceUnavailable); - } - - const PaDeviceInfo* in_dev = Pa_GetDeviceInfo(inputParameters.device); - const PaDeviceInfo* out_dev = Pa_GetDeviceInfo(outputParameters.device); - - // Count number of input and output audio ports/channels - inputParameters.channelCount = 0; - outputParameters.channelCount = 0; - for (uint32_t i = 0; i < jalv->num_ports; ++i) { - if (jalv->ports[i].type == TYPE_AUDIO) { - if (jalv->ports[i].flow == FLOW_INPUT) { - ++inputParameters.channelCount; - } else if (jalv->ports[i].flow == FLOW_OUTPUT) { - ++outputParameters.channelCount; - } - } - } - - // Configure audio format - inputParameters.sampleFormat = paFloat32|paNonInterleaved; - inputParameters.suggestedLatency = in_dev->defaultLowInputLatency; - inputParameters.hostApiSpecificStreamInfo = NULL; - outputParameters.sampleFormat = paFloat32|paNonInterleaved; - outputParameters.suggestedLatency = out_dev->defaultLowOutputLatency; - outputParameters.hostApiSpecificStreamInfo = NULL; - - // Open stream - if ((st = Pa_OpenStream( - &stream, - inputParameters.channelCount ? &inputParameters : NULL, - outputParameters.channelCount ? &outputParameters : NULL, - in_dev->defaultSampleRate, - paFramesPerBufferUnspecified, - 0, - pa_process_cb, - jalv))) { - return pa_error("Failed to open audio stream", st); - } - - // Set audio parameters - jalv->sample_rate = in_dev->defaultSampleRate; - // jalv->block_length = FIXME - jalv->midi_buf_size = 4096; - - // Allocate and return opaque backend - JalvBackend* backend = (JalvBackend*)calloc(1, sizeof(JalvBackend)); - backend->stream = stream; - return backend; + return (JalvBackend*)calloc(1, sizeof(JalvBackend)); } void -jalv_backend_close(Jalv* jalv) +jalv_backend_free(JalvBackend* const backend) { - Pa_Terminate(); - free(jalv->backend); - jalv->backend = NULL; + free(backend); +} + +int +jalv_backend_open(JalvBackend* const backend, + const JalvURIDs* const ZIX_UNUSED(urids), + JalvSettings* const settings, + JalvProcess* const proc, + ZixSem* const ZIX_UNUSED(done), + const char* const ZIX_UNUSED(name), + const bool ZIX_UNUSED(exact_name)) +{ + PaStreamParameters inputParameters; + PaStreamParameters outputParameters; + PaStream* stream = NULL; + PaError st = paNoError; + + if ((st = Pa_Initialize())) { + return setup_error("Failed to initialize audio system", st); + } + + // Get default input and output devices + inputParameters.device = Pa_GetDefaultInputDevice(); + outputParameters.device = Pa_GetDefaultOutputDevice(); + if (inputParameters.device == paNoDevice) { + return setup_error("No default input device", paDeviceUnavailable); + } + + if (outputParameters.device == paNoDevice) { + return setup_error("No default output device", paDeviceUnavailable); + } + + const PaDeviceInfo* in_dev = Pa_GetDeviceInfo(inputParameters.device); + const PaDeviceInfo* out_dev = Pa_GetDeviceInfo(outputParameters.device); + + // Count number of input and output audio ports/channels + inputParameters.channelCount = 0; + outputParameters.channelCount = 0; + for (uint32_t i = 0; i < proc->num_ports; ++i) { + if (proc->ports[i].type == TYPE_AUDIO) { + if (proc->ports[i].flow == FLOW_INPUT) { + ++inputParameters.channelCount; + } else if (proc->ports[i].flow == FLOW_OUTPUT) { + ++outputParameters.channelCount; + } + } + } + + // Configure audio format + inputParameters.sampleFormat = paFloat32 | paNonInterleaved; + inputParameters.suggestedLatency = in_dev->defaultLowInputLatency; + inputParameters.hostApiSpecificStreamInfo = NULL; + outputParameters.sampleFormat = paFloat32 | paNonInterleaved; + outputParameters.suggestedLatency = out_dev->defaultLowOutputLatency; + outputParameters.hostApiSpecificStreamInfo = NULL; + + // Open stream + if ((st = + Pa_OpenStream(&stream, + inputParameters.channelCount ? &inputParameters : NULL, + outputParameters.channelCount ? &outputParameters : NULL, + in_dev->defaultSampleRate, + paFramesPerBufferUnspecified, + 0, + process_cb, + proc))) { + return setup_error("Failed to open audio stream", st); + } + + // Set audio parameters + settings->sample_rate = in_dev->defaultSampleRate; + // settings->block_length = FIXME + settings->midi_buf_size = 4096; + + backend->stream = stream; + return 0; +} + +void +jalv_backend_close(JalvBackend* const backend) +{ + if (backend) { + PaError st = paNoError; + if (backend->stream && (st = Pa_CloseStream(backend->stream))) { + jalv_log(JALV_LOG_ERR, "Error closing audio (%s)\n", Pa_GetErrorText(st)); + } + + if ((st = Pa_Terminate())) { + jalv_log( + JALV_LOG_ERR, "Error terminating audio (%s)\n", Pa_GetErrorText(st)); + } + } } void -jalv_backend_activate(Jalv* jalv) +jalv_backend_activate(JalvBackend* const backend) { - const int st = Pa_StartStream(jalv->backend->stream); - if (st != paNoError) { - fprintf(stderr, "error: Error starting audio stream (%s)\n", - Pa_GetErrorText(st)); - } + const PaError st = Pa_StartStream(backend->stream); + if (st != paNoError) { + jalv_log(JALV_LOG_ERR, "Error starting audio (%s)\n", Pa_GetErrorText(st)); + } } void -jalv_backend_deactivate(Jalv* jalv) +jalv_backend_deactivate(JalvBackend* const backend) { - const int st = Pa_CloseStream(jalv->backend->stream); - if (st != paNoError) { - fprintf(stderr, "error: Error closing audio stream (%s)\n", - Pa_GetErrorText(st)); - } + const PaError st = Pa_StopStream(backend->stream); + if (st != paNoError) { + jalv_log(JALV_LOG_ERR, "Error stopping audio (%s)\n", Pa_GetErrorText(st)); + } } void -jalv_backend_activate_port(Jalv* jalv, uint32_t port_index) +jalv_backend_activate_port(JalvBackend* const ZIX_UNUSED(backend), + JalvProcess* const proc, + const uint32_t port_index) { - struct Port* const port = &jalv->ports[port_index]; - switch (port->type) { - case TYPE_CONTROL: - lilv_instance_connect_port(jalv->instance, port_index, &port->control); - break; - default: - break; - } + JalvProcessPort* const port = &proc->ports[port_index]; + + if (port->type == TYPE_CONTROL) { + lilv_instance_connect_port( + proc->instance, port_index, &proc->controls_buf[port_index]); + } } + +void +jalv_backend_recompute_latencies(JalvBackend* const ZIX_UNUSED(backend)) +{} |