You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
445 lines
15 KiB
445 lines
15 KiB
/*
|
|
Calf Box, an open source musical instrument.
|
|
Copyright (C) 2010-2013 Krzysztof Foltman
|
|
|
|
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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "blob.h"
|
|
#include "dom.h"
|
|
#include "engine.h"
|
|
#include "instr.h"
|
|
#include "io.h"
|
|
#include "layer.h"
|
|
#include "midi.h"
|
|
#include "mididest.h"
|
|
#include "module.h"
|
|
#include "rt.h"
|
|
#include "scene.h"
|
|
#include "seq.h"
|
|
#include "song.h"
|
|
#include "stm.h"
|
|
#include "track.h"
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
|
|
CBOX_CLASS_DEFINITION_ROOT(cbox_engine)
|
|
|
|
static gboolean cbox_engine_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error);
|
|
|
|
struct cbox_engine *cbox_engine_new(struct cbox_document *doc, struct cbox_rt *rt)
|
|
{
|
|
struct cbox_engine *engine = malloc(sizeof(struct cbox_engine));
|
|
CBOX_OBJECT_HEADER_INIT(engine, cbox_engine, doc);
|
|
|
|
engine->rt = rt;
|
|
engine->scenes = NULL;
|
|
engine->scene_count = 0;
|
|
engine->effect = NULL;
|
|
engine->master = cbox_master_new(engine);
|
|
engine->master->song = cbox_song_new(doc);
|
|
engine->spb = NULL;
|
|
engine->spb_lock = 0;
|
|
engine->spb_retry = 0;
|
|
|
|
if (rt)
|
|
cbox_io_env_copy(&engine->io_env, &rt->io_env);
|
|
else
|
|
{
|
|
engine->io_env.srate = 0; // must be overridden
|
|
engine->io_env.buffer_size = 256;
|
|
engine->io_env.input_count = 0;
|
|
engine->io_env.output_count = 2;
|
|
}
|
|
|
|
cbox_midi_buffer_init(&engine->midibuf_aux);
|
|
cbox_midi_buffer_init(&engine->midibuf_jack);
|
|
cbox_midi_buffer_init(&engine->midibuf_song);
|
|
engine->stmap = malloc(sizeof(struct cbox_song_time_mapper));
|
|
cbox_song_time_mapper_init(engine->stmap, engine);
|
|
cbox_midi_appsink_init(&engine->appsink, rt, &engine->stmap->tmap);
|
|
|
|
cbox_command_target_init(&engine->cmd_target, cbox_engine_process_cmd, engine);
|
|
CBOX_OBJECT_REGISTER(engine);
|
|
|
|
return engine;
|
|
}
|
|
|
|
struct cbox_objhdr *cbox_engine_newfunc(struct cbox_class *class_ptr, struct cbox_document *doc)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
void cbox_engine_destroyfunc(struct cbox_objhdr *obj_ptr)
|
|
{
|
|
struct cbox_engine *engine = (struct cbox_engine *)obj_ptr;
|
|
while(engine->scene_count)
|
|
CBOX_DELETE(engine->scenes[0]);
|
|
if (engine->master->song)
|
|
{
|
|
CBOX_DELETE(engine->master->song);
|
|
engine->master->song = NULL;
|
|
}
|
|
cbox_master_destroy(engine->master);
|
|
engine->master = NULL;
|
|
free(engine->stmap);
|
|
engine->stmap = NULL;
|
|
|
|
free(engine);
|
|
}
|
|
|
|
static gboolean cbox_engine_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
|
|
{
|
|
struct cbox_engine *engine = ct->user_data;
|
|
if (!strcmp(cmd->command, "/status") && !strcmp(cmd->arg_types, ""))
|
|
{
|
|
for (uint32_t i = 0; i < engine->scene_count; i++)
|
|
{
|
|
if (!cbox_execute_on(fb, NULL, "/scene", "o", error, engine->scenes[i]))
|
|
return FALSE;
|
|
}
|
|
return CBOX_OBJECT_DEFAULT_STATUS(engine, fb, error);
|
|
}
|
|
else if (!strcmp(cmd->command, "/render_stereo") && !strcmp(cmd->arg_types, "i"))
|
|
{
|
|
if (!cbox_check_fb_channel(fb, cmd->command, error))
|
|
return FALSE;
|
|
if (engine->rt && engine->rt->io)
|
|
{
|
|
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot use render function in real-time mode.");
|
|
return FALSE;
|
|
}
|
|
struct cbox_midi_buffer midibuf_song;
|
|
cbox_midi_buffer_init(&midibuf_song);
|
|
int nframes = CBOX_ARG_I(cmd, 0);
|
|
float *data = malloc(2 * nframes * sizeof(float));
|
|
float *data_i = malloc(2 * nframes * sizeof(float));
|
|
float *buffers[2] = { data, data + nframes };
|
|
for (int i = 0; i < nframes; i++)
|
|
{
|
|
buffers[0][i] = 0.f;
|
|
buffers[1][i] = 0.f;
|
|
}
|
|
cbox_engine_process(engine, NULL, nframes, buffers, 2);
|
|
for (int i = 0; i < nframes; i++)
|
|
{
|
|
data_i[i * 2] = buffers[0][i];
|
|
data_i[i * 2 + 1] = buffers[1][i];
|
|
}
|
|
free(data);
|
|
|
|
if (!cbox_execute_on(fb, NULL, "/data", "b", error, cbox_blob_new_acquire_data(data_i, nframes * 2 * sizeof(float))))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
else if (!strncmp(cmd->command, "/master_effect/",15))
|
|
{
|
|
return cbox_module_slot_process_cmd(&engine->effect, fb, cmd, cmd->command + 14, CBOX_GET_DOCUMENT(engine), engine->rt, engine, error);
|
|
}
|
|
else if (!strcmp(cmd->command, "/new_scene") && !strcmp(cmd->arg_types, ""))
|
|
{
|
|
if (!cbox_check_fb_channel(fb, cmd->command, error))
|
|
return FALSE;
|
|
|
|
struct cbox_scene *s = cbox_scene_new(CBOX_GET_DOCUMENT(engine), engine);
|
|
|
|
return s ? cbox_execute_on(fb, NULL, "/uuid", "o", error, s) : FALSE;
|
|
}
|
|
else if (!strcmp(cmd->command, "/new_recorder") && !strcmp(cmd->arg_types, "s"))
|
|
{
|
|
if (!cbox_check_fb_channel(fb, cmd->command, error))
|
|
return FALSE;
|
|
|
|
struct cbox_recorder *rec = cbox_recorder_new_stream(engine, engine->rt, CBOX_ARG_S(cmd, 0));
|
|
|
|
return rec ? cbox_execute_on(fb, NULL, "/uuid", "o", error, rec) : FALSE;
|
|
}
|
|
else
|
|
return cbox_object_default_process_cmd(ct, fb, cmd, error);
|
|
}
|
|
|
|
void cbox_engine_process(struct cbox_engine *engine, struct cbox_io *io, uint32_t nframes, float **output_buffers, uint32_t output_channels)
|
|
{
|
|
struct cbox_module *effect = engine->effect;
|
|
uint32_t i, j;
|
|
|
|
cbox_midi_buffer_clear(&engine->midibuf_aux);
|
|
cbox_midi_buffer_clear(&engine->midibuf_song);
|
|
if (io)
|
|
cbox_io_get_midi_data(io, &engine->midibuf_jack);
|
|
else
|
|
cbox_midi_buffer_clear(&engine->midibuf_jack);
|
|
|
|
// Copy MIDI input to the app-sink
|
|
cbox_midi_appsink_supply(&engine->appsink, &engine->midibuf_jack, io->free_running_frame_counter);
|
|
|
|
// Clear external track outputs
|
|
if (engine->spb)
|
|
cbox_song_playback_prepare_render(engine->spb);
|
|
|
|
if (engine->rt)
|
|
cbox_rt_handle_rt_commands(engine->rt);
|
|
|
|
// Combine various sources of events (song, non-RT thread, JACK input)
|
|
if (engine->spb)
|
|
{
|
|
engine->frame_start_song_pos = engine->spb->song_pos_samples;
|
|
cbox_song_playback_render(engine->spb, &engine->midibuf_song, nframes);
|
|
}
|
|
|
|
for (uint32_t i = 0; i < engine->scene_count; i++)
|
|
cbox_scene_render(engine->scenes[i], nframes, output_buffers, output_channels);
|
|
|
|
// Process "master" effect
|
|
if (effect)
|
|
{
|
|
for (i = 0; i < nframes; i += CBOX_BLOCK_SIZE)
|
|
{
|
|
cbox_sample_t left[CBOX_BLOCK_SIZE], right[CBOX_BLOCK_SIZE];
|
|
cbox_sample_t *in_bufs[2] = {output_buffers[0] + i, output_buffers[1] + i};
|
|
cbox_sample_t *out_bufs[2] = {left, right};
|
|
(*effect->process_block)(effect, in_bufs, out_bufs);
|
|
for (j = 0; j < CBOX_BLOCK_SIZE; j++)
|
|
{
|
|
output_buffers[0][i + j] = left[j];
|
|
output_buffers[1][i + j] = right[j];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void cbox_engine_add_scene(struct cbox_engine *engine, struct cbox_scene *scene)
|
|
{
|
|
assert(scene->engine == engine);
|
|
|
|
cbox_rt_array_insert(engine->rt, (void ***)&engine->scenes, &engine->scene_count, -1, scene);
|
|
}
|
|
|
|
void cbox_engine_remove_scene(struct cbox_engine *engine, struct cbox_scene *scene)
|
|
{
|
|
assert(scene->engine == engine);
|
|
cbox_rt_array_remove_by_value(engine->rt, (void ***)&engine->scenes, &engine->scene_count, scene);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define cbox_engine_set_song_playback_args(ARG) ARG(struct cbox_song_playback *, old_song) ARG(struct cbox_song_playback *, new_song) ARG(uint32_t, new_time_ppqn)
|
|
|
|
DEFINE_ASYNC_RT_FUNC(cbox_engine, engine, cbox_engine_set_song_playback)
|
|
{
|
|
// If there's no new song, silence all ongoing notes. Otherwise, copy the
|
|
// ongoing notes to the new playback structure so that the notes get released
|
|
// when playback is stopped (or possibly earlier).
|
|
if (engine->spb)
|
|
{
|
|
if (new_song)
|
|
cbox_song_playback_apply_old_state(new_song);
|
|
|
|
if (cbox_song_playback_active_notes_release(engine->spb, new_song, new_time_ppqn == (uint32_t)-1 ? old_song->song_pos_ppqn : new_time_ppqn, &engine->midibuf_aux) < 0)
|
|
{
|
|
RT_CALL_AGAIN_LATER();
|
|
return;
|
|
}
|
|
}
|
|
engine->spb = new_song;
|
|
engine->master->spb = new_song;
|
|
if (new_song)
|
|
{
|
|
if (new_time_ppqn == (uint32_t)-1)
|
|
{
|
|
int old_time_ppqn = old_song ? old_song->song_pos_ppqn : 0;
|
|
cbox_song_playback_seek_samples(engine->master->spb, old_song ? old_song->song_pos_samples : 0);
|
|
// If tempo change occurred anywhere before playback point, then
|
|
// sample-based position corresponds to a completely different location.
|
|
// So, if new sample-based position corresponds to different PPQN
|
|
// position, seek again using PPQN position.
|
|
if (old_song && abs(new_song->song_pos_ppqn - old_time_ppqn) > 1)
|
|
cbox_song_playback_seek_ppqn(engine->master->spb, old_time_ppqn, FALSE);
|
|
}
|
|
else
|
|
cbox_song_playback_seek_ppqn(engine->master->spb, new_time_ppqn, FALSE);
|
|
}
|
|
}
|
|
|
|
ASYNC_PREPARE_FUNC(cbox_engine, engine, cbox_engine_set_song_playback)
|
|
{
|
|
// If update is already in progress, reschedule another at the end of it
|
|
if (engine->spb_lock)
|
|
{
|
|
engine->spb_retry = 1;
|
|
return 1;
|
|
}
|
|
++engine->spb_lock;
|
|
args->old_song = engine->spb;
|
|
args->new_song = cbox_song_playback_new(engine->master->song, engine->master, engine, args->old_song);
|
|
|
|
return 0;
|
|
}
|
|
|
|
ASYNC_CLEANUP_FUNC(cbox_engine, engine, cbox_engine_set_song_playback)
|
|
{
|
|
--engine->spb_lock;
|
|
assert(!engine->spb_lock);
|
|
if (args->old_song)
|
|
cbox_song_playback_destroy(args->old_song);
|
|
// If another update was requested while this one was in progress, repeat
|
|
// the operation
|
|
if (engine->spb_retry) {
|
|
engine->spb_retry = 0;
|
|
cbox_engine_set_song_playback(engine, NULL, NULL, args->new_time_ppqn);
|
|
}
|
|
}
|
|
|
|
void cbox_engine_update_song(struct cbox_engine *engine, int new_pos_ppqn)
|
|
{
|
|
cbox_engine_set_song_playback(engine, NULL, NULL, new_pos_ppqn);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void cbox_engine_update_song_playback(struct cbox_engine *engine)
|
|
{
|
|
cbox_engine_update_song(engine, -1);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
uint32_t cbox_engine_current_pos_samples(struct cbox_engine *engine)
|
|
{
|
|
uint32_t pos = engine->frame_start_song_pos + engine->song_pos_offset;
|
|
if (engine->spb && engine->spb->loop_start_ppqn < engine->spb->loop_end_ppqn)
|
|
pos = cbox_song_playback_correct_for_looping(engine->spb, pos);
|
|
return pos;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void cbox_engine_update_input_connections(struct cbox_engine *engine)
|
|
{
|
|
for (uint32_t i = 0; i < engine->scene_count; i++)
|
|
cbox_scene_update_connected_inputs(engine->scenes[i]);
|
|
}
|
|
|
|
void cbox_engine_update_output_connections(struct cbox_engine *engine)
|
|
{
|
|
for (uint32_t i = 0; i < engine->scene_count; i++)
|
|
cbox_scene_update_connected_outputs(engine->scenes[i]);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void cbox_engine_send_events_to(struct cbox_engine *engine, struct cbox_midi_merger *merger, struct cbox_midi_buffer *buffer)
|
|
{
|
|
if (!engine || !buffer)
|
|
return;
|
|
if (merger)
|
|
cbox_midi_merger_push(merger, buffer, engine->rt);
|
|
else
|
|
{
|
|
for (uint32_t i = 0; i < engine->scene_count; i++)
|
|
cbox_midi_merger_push(&engine->scenes[i]->scene_input_merger, buffer, engine->rt);
|
|
if (!engine->rt || !engine->rt->io)
|
|
return;
|
|
for (GSList *p = engine->rt->io->midi_outputs; p; p = p->next)
|
|
{
|
|
struct cbox_midi_output *midiout = p->data;
|
|
cbox_midi_merger_push(&midiout->merger, buffer, engine->rt);
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void cbox_engine_on_tempo_sync(struct cbox_engine *engine, double beats_per_minute)
|
|
{
|
|
if (!engine->master)
|
|
return;
|
|
if (beats_per_minute && beats_per_minute != engine->master->tempo && beats_per_minute != engine->master->new_tempo) {
|
|
engine->master->new_tempo = beats_per_minute;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
gboolean cbox_engine_on_transport_sync(struct cbox_engine *engine, enum cbox_transport_state state, uint32_t frame)
|
|
{
|
|
if (state == ts_stopping)
|
|
{
|
|
if (engine->master->state == CMTS_ROLLING)
|
|
engine->master->state = engine->spb ? CMTS_STOPPING : CMTS_STOP;
|
|
|
|
return engine->master->state == CMTS_STOP;
|
|
}
|
|
if (state == ts_starting)
|
|
{
|
|
if (engine->master->state == CMTS_STOPPING)
|
|
return FALSE;
|
|
if (engine->master->state == CMTS_ROLLING)
|
|
{
|
|
if (engine->spb->song_pos_samples == frame)
|
|
return TRUE;
|
|
engine->master->state = CMTS_STOPPING;
|
|
return FALSE;
|
|
}
|
|
if (engine->spb && engine->spb->song_pos_samples != frame)
|
|
{
|
|
cbox_song_playback_seek_samples(engine->spb, frame);
|
|
}
|
|
engine->frame_start_song_pos = frame;
|
|
return TRUE;
|
|
}
|
|
if (state == ts_rolling)
|
|
{
|
|
// When starting with JACK transport rolling, there is no
|
|
// ts_starting message in first place (because there can't be without
|
|
// interfering with other applications). Seek immediately.
|
|
if (engine->spb && engine->spb->song_pos_samples != frame)
|
|
{
|
|
cbox_song_playback_seek_samples(engine->spb, frame);
|
|
}
|
|
else
|
|
engine->frame_start_song_pos = frame;
|
|
engine->master->state = CMTS_ROLLING;
|
|
return TRUE;
|
|
}
|
|
if (state == ts_stopped)
|
|
{
|
|
if (engine->master->state == CMTS_ROLLING)
|
|
engine->master->state = CMTS_STOPPING;
|
|
|
|
if (engine->master->state == CMTS_STOP && engine->spb && engine->spb->song_pos_samples != frame)
|
|
{
|
|
cbox_song_playback_seek_samples(engine->spb, frame);
|
|
}
|
|
|
|
return engine->master->state == CMTS_STOP;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct cbox_midi_merger *cbox_engine_get_midi_output(struct cbox_engine *engine, struct cbox_uuid *uuid)
|
|
{
|
|
struct cbox_objhdr *objhdr = cbox_document_get_object_by_uuid(CBOX_GET_DOCUMENT(engine), uuid);
|
|
if (!objhdr)
|
|
return NULL;
|
|
struct cbox_scene *scene = (struct cbox_scene *)objhdr;
|
|
if (!CBOX_IS_A(scene, cbox_scene))
|
|
return NULL;
|
|
return &scene->scene_input_merger;
|
|
}
|
|
|