void
ags_audio_test_finalize()
{
AgsAudio *audio;
/* instantiate audio */
audio = ags_audio_new(devout);
/* set audio channels */
audio->audio_channels = AGS_AUDIO_TEST_FINALIZE_AUDIO_CHANNELS;
/* set input pads */
ags_audio_set_pads(audio,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_FINALIZE_INPUT_PADS, 0);
/* set output pads */
ags_audio_set_pads(audio,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_FINALIZE_OUTPUT_PADS, 0);
/* run dispose */
g_object_run_dispose(audio);
/* stub */
audio_test_finalized = FALSE;
G_OBJECT_GET_CLASS(audio)->finalize = ags_audio_test_finalize_stub;
/* unref and assert */
g_object_unref(audio);
CU_ASSERT(audio_test_finalized == TRUE);
}
/* 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);
}
void
ags_menu_action_add_live_dssi_bridge_callback(GtkWidget *menu_item, gpointer data)
{
AgsWindow *window;
AgsLiveDssiBridge *live_dssi_bridge;
AgsThread *gui_thread;
AgsAddAudio *add_audio;
AgsApplicationContext *application_context;
gchar *filename, *effect;
filename = g_object_get_data((GObject *) menu_item,
AGS_MENU_ITEM_FILENAME_KEY);
effect = g_object_get_data((GObject *) menu_item,
AGS_MENU_ITEM_EFFECT_KEY);
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
gui_thread = ags_ui_provider_get_gui_thread(AGS_UI_PROVIDER(application_context));
/* create live dssi bridge */
live_dssi_bridge = ags_live_dssi_bridge_new(G_OBJECT(window->soundcard),
filename,
effect);
add_audio = ags_add_audio_new((AgsApplicationContext *) window->application_context,
AGS_MACHINE(live_dssi_bridge)->audio);
ags_gui_thread_schedule_task((AgsGuiThread *) gui_thread,
(GObject *) add_audio);
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(live_dssi_bridge),
FALSE, FALSE, 0);
/* connect everything */
ags_connectable_connect(AGS_CONNECTABLE(live_dssi_bridge));
/* */
AGS_MACHINE(live_dssi_bridge)->audio->audio_channels = 2;
/* */
ags_audio_set_pads(AGS_MACHINE(live_dssi_bridge)->audio,
AGS_TYPE_INPUT,
128, 0);
ags_audio_set_pads(AGS_MACHINE(live_dssi_bridge)->audio,
AGS_TYPE_OUTPUT,
1, 0);
/* */
ags_live_dssi_bridge_load(live_dssi_bridge);
/* */
gtk_widget_show_all(GTK_WIDGET(live_dssi_bridge));
}
void
ags_menu_bar_add_drum_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
AgsDrum *drum;
AgsAddAudio *add_audio;
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) menu_bar, AGS_TYPE_WINDOW);
application_context = window->application_context;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
drum = ags_drum_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new(window->soundcard,
AGS_MACHINE(drum)->audio);
ags_task_thread_append_task(task_thread,
AGS_TASK(add_audio));
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(drum),
FALSE, FALSE, 0);
/* connect everything */
ags_connectable_connect(AGS_CONNECTABLE(drum));
/* */
gtk_widget_show_all(GTK_WIDGET(drum));
/* */
drum->machine.audio->audio_channels = 2;
/* AgsDrumInputPad */
ags_audio_set_pads(drum->machine.audio, AGS_TYPE_INPUT, 8);
ags_audio_set_pads(drum->machine.audio, AGS_TYPE_OUTPUT, 1);
ags_machine_find_port(AGS_MACHINE(drum));
gtk_widget_show_all(drum->output_pad);
gtk_widget_show_all(drum->input_pad);
}
void
ags_menu_action_add_matrix_callback(GtkWidget *menu_item, gpointer data)
{
AgsWindow *window;
AgsMatrix *matrix;
AgsThread *gui_thread;
AgsAddAudio *add_audio;
AgsApplicationContext *application_context;
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
gui_thread = ags_ui_provider_get_gui_thread(AGS_UI_PROVIDER(application_context));
/* create matrix */
matrix = ags_matrix_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new((AgsApplicationContext *) window->application_context,
AGS_MACHINE(matrix)->audio);
ags_gui_thread_schedule_task((AgsGuiThread *) gui_thread,
(GObject *) add_audio);
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(matrix),
FALSE, FALSE,
0);
/* connect everything */
ags_connectable_connect(AGS_CONNECTABLE(matrix));
/* */
AGS_MACHINE(matrix)->audio->audio_channels = 1;
/* AgsMatrixInputPad */
ags_audio_set_pads(AGS_MACHINE(matrix)->audio,
AGS_TYPE_INPUT,
78, 0);
ags_audio_set_pads(AGS_MACHINE(matrix)->audio,
AGS_TYPE_OUTPUT,
1, 0);
/* */
gtk_widget_show_all(GTK_WIDGET(matrix));
}
/* 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_menu_bar_add_lv2_bridge_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
AgsLv2Bridge *lv2_bridge;
AgsAddAudio *add_audio;
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) menu_bar, AGS_TYPE_WINDOW);
application_context = window->application_context;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
lv2_bridge = ags_lv2_bridge_new(G_OBJECT(window->soundcard),
g_object_get_data(menu_item,
AGS_MENU_BAR_LV2_FILENAME_KEY),
g_object_get_data(menu_item,
AGS_MENU_BAR_LV2_URI_KEY));
add_audio = ags_add_audio_new(window->soundcard,
AGS_MACHINE(lv2_bridge)->audio);
ags_task_thread_append_task(task_thread,
AGS_TASK(add_audio));
gtk_box_pack_start((GtkBox *) window->machines,
(GtkWidget *) lv2_bridge,
FALSE, FALSE, 0);
ags_lv2_bridge_load(lv2_bridge);
ags_connectable_connect(AGS_CONNECTABLE(lv2_bridge));
// lv2_bridge->machine.audio->frequence = ;
lv2_bridge->machine.audio->audio_channels = 2;
ags_audio_set_pads(AGS_MACHINE(lv2_bridge)->audio, AGS_TYPE_INPUT, 1);
ags_audio_set_pads(AGS_MACHINE(lv2_bridge)->audio, AGS_TYPE_OUTPUT, 1);
ags_machine_find_port(AGS_MACHINE(lv2_bridge));
gtk_widget_show_all((GtkWidget *) lv2_bridge);
}
void
ags_menu_action_add_audiorec_callback(GtkWidget *menu_item, gpointer data)
{
AgsWindow *window;
AgsAudiorec *audiorec;
AgsThread *gui_thread;
AgsAddAudio *add_audio;
AgsApplicationContext *application_context;
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
gui_thread = ags_ui_provider_get_gui_thread(AGS_UI_PROVIDER(application_context));
/* create audiorec */
audiorec = ags_audiorec_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new((AgsApplicationContext *) window->application_context,
AGS_MACHINE(audiorec)->audio);
ags_gui_thread_schedule_task((AgsGuiThread *) gui_thread,
(GObject *) add_audio);
gtk_box_pack_start((GtkBox *) window->machines,
(GtkWidget *) audiorec,
FALSE, FALSE,
0);
ags_connectable_connect(AGS_CONNECTABLE(audiorec));
AGS_MACHINE(audiorec)->audio->audio_channels = 2;
ags_audio_set_pads(AGS_MACHINE(audiorec)->audio,
AGS_TYPE_INPUT,
1, 0);
ags_audio_set_pads(AGS_MACHINE(audiorec)->audio,
AGS_TYPE_OUTPUT,
1, 0);
gtk_widget_show_all((GtkWidget *) audiorec);
}
void
ags_audio_test_dispose()
{
AgsAudio *audio;
/* instantiate audio */
audio = ags_audio_new(devout);
/* set audio channels */
audio->audio_channels = AGS_AUDIO_TEST_DISPOSE_AUDIO_CHANNELS;
/* set input pads */
ags_audio_set_pads(audio,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_DISPOSE_INPUT_PADS, 0);
/* set output pads */
ags_audio_set_pads(audio,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_DISPOSE_OUTPUT_PADS, 0);
/* run dispose and assert */
g_object_run_dispose(audio);
CU_ASSERT(audio->output_soundcard == NULL);
CU_ASSERT(audio->input_sequencer == NULL);
CU_ASSERT(audio->output_midi_file == NULL);
CU_ASSERT(audio->output == NULL);
CU_ASSERT(audio->input == NULL);
CU_ASSERT(audio->playback_domain == NULL);
CU_ASSERT(audio->notation == NULL);
CU_ASSERT(audio->automation == NULL);
CU_ASSERT(audio->recall_id == NULL);
CU_ASSERT(audio->recycling_context == NULL);
CU_ASSERT(audio->recall_container == NULL);
CU_ASSERT(audio->recall == NULL);
CU_ASSERT(audio->play == NULL);
}
void
ags_menu_bar_add_panel_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
AgsPanel *panel;
AgsAddAudio *add_audio;
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) menu_bar, AGS_TYPE_WINDOW);
application_context = window->application_context;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
panel = ags_panel_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new(window->soundcard,
AGS_MACHINE(panel)->audio);
ags_task_thread_append_task(task_thread,
AGS_TASK(add_audio));
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(panel),
FALSE, FALSE, 0);
ags_connectable_connect(AGS_CONNECTABLE(panel));
gtk_widget_show_all(GTK_WIDGET(panel));
AGS_MACHINE(panel)->audio->audio_channels = 2;
ags_audio_set_pads(AGS_MACHINE(panel)->audio,
AGS_TYPE_INPUT, 1);
ags_audio_set_pads(AGS_MACHINE(panel)->audio,
AGS_TYPE_OUTPUT, 1);
ags_machine_find_port(AGS_MACHINE(panel));
gtk_widget_show_all(panel->vbox);
}
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_menu_bar_add_ffplayer_callback(GtkWidget *menu_item, AgsMenuBar *menu_bar)
{
AgsWindow *window;
AgsFFPlayer *ffplayer;
AgsAddAudio *add_audio;
AgsThread *main_loop;
AgsTaskThread *task_thread;
AgsApplicationContext *application_context;
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) menu_bar, AGS_TYPE_WINDOW);
application_context = window->application_context;
main_loop = application_context->main_loop;
task_thread = ags_thread_find_type(main_loop,
AGS_TYPE_TASK_THREAD);
ffplayer = ags_ffplayer_new(G_OBJECT(window->soundcard));
add_audio = ags_add_audio_new(window->soundcard,
AGS_MACHINE(ffplayer)->audio);
ags_task_thread_append_task(task_thread,
AGS_TASK(add_audio));
gtk_box_pack_start((GtkBox *) window->machines,
(GtkWidget *) ffplayer,
FALSE, FALSE, 0);
ags_connectable_connect(AGS_CONNECTABLE(ffplayer));
// ffplayer->machine.audio->frequence = ;
ffplayer->machine.audio->audio_channels = 2;
ags_audio_set_pads(AGS_MACHINE(ffplayer)->audio, AGS_TYPE_INPUT, 78);
ags_audio_set_pads(AGS_MACHINE(ffplayer)->audio, AGS_TYPE_OUTPUT, 1);
ags_machine_find_port(AGS_MACHINE(ffplayer));
gtk_widget_show_all((GtkWidget *) ffplayer);
}
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_menu_action_add_lv2_bridge_callback(GtkWidget *menu_item, gpointer data)
{
AgsWindow *window;
AgsLv2Bridge *lv2_bridge;
AgsThread *gui_thread;
AgsAddAudio *add_audio;
AgsApplicationContext *application_context;
AgsLv2Plugin *lv2_plugin;
gchar *filename, *effect;
filename = g_object_get_data((GObject *) menu_item,
AGS_MENU_ITEM_FILENAME_KEY);
effect = g_object_get_data((GObject *) menu_item,
AGS_MENU_ITEM_EFFECT_KEY);
application_context = ags_application_context_get_instance();
window = (AgsWindow *) ags_ui_provider_get_window(AGS_UI_PROVIDER(application_context));
gui_thread = ags_ui_provider_get_gui_thread(AGS_UI_PROVIDER(application_context));
/* create lv2 bridge */
lv2_bridge = ags_lv2_bridge_new(G_OBJECT(window->soundcard),
filename,
effect);
lv2_plugin = ags_lv2_manager_find_lv2_plugin(ags_lv2_manager_get_instance(),
filename, effect);
if(lv2_plugin != NULL &&
(AGS_LV2_PLUGIN_IS_SYNTHESIZER & (lv2_plugin->flags)) != 0){
ags_audio_set_flags(AGS_MACHINE(lv2_bridge)->audio, (AGS_AUDIO_OUTPUT_HAS_RECYCLING |
AGS_AUDIO_INPUT_HAS_RECYCLING |
AGS_AUDIO_SYNC |
AGS_AUDIO_ASYNC));
ags_audio_set_ability_flags(AGS_MACHINE(lv2_bridge)->audio, (AGS_SOUND_ABILITY_NOTATION));
ags_audio_set_behaviour_flags(AGS_MACHINE(lv2_bridge)->audio, (AGS_SOUND_BEHAVIOUR_DEFAULTS_TO_INPUT |
AGS_SOUND_BEHAVIOUR_REVERSE_MAPPING));
g_object_set(AGS_MACHINE(lv2_bridge)->audio,
"max-input-pads", 128,
"audio-start-mapping", 0,
"audio-end-mapping", 128,
"midi-start-mapping", 0,
"midi-end-mapping", 128,
NULL);
AGS_MACHINE(lv2_bridge)->flags |= (AGS_MACHINE_IS_SYNTHESIZER |
AGS_MACHINE_REVERSE_NOTATION);
ags_machine_popup_add_connection_options((AgsMachine *) lv2_bridge,
(AGS_MACHINE_POPUP_MIDI_DIALOG));
ags_machine_popup_add_edit_options((AgsMachine *) lv2_bridge,
(AGS_MACHINE_POPUP_ENVELOPE));
}
add_audio = ags_add_audio_new((AgsApplicationContext *) window->application_context,
AGS_MACHINE(lv2_bridge)->audio);
ags_gui_thread_schedule_task((AgsGuiThread *) gui_thread,
(GObject *) add_audio);
gtk_box_pack_start((GtkBox *) window->machines,
GTK_WIDGET(lv2_bridge),
FALSE, FALSE, 0);
/* connect everything */
ags_connectable_connect(AGS_CONNECTABLE(lv2_bridge));
/* */
AGS_MACHINE(lv2_bridge)->audio->audio_channels = 2;
/* */
if(lv2_plugin != NULL){
if((AGS_LV2_PLUGIN_IS_SYNTHESIZER & (lv2_plugin->flags)) == 0){
ags_audio_set_pads(AGS_MACHINE(lv2_bridge)->audio,
AGS_TYPE_INPUT,
1, 0);
}else{
ags_audio_set_pads(AGS_MACHINE(lv2_bridge)->audio,
AGS_TYPE_INPUT,
128, 0);
}
}
ags_audio_set_pads(AGS_MACHINE(lv2_bridge)->audio,
AGS_TYPE_OUTPUT,
1, 0);
/* */
ags_lv2_bridge_load(lv2_bridge);
/* */
gtk_widget_show_all(GTK_WIDGET(lv2_bridge));
}
void
ags_open_file_launch(AgsTask *task)
{
AgsOpenFile *open_file;
AgsAudio *audio;
AgsChannel *channel, *iter;
AgsAudioFile *audio_file;
AgsFileLink *file_link;
GSList *current;
GList *audio_signal;
gchar *current_filename;
guint i, i_stop;
GError *error;
open_file = AGS_OPEN_FILE(task);
audio = open_file->audio;
current = open_file->filenames;
i_stop = 0;
if(open_file->overwrite_channels){
channel = audio->input;
i_stop = audio->input_pads;
}
/* */
if(open_file->create_channels){
guint pads_old;
i_stop = g_slist_length(open_file->filenames);
pads_old = audio->input_pads;
if(open_file->overwrite_channels){
if(i_stop > audio->input_pads){
ags_audio_set_pads(audio, AGS_TYPE_INPUT,
i_stop);
}
channel = audio->input;
}else{
ags_audio_set_pads(audio, AGS_TYPE_INPUT,
audio->input_pads + i_stop);
channel = ags_channel_pad_nth(audio->input,
pads_old);
}
iter = ags_channel_pad_nth(audio->input,
pads_old);
while(iter != NULL){
ags_connectable_connect(AGS_CONNECTABLE(iter));
iter = iter->next;
}
}
for(i = 0; i < i_stop && current != NULL; i++){
current_filename = (gchar *) current->data;
audio_file = ags_audio_file_new((gchar *) current_filename,
audio->soundcard,
0, open_file->audio->audio_channels);
ags_audio_file_open(audio_file);
ags_audio_file_read_audio_signal(audio_file);
iter = channel;
audio_signal = audio_file->audio_signal;
while(iter != channel->next_pad && audio_signal != NULL){
file_link = g_object_new(AGS_TYPE_FILE_LINK,
"filename\0", current_filename,
NULL);
g_object_set(G_OBJECT(iter),
"file-link", file_link,
NULL);
AGS_AUDIO_SIGNAL(audio_signal->data)->flags |= AGS_AUDIO_SIGNAL_TEMPLATE;
if(iter->link != NULL){
error = NULL;
ags_channel_set_link(iter, NULL,
&error);
if(error != NULL){
g_warning(error->message);
}
}
//TODO:JK: add mutex
ags_recycling_add_audio_signal(iter->first_recycling,
AGS_AUDIO_SIGNAL(audio_signal->data));
audio_signal = audio_signal->next;
iter = iter->next;
}
channel = channel->next_pad;
current = current->next;
}
}
void
ags_audio_test_set_pads()
{
AgsAudio *audio;
AgsChannel *channel, *current;
guint i, j;
/* instantiate */
audio = ags_audio_new(devout);
CU_ASSERT(audio != NULL);
/* set audio channels */
audio->audio_channels = AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS;
/* set input pads */
ags_audio_set_pads(audio,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_SET_PADS_INPUT_PADS, 0);
CU_ASSERT(audio->input_pads == AGS_AUDIO_TEST_SET_PADS_INPUT_PADS);
/* verify pad count */
channel = audio->input;
for(i = 0; channel != audio->input->next_pad; i++){
current = channel;
for(j = 0; current != NULL; j++){
current = current->next_pad;
}
CU_ASSERT(j == AGS_AUDIO_TEST_SET_PADS_INPUT_PADS);
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* verify reverse pad count */
channel = ags_channel_last(audio->input);
for(i = 0; channel != ags_channel_last(audio->input)->prev_pad; i++){
current = channel;
for(j = 0; current != NULL; j++){
current = current->prev_pad;
}
g_message("--- %d", j);
CU_ASSERT(j == AGS_AUDIO_TEST_SET_PADS_INPUT_PADS);
channel = channel->prev;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* verify line count */
channel = audio->input;
for(i = 0; channel != NULL; i++){
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_INPUT_PADS * AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* verify reverse line count */
channel = ags_channel_last(audio->input);
for(i = 0; channel != NULL; i++){
channel = channel->prev;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_INPUT_PADS * AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* set output pads */
ags_audio_set_pads(audio,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_SET_PADS_OUTPUT_PADS, 0);
CU_ASSERT(audio->output_pads == AGS_AUDIO_TEST_SET_PADS_OUTPUT_PADS);
/* verify pad count */
channel = audio->output;
for(i = 0; channel != audio->output->next_pad; i++){
current = channel;
for(j = 0; current != NULL; j++){
current = current->next_pad;
}
CU_ASSERT(j == AGS_AUDIO_TEST_SET_PADS_OUTPUT_PADS);
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* verify line count */
channel = audio->output;
for(i = 0; channel != NULL; i++){
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_OUTPUT_PADS * AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/*
* grow pads
*/
/* set input pads */
ags_audio_set_pads(audio,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_SET_PADS_GROW_INPUT_PADS, 0);
CU_ASSERT(audio->input_pads == AGS_AUDIO_TEST_SET_PADS_GROW_INPUT_PADS);
/* verify pad count */
channel = audio->input;
for(i = 0; channel != audio->input->next_pad; i++){
current = channel;
for(j = 0; current != NULL; j++){
current = current->next_pad;
}
CU_ASSERT(j == AGS_AUDIO_TEST_SET_PADS_GROW_INPUT_PADS);
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* verify line count */
channel = audio->input;
for(i = 0; channel != NULL; i++){
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_GROW_INPUT_PADS * AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* set output pads */
ags_audio_set_pads(audio,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_SET_PADS_GROW_OUTPUT_PADS, 0);
CU_ASSERT(audio->output_pads == AGS_AUDIO_TEST_SET_PADS_GROW_OUTPUT_PADS);
/* verify pad count */
channel = audio->output;
for(i = 0; channel != audio->output->next_pad; i++){
current = channel;
for(j = 0; current != NULL; j++){
current = current->next_pad;
}
CU_ASSERT(j == AGS_AUDIO_TEST_SET_PADS_GROW_OUTPUT_PADS);
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* verify line count */
channel = audio->output;
for(i = 0; channel != NULL; i++){
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_GROW_OUTPUT_PADS * AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/*
* shrink pads
*/
/* set input pads */
ags_audio_set_pads(audio,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_SET_PADS_SHRINK_INPUT_PADS, 0);
CU_ASSERT(audio->input_pads == AGS_AUDIO_TEST_SET_PADS_SHRINK_INPUT_PADS);
/* verify pad count */
channel = audio->input;
for(i = 0; channel != audio->input->next_pad; i++){
current = channel;
for(j = 0; current != NULL; j++){
current = current->next_pad;
}
CU_ASSERT(j == AGS_AUDIO_TEST_SET_PADS_SHRINK_INPUT_PADS);
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* verify line count */
channel = audio->input;
for(i = 0; channel != NULL; i++){
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_SHRINK_INPUT_PADS * AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* set output pads */
ags_audio_set_pads(audio,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_SET_PADS_SHRINK_OUTPUT_PADS, 0);
CU_ASSERT(audio->output_pads == AGS_AUDIO_TEST_SET_PADS_SHRINK_OUTPUT_PADS);
/* verify pad count */
channel = audio->output;
for(i = 0; channel != audio->output->next_pad; i++){
current = channel;
for(j = 0; current != NULL; j++){
current = current->next_pad;
}
CU_ASSERT(j == AGS_AUDIO_TEST_SET_PADS_SHRINK_OUTPUT_PADS);
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
/* verify line count */
channel = audio->output;
for(i = 0; channel != NULL; i++){
channel = channel->next;
}
CU_ASSERT(i == AGS_AUDIO_TEST_SET_PADS_SHRINK_OUTPUT_PADS * AGS_AUDIO_TEST_SET_PADS_AUDIO_CHANNELS);
}
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_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_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;
}
}
