Sampled Instrument Player with static and monolithic design. All instruments are built-in.
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

/*
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;
}