Channel_defaults_list* new_Channel_defaults_list(Streader* sr)
{
assert(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;
}
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;
}
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;
}
bool read_default_manifest(Streader* sr)
{
rassert(sr != NULL);
if (Streader_is_error_set(sr))
return false;
if (!Streader_has_data(sr))
return false;
return Streader_read_dict(sr, read_manifest_entry, NULL);
}
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;
}
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;
}
Tuning_table* new_Tuning_table_from_string(Streader* sr)
{
rassert(sr != NULL);
if (Streader_is_error_set(sr))
return NULL;
Tuning_table* tt = new_Tuning_table(
TUNING_TABLE_DEFAULT_REF_PITCH, TUNING_TABLE_DEFAULT_OCTAVE_WIDTH);
if (tt == NULL)
{
Streader_set_memory_error(
sr, "Couldn't allocate memory for tuning table");
return NULL;
}
if (Streader_has_data(sr))
{
if (!Streader_read_dict(sr, read_tuning_table_item, tt))
{
del_Tuning_table(tt);
return NULL;
}
if (tt->ref_note >= tt->note_count)
{
Streader_set_error(sr,
"Reference note doesn't exist: %d", tt->ref_note);
del_Tuning_table(tt);
return NULL;
}
}
if (!Tuning_table_build_pitch_map(tt))
{
Streader_set_memory_error(sr, "Couldn't allocate memory for tuning table");
del_Tuning_table(tt);
return NULL;
}
return tt;
}
bool Module_read_dc_blocker_enabled(Module* module, Streader* sr)
{
rassert(module != NULL);
rassert(sr != NULL);
if (Streader_is_error_set(sr))
return false;
bool enabled = true;
if (Streader_has_data(sr))
{
if (!Streader_read_bool(sr, &enabled))
return false;
}
module->is_dc_blocker_enabled = enabled;
return true;
}
Num_list* new_Num_list_from_string(Streader* sr)
{
rassert(sr != NULL);
if (Streader_is_error_set(sr))
return NULL;
if (!Streader_has_data(sr))
return NULL;
Num_list* nl = memory_alloc_item(Num_list);
if (nl == NULL)
{
Streader_set_memory_error(
sr, "Could not allocate memory for number list");
return NULL;
}
nl->len = 0;
nl->res = 8;
nl->nums = NULL;
nl->nums = memory_alloc_items(double, nl->res);
if (nl->nums == NULL)
{
del_Num_list(nl);
Streader_set_memory_error(
sr, "Could not allocate memory for number list");
return NULL;
}
if (!Streader_read_list(sr, read_num, nl))
{
del_Num_list(nl);
return NULL;
}
return nl;
}
bool Environment_parse(Environment* env, Streader* sr)
{
assert(env != NULL);
assert(sr != NULL);
if (Streader_is_error_set(sr))
return false;
if (!Streader_has_data(sr))
{
AAtree_clear(env->vars);
AAiter_change_tree(env->iter, env->vars);
return true;
}
AAtree* new_vars = new_AAtree(
(int (*)(const void*, const void*))strcmp,
(void (*)(void*))del_Env_var);
if (new_vars == NULL)
{
Streader_set_memory_error(
sr, "Could not allocate memory for environment");
return false;
}
if (!Streader_read_list(sr, read_env_var, new_vars))
{
del_AAtree(new_vars);
return false;
}
AAiter_change_tree(env->iter, new_vars);
AAtree* old_vars = env->vars;
env->vars = new_vars;
del_AAtree(old_vars);
return true;
}
