/* The suite initialization function.
* Opens the temporary file used by the tests.
* Returns zero on success, non-zero otherwise.
*/
int
ags_envelope_audio_signal_test_init_suite()
{
application_context = ags_audio_application_context_new();
g_object_ref(application_context);
ags_application_context_prepare(application_context);
ags_application_context_setup(application_context);
/* create soundcard */
devout = g_object_new(AGS_TYPE_DEVOUT,
NULL);
g_object_ref(devout);
/* create audio */
audio = ags_audio_new(devout);
g_object_ref(audio);
ags_audio_set_flags(audio,
(AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_INPUT_HAS_RECYCLING));
ags_audio_set_ability_flags(audio,
AGS_SOUND_ABILITY_PLAYBACK);
/* create input/output */
ags_audio_set_audio_channels(audio,
1, 0);
ags_audio_set_pads(audio,
AGS_TYPE_OUTPUT,
1, 0);
ags_audio_set_pads(audio,
AGS_TYPE_INPUT,
1, 0);
ags_channel_set_ability_flags(audio->output,
AGS_SOUND_ABILITY_PLAYBACK);
ags_channel_set_ability_flags(audio->input,
AGS_SOUND_ABILITY_PLAYBACK);
ags_connectable_connect(AGS_CONNECTABLE(audio));
ags_connectable_connect(AGS_CONNECTABLE(audio->output));
ags_connectable_connect(AGS_CONNECTABLE(audio->input));
/* create ags-envelope */
recall = ags_recall_factory_create(audio,
NULL, NULL,
"ags-envelope",
0, 1,
0, 1,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_ADD |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_RECALL),
0);
return(0);
}
/* The suite initialization function.
* Opens the temporary file used by the tests.
* Returns zero on success, non-zero otherwise.
*/
int
ags_mute_channel_test_init_suite()
{
application_context = ags_audio_application_context_new();
g_object_ref(application_context);
ags_application_context_prepare(application_context);
ags_application_context_setup(application_context);
/* create soundcard */
devout = g_object_new(AGS_TYPE_DEVOUT,
NULL);
g_object_ref(devout);
/* create audio */
audio = ags_audio_new(devout);
g_object_ref(audio);
ags_audio_set_flags(audio,
(AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_INPUT_HAS_RECYCLING));
ags_audio_set_ability_flags(audio,
AGS_SOUND_ABILITY_PLAYBACK);
/* create input/output */
ags_audio_set_audio_channels(audio,
1, 0);
ags_audio_set_pads(audio,
AGS_TYPE_OUTPUT,
1, 0);
ags_audio_set_pads(audio,
AGS_TYPE_INPUT,
1, 0);
ags_channel_set_ability_flags(audio->output,
AGS_SOUND_ABILITY_PLAYBACK);
ags_channel_set_ability_flags(audio->input,
AGS_SOUND_ABILITY_PLAYBACK);
ags_connectable_connect(AGS_CONNECTABLE(audio));
ags_connectable_connect(AGS_CONNECTABLE(audio->output));
ags_connectable_connect(AGS_CONNECTABLE(audio->input));
return(0);
}
void
ags_resize_audio_launch(AgsTask *task)
{
AgsAudio *audio;
AgsResizeAudio *resize_audio;
guint audio_channels_old;
guint input_pads_old, output_pads_old;
resize_audio = AGS_RESIZE_AUDIO(task);
audio = resize_audio->audio;
/* get some fields */
g_object_get(audio,
"audio-channels", &audio_channels_old,
"output-pads", &output_pads_old,
"input-pads", &input_pads_old,
NULL);
/* resize audio - audio channels */
if(audio_channels_old != resize_audio->audio_channels){
ags_audio_set_audio_channels(audio,
resize_audio->audio_channels, audio_channels_old);
}
/* resize audio - output */
if(output_pads_old != resize_audio->output_pads){
ags_audio_set_pads(audio,
AGS_TYPE_OUTPUT,
resize_audio->output_pads, output_pads_old);
}
/* resize audio - input */
if(input_pads_old != resize_audio->input_pads){
ags_audio_set_pads(audio,
AGS_TYPE_INPUT,
resize_audio->input_pads, input_pads_old);
}
}
void
ags_start_audio_test_launch()
{
AgsAudio *audio;
AgsStartAudio *start_audio;
audio = ags_audio_new(NULL);
ags_audio_set_flags(audio,
(AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_INPUT_HAS_RECYCLING));
ags_audio_set_ability_flags(audio,
(AGS_SOUND_ABILITY_SEQUENCER |
AGS_SOUND_ABILITY_NOTATION |
AGS_SOUND_ABILITY_WAVE));
ags_audio_set_audio_channels(audio,
2, 0);
ags_audio_set_pads(audio,
AGS_TYPE_OUTPUT,
1, 0);
ags_audio_set_pads(audio,
AGS_TYPE_INPUT,
8, 0);
start_audio = ags_start_audio_new(audio,
-1);
CU_ASSERT(AGS_IS_START_AUDIO(start_audio));
CU_ASSERT(start_audio->audio == audio);
CU_ASSERT(start_audio->sound_scope == -1);
/* launch */
ags_task_launch(start_audio);
CU_ASSERT(audio->recall_id != NULL);
}
/* The suite initialization function.
* Opens the temporary file used by the tests.
* Returns zero on success, non-zero otherwise.
*/
int
ags_osc_renew_controller_test_init_suite()
{
AgsConfig *config;
GList *start_audio;
config = ags_config_get_instance();
ags_config_load_from_data(config,
AGS_OSC_RENEW_CONTROLLER_TEST_CONFIG,
strlen(AGS_OSC_RENEW_CONTROLLER_TEST_CONFIG));
application_context = ags_audio_application_context_new();
g_object_ref(application_context);
ags_application_context_prepare(application_context);
ags_application_context_setup(application_context);
default_soundcard = ags_sound_provider_get_default_soundcard(AGS_SOUND_PROVIDER(application_context));
/* panel */
panel = ags_audio_new(default_soundcard);
g_object_ref(panel);
g_object_set(panel,
"audio-name", "test-panel",
NULL);
ags_audio_set_flags(panel,
(AGS_AUDIO_SYNC));
ags_audio_set_audio_channels(panel,
2, 0);
ags_audio_set_pads(panel,
AGS_TYPE_OUTPUT,
1, 0);
ags_audio_set_pads(panel,
AGS_TYPE_INPUT,
1, 0);
start_audio = ags_sound_provider_get_audio(AGS_SOUND_PROVIDER(application_context));
ags_sound_provider_set_audio(AGS_SOUND_PROVIDER(application_context),
g_list_prepend(start_audio,
panel));
/* ags-play */
ags_recall_factory_create(panel,
NULL, NULL,
"ags-play-master",
0, 2,
0, 1,
(AGS_RECALL_FACTORY_INPUT,
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
/* ags-mute */
ags_recall_factory_create(panel,
NULL, NULL,
"ags-mute",
0, 2,
0, 1,
(AGS_RECALL_FACTORY_INPUT,
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
/* spectrometer */
spectrometer = ags_audio_new(default_soundcard);
g_object_ref(spectrometer);
g_object_set(spectrometer,
"audio-name", "test-spectrometer",
NULL);
ags_audio_set_flags(spectrometer,
(AGS_AUDIO_SYNC));
ags_audio_set_audio_channels(spectrometer,
2, 0);
ags_audio_set_pads(spectrometer,
AGS_TYPE_OUTPUT,
1, 0);
ags_audio_set_pads(spectrometer,
AGS_TYPE_INPUT,
1, 0);
start_audio = ags_sound_provider_get_audio(AGS_SOUND_PROVIDER(application_context));
ags_sound_provider_set_audio(AGS_SOUND_PROVIDER(application_context),
g_list_prepend(start_audio,
spectrometer));
ags_recall_factory_create(spectrometer,
NULL, NULL,
"ags-analyse",
0, 2,
0, 1,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_RECALL |
AGS_RECALL_FACTORY_ADD),
0);
/* drum */
drum = ags_audio_new(default_soundcard);
g_object_ref(drum);
g_object_set(drum,
"audio-name", "test-drum",
NULL);
ags_audio_set_flags(drum,
(AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_INPUT_HAS_RECYCLING |
AGS_AUDIO_SYNC |
AGS_AUDIO_ASYNC));
ags_audio_set_audio_channels(drum,
2, 0);
ags_audio_set_pads(drum,
AGS_TYPE_OUTPUT,
1, 0);
ags_audio_set_pads(drum,
AGS_TYPE_INPUT,
8, 0);
start_audio = ags_sound_provider_get_audio(AGS_SOUND_PROVIDER(application_context));
ags_sound_provider_set_audio(AGS_SOUND_PROVIDER(application_context),
g_list_prepend(start_audio,
drum));
/* ags-copy-pattern */
ags_recall_factory_create(drum,
NULL, NULL,
"ags-copy-pattern",
0, 2,
0, 8,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_REMAP |
AGS_RECALL_FACTORY_RECALL),
0);
/* ags-volume */
ags_recall_factory_create(drum,
NULL, NULL,
"ags-volume",
0, 2,
0, 8,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_RECALL |
AGS_RECALL_FACTORY_ADD),
0);
/* ags-envelope */
ags_recall_factory_create(drum,
NULL, NULL,
"ags-envelope",
0, 2,
0, 8,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_RECALL |
AGS_RECALL_FACTORY_ADD),
0);
return(0);
}
void
ags_ffplayer_instrument_changed_callback(GtkComboBox *instrument, AgsFFPlayer *ffplayer)
{
AgsChannel *channel;
AgsAudioSignal *audio_signal_source_old;
AgsPlayable *playable;
AgsLinkChannel *link_channel;
AgsAddAudioSignal *add_audio_signal;
gchar *instrument_name;
gchar **preset;
gchar **sample;
GList *task;
GList *list;
guint count;
int i;
gboolean has_more;
GError *error;
playable = AGS_PLAYABLE(ffplayer->ipatch);
instrument_name = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(instrument));
/* select instrument */
error = NULL;
ags_playable_level_select(playable,
2, instrument_name,
&error);
if(error != NULL){
g_error("%s\0", error->message);
}
/* select first sample */
sample = NULL;
AGS_IPATCH(ffplayer->ipatch)->nth_level = 3;
sample = ags_playable_sublevel_names(playable);
error = NULL;
ags_playable_level_select(playable,
3, *sample,
&error);
if(error != NULL){
g_error("%s\0", error->message);
}
count = 0;
while(*sample != NULL){
sample++;
count++;
}
/* read all samples */
ags_audio_set_audio_channels(AGS_MACHINE(ffplayer)->audio,
AGS_IPATCH_DEFAULT_CHANNELS);
AGS_IPATCH(ffplayer->ipatch)->nth_level = 3;
ags_playable_iter_start(playable);
ags_audio_set_pads(AGS_MACHINE(ffplayer)->audio, AGS_TYPE_INPUT,
count);
channel = AGS_MACHINE(ffplayer)->audio->input;
task = NULL;
has_more = TRUE;
while(channel != NULL && has_more){
list = ags_playable_read_audio_signal(playable,
AGS_MACHINE(ffplayer)->audio->soundcard,
channel->audio_channel, AGS_IPATCH_DEFAULT_CHANNELS);
for(i = 0; i < AGS_IPATCH_DEFAULT_CHANNELS && list != NULL; i++){
/* create task */
link_channel = ags_link_channel_new(channel, NULL);
task = g_list_prepend(task,
link_channel);
AGS_AUDIO_SIGNAL(list->data)->flags |= AGS_AUDIO_SIGNAL_TEMPLATE;
ags_recycling_add_audio_signal(channel->first_recycling,
AGS_AUDIO_SIGNAL(list->data));
// add_audio_signal = ags_add_audio_signal_new(channel->first_recycling,
// AGS_AUDIO_SIGNAL(list->data),
// AGS_MACHINE(ffplayer)->audio->soundcard,
// NULL,
// AGS_AUDIO_SIGNAL_TEMPLATE);
// task = g_list_prepend(task,
// add_audio_signal);
/* iterate */
channel = channel->next;
list = list->next;
}
has_more = ags_playable_iter_next(playable);
}
/* append tasks */
// task = g_list_reverse(task);
// ags_task_thread_append_tasks(AGS_AUDIO_LOOP(AGS_MAIN(AGS_SOUNDCARD(AGS_MACHINE(ffplayer)->audio->soundcard)->ags_main)->main_loop)->task_thread,
// task);
}
void
ags_audio_test_link_channel()
{
AgsChannel *channel, *link;
AgsChannel *output, *first_channel;
guint i;
GError *error;
/* audio - master */
test_link_channel.master = ags_audio_new(devout);
test_link_channel.master->flags |= AGS_AUDIO_ASYNC;
ags_audio_set_audio_channels(test_link_channel.master,
AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_AUDIO_CHANNELS, 0);
ags_audio_set_pads(test_link_channel.master,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_INPUT_PADS, 0);
ags_audio_set_pads(test_link_channel.master,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_OUTPUT_PADS, 0);
/* audio - slave 0 */
test_link_channel.slave_0 = ags_audio_new(devout);
test_link_channel.slave_0->flags |= (AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_ASYNC);
ags_audio_set_audio_channels(test_link_channel.slave_0,
AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_0_AUDIO_CHANNELS, 0);
ags_audio_set_pads(test_link_channel.slave_0,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_0_INPUT_PADS, 0);
ags_audio_set_pads(test_link_channel.slave_0,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_0_OUTPUT_PADS, 0);
/* audio - slave 1 */
test_link_channel.slave_1 = ags_audio_new(devout);
test_link_channel.slave_1->flags |= (AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_ASYNC);
ags_audio_set_audio_channels(test_link_channel.slave_1,
AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_1_AUDIO_CHANNELS, 0);
ags_audio_set_pads(test_link_channel.slave_1,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_1_INPUT_PADS, 0);
ags_audio_set_pads(test_link_channel.slave_1,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_1_OUTPUT_PADS, 0);
/* audio - slave 2 */
test_link_channel.slave_2 = ags_audio_new(devout);
test_link_channel.slave_2->flags |= (AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_ASYNC);
ags_audio_set_audio_channels(test_link_channel.slave_2,
AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_2_AUDIO_CHANNELS, 0);
ags_audio_set_pads(test_link_channel.slave_2,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_2_INPUT_PADS, 0);
ags_audio_set_pads(test_link_channel.slave_2,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_2_OUTPUT_PADS, 0);
/* setup link master to slave_0 */
/* connect callback */
channel = test_link_channel.master->input;
link = test_link_channel.slave_0->output;
for(i = 0;
i < AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_0_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
//TODO:JK: implement me
/*
g_signal_connect(G_OBJECT(channel), "set-link",
G_CALLBACK(ags_audio_test_set_link_callback), test_link_channel.master);
g_signal_connect(G_OBJECT(link), "set-link",
G_CALLBACK(ags_audio_test_set_link_callback), test_link_channel.slave_0);
*/
channel = channel->next;
link = link->next;
}
/* set link */
channel = test_link_channel.master->input;
link = test_link_channel.slave_0->output;
for(i = 0;
i < AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_0_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
error = NULL;
ags_channel_set_link(channel, link,
&error);
/* assert link set */
CU_ASSERT(error == NULL);
CU_ASSERT(channel->link == link);
CU_ASSERT(link->link == channel);
/* check recycling */
CU_ASSERT(channel->first_recycling == link->first_recycling);
CU_ASSERT(channel->last_recycling == link->last_recycling);
/* iterate */
channel = channel->next;
link = link->next;
}
/* check output recycling */
output = test_link_channel.master->output;
first_channel =
link = test_link_channel.slave_0->output;
for(i = 0;
i < AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_0_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
CU_ASSERT(output->first_recycling == link->first_recycling);
CU_ASSERT(output->last_recycling == link->last_recycling);
}
/* setup link master to slave_1 */
/* connect callback */
channel = ags_channel_pad_nth(test_link_channel.master->input,
1);
link = test_link_channel.slave_1->output;
for(i = 0;
i < AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_1_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
//TODO:JK: implement me
/*
g_signal_connect(G_OBJECT(channel), "set-link",
G_CALLBACK(ags_audio_test_set_link_callback), test_link_channel.master);
g_signal_connect(G_OBJECT(link), "set-link",
G_CALLBACK(ags_audio_test_set_link_callback), test_link_channel.slave_1);
*/
channel = channel->next;
link = link->next;
}
/* set link */
channel = ags_channel_pad_nth(test_link_channel.master->input,
1);
link = test_link_channel.slave_1->output;
for(i = 0;
i < AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_1_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
error = NULL;
ags_channel_set_link(channel, link,
&error);
/* assert link set */
CU_ASSERT(error == NULL);
CU_ASSERT(channel->link == link);
CU_ASSERT(link->link == channel);
/* check recycling */
CU_ASSERT(channel->first_recycling == link->first_recycling);
CU_ASSERT(channel->last_recycling == link->last_recycling);
/* iterate */
channel = channel->next;
link = link->next;
}
/* check output recycling */
output = test_link_channel.master->output;
first_channel = test_link_channel.slave_0->output;
link = test_link_channel.slave_1->output;
for(i = 0;
i < AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_1_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
CU_ASSERT(output->first_recycling == first_channel->first_recycling);
CU_ASSERT(output->last_recycling == link->last_recycling);
output = output->next;
first_channel = first_channel->next;
link = link->next;
}
/* setup link master to slave_2 */
/* connect callback */
channel = ags_channel_pad_nth(test_link_channel.master->input,
2);
link = test_link_channel.slave_2->output;
for(i = 0;
i < AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_2_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
//TODO:JK: implement me
/*
g_signal_connect(G_OBJECT(channel), "set-link",
G_CALLBACK(ags_audio_test_set_link_callback), test_link_channel.master);
g_signal_connect(G_OBJECT(link), "set-link",
G_CALLBACK(ags_audio_test_set_link_callback), test_link_channel.slave_2);
*/
channel = channel->next;
link = link->next;
}
/* set link */
channel = ags_channel_pad_nth(test_link_channel.master->input,
2);
link = test_link_channel.slave_2->output;
for(i = 0;
i < AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_2_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
error = NULL;
ags_channel_set_link(channel, link,
&error);
/* assert link set */
CU_ASSERT(error == NULL);
CU_ASSERT(channel->link == link);
CU_ASSERT(link->link == channel);
/* check recycling */
CU_ASSERT(channel->first_recycling == link->first_recycling);
CU_ASSERT(channel->last_recycling == link->last_recycling);
/* iterate */
channel = channel->next;
link = link->next;
}
/* check output recycling */
output = test_link_channel.master->output;
first_channel = test_link_channel.slave_0->output;
link = test_link_channel.slave_2->output;
for(i = 0;
i < AGS_AUDIO_TEST_LINK_CHANNEL_SLAVE_2_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_LINK_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
CU_ASSERT(output->first_recycling == first_channel->first_recycling);
CU_ASSERT(output->last_recycling == link->last_recycling);
output = output->next;
first_channel = first_channel->next;
link = link->next;
}
}
void
ags_audio_test_set_audio_channels()
{
AgsAudio *audio;
AgsChannel *channel, *current;
guint i, j;
/* instantiate */
audio = ags_audio_new(devout);
CU_ASSERT(audio != NULL);
/* set pads */
audio->output_pads = AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_OUTPUT_PADS;
audio->input_pads = AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_INPUT_PADS;
/* set audio channels */
ags_audio_set_audio_channels(audio,
AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_AUDIO_CHANNELS, 0);
CU_ASSERT(audio->audio_channels == AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_AUDIO_CHANNELS);
/* verify pad count */
channel = audio->input;
for(i = 0; channel != ags_channel_nth(audio->input,
AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_AUDIO_CHANNELS); i++){
current = channel;
for(j = 0; current != NULL; j++){
current = current->next_pad;
}
CU_ASSERT(j == AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_INPUT_PADS);
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_AUDIO_CHANNELS);
/* verify line count */
channel = audio->input;
for(i = 0; channel != NULL; i++){
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_INPUT_PADS * AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_AUDIO_CHANNELS);
/* verify pad count */
channel = audio->output;
for(i = 0; channel != ags_channel_nth(audio->output,
AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_AUDIO_CHANNELS); i++){
current = channel;
for(j = 0; current != NULL; j++){
current = current->next_pad;
}
CU_ASSERT(j == AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_OUTPUT_PADS);
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_AUDIO_CHANNELS);
/* verify line count */
channel = audio->output;
for(i = 0; channel != NULL; i++){
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_OUTPUT_PADS * AGS_AUDIO_TEST_SET_AUDIO_CHANNELS_AUDIO_CHANNELS);
}
void
ags_audio_test_finalize_linked_channel()
{
AgsChannel *channel, *link;
AgsChannel *output, *current, *last_channel;
guint i;
GError *error;
/* audio - master */
test_finalize_linked_channel.master = ags_audio_new(devout);
test_finalize_linked_channel.master->flags |= AGS_AUDIO_ASYNC;
ags_audio_set_audio_channels(test_finalize_linked_channel.master,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS, 0);
ags_audio_set_pads(test_finalize_linked_channel.master,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_INPUT_PADS, 0);
ags_audio_set_pads(test_finalize_linked_channel.master,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_OUTPUT_PADS, 0);
/* audio - slave 0 */
test_finalize_linked_channel.slave_0 = ags_audio_new(devout);
test_finalize_linked_channel.slave_0->flags |= (AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_ASYNC);
ags_audio_set_audio_channels(test_finalize_linked_channel.slave_0,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_0_AUDIO_CHANNELS, 0);
ags_audio_set_pads(test_finalize_linked_channel.slave_0,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_0_INPUT_PADS, 0);
ags_audio_set_pads(test_finalize_linked_channel.slave_0,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_0_OUTPUT_PADS, 0);
/* audio - slave 1 */
test_finalize_linked_channel.slave_1 = ags_audio_new(devout);
test_finalize_linked_channel.slave_1->flags |= (AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_ASYNC);
ags_audio_set_audio_channels(test_finalize_linked_channel.slave_1,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_1_AUDIO_CHANNELS, 0);
ags_audio_set_pads(test_finalize_linked_channel.slave_1,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_1_INPUT_PADS, 0);
ags_audio_set_pads(test_finalize_linked_channel.slave_1,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_1_OUTPUT_PADS, 0);
/* audio - slave 2 */
test_finalize_linked_channel.slave_2 = ags_audio_new(devout);
test_finalize_linked_channel.slave_2->flags |= (AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_ASYNC);
ags_audio_set_audio_channels(test_finalize_linked_channel.slave_2,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_2_AUDIO_CHANNELS, 0);
ags_audio_set_pads(test_finalize_linked_channel.slave_2,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_2_INPUT_PADS, 0);
ags_audio_set_pads(test_finalize_linked_channel.slave_2,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_2_OUTPUT_PADS, 0);
/* setup link master to slave_0 */
/* set link */
channel = test_finalize_linked_channel.master->input;
link = test_finalize_linked_channel.slave_0->output;
for(i = 0;
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_0_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
error = NULL;
ags_channel_set_link(channel, link,
&error);
/* iterate */
channel = channel->next;
link = link->next;
}
/* setup link master to slave_1 */
/* set link */
channel = ags_channel_pad_nth(test_finalize_linked_channel.master->input,
1);
link = test_finalize_linked_channel.slave_1->output;
for(i = 0;
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_1_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
error = NULL;
ags_channel_set_link(channel, link,
&error);
/* iterate */
channel = channel->next;
link = link->next;
}
/* setup link master to slave_2 */
/* set link */
channel = ags_channel_pad_nth(test_finalize_linked_channel.master->input,
2);
link = test_finalize_linked_channel.slave_2->output;
for(i = 0;
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_2_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
error = NULL;
ags_channel_set_link(channel, link,
&error);
/* iterate */
channel = channel->next;
link = link->next;
}
/* asserts */
/* unset link */
channel = test_finalize_linked_channel.master->input;
ags_audio_set_pads(test_finalize_linked_channel.slave_0,
AGS_TYPE_INPUT,
0, 0);
ags_audio_set_pads(test_finalize_linked_channel.slave_0,
AGS_TYPE_OUTPUT,
0, 0);
g_object_unref(test_finalize_linked_channel.slave_0);
for(i = 0; i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS; i++){
/* assert link set */
CU_ASSERT(channel->link == NULL);
/* check recycling */
CU_ASSERT(channel->first_recycling == NULL);
CU_ASSERT(channel->last_recycling == NULL);
/* iterate */
channel = channel->next;
}
/* check output recycling */
output = test_finalize_linked_channel.master->output;
current = test_finalize_linked_channel.slave_1->output;
for(i = 0; i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_1_AUDIO_CHANNELS;
i++){
CU_ASSERT(output->first_recycling == current->first_recycling);
output = output->next;
current = current->next;
}
output = test_finalize_linked_channel.master->output;
last_channel = test_finalize_linked_channel.slave_2->output;
for(i = 0; i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_2_AUDIO_CHANNELS;
i++){
CU_ASSERT(output->last_recycling == last_channel->last_recycling);
output = output->next;
last_channel = last_channel->next;
}
/* unset link */
channel = ags_channel_pad_nth(test_finalize_linked_channel.master->input,
1);
ags_audio_set_pads(test_finalize_linked_channel.slave_1,
AGS_TYPE_INPUT,
0, 0);
ags_audio_set_pads(test_finalize_linked_channel.slave_1,
AGS_TYPE_OUTPUT,
0, 0);
g_object_unref(test_finalize_linked_channel.slave_1);
for(i = 0; i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS; i++){
/* assert link set */
CU_ASSERT(channel->link == NULL);
/* check recycling */
CU_ASSERT(channel->first_recycling == NULL);
CU_ASSERT(channel->last_recycling == NULL);
/* iterate */
channel = channel->next;
}
/* check output recycling */
output = test_finalize_linked_channel.master->output;
last_channel = test_finalize_linked_channel.slave_2->output;
for(i = 0;
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_1_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
/* check recycling */
CU_ASSERT(output->first_recycling == last_channel->first_recycling);
CU_ASSERT(output->last_recycling == last_channel->last_recycling);
output = output->next;
last_channel = last_channel->next;
}
/* unset link */
channel = ags_channel_pad_nth(test_finalize_linked_channel.master->input,
2);
ags_audio_set_pads(test_finalize_linked_channel.slave_2,
AGS_TYPE_INPUT,
0, 0);
ags_audio_set_pads(test_finalize_linked_channel.slave_2,
AGS_TYPE_OUTPUT,
0, 0);
g_object_unref(test_finalize_linked_channel.slave_2);
for(i = 0;
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_2_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
/* assert link unset */
CU_ASSERT(channel->link == NULL);
/* check recycling */
CU_ASSERT(channel->first_recycling == NULL);
CU_ASSERT(channel->last_recycling == NULL);
/* iterate */
channel = channel->next;
}
/* check output recycling */
output = test_finalize_linked_channel.master->output;
for(i = 0;
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_SLAVE_2_AUDIO_CHANNELS &&
i < AGS_AUDIO_TEST_FINALIZE_LINKED_CHANNEL_MASTER_AUDIO_CHANNELS;
i++){
CU_ASSERT(output->first_recycling == NULL);
CU_ASSERT(output->last_recycling == NULL);
output = output->next;
}
}
