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