Voice* new_Voice(void)
{
Voice* voice = memory_alloc_item(Voice);
if (voice == NULL)
return NULL;
voice->id = 0;
voice->prio = VOICE_PRIO_INACTIVE;
voice->gen = NULL;
voice->state_size = 0;
voice->state = NULL;
voice->state_size = sizeof(Voice_state);
voice->state = memory_alloc_item(Voice_state);
voice->rand_p = new_Random();
voice->rand_s = new_Random();
if (voice->state == NULL || voice->rand_p == NULL ||
voice->rand_s == NULL)
{
del_Voice(voice);
return NULL;
}
Random_set_context(voice->rand_p, "vp");
Random_set_context(voice->rand_s, "vs");
Voice_state_clear(voice->state);
return voice;
}
static Entry* new_Entry(Device_state* state, int thread_count)
{
rassert(state != NULL);
rassert(thread_count >= 0);
Entry* entry = memory_alloc_item(Entry);
if (entry == NULL)
return NULL;
entry->next = NULL;
entry->state = state;
for (int ti = 0; ti < KQT_THREADS_MAX; ++ti)
entry->thread_states[ti] = NULL;
const Device* device = state->device;
const int32_t audio_buffer_size = state->audio_buffer_size;
for (int ti = 0; ti < thread_count; ++ti)
{
entry->thread_states[ti] = new_Device_thread_state(device, audio_buffer_size);
if (entry->thread_states[ti] == NULL)
{
del_Entry(entry);
return NULL;
}
}
return entry;
}
Hit_map* new_Hit_map_from_string(Streader* sr)
{
rassert(sr != NULL);
if (Streader_is_error_set(sr))
return NULL;
Hit_map* map = memory_alloc_item(Hit_map);
if (map == NULL)
{
Streader_set_memory_error(sr, "Could not allocate memory for hit map");
return NULL;
}
for (int i = 0; i < KQT_HITS_MAX; ++i)
map->hits[i] = NULL;
if (!Streader_has_data(sr))
return map;
if (!Streader_read_list(sr, read_mapping, map))
{
del_Hit_map(map);
return NULL;
}
return map;
}
Work_buffers* new_Work_buffers(int32_t buf_size)
{
rassert(buf_size >= 0);
rassert(buf_size <= WORK_BUFFER_SIZE_MAX);
Work_buffers* buffers = memory_alloc_item(Work_buffers);
if (buffers == NULL)
return NULL;
// Sanitise fields
for (int i = 0; i < WORK_BUFFER_COUNT_; ++i)
buffers->buffers[i] = NULL;
// Allocate buffers
for (int i = 0; i < WORK_BUFFER_COUNT_; ++i)
{
buffers->buffers[i] = new_Work_buffer(buf_size);
if (buffers->buffers[i] == NULL)
{
del_Work_buffers(buffers);
return NULL;
}
}
return buffers;
}
Device_state* new_Compress_pstate(
const Device* device, int32_t audio_rate, int32_t audio_buffer_size)
{
rassert(device != NULL);
rassert(audio_rate > 0);
rassert(audio_buffer_size >= 0);
Compress_pstate* cpstate = memory_alloc_item(Compress_pstate);
if (cpstate == NULL)
return NULL;
if (!Proc_state_init(&cpstate->parent, device, audio_rate, audio_buffer_size))
{
del_Device_state((Device_state*)cpstate);
return NULL;
}
cpstate->parent.destroy = del_Compress_pstate;
cpstate->parent.reset = Compress_pstate_reset;
cpstate->parent.render_mixed = Compress_pstate_render_mixed;
for (int ch = 0; ch < 2; ++ch)
Compress_state_init(&cpstate->cstates[ch]);
return (Device_state*)cpstate;
}
kqt_Handle kqt_new_Handle(void)
{
Handle* handle = memory_alloc_item(Handle);
if (handle == NULL)
{
Handle_set_error(0, ERROR_MEMORY, "Couldn't allocate memory");
return 0;
}
if (!Handle_init(handle))
{
memory_free(handle);
return 0;
}
kqt_Handle id = add_handle(handle);
if (id == 0)
{
Handle_deinit(handle);
memory_free(handle);
return 0;
}
return id;
}
Device_impl* new_DSP_gc(DSP* dsp)
{
DSP_gc* gc = memory_alloc_item(DSP_gc);
if (gc == NULL)
return NULL;
if (!Device_impl_init(&gc->parent, del_DSP_gc))
{
memory_free(gc);
return NULL;
}
gc->parent.device = (Device*)dsp;
Device_set_process((Device*)dsp, DSP_gc_process);
gc->map = NULL;
if (!Device_impl_register_set_envelope(
&gc->parent, "p_e_map.json", NULL, DSP_gc_set_map, NULL))
{
del_DSP_gc(&gc->parent);
return NULL;
}
Device_register_port(gc->parent.device, DEVICE_PORT_TYPE_RECEIVE, 0);
Device_register_port(gc->parent.device, DEVICE_PORT_TYPE_SEND, 0);
return &gc->parent;
}
Input_map* new_Input_map(Streader* sr, int32_t num_inputs, int32_t num_outputs)
{
rassert(sr != NULL);
rassert(num_inputs > 0);
rassert(num_outputs > 0);
Input_map* im = memory_alloc_item(Input_map);
if (im == NULL)
return NULL;
im->map = NULL;
im->num_inputs = num_inputs;
im->num_outputs = num_outputs;
im->map = new_AAtree(
(AAtree_item_cmp*)Entry_cmp, (AAtree_item_destroy*)memory_free);
if (im->map == NULL)
{
del_Input_map(im);
return NULL;
}
if (!Streader_read_list(sr, read_entry, im))
{
del_Input_map(im);
return NULL;
}
return im;
}
bool Channel_cv_state_add_entry(Channel_cv_state* state, const char* var_name)
{
rassert(state != NULL);
rassert(var_name != NULL);
rassert(strlen(var_name) < KQT_VAR_NAME_MAX);
const Entry* entry = Entry_init(ENTRY_AUTO, var_name);
if (!AAtree_contains(state->tree, entry))
{
Entry* new_entry = memory_alloc_item(Entry);
if (new_entry == NULL)
return false;
*new_entry = *entry;
if (!AAtree_ins(state->tree, new_entry))
{
memory_free(new_entry);
return false;
}
}
return true;
}
Channel_defaults_list* new_Channel_defaults_list(Streader* sr)
{
rassert(sr != NULL);
if (Streader_is_error_set(sr))
return NULL;
Channel_defaults_list* cdl = memory_alloc_item(Channel_defaults_list);
if (cdl == NULL)
{
Streader_set_memory_error(sr, "Could not allocate memory for channel defaults");
return NULL;
}
for (int ch = 0; ch < KQT_CHANNELS_MAX; ++ch)
Channel_defaults_init(&cdl->ch_defaults[ch]);
if (!Streader_has_data(sr))
return cdl;
if (!Streader_read_list(sr, read_ch_defaults_item, cdl))
{
del_Channel_defaults_list(cdl);
return NULL;
}
return cdl;
}
Connections* new_Connections_from_string(
Streader* sr, Connection_level level, Au_table* au_table, Device* master)
{
rassert(sr != NULL);
rassert(au_table != NULL);
rassert(master != NULL);
if (Streader_is_error_set(sr))
return NULL;
Connections* graph = memory_alloc_item(Connections);
if (graph == NULL)
{
Streader_set_memory_error(
sr, "Could not allocate memory for connections");
return NULL;
}
graph->nodes = NULL;
graph->nodes = new_AAtree(
(int (*)(const void*, const void*))Device_node_cmp,
(void (*)(void*))del_Device_node);
mem_error_if(graph->nodes == NULL, graph, NULL, sr);
Device_node* master_node = NULL;
if (level == CONNECTION_LEVEL_AU)
{
const Device* iface = Audio_unit_get_output_interface((Audio_unit*)master);
master_node = new_Device_node("", au_table, iface);
}
else
{
master_node = new_Device_node("", au_table, master);
}
mem_error_if(master_node == NULL, graph, NULL, sr);
mem_error_if(!AAtree_ins(graph->nodes, master_node), graph, master_node, sr);
if (!Streader_has_data(sr))
return graph;
read_conn_data rcdata = { graph, level, au_table, master };
if (!Streader_read_list(sr, read_connection, &rcdata))
{
del_Connections(graph);
return NULL;
}
if (Connections_is_cyclic(graph))
{
Streader_set_error(sr, "The connection graph contains a cycle");
del_Connections(graph);
return NULL;
}
return graph;
}
Tuning_state* new_Tuning_state(void)
{
Tuning_state* ts = memory_alloc_item(Tuning_state);
if (ts == NULL)
return NULL;
Tuning_state_reset(ts, NULL);
return ts;
}
static Index_mapping* new_Index_mapping(Index_mapping* im)
{
rassert(im != NULL);
Index_mapping* new_im = memory_alloc_item(Index_mapping);
if (new_im == NULL)
return NULL;
*new_im = *im;
return new_im;
}
Effect* new_Effect(void)
{
Effect* eff = memory_alloc_item(Effect);
if (eff == NULL)
return NULL;
eff->out_iface = NULL;
eff->in_iface = NULL;
eff->connections = NULL;
eff->dsps = NULL;
if (!Device_init(&eff->parent, false))
{
del_Effect(eff);
return NULL;
}
Device_set_state_creator(&eff->parent, Effect_create_state);
Device_set_reset(&eff->parent, Effect_reset);
Device_register_set_audio_rate(&eff->parent, Effect_set_audio_rate);
Device_register_update_tempo(&eff->parent, Effect_update_tempo);
Device_register_set_buffer_size(&eff->parent, Effect_set_buffer_size);
//Device_set_sync(&eff->parent, Effect_sync);
Device_set_process(&eff->parent, Effect_process);
for (int port = 0; port < KQT_DEVICE_PORTS_MAX; ++port)
{
Device_register_port(&eff->parent, DEVICE_PORT_TYPE_RECEIVE, port);
Device_register_port(&eff->parent, DEVICE_PORT_TYPE_SEND, port);
}
eff->out_iface = new_Effect_interface();
eff->in_iface = new_Effect_interface();
eff->dsps = new_DSP_table(KQT_DSPS_MAX);
if (eff->out_iface == NULL || eff->in_iface == NULL || eff->dsps == NULL)
{
del_Effect(eff);
return NULL;
}
for (int port = 0; port < KQT_DEVICE_PORTS_MAX; ++port)
{
Device_register_port(&eff->out_iface->parent,
DEVICE_PORT_TYPE_SEND, port);
Device_register_port(&eff->in_iface->parent,
DEVICE_PORT_TYPE_SEND, port);
}
Device_register_port(&eff->out_iface->parent,
DEVICE_PORT_TYPE_RECEIVE, 0);
//fprintf(stderr, "New effect %p\n", (void*)eff);
return eff;
}
Device_states* new_Device_states(void)
{
Device_states* states = memory_alloc_item(Device_states);
if (states == NULL)
return NULL;
states->thread_count = 0;
for (int i = 0; i < ENTRY_TABLE_SIZE; ++i)
states->entries[i] = NULL;
return states;
}
Order_list* new_Order_list(Streader* sr)
{
rassert(sr != NULL);
if (Streader_is_error_set(sr))
return NULL;
// Create the base structure
Order_list* ol = memory_alloc_item(Order_list);
if (ol == NULL)
{
Streader_set_memory_error(
sr, "Could not allocate memory for order list");
return NULL;
}
ol->pat_insts = NULL;
ol->index_map = NULL;
// Create Pattern instance reference vector
ol->pat_insts = new_Vector(sizeof(Pat_inst_ref));
if (ol->pat_insts == NULL)
{
Streader_set_memory_error(
sr, "Could not allocate memory for order list");
del_Order_list(ol);
return NULL;
}
// Create reverse index of ol->pat_insts
ol->index_map = new_AAtree(
(AAtree_item_cmp*)Pat_inst_ref_cmp, (AAtree_item_destroy*)memory_free);
if (ol->index_map == NULL)
{
Streader_set_memory_error(
sr, "Could not allocate memory for order list");
del_Order_list(ol);
return NULL;
}
// List is empty by default
if (!Streader_has_data(sr))
return ol;
// Read the list of Pattern instance references
if (!Streader_read_list(sr, read_piref, ol))
{
del_Order_list(ol);
return NULL;
}
return ol;
}
Voice_work_buffers* new_Voice_work_buffers(void)
{
Voice_work_buffers* wbs = memory_alloc_item(Voice_work_buffers);
if (wbs == NULL)
return NULL;
wbs->count = 0;
wbs->buf_size = 0;
wbs->wbs = NULL;
wbs->space = NULL;
return wbs;
}
static Event_state* new_Event_state(const char* event_name)
{
rassert(event_name != NULL);
rassert(strlen(event_name) <= EVENT_NAME_MAX);
Event_state* es = memory_alloc_item(Event_state);
if (es == NULL)
return NULL;
strcpy(es->event_name, event_name);
es->value.type = VALUE_TYPE_NONE;
return es;
}
Note_map* new_Note_map_from_string(Streader* sr)
{
assert(sr != NULL);
if (Streader_is_error_set(sr))
return NULL;
Note_map* map = memory_alloc_item(Note_map);
if (map == NULL)
{
Streader_set_memory_error(
sr, "Could not allocate memory for note map");
return NULL;
}
map->map = NULL;
map->iter = NULL;
map->map = new_AAtree(
(int (*)(const void*, const void*))Random_list_cmp,
(void (*)(void*))del_Random_list);
if (map->map == NULL)
{
del_Note_map(map);
Streader_set_memory_error(
sr, "Could not allocate memory for note map");
return NULL;
}
map->iter = new_AAiter(map->map);
if (map->iter == NULL)
{
del_Note_map(map);
Streader_set_memory_error(
sr, "Could not allocate memory for note map");
return NULL;
}
if (!Streader_has_data(sr))
return map;
if (!Streader_read_list(sr, read_mapping, map))
{
del_Note_map(map);
return NULL;
}
return map;
}
Device_thread_state* new_Device_thread_state(
uint32_t device_id, int32_t audio_buffer_size)
{
rassert(audio_buffer_size >= 0);
Device_thread_state* ts = memory_alloc_item(Device_thread_state);
if (ts == NULL)
return NULL;
ts->device_id = device_id;
ts->audio_buffer_size = audio_buffer_size;
ts->node_state = DEVICE_NODE_STATE_NEW;
ts->has_mixed_audio = false;
ts->in_connected = NULL;
for (Device_buffer_type buf_type = DEVICE_BUFFER_MIXED;
buf_type < DEVICE_BUFFER_TYPES; ++buf_type)
{
for (Device_port_type port_type = DEVICE_PORT_TYPE_RECV;
port_type < DEVICE_PORT_TYPES; ++port_type)
ts->buffers[buf_type][port_type] = NULL;
}
ts->in_connected = new_Bit_array(KQT_DEVICE_PORTS_MAX);
if (ts->in_connected == NULL)
{
del_Device_thread_state(ts);
return NULL;
}
for (Device_buffer_type buf_type = DEVICE_BUFFER_MIXED;
buf_type < DEVICE_BUFFER_TYPES; ++buf_type)
{
for (Device_port_type port_type = DEVICE_PORT_TYPE_RECV;
port_type < DEVICE_PORT_TYPES; ++port_type)
{
ts->buffers[buf_type][port_type] =
new_Etable(KQT_DEVICE_PORTS_MAX, (void (*)(void*))del_Work_buffer);
if (ts->buffers[buf_type][port_type] == NULL)
{
del_Device_thread_state(ts);
return NULL;
}
}
}
return ts;
}
Env_var* new_Env_var(Value_type type, const char* name)
{
rassert((type == VALUE_TYPE_BOOL) || (type == VALUE_TYPE_INT) ||
(type == VALUE_TYPE_FLOAT) || (type == VALUE_TYPE_TSTAMP));
rassert(name != NULL);
rassert(is_valid_var_name(name));
Env_var* var = memory_alloc_item(Env_var);
if (var == NULL)
return NULL;
strcpy(var->name, name);
var->value.type = type;
return var;
}
Event_cache* new_Event_cache(void)
{
Event_cache* cache = memory_alloc_item(Event_cache);
if (cache == NULL)
return NULL;
cache->cache = new_AAtree(
(AAtree_item_cmp*)strcmp, (AAtree_item_destroy*)del_Event_state);
if (cache->cache == NULL)
{
del_Event_cache(cache);
return NULL;
}
return cache;
}
Device_impl* new_Proc_ringmod(void)
{
Proc_ringmod* ringmod = memory_alloc_item(Proc_ringmod);
if (ringmod == NULL)
return NULL;
if (!Device_impl_init(&ringmod->parent, del_Proc_ringmod))
{
del_Device_impl(&ringmod->parent);
return NULL;
}
ringmod->parent.create_pstate = new_Ringmod_pstate;
ringmod->parent.init_vstate = Ringmod_vstate_init;
return &ringmod->parent;
}
Au_expressions* new_Au_expressions(Streader* sr)
{
rassert(sr != NULL);
if (Streader_is_error_set(sr))
return NULL;
Au_expressions* ae = memory_alloc_item(Au_expressions);
if (ae == NULL)
{
Streader_set_memory_error(
sr, "Could not allocate memory for audio unit expressions");
return NULL;
}
memset(ae->default_note_expr, '\0', KQT_VAR_NAME_MAX);
ae->entries = new_AAtree(
(AAtree_item_cmp*)strcmp, (AAtree_item_destroy*)del_Entry);
if (ae->entries == NULL)
{
Streader_set_memory_error(
sr, "Could not allocate memory for audio unit expressions");
del_Au_expressions(ae);
return NULL;
}
if (!Streader_read_dict(sr, read_expressions_def, ae))
{
rassert(Streader_is_error_set(sr));
del_Au_expressions(ae);
return NULL;
}
if (ae->default_note_expr[0] != '\0' &&
!Au_expressions_get_proc_filter(ae, ae->default_note_expr))
{
Streader_set_error(
sr,
"Audio unit expressions do not contain the default expression %s",
ae->default_note_expr);
del_Au_expressions(ae);
return NULL;
}
return ae;
}
static Device_state* Effect_create_state(
const Device* device,
int32_t audio_rate,
int32_t audio_buffer_size)
{
assert(device != NULL);
assert(audio_rate > 0);
assert(audio_buffer_size >= 0);
Effect_state* es = memory_alloc_item(Effect_state);
if (es == NULL)
return NULL;
Device_state_init(&es->parent, device, audio_rate, audio_buffer_size);
Effect_state_reset(es);
return &es->parent;
}
Device_impl* new_Proc_noise(void)
{
Proc_noise* noise = memory_alloc_item(Proc_noise);
if (noise == NULL)
return NULL;
if (!Device_impl_init(&noise->parent, del_Proc_noise))
{
del_Device_impl(&noise->parent);
return NULL;
}
noise->parent.create_pstate = new_Noise_pstate;
noise->parent.get_vstate_size = Noise_vstate_get_size;
noise->parent.init_vstate = Noise_vstate_init;
return &noise->parent;
}
Channel_cv_state* new_Channel_cv_state(void)
{
Channel_cv_state* state = memory_alloc_item(Channel_cv_state);
if (state == NULL)
return NULL;
state->tree = NULL;
state->tree = new_AAtree(
(AAtree_item_cmp*)strcmp, (AAtree_item_destroy*)memory_free);
if (state->tree == NULL)
{
del_Channel_cv_state(state);
return NULL;
}
return state;
}
Device_state* new_Delay_pstate(
const Device* device, int32_t audio_rate, int32_t audio_buffer_size)
{
assert(device != NULL);
assert(audio_rate > 0);
assert(audio_buffer_size >= 0);
Delay_pstate* dpstate = memory_alloc_item(Delay_pstate);
if (dpstate == NULL)
return NULL;
if (!Proc_state_init(&dpstate->parent, device, audio_rate, audio_buffer_size))
{
memory_free(dpstate);
return NULL;
}
dpstate->parent.destroy = del_Delay_pstate;
dpstate->parent.set_audio_rate = Delay_pstate_set_audio_rate;
dpstate->parent.reset = Delay_pstate_reset;
dpstate->parent.render_mixed = Delay_pstate_render_mixed;
dpstate->parent.clear_history = Delay_pstate_clear_history;
dpstate->buf_pos = 0;
for (int i = 0; i < KQT_BUFFERS_MAX; ++i)
dpstate->bufs[i] = NULL;
const Proc_delay* delay = (const Proc_delay*)device->dimpl;
const int32_t delay_buf_size = delay->max_delay * audio_rate + 1;
for (int i = 0; i < KQT_BUFFERS_MAX; ++i)
{
dpstate->bufs[i] = new_Work_buffer(delay_buf_size);
if (dpstate->bufs[i] == NULL)
{
del_Device_state(&dpstate->parent.parent);
return NULL;
}
}
return &dpstate->parent.parent;
}
Device_state* new_Au_state(
const Device* device, int32_t audio_rate, int32_t audio_buffer_size)
{
rassert(device != NULL);
rassert(audio_rate > 0);
rassert(audio_buffer_size >= 0);
Au_state* au_state = memory_alloc_item(Au_state);
if (au_state == NULL)
return NULL;
if (!Au_state_init(au_state, device, audio_rate, audio_buffer_size))
{
del_Device_state(&au_state->parent);
return NULL;
}
return &au_state->parent;
}
Voice_pool* new_Voice_pool(uint16_t size)
{
//assert(size >= 0);
Voice_pool* pool = memory_alloc_item(Voice_pool);
if (pool == NULL)
return NULL;
pool->size = size;
pool->state_size = 0;
pool->new_group_id = 0;
pool->voices = NULL;
pool->group_iter_offset = 0;
pool->group_iter = *VOICE_GROUP_AUTO;
if (size > 0)
{
pool->voices = memory_alloc_items(Voice, size);
if (pool->voices == NULL)
{
memory_free(pool);
return NULL;
}
}
for (int i = 0; i < size; ++i)
{
pool->voices[i] = new_Voice();
if (pool->voices[i] == NULL)
{
for (--i; i >= 0; --i)
{
del_Voice(pool->voices[i]);
}
memory_free(pool->voices);
memory_free(pool);
return NULL;
}
}
return pool;
}
