const Env_var* Environment_get(const Environment* env, const char* name)
{
assert(env != NULL);
assert(name != NULL);
return AAtree_get_exact(env->vars, name);
}
const Value* Event_cache_get_value(const Event_cache* cache, const char* event_name)
{
rassert(cache != NULL);
rassert(event_name != NULL);
Event_state* state = AAtree_get_exact(cache->cache, event_name);
rassert(state != NULL);
return &state->value;
}
void Event_cache_update(Event_cache* cache, const char* event_name, const Value* value)
{
rassert(cache != NULL);
rassert(event_name != NULL);
rassert(value != NULL);
Event_state* state = AAtree_get_exact(cache->cache, event_name);
if (state == NULL)
return;
Value_copy(&state->value, value);
return;
}
void Connections_print(const Connections* graph, FILE* out)
{
rassert(graph != NULL);
rassert(out != NULL);
// Connections_reset(graph);
const Device_node* master = AAtree_get_exact(graph->nodes, "");
rassert(master != NULL);
Device_node_print(master, out);
fprintf(out, "\n");
return;
}
int32_t Input_map_get_device_index(const Input_map* im, int32_t input_id)
{
rassert(im != NULL);
rassert(input_id >= 0);
rassert(input_id < im->num_inputs);
const Entry* key = ENTRY_KEY(input_id);
const Entry* result = AAtree_get_exact(im->map, key);
if (result == NULL)
return -1;
return result->output;
}
bool Channel_cv_state_is_carrying_enabled(
const 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* key = Entry_init(ENTRY_AUTO, var_name);
const Entry* entry = AAtree_get_exact(state->tree, key);
if (entry == NULL)
return false;
return entry->carry;
}
const Value* Channel_cv_state_get_value(
const 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* key = Entry_init(ENTRY_AUTO, var_name);
const Entry* entry = AAtree_get_exact(state->tree, key);
if ((entry == NULL) || !entry->is_set)
return NULL;
return &entry->value;
}
bool Event_cache_add_event(Event_cache* cache, char* event_name)
{
rassert(cache != NULL);
rassert(event_name != NULL);
if (AAtree_get_exact(cache->cache, event_name) != NULL)
return true;
Event_state* es = new_Event_state(event_name);
if (es == NULL || !AAtree_ins(cache->cache, es))
{
del_Event_state(es);
return false;
}
return true;
}
const Param_proc_filter* Au_expressions_get_proc_filter(
const Au_expressions* ae, const char* name)
{
rassert(ae != NULL);
rassert(name != NULL);
if (strlen(name) >= KQT_VAR_NAME_MAX)
return NULL;
Entry* key = ENTRY_AUTO;
strcpy(key->name, name);
const Entry* entry = AAtree_get_exact(ae->entries, key);
if (entry == NULL)
return NULL;
return entry->filter;
}
bool Channel_cv_state_set_value(
Channel_cv_state* state, const char* var_name, const Value* value)
{
rassert(state != NULL);
rassert(var_name != NULL);
rassert(strlen(var_name) < KQT_VAR_NAME_MAX);
rassert(value != NULL);
rassert(Value_type_is_realtime(value->type));
const Entry* key = Entry_init(ENTRY_AUTO, var_name);
Entry* entry = AAtree_get_exact(state->tree, key);
if (entry == NULL)
return false;
Value_copy(&entry->value, value);
entry->is_set = true;
return true;
}
bool Note_map_add_entry(
Note_map* map,
double cents,
double force,
Sample_entry* entry)
{
assert(map != NULL);
assert(isfinite(cents));
assert(isfinite(force));
assert(entry != NULL);
Random_list* key = &(Random_list){ .force = force, .cents = cents };
Random_list* list = AAtree_get_exact(map->map, key);
if (list == NULL)
{
Random_list* list = memory_alloc_item(Random_list);
if (list == NULL || !AAtree_ins(map->map, list))
{
memory_free(list);
return false;
}
list->freq = exp2(cents / 1200) * 440;
list->cents = cents;
list->force = force;
list->entry_count = 0;
}
if (list->entry_count >= NOTE_MAP_RANDOMS_MAX)
{
assert(list->entry_count == NOTE_MAP_RANDOMS_MAX);
return false;
}
list->entries[list->entry_count].ref_freq = list->freq;
list->entries[list->entry_count].cents = entry->cents;
list->entries[list->entry_count].vol_scale = entry->vol_scale;
list->entries[list->entry_count].sample = entry->sample;
++list->entry_count;
return true;
}
static bool read_connection(Streader* sr, int32_t index, void* userdata)
{
rassert(sr != NULL);
rassert(userdata != NULL);
ignore(index);
read_conn_data* rcdata = userdata;
char src_name[KQT_DEVICE_NODE_NAME_MAX] = "";
char dest_name[KQT_DEVICE_NODE_NAME_MAX] = "";
if (!Streader_readf(
sr,
"[%s,%s]",
READF_STR(KQT_DEVICE_NODE_NAME_MAX, src_name),
READF_STR(KQT_DEVICE_NODE_NAME_MAX, dest_name)))
return false;
int src_port = validate_connection_path(
sr, src_name, rcdata->level, DEVICE_PORT_TYPE_SEND);
int dest_port = validate_connection_path(
sr, dest_name, rcdata->level, DEVICE_PORT_TYPE_RECV);
if (Streader_is_error_set(sr))
return false;
if (rcdata->level == CONNECTION_LEVEL_AU)
{
if (string_eq(src_name, ""))
strcpy(src_name, "Iin");
}
if (AAtree_get_exact(rcdata->graph->nodes, src_name) == NULL)
{
const Device* actual_master = rcdata->master;
if ((rcdata->level == CONNECTION_LEVEL_AU) &&
string_eq(src_name, "Iin"))
actual_master = Audio_unit_get_input_interface((Audio_unit*)rcdata->master);
Device_node* new_src = new_Device_node(
src_name, rcdata->au_table, actual_master);
mem_error_if(new_src == NULL, rcdata->graph, NULL, sr);
mem_error_if(
!AAtree_ins(rcdata->graph->nodes, new_src),
rcdata->graph,
new_src,
sr);
}
Device_node* src_node = AAtree_get_exact(rcdata->graph->nodes, src_name);
if (AAtree_get_exact(rcdata->graph->nodes, dest_name) == NULL)
{
Device_node* new_dest = new_Device_node(
dest_name, rcdata->au_table, rcdata->master);
mem_error_if(new_dest == NULL, rcdata->graph, NULL, sr);
mem_error_if(
!AAtree_ins(rcdata->graph->nodes, new_dest),
rcdata->graph,
new_dest,
sr);
}
Device_node* dest_node = AAtree_get_exact(rcdata->graph->nodes, dest_name);
rassert(src_node != NULL);
rassert(dest_node != NULL);
mem_error_if(
!Device_node_connect(dest_node, dest_port, src_node, src_port),
rcdata->graph,
NULL,
sr);
return true;
}
const Device_node* Connections_get_master(const Connections* graph)
{
rassert(graph != NULL);
return AAtree_get_exact(graph->nodes, "");
}
