/* 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_matrix_output_map_recall(AgsMatrix *matrix, guint output_pad_start)
{
AgsAudio *audio;
AgsChannel *source;
AgsDelayAudio *recall_delay_audio;
AgsCountBeatsAudioRun *recall_count_beats_audio_run;
GList *list;
audio = AGS_MACHINE(matrix)->audio;
if(matrix->mapped_output_pad > output_pad_start){
return;
}
source = ags_channel_nth(audio->output,
output_pad_start * audio->audio_channels);
if(source == NULL){
return;
}
/* get some recalls */
list = ags_recall_find_type(audio->play, AGS_TYPE_DELAY_AUDIO);
if(list != NULL){
recall_delay_audio = AGS_DELAY_AUDIO(list->data);
}else{
recall_delay_audio = NULL;
}
list = ags_recall_find_type(audio->play, AGS_TYPE_COUNT_BEATS_AUDIO_RUN);
if(list != NULL){
recall_count_beats_audio_run = AGS_COUNT_BEATS_AUDIO_RUN(list->data);
}else{
recall_count_beats_audio_run = NULL;
}
/* ags-stream */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-stream\0",
source->audio_channel, source->audio_channel + 1,
output_pad_start, audio->output_pads,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
matrix->mapped_output_pad = output_pad_start;
}
void
ags_drum_output_line_add_default_recall(AgsDrumOutputLine *drum_output_line)
{
AgsDrum *drum;
AgsLine *line;
AgsAudio *audio;
AgsChannel *output;
AgsDelayAudio *recall_delay_audio;
AgsCountBeatsAudioRun *recall_count_beats_audio_run;
GList *list;
printf("ags_drum_output_line_map_recall\n\0");
line = AGS_LINE(drum_output_line);
line->flags |= AGS_LINE_MAPPED_RECALL;
output = AGS_LINE(drum_output_line)->channel;
audio = AGS_AUDIO(output->audio);
drum = AGS_DRUM(audio->machine);
/* get some recalls */
list = ags_recall_find_type(audio->play, AGS_TYPE_DELAY_AUDIO);
if(list != NULL){
recall_delay_audio = AGS_DELAY_AUDIO(list->data);
}else{
recall_delay_audio = NULL;
}
list = ags_recall_find_type(audio->play, AGS_TYPE_COUNT_BEATS_AUDIO_RUN);
if(list != NULL){
recall_count_beats_audio_run = AGS_COUNT_BEATS_AUDIO_RUN(list->data);
}else{
recall_count_beats_audio_run = NULL;
}
/* ags-stream */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-stream\0",
output->audio_channel, output->audio_channel + 1,
output->pad, output->pad + 1,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_RECALL |
AGS_RECALL_FACTORY_ADD),
0);
}
/* 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_drum_input_line_map_recall(AgsDrumInputLine *drum_input_line,
guint output_pad_start)
{
AgsDrum *drum;
AgsLine *line;
AgsLineMember *line_member;
AgsAudio *audio;
AgsChannel *source;
AgsChannel *current, *destination;
AgsCopyChannel *copy_channel;
AgsCopyChannelRun *copy_channel_run;
GList *list;
guint i;
line = AGS_LINE(drum_input_line);
line->flags |= AGS_LINE_MAPPED_RECALL;
audio = AGS_AUDIO(line->channel->audio);
drum = AGS_DRUM(audio->machine);
source = line->channel;
/* ags-play */
// ags_recall_factory_create(audio,
// "ags-play\0",
// 0, audio->audio_channels,
// source->pad, source->pad + 1,
// FALSE,
// FALSE);
/* ags-volume */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-volume\0",
source->audio_channel, source->audio_channel + 1,
source->pad, source->pad + 1,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_RECALL |
AGS_RECALL_FACTORY_ADD),
0);
/* ags-copy */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-copy\0",
source->audio_channel, source->audio_channel + 1,
source->pad, source->pad + 1,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_RECALL |
AGS_RECALL_FACTORY_ADD),
0);
current = source;
destination = ags_channel_nth(audio->output,
current->audio_channel);
while(destination != NULL){
/* recall */
list = current->recall;
while((list = ags_recall_find_type(list, AGS_TYPE_COPY_CHANNEL)) != NULL){
copy_channel = AGS_COPY_CHANNEL(list->data);
g_object_set(G_OBJECT(copy_channel),
"destination\0", destination,
NULL);
list = list->next;
}
list = current->recall;
while((list = ags_recall_find_type(list, AGS_TYPE_COPY_CHANNEL_RUN)) != NULL){
copy_channel_run = AGS_COPY_CHANNEL_RUN(list->data);
g_object_set(G_OBJECT(copy_channel_run),
"destination\0", destination,
NULL);
list = list->next;
}
destination = destination->next_pad;
}
/* ags-stream */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-stream\0",
source->audio_channel, source->audio_channel + 1,
source->pad, source->pad + 1,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_RECALL |
AGS_RECALL_FACTORY_ADD),
0);
}
void
ags_panel_input_line_map_recall(AgsLine *line,
guint output_pad_start)
{
AgsPanel *panel;
AgsPanelInputLine *panel_input_line;
AgsAudio *audio;
AgsChannel *source;
AgsChannel *current;
AgsPlayChannel *play_channel;
AgsPlayChannelRunMaster *play_channel_run;
GList *list;
if((AGS_LINE_MAPPED_RECALL & (line->flags)) != 0 ||
(AGS_LINE_PREMAPPED_RECALL & (line->flags)) != 0){
return;
}
panel_input_line = AGS_PANEL_INPUT_LINE(line);
audio = AGS_AUDIO(line->channel->audio);
panel = AGS_PANEL(audio->machine_widget);
source = line->channel;
/* ags-play */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-play-master\0",
source->audio_channel, source->audio_channel + 1,
source->pad, source->pad + 1,
(AGS_RECALL_FACTORY_INPUT,
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
/* set audio channel */
list = source->play;
while((list = ags_recall_template_find_type(list,
AGS_TYPE_PLAY_CHANNEL)) != NULL){
GValue audio_channel_value = {0,};
play_channel = AGS_PLAY_CHANNEL(list->data);
g_value_init(&audio_channel_value, G_TYPE_UINT64);
g_value_set_uint64(&audio_channel_value,
source->audio_channel);
ags_port_safe_write(play_channel->audio_channel,
&audio_channel_value);
list = list->next;
}
/* call parent */
AGS_LINE_CLASS(ags_panel_input_line_parent_class)->map_recall(line,
output_pad_start);
}
void
ags_audiorec_resize_audio_channels(AgsMachine *machine,
guint audio_channels, guint audio_channels_old,
gpointer data)
{
AgsAudiorec *audiorec;
AgsAudio *audio;
AgsChannel *start_output;
AgsChannel *channel, *next_pad, *next_channel, *nth_channel;
AgsRecycling *first_recycling;
AgsAudioSignal *audio_signal;
GObject *output_soundcard;
guint output_pads, input_pads;
audiorec = AGS_AUDIOREC(machine);
audio = AGS_MACHINE(audiorec)->audio;
g_object_get(audio,
"input-pads", &input_pads,
"output-pads", &output_pads,
"output", &start_output,
NULL);
if(audio_channels > audio_channels_old){
AgsHIndicator *hindicator;
guint i;
/* AgsOutput */
channel = start_output;
if(channel != NULL){
g_object_ref(channel);
}
next_pad = NULL;
while(channel != NULL){
/* get some fields */
next_pad = ags_channel_next_pad(channel),
nth_channel = ags_channel_pad_nth(channel,
audio_channels_old);
g_object_unref(channel);
channel = nth_channel;
while(channel != next_pad){
ags_channel_set_ability_flags(channel, (AGS_SOUND_ABILITY_WAVE));
/* get some fields */
g_object_get(channel,
"output-soundcard", &output_soundcard,
"first-recycling", &first_recycling,
NULL);
/* audio signal */
audio_signal = ags_audio_signal_new(output_soundcard,
(GObject *) first_recycling,
NULL);
audio_signal->flags |= AGS_AUDIO_SIGNAL_TEMPLATE;
ags_audio_signal_stream_resize(audio_signal,
3);
ags_recycling_add_audio_signal(first_recycling,
audio_signal);
if(output_soundcard != NULL){
g_object_unref(output_soundcard);
}
if(first_recycling != NULL){
g_object_unref(first_recycling);
}
/* iterate */
next_channel = ags_channel_next(channel);
g_object_unref(channel);
channel = next_channel;
}
}
if(next_pad != NULL){
g_object_unref(next_pad);
}
if(input_pads > 0){
}
if(output_pads > 0){
/* AgsOutput */
/* ags-play-wave */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-play-wave",
audio_channels_old, audio_channels,
0, output_pads,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
/* ags-capture-wave */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-capture-wave",
audio_channels_old, audio_channels,
0, output_pads,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
/* ags-peak */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-peak",
audio_channels, audio_channels_old,
0, output_pads,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
}
/* widgets */
for(i = audio_channels_old; i < audio_channels; i++){
hindicator = ags_hindicator_new();
gtk_box_pack_start((GtkBox *) audiorec->hindicator_vbox,
(GtkWidget *) hindicator,
FALSE, FALSE,
8);
}
gtk_widget_show_all((GtkWidget *) audiorec->hindicator_vbox);
}else{
GList *list, *list_start;
list_start =
list = gtk_container_get_children((GtkContainer *) audiorec->hindicator_vbox);
list = g_list_nth(list_start,
audio_channels);
while(list != NULL){
gtk_widget_destroy((GtkWidget *) list->data);
list = list->next;
}
g_list_free(list_start);
}
/* unref */
if(start_output != NULL){
g_object_unref(start_output);
}
}
void
ags_audiorec_output_map_recall(AgsAudiorec *audiorec, guint output_pad_start)
{
AgsWindow *window;
AgsAudio *audio;
AgsChannel *start_output;
AgsChannel *output, *next_output, *nth_output;
guint output_pads;
guint audio_channels;
if(audiorec->mapped_output_pad > output_pad_start){
return;
}
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) audiorec,
AGS_TYPE_WINDOW);
audio = AGS_MACHINE(audiorec)->audio;
g_object_get(audio,
"output", &start_output,
"output-pads", &output_pads,
"audio-channels", &audio_channels,
NULL);
/* ags-peak */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-peak",
0, audio_channels,
output_pad_start, output_pads,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
/* ags-play-wave */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-play-wave",
0, audio_channels,
output_pad_start, output_pads,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
nth_output = ags_channel_pad_nth(start_output,
output_pad_start);
output = nth_output;
next_output = NULL;
while(output != NULL){
GList *start_play, *play;
g_object_get(output,
"play", &start_play,
NULL);
play = ags_recall_find_type(start_play,
AGS_TYPE_PLAY_WAVE_CHANNEL_RUN);
if(play != NULL){
GValue value = {0,};
ags_seekable_seek(AGS_SEEKABLE(play->data),
(gint64) 16 * window->navigation->position_tact->adjustment->value,
AGS_SEEK_SET);
}
g_list_free_full(start_play,
g_object_unref);
/* iterate */
next_output = ags_channel_next(output);
g_object_unref(output);
output = next_output;
}
if(next_output != NULL){
g_object_unref(next_output);
}
/* ags-capture-wave */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-capture-wave",
0, audio_channels,
output_pad_start, output_pads,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_PLAY |
AGS_RECALL_FACTORY_ADD),
0);
nth_output = ags_channel_pad_nth(start_output,
output_pad_start);
output = nth_output;
next_output = NULL;
while(output != NULL){
GList *start_play, *play;
g_object_get(output,
"play", &start_play,
NULL);
play = ags_recall_find_type(start_play,
AGS_TYPE_CAPTURE_WAVE_CHANNEL_RUN);
if(play != NULL){
GValue value = {0,};
ags_seekable_seek(AGS_SEEKABLE(play->data),
(gint64) 16 * window->navigation->position_tact->adjustment->value,
AGS_SEEK_SET);
}
g_list_free_full(start_play,
g_object_unref);
/* iterate */
next_output = ags_channel_next(output);
g_object_unref(output);
output = next_output;
}
if(next_output != NULL){
g_object_unref(next_output);
}
/* unref */
if(start_output != NULL){
g_object_unref(start_output);
}
audiorec->mapped_output_pad = output_pads;
}
void
ags_audiorec_map_recall(AgsMachine *machine)
{
AgsWindow *window;
AgsAudiorec *audiorec;
AgsAudio *audio;
AgsPlayWaveAudioRun *play_wave_audio_run;
AgsCaptureWaveAudioRun *capture_wave_audio_run;
GList *start_play, *play;
if((AGS_MACHINE_MAPPED_RECALL & (machine->flags)) != 0 ||
(AGS_MACHINE_PREMAPPED_RECALL & (machine->flags)) != 0){
return;
}
audiorec = AGS_AUDIOREC(machine);
window = (AgsWindow *) gtk_widget_get_ancestor((GtkWidget *) machine,
AGS_TYPE_WINDOW);
audio = machine->audio;
/* ags-play-wave */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-play-wave",
0, 0,
0, 0,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_ADD |
AGS_RECALL_FACTORY_PLAY),
0);
g_object_get(audio,
"play", &start_play,
NULL);
play = ags_recall_find_type(start_play,
AGS_TYPE_PLAY_WAVE_AUDIO_RUN);
if(play != NULL){
GValue value = {0,};
play_wave_audio_run = play->data;
/* wave loop */
g_value_init(&value, G_TYPE_BOOLEAN);
g_value_set_boolean(&value, gtk_toggle_button_get_active((GtkToggleButton *) window->navigation->loop));
ags_port_safe_write(AGS_PLAY_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(play_wave_audio_run)->recall_audio)->wave_loop,
&value);
g_value_unset(&value);
g_value_init(&value, G_TYPE_UINT64);
g_value_set_uint64(&value, 16 * window->navigation->loop_left_tact->adjustment->value);
ags_port_safe_write(AGS_PLAY_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(play_wave_audio_run)->recall_audio)->wave_loop_start,
&value);
g_value_reset(&value);
g_value_set_uint64(&value, 16 * window->navigation->loop_right_tact->adjustment->value);
ags_port_safe_write(AGS_PLAY_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(play_wave_audio_run)->recall_audio)->wave_loop_end,
&value);
}
g_list_free_full(start_play,
g_object_unref);
/* ags-capture-wave */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-capture-wave",
0, 0,
0, 0,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_ADD |
AGS_RECALL_FACTORY_PLAY),
0);
g_object_get(audio,
"play", &start_play,
NULL);
play = ags_recall_find_type(start_play,
AGS_TYPE_CAPTURE_WAVE_AUDIO_RUN);
if(play != NULL){
GValue value = {0,};
capture_wave_audio_run = play->data;
/* wave loop */
g_value_init(&value, G_TYPE_BOOLEAN);
g_value_set_boolean(&value, gtk_toggle_button_get_active((GtkToggleButton *) window->navigation->loop));
ags_port_safe_write(AGS_CAPTURE_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(capture_wave_audio_run)->recall_audio)->wave_loop,
&value);
g_value_unset(&value);
g_value_init(&value, G_TYPE_UINT64);
g_value_set_uint64(&value, 16 * window->navigation->loop_left_tact->adjustment->value);
ags_port_safe_write(AGS_CAPTURE_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(capture_wave_audio_run)->recall_audio)->wave_loop_start,
&value);
g_value_reset(&value);
g_value_set_uint64(&value, 16 * window->navigation->loop_right_tact->adjustment->value);
ags_port_safe_write(AGS_CAPTURE_WAVE_AUDIO(AGS_RECALL_AUDIO_RUN(capture_wave_audio_run)->recall_audio)->wave_loop_end,
&value);
}
g_list_free_full(start_play,
g_object_unref);
/* depending on destination */
ags_audiorec_input_map_recall(audiorec, 0);
/* depending on destination */
ags_audiorec_output_map_recall(audiorec, 0);
/* call parent */
AGS_MACHINE_CLASS(ags_audiorec_parent_class)->map_recall(machine);
}
void
ags_drum_map_recall(AgsMachine *machine)
{
AgsAudio *audio;
AgsDelayAudio *play_delay_audio;
AgsDelayAudioRun *play_delay_audio_run;
AgsCountBeatsAudio *play_count_beats_audio;
AgsCountBeatsAudioRun *play_count_beats_audio_run;
AgsCopyPatternAudio *recall_copy_pattern_audio;
AgsCopyPatternAudioRun *recall_copy_pattern_audio_run;
GList *list;
if((AGS_MACHINE_MAPPED_RECALL & (machine->flags)) != 0 ||
(AGS_MACHINE_PREMAPPED_RECALL & (machine->flags)) != 0){
return;
}
audio = machine->audio;
/* ags-delay */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-delay\0",
0, 0,
0, 0,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_ADD |
AGS_RECALL_FACTORY_PLAY),
0);
list = ags_recall_find_type(audio->play, AGS_TYPE_DELAY_AUDIO_RUN);
if(list != NULL){
play_delay_audio_run = AGS_DELAY_AUDIO_RUN(list->data);
// AGS_RECALL(play_delay_audio_run)->flags |= AGS_RECALL_PERSISTENT;
}
/* ags-count-beats */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-count-beats\0",
0, 0,
0, 0,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_ADD |
AGS_RECALL_FACTORY_PLAY),
0);
list = ags_recall_find_type(audio->play, AGS_TYPE_COUNT_BEATS_AUDIO_RUN);
if(list != NULL){
play_count_beats_audio_run = AGS_COUNT_BEATS_AUDIO_RUN(list->data);
/* set dependency */
g_object_set(G_OBJECT(play_count_beats_audio_run),
"delay-audio-run\0", play_delay_audio_run,
NULL);
}
/* ags-copy-pattern */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-copy-pattern\0",
0, 0,
0, 0,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_ADD |
AGS_RECALL_FACTORY_RECALL),
0);
list = ags_recall_find_type(audio->recall, AGS_TYPE_COPY_PATTERN_AUDIO_RUN);
if(list != NULL){
recall_copy_pattern_audio_run = AGS_COPY_PATTERN_AUDIO_RUN(list->data);
/* set dependency */
g_object_set(G_OBJECT(recall_copy_pattern_audio_run),
"delay-audio-run\0", play_delay_audio_run,
"count-beats-audio-run\0", play_count_beats_audio_run,
NULL);
}
AGS_MACHINE_CLASS(ags_drum_parent_class)->map_recall(machine);
}
void
ags_matrix_input_map_recall(AgsMatrix *matrix, guint input_pad_start)
{
AgsAudio *audio;
AgsPattern *pattern;
AgsChannel *source, *current, *destination;
AgsBufferChannel *buffer_channel;
AgsBufferChannelRun *buffer_channel_run;
GList *list;
audio = AGS_MACHINE(matrix)->audio;
if(matrix->mapped_input_pad > input_pad_start){
return;
}
source = ags_channel_nth(audio->input,
input_pad_start * audio->audio_channels);
if(source == NULL){
return;
}
current = source;
while(current != NULL){
/* ags-buffer */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-buffer\0",
current->audio_channel, current->audio_channel + 1,
current->pad, current->pad + 1,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_RECALL |
AGS_RECALL_FACTORY_ADD),
0);
destination = ags_channel_nth(audio->output,
current->audio_channel);
while(destination != NULL){
/* recall */
list = current->recall;
while((list = ags_recall_find_type(list, AGS_TYPE_BUFFER_CHANNEL)) != NULL){
buffer_channel = AGS_BUFFER_CHANNEL(list->data);
g_object_set(G_OBJECT(buffer_channel),
"destination\0", destination,
NULL);
list = list->next;
}
list = current->recall;
while((list = ags_recall_find_type(list, AGS_TYPE_BUFFER_CHANNEL_RUN)) != NULL){
buffer_channel_run = AGS_BUFFER_CHANNEL_RUN(list->data);
g_object_set(G_OBJECT(buffer_channel_run),
"destination\0", destination,
NULL);
list = list->next;
}
destination = destination->next_pad;
}
/* ags-stream */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-stream\0",
current->audio_channel, current->audio_channel + 1,
current->pad, current->pad + 1,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_RECALL |
AGS_RECALL_FACTORY_ADD),
0);
current = current->next_pad;
}
matrix->mapped_input_pad = input_pad_start;
}
void
ags_matrix_map_recall(AgsMachine *machine)
{
AgsMatrix *matrix;
AgsAudio *audio;
AgsChannel *channel;
AgsPattern *pattern;
AgsDelayAudio *play_delay_audio;
AgsDelayAudioRun *play_delay_audio_run;
AgsCountBeatsAudio *play_count_beats_audio;
AgsCountBeatsAudioRun *play_count_beats_audio_run;
AgsCopyPatternAudio *recall_copy_pattern_audio;
AgsCopyPatternAudioRun *recall_copy_pattern_audio_run;
AgsPlayNotationAudio *play_notation;
AgsCopyPatternChannel *copy_pattern_channel;
GList *notation;
GList *list;
guint i, j;
GValue value = {0,};
if((AGS_MACHINE_MAPPED_RECALL & (machine->flags)) != 0 ||
(AGS_MACHINE_PREMAPPED_RECALL & (machine->flags)) != 0){
return;
}
audio = machine->audio;
matrix = AGS_MATRIX(machine);
/* ags-delay */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-delay\0",
0, 0,
0, 0,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_ADD |
AGS_RECALL_FACTORY_PLAY),
0);
list = ags_recall_find_type(audio->play, AGS_TYPE_DELAY_AUDIO_RUN);
if(list != NULL){
play_delay_audio_run = AGS_DELAY_AUDIO_RUN(list->data);
// AGS_RECALL(play_delay_audio_run)->flags |= AGS_RECALL_PERSISTENT;
}
/* ags-count-beats */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-count-beats\0",
0, 0,
0, 0,
(AGS_RECALL_FACTORY_OUTPUT |
AGS_RECALL_FACTORY_ADD |
AGS_RECALL_FACTORY_PLAY),
0);
list = ags_recall_find_type(audio->play, AGS_TYPE_COUNT_BEATS_AUDIO_RUN);
if(list != NULL){
play_count_beats_audio_run = AGS_COUNT_BEATS_AUDIO_RUN(list->data);
/* set dependency */
g_object_set(G_OBJECT(play_count_beats_audio_run),
"delay-audio-run\0", play_delay_audio_run,
NULL);
}
/* ags-copy-pattern */
ags_recall_factory_create(audio,
NULL, NULL,
"ags-copy-pattern\0",
0, audio->audio_channels,
0, audio->input_lines,
(AGS_RECALL_FACTORY_INPUT |
AGS_RECALL_FACTORY_ADD |
AGS_RECALL_FACTORY_RECALL),
0);
list = ags_recall_find_type(audio->recall, AGS_TYPE_COPY_PATTERN_AUDIO_RUN);
if(list != NULL){
recall_copy_pattern_audio_run = AGS_COPY_PATTERN_AUDIO_RUN(list->data);
/* set dependency */
g_object_set(G_OBJECT(recall_copy_pattern_audio_run),
"delay-audio-run\0", play_delay_audio_run,
"count-beats-audio-run\0", play_count_beats_audio_run,
NULL);
}
/* set pattern object on port */
channel = ags_channel_pad_nth(audio->input, 0);
for(i = 0; i < audio->input_pads; i++){
for(j = 0; j < audio->audio_channels; j++){
list = ags_recall_template_find_type(channel->recall, AGS_TYPE_COPY_PATTERN_CHANNEL);
copy_pattern_channel = AGS_COPY_PATTERN_CHANNEL(list->data);
list = channel->pattern;
pattern = AGS_PATTERN(list->data);
copy_pattern_channel->pattern->port_value.ags_port_object = (GObject *) pattern;
ags_portlet_set_port(AGS_PORTLET(pattern), copy_pattern_channel->pattern);
channel = channel->next;
}
}
/* */
list = audio->recall;
while((list = ags_recall_find_type(list,
AGS_TYPE_PLAY_NOTATION_AUDIO)) != NULL){
play_notation = AGS_PLAY_NOTATION_AUDIO(list->data);
ags_port_safe_read(play_notation->notation,
&value);
if(g_value_get_object(&value) == NULL){
notation = audio->notation;
while(notation != NULL){
g_object_set(G_OBJECT(play_notation),
"notation\0", notation->data,
NULL);
notation = notation->next;
}
}
list = list->next;
}
/* depending on destination */
ags_matrix_input_map_recall(matrix, 0);
/* depending on destination */
ags_matrix_output_map_recall(matrix, 0);
AGS_MACHINE_CLASS(ags_matrix_parent_class)->map_recall(machine);
}
