1 /* GSequencer - Advanced GTK Sequencer
2 * Copyright (C) 2005-2021 Joël Krähemann
3 *
4 * This file is part of GSequencer.
5 *
6 * GSequencer is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * GSequencer is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with GSequencer. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <ags/audio/ags_fx_factory.h>
21
22 #include <ags/plugin/ags_base_plugin.h>
23 #include <ags/plugin/ags_lv2_manager.h>
24 #include <ags/plugin/ags_lv2_plugin.h>
25
26 #include <ags/audio/fx/ags_fx_playback_audio.h>
27 #include <ags/audio/fx/ags_fx_playback_audio_processor.h>
28 #include <ags/audio/fx/ags_fx_playback_channel.h>
29 #include <ags/audio/fx/ags_fx_playback_channel_processor.h>
30 #include <ags/audio/fx/ags_fx_playback_recycling.h>
31 #include <ags/audio/fx/ags_fx_playback_audio_signal.h>
32
33 #include <ags/audio/fx/ags_fx_buffer_audio.h>
34 #include <ags/audio/fx/ags_fx_buffer_audio_processor.h>
35 #include <ags/audio/fx/ags_fx_buffer_channel.h>
36 #include <ags/audio/fx/ags_fx_buffer_channel_processor.h>
37 #include <ags/audio/fx/ags_fx_buffer_recycling.h>
38 #include <ags/audio/fx/ags_fx_buffer_audio_signal.h>
39
40 #include <ags/audio/fx/ags_fx_volume_audio.h>
41 #include <ags/audio/fx/ags_fx_volume_audio_processor.h>
42 #include <ags/audio/fx/ags_fx_volume_channel.h>
43 #include <ags/audio/fx/ags_fx_volume_channel_processor.h>
44 #include <ags/audio/fx/ags_fx_volume_recycling.h>
45 #include <ags/audio/fx/ags_fx_volume_audio_signal.h>
46
47 #include <ags/audio/fx/ags_fx_peak_audio.h>
48 #include <ags/audio/fx/ags_fx_peak_audio_processor.h>
49 #include <ags/audio/fx/ags_fx_peak_channel.h>
50 #include <ags/audio/fx/ags_fx_peak_channel_processor.h>
51 #include <ags/audio/fx/ags_fx_peak_recycling.h>
52 #include <ags/audio/fx/ags_fx_peak_audio_signal.h>
53
54 #include <ags/audio/fx/ags_fx_eq10_audio.h>
55 #include <ags/audio/fx/ags_fx_eq10_audio_processor.h>
56 #include <ags/audio/fx/ags_fx_eq10_channel.h>
57 #include <ags/audio/fx/ags_fx_eq10_channel_processor.h>
58 #include <ags/audio/fx/ags_fx_eq10_recycling.h>
59 #include <ags/audio/fx/ags_fx_eq10_audio_signal.h>
60
61 #include <ags/audio/fx/ags_fx_analyse_audio.h>
62 #include <ags/audio/fx/ags_fx_analyse_audio_processor.h>
63 #include <ags/audio/fx/ags_fx_analyse_channel.h>
64 #include <ags/audio/fx/ags_fx_analyse_channel_processor.h>
65 #include <ags/audio/fx/ags_fx_analyse_recycling.h>
66 #include <ags/audio/fx/ags_fx_analyse_audio_signal.h>
67
68 #include <ags/audio/fx/ags_fx_two_pass_aliase_audio.h>
69 #include <ags/audio/fx/ags_fx_two_pass_aliase_audio_processor.h>
70 #include <ags/audio/fx/ags_fx_two_pass_aliase_channel.h>
71 #include <ags/audio/fx/ags_fx_two_pass_aliase_channel_processor.h>
72 #include <ags/audio/fx/ags_fx_two_pass_aliase_recycling.h>
73 #include <ags/audio/fx/ags_fx_two_pass_aliase_audio_signal.h>
74
75 #include <ags/audio/fx/ags_fx_lfo_audio.h>
76 #include <ags/audio/fx/ags_fx_lfo_audio_processor.h>
77 #include <ags/audio/fx/ags_fx_lfo_channel.h>
78 #include <ags/audio/fx/ags_fx_lfo_channel_processor.h>
79 #include <ags/audio/fx/ags_fx_lfo_recycling.h>
80 #include <ags/audio/fx/ags_fx_lfo_audio_signal.h>
81
82 #include <ags/audio/fx/ags_fx_envelope_audio.h>
83 #include <ags/audio/fx/ags_fx_envelope_audio_processor.h>
84 #include <ags/audio/fx/ags_fx_envelope_channel.h>
85 #include <ags/audio/fx/ags_fx_envelope_channel_processor.h>
86 #include <ags/audio/fx/ags_fx_envelope_recycling.h>
87 #include <ags/audio/fx/ags_fx_envelope_audio_signal.h>
88
89 #include <ags/audio/fx/ags_fx_pattern_audio.h>
90 #include <ags/audio/fx/ags_fx_pattern_audio_processor.h>
91 #include <ags/audio/fx/ags_fx_pattern_channel.h>
92 #include <ags/audio/fx/ags_fx_pattern_channel_processor.h>
93 #include <ags/audio/fx/ags_fx_pattern_recycling.h>
94 #include <ags/audio/fx/ags_fx_pattern_audio_signal.h>
95
96 #include <ags/audio/fx/ags_fx_notation_audio.h>
97 #include <ags/audio/fx/ags_fx_notation_audio_processor.h>
98 #include <ags/audio/fx/ags_fx_notation_channel.h>
99 #include <ags/audio/fx/ags_fx_notation_channel_processor.h>
100 #include <ags/audio/fx/ags_fx_notation_recycling.h>
101 #include <ags/audio/fx/ags_fx_notation_audio_signal.h>
102
103 #include <ags/audio/fx/ags_fx_ladspa_audio.h>
104 #include <ags/audio/fx/ags_fx_ladspa_audio_processor.h>
105 #include <ags/audio/fx/ags_fx_ladspa_channel.h>
106 #include <ags/audio/fx/ags_fx_ladspa_channel_processor.h>
107 #include <ags/audio/fx/ags_fx_ladspa_recycling.h>
108 #include <ags/audio/fx/ags_fx_ladspa_audio_signal.h>
109
110 #include <ags/audio/fx/ags_fx_dssi_audio.h>
111 #include <ags/audio/fx/ags_fx_dssi_audio_processor.h>
112 #include <ags/audio/fx/ags_fx_dssi_channel.h>
113 #include <ags/audio/fx/ags_fx_dssi_channel_processor.h>
114 #include <ags/audio/fx/ags_fx_dssi_recycling.h>
115 #include <ags/audio/fx/ags_fx_dssi_audio_signal.h>
116
117 #include <ags/audio/fx/ags_fx_lv2_audio.h>
118 #include <ags/audio/fx/ags_fx_lv2_audio_processor.h>
119 #include <ags/audio/fx/ags_fx_lv2_channel.h>
120 #include <ags/audio/fx/ags_fx_lv2_channel_processor.h>
121 #include <ags/audio/fx/ags_fx_lv2_recycling.h>
122 #include <ags/audio/fx/ags_fx_lv2_audio_signal.h>
123
124 /**
125 * SECTION:ags_fx_factory
126 * @short_description: Factory pattern
127 * @title: AgsFxFactory
128 * @section_id:
129 * @include: ags/audio/ags_fx_factory.h
130 *
131 * Factory function to instantiate fx recalls.
132 */
133
134 gint ags_fx_factory_get_output_position(AgsAudio *audio,
135 gint position);
136 gint ags_fx_factory_get_input_position(AgsAudio *audio,
137 gint position);
138
139 /* declaration */
140 GList* ags_fx_factory_create_playback(AgsAudio *audio,
141 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
142 gchar *plugin_name,
143 gchar *filename,
144 gchar *effect,
145 guint start_audio_channel, guint stop_audio_channel,
146 guint start_pad, guint stop_pad,
147 gint position,
148 guint create_flags, guint recall_flags);
149
150 GList* ags_fx_factory_create_buffer(AgsAudio *audio,
151 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
152 gchar *plugin_name,
153 gchar *filename,
154 gchar *effect,
155 guint start_audio_channel, guint stop_audio_channel,
156 guint start_pad, guint stop_pad,
157 gint position,
158 guint create_flags, guint recall_flags);
159
160 GList* ags_fx_factory_create_volume(AgsAudio *audio,
161 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
162 gchar *plugin_name,
163 gchar *filename,
164 gchar *effect,
165 guint start_audio_channel, guint stop_audio_channel,
166 guint start_pad, guint stop_pad,
167 gint position,
168 guint create_flags, guint recall_flags);
169
170 GList* ags_fx_factory_create_peak(AgsAudio *audio,
171 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
172 gchar *plugin_name,
173 gchar *filename,
174 gchar *effect,
175 guint start_audio_channel, guint stop_audio_channel,
176 guint start_pad, guint stop_pad,
177 gint position,
178 guint create_flags, guint recall_flags);
179
180 GList* ags_fx_factory_create_eq10(AgsAudio *audio,
181 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
182 gchar *plugin_name,
183 gchar *filename,
184 gchar *effect,
185 guint start_audio_channel, guint stop_audio_channel,
186 guint start_pad, guint stop_pad,
187 gint position,
188 guint create_flags, guint recall_flags);
189
190 GList* ags_fx_factory_create_analyse(AgsAudio *audio,
191 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
192 gchar *plugin_name,
193 gchar *filename,
194 gchar *effect,
195 guint start_audio_channel, guint stop_audio_channel,
196 guint start_pad, guint stop_pad,
197 gint position,
198 guint create_flags, guint recall_flags);
199
200 GList* ags_fx_factory_create_two_pass_aliase(AgsAudio *audio,
201 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
202 gchar *plugin_name,
203 gchar *filename,
204 gchar *effect,
205 guint start_audio_channel, guint stop_audio_channel,
206 guint start_pad, guint stop_pad,
207 gint position,
208 guint create_flags, guint recall_flags);
209
210 GList* ags_fx_factory_create_lfo(AgsAudio *audio,
211 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
212 gchar *plugin_name,
213 gchar *filename,
214 gchar *effect,
215 guint start_audio_channel, guint stop_audio_channel,
216 guint start_pad, guint stop_pad,
217 gint position,
218 guint create_flags, guint recall_flags);
219
220 GList* ags_fx_factory_create_envelope(AgsAudio *audio,
221 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
222 gchar *plugin_name,
223 gchar *filename,
224 gchar *effect,
225 guint start_audio_channel, guint stop_audio_channel,
226 guint start_pad, guint stop_pad,
227 gint position,
228 guint create_flags, guint recall_flags);
229
230 GList* ags_fx_factory_create_pattern(AgsAudio *audio,
231 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
232 gchar *plugin_name,
233 gchar *filename,
234 gchar *effect,
235 guint start_audio_channel, guint stop_audio_channel,
236 guint start_pad, guint stop_pad,
237 gint position,
238 guint create_flags, guint recall_flags);
239
240 GList* ags_fx_factory_create_notation(AgsAudio *audio,
241 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
242 gchar *plugin_name,
243 gchar *filename,
244 gchar *effect,
245 guint start_audio_channel, guint stop_audio_channel,
246 guint start_pad, guint stop_pad,
247 gint position,
248 guint create_flags, guint recall_flags);
249
250 GList* ags_fx_factory_create_ladspa(AgsAudio *audio,
251 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
252 gchar *plugin_name,
253 gchar *filename,
254 gchar *effect,
255 guint start_audio_channel, guint stop_audio_channel,
256 guint start_pad, guint stop_pad,
257 gint position,
258 guint create_flags, guint recall_flags);
259
260 GList* ags_fx_factory_create_dssi(AgsAudio *audio,
261 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
262 gchar *plugin_name,
263 gchar *filename,
264 gchar *effect,
265 guint start_audio_channel, guint stop_audio_channel,
266 guint start_pad, guint stop_pad,
267 gint position,
268 guint create_flags, guint recall_flags);
269
270 GList* ags_fx_factory_create_lv2(AgsAudio *audio,
271 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
272 gchar *plugin_name,
273 gchar *filename,
274 gchar *effect,
275 guint start_audio_channel, guint stop_audio_channel,
276 guint start_pad, guint stop_pad,
277 gint position,
278 guint create_flags, guint recall_flags);
279
280 GType
ags_fx_factory_create_flags_get_type()281 ags_fx_factory_create_flags_get_type()
282 {
283 static volatile gsize g_flags_type_id__volatile;
284
285 if(g_once_init_enter (&g_flags_type_id__volatile)){
286 static const GFlagsValue values[] = {
287 { AGS_FX_FACTORY_OUTPUT, "AGS_FX_FACTORY_OUTPUT", "fx-factory-output" },
288 { AGS_FX_FACTORY_INPUT, "AGS_FX_FACTORY_INPUT", "fx-factory-input" },
289 { AGS_FX_FACTORY_REMAP, "AGS_FX_FACTORY_REMAP", "fx-factory-remap" },
290 { AGS_FX_FACTORY_ADD, "AGS_FX_FACTORY_ADD", "fx-factory-add" },
291 { AGS_FX_FACTORY_PLAY, "AGS_FX_FACTORY_PLAY", "fx-factory-play" },
292 { AGS_FX_FACTORY_RECALL, "AGS_FX_FACTORY_RECALL", "fx-factory-recall" },
293 { AGS_FX_FACTORY_BULK, "AGS_FX_FACTORY_BULK", "fx-factory-bulk" },
294 { AGS_FX_FACTORY_LIVE, "AGS_FX_FACTORY_LIVE", "fx-factory-live" },
295 { 0, NULL, NULL }
296 };
297
298 GType g_flags_type_id = g_flags_register_static(g_intern_static_string("AgsFxFactoryCreateFlags"), values);
299
300 g_once_init_leave (&g_flags_type_id__volatile, g_flags_type_id);
301 }
302
303 return g_flags_type_id__volatile;
304 }
305
306 gint
ags_fx_factory_get_output_position(AgsAudio * audio,gint position)307 ags_fx_factory_get_output_position(AgsAudio *audio,
308 gint position)
309 {
310 GList *start_recall, *recall;
311
312 gint output_position;
313 guint i;
314
315 if(position == -1){
316 return(-1);
317 }
318
319 recall =
320 start_recall = ags_audio_get_play(audio);
321
322 output_position = 0;
323
324 for(i = 0; i < position && recall != NULL; i++){
325 if(ags_recall_test_behaviour_flags(recall->data, AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT)){
326 output_position++;
327 }
328
329 recall = recall->next;
330 }
331
332 g_list_free_full(start_recall,
333 (GDestroyNotify) g_object_unref);
334
335 return(output_position);
336 }
337
338 gint
ags_fx_factory_get_input_position(AgsAudio * audio,gint position)339 ags_fx_factory_get_input_position(AgsAudio *audio,
340 gint position)
341 {
342 GList *start_recall, *recall;
343
344 gint input_position;
345 guint i;
346
347 if(position == -1){
348 return(-1);
349 }
350
351 recall =
352 start_recall = ags_audio_get_play(audio);
353
354 input_position = 0;
355
356 for(i = 0; i < position && recall != NULL; i++){
357 if(!ags_recall_test_behaviour_flags(recall->data, AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT)){
358 input_position++;
359 }
360
361 recall = recall->next;
362 }
363
364 g_list_free_full(start_recall,
365 (GDestroyNotify) g_object_unref);
366
367 return(input_position);
368 }
369
370 /* implementation */
371 GList*
ags_fx_factory_create_playback(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)372 ags_fx_factory_create_playback(AgsAudio *audio,
373 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
374 gchar *plugin_name,
375 gchar *filename,
376 gchar *effect,
377 guint start_audio_channel, guint stop_audio_channel,
378 guint start_pad, guint stop_pad,
379 gint position,
380 guint create_flags, guint recall_flags)
381 {
382 AgsChannel *start_input;
383 AgsChannel *channel, *next_channel;
384
385 AgsFxPlaybackAudio *fx_playback_audio;
386 AgsFxPlaybackAudioProcessor *fx_playback_audio_processor;
387 AgsFxPlaybackChannel *fx_playback_channel;
388 AgsFxPlaybackChannelProcessor *fx_playback_channel_processor;
389
390 GObject *output_soundcard;
391 GObject *input_sequencer;
392
393 GList *start_recall;
394
395 gint channel_position;
396 guint audio_channels;
397 guint i, j;
398
399 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
400 !AGS_IS_RECALL_CONTAINER(recall_container)){
401 g_warning("ags-fx-playback recall container not provided");
402
403 return(NULL);
404 }
405
406 start_recall = NULL;
407
408 g_object_get(audio,
409 "output-soundcard", &output_soundcard,
410 "input-sequencer", &input_sequencer,
411 "input", &start_input,
412 "audio-channels", &audio_channels,
413 NULL);
414
415 channel_position = 0;
416
417 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
418 channel_position = ags_fx_factory_get_output_position(audio,
419 position);
420 }else{
421 channel_position = ags_fx_factory_get_input_position(audio,
422 position);
423 }
424
425 /* audio - play context */
426 fx_playback_audio = NULL;
427 fx_playback_audio_processor = NULL;
428
429 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
430 /* AgsFxPlaybackAudio */
431 fx_playback_audio = (AgsFxPlaybackAudio *) g_object_new(AGS_TYPE_FX_PLAYBACK_AUDIO,
432 "output-soundcard", output_soundcard,
433 "audio", audio,
434 "recall-container", play_container,
435 NULL);
436 ags_recall_set_flags((AgsRecall *) fx_playback_audio,
437 (AGS_RECALL_TEMPLATE));
438 ags_recall_set_ability_flags((AgsRecall *) fx_playback_audio,
439 (AGS_SOUND_ABILITY_PLAYBACK |
440 AGS_SOUND_ABILITY_NOTATION |
441 AGS_SOUND_ABILITY_SEQUENCER |
442 AGS_SOUND_ABILITY_MIDI |
443 AGS_SOUND_ABILITY_WAVE));
444 ags_recall_set_behaviour_flags((AgsRecall *) fx_playback_audio,
445 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
446
447 ags_audio_insert_recall(audio, (GObject *) fx_playback_audio,
448 TRUE,
449 position);
450 ags_recall_container_add(play_container,
451 fx_playback_audio);
452
453 start_recall = g_list_prepend(start_recall,
454 fx_playback_audio);
455
456 ags_connectable_connect(AGS_CONNECTABLE(fx_playback_audio));
457
458 /* AgsFxPlaybackAudioProcessor */
459 fx_playback_audio_processor = (AgsFxPlaybackAudioProcessor *) g_object_new(AGS_TYPE_FX_PLAYBACK_AUDIO_PROCESSOR,
460 "output-soundcard", output_soundcard,
461 "audio", audio,
462 "recall-audio", fx_playback_audio,
463 "recall-container", play_container,
464 NULL);
465 ags_recall_set_flags((AgsRecall *) fx_playback_audio_processor,
466 (AGS_RECALL_TEMPLATE));
467 ags_recall_set_ability_flags((AgsRecall *) fx_playback_audio_processor,
468 (AGS_SOUND_ABILITY_PLAYBACK |
469 AGS_SOUND_ABILITY_NOTATION |
470 AGS_SOUND_ABILITY_SEQUENCER |
471 AGS_SOUND_ABILITY_MIDI |
472 AGS_SOUND_ABILITY_WAVE));
473 ags_recall_set_behaviour_flags((AgsRecall *) fx_playback_audio_processor,
474 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
475
476 ags_audio_insert_recall(audio, (GObject *) fx_playback_audio_processor,
477 TRUE,
478 position);
479 ags_recall_container_add(play_container,
480 fx_playback_audio_processor);
481
482 start_recall = g_list_prepend(start_recall,
483 fx_playback_audio_processor);
484
485 ags_connectable_connect(AGS_CONNECTABLE(fx_playback_audio_processor));
486 }else{
487 GList *start_recall_audio_run, *recall_audio_run;
488
489 fx_playback_audio = ags_recall_container_get_recall_audio(play_container);
490
491 if(fx_playback_audio != NULL){
492 g_object_ref(fx_playback_audio);
493 }
494
495 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
496
497 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
498 fx_playback_audio_processor = recall_audio_run->data;
499 g_object_ref(fx_playback_audio_processor);
500 }
501 }
502
503 for(i = 0; i < stop_pad - start_pad; i++){
504 channel = ags_channel_pad_nth(start_input,
505 start_pad + i);
506
507 next_channel = ags_channel_nth(channel,
508 start_audio_channel);
509
510 if(channel != NULL){
511 g_object_unref(channel);
512 }
513
514 channel = next_channel;
515
516 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
517 /* add recall container */
518 ags_channel_add_recall_container(channel,
519 (GObject *) play_container);
520
521 /* AgsFxPlaybackChannel */
522 fx_playback_channel = (AgsFxPlaybackChannel *) g_object_new(AGS_TYPE_FX_PLAYBACK_CHANNEL,
523 "output-soundcard", output_soundcard,
524 "source", channel,
525 "recall-audio", fx_playback_audio,
526 "recall-container", play_container,
527 NULL);
528 ags_recall_set_flags((AgsRecall *) fx_playback_channel,
529 (AGS_RECALL_TEMPLATE));
530 ags_recall_set_ability_flags((AgsRecall *) fx_playback_channel,
531 (AGS_SOUND_ABILITY_PLAYBACK |
532 AGS_SOUND_ABILITY_NOTATION |
533 AGS_SOUND_ABILITY_SEQUENCER |
534 AGS_SOUND_ABILITY_MIDI |
535 AGS_SOUND_ABILITY_WAVE));
536 ags_recall_set_behaviour_flags((AgsRecall *) fx_playback_channel,
537 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
538
539 ags_channel_insert_recall(channel, (GObject *) fx_playback_channel,
540 TRUE,
541 channel_position);
542 ags_recall_container_add(play_container,
543 fx_playback_channel);
544
545 start_recall = g_list_prepend(start_recall,
546 fx_playback_channel);
547
548 ags_connectable_connect(AGS_CONNECTABLE(fx_playback_channel));
549
550 /* AgsFxPlaybackChannelProcessor */
551 fx_playback_channel_processor = (AgsFxPlaybackChannelProcessor *) g_object_new(AGS_TYPE_FX_PLAYBACK_CHANNEL_PROCESSOR,
552 "output-soundcard", output_soundcard,
553 "source", channel,
554 "recall-audio", fx_playback_audio,
555 "recall-audio-run", fx_playback_audio_processor,
556 "recall-channel", fx_playback_channel,
557 "recall-container", play_container,
558 NULL);
559 ags_recall_set_flags((AgsRecall *) fx_playback_channel_processor,
560 (AGS_RECALL_TEMPLATE));
561 ags_recall_set_ability_flags((AgsRecall *) fx_playback_channel_processor,
562 (AGS_SOUND_ABILITY_PLAYBACK |
563 AGS_SOUND_ABILITY_NOTATION |
564 AGS_SOUND_ABILITY_SEQUENCER |
565 AGS_SOUND_ABILITY_MIDI |
566 AGS_SOUND_ABILITY_WAVE));
567 ags_recall_set_behaviour_flags((AgsRecall *) fx_playback_channel_processor,
568 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
569
570 ags_channel_insert_recall(channel, (GObject *) fx_playback_channel_processor,
571 TRUE,
572 channel_position);
573 ags_recall_container_add(play_container,
574 fx_playback_channel_processor);
575
576 start_recall = g_list_prepend(start_recall,
577 fx_playback_channel_processor);
578
579 ags_connectable_connect(AGS_CONNECTABLE(fx_playback_channel_processor));
580
581 /* iterate */
582 next_channel = ags_channel_next(channel);
583
584 g_object_unref(channel);
585
586 channel = next_channel;
587 }
588
589 if(channel != NULL){
590 g_object_unref(channel);
591 }
592 }
593
594 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
595 if(fx_playback_audio != NULL){
596 g_object_unref(fx_playback_audio);
597 }
598
599 if(fx_playback_audio_processor != NULL){
600 g_object_unref(fx_playback_audio_processor);
601 }
602 }
603
604 /* audio - recall context */
605 fx_playback_audio = NULL;
606 fx_playback_audio_processor = NULL;
607
608 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
609 /* AgsFxPlaybackAudio */
610 fx_playback_audio = (AgsFxPlaybackAudio *) g_object_new(AGS_TYPE_FX_PLAYBACK_AUDIO,
611 "output-soundcard", output_soundcard,
612 "audio", audio,
613 "recall-container", recall_container,
614 NULL);
615 ags_recall_set_flags((AgsRecall *) fx_playback_audio,
616 (AGS_RECALL_TEMPLATE));
617 ags_recall_set_ability_flags((AgsRecall *) fx_playback_audio,
618 (AGS_SOUND_ABILITY_PLAYBACK |
619 AGS_SOUND_ABILITY_SEQUENCER |
620 AGS_SOUND_ABILITY_NOTATION |
621 AGS_SOUND_ABILITY_WAVE |
622 AGS_SOUND_ABILITY_MIDI));
623 ags_recall_set_behaviour_flags((AgsRecall *) fx_playback_audio,
624 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
625
626 ags_audio_insert_recall(audio, (GObject *) fx_playback_audio,
627 FALSE,
628 position);
629 ags_recall_container_add(recall_container,
630 fx_playback_audio);
631
632 start_recall = g_list_prepend(start_recall,
633 fx_playback_audio);
634
635 ags_connectable_connect(AGS_CONNECTABLE(fx_playback_audio));
636
637 /* AgsFxPlaybackAudioProcessor */
638 fx_playback_audio_processor = (AgsFxPlaybackAudioProcessor *) g_object_new(AGS_TYPE_FX_PLAYBACK_AUDIO_PROCESSOR,
639 "output-soundcard", output_soundcard,
640 "audio", audio,
641 "recall-audio", fx_playback_audio,
642 "recall-container", recall_container,
643 NULL);
644 ags_recall_set_flags((AgsRecall *) fx_playback_audio_processor,
645 (AGS_RECALL_TEMPLATE));
646 ags_recall_set_ability_flags((AgsRecall *) fx_playback_audio_processor,
647 (AGS_SOUND_ABILITY_PLAYBACK |
648 AGS_SOUND_ABILITY_SEQUENCER |
649 AGS_SOUND_ABILITY_NOTATION |
650 AGS_SOUND_ABILITY_WAVE |
651 AGS_SOUND_ABILITY_MIDI));
652 ags_recall_set_behaviour_flags((AgsRecall *) fx_playback_audio_processor,
653 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
654
655 ags_audio_insert_recall(audio, (GObject *) fx_playback_audio_processor,
656 FALSE,
657 position);
658 ags_recall_container_add(recall_container,
659 fx_playback_audio_processor);
660
661 start_recall = g_list_prepend(start_recall,
662 fx_playback_audio_processor);
663
664 ags_connectable_connect(AGS_CONNECTABLE(fx_playback_audio_processor));
665 }else{
666 GList *start_recall_audio_run, *recall_audio_run;
667
668 fx_playback_audio = ags_recall_container_get_recall_audio(recall_container);
669
670 if(fx_playback_audio != NULL){
671 g_object_ref(fx_playback_audio);
672 }
673
674 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
675
676 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
677 fx_playback_audio_processor = recall_audio_run->data;
678 g_object_ref(fx_playback_audio_processor);
679 }
680 }
681
682 /* channel - recall context */
683 for(i = 0; i < stop_pad - start_pad; i++){
684 channel = ags_channel_pad_nth(start_input,
685 start_pad + i);
686
687 next_channel = ags_channel_nth(channel,
688 start_audio_channel);
689
690 if(channel != NULL){
691 g_object_unref(channel);
692 }
693
694 channel = next_channel;
695
696 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
697 /* AgsFxPlaybackChannel */
698 fx_playback_channel = (AgsFxPlaybackChannel *) g_object_new(AGS_TYPE_FX_PLAYBACK_CHANNEL,
699 "output-soundcard", output_soundcard,
700 "source", channel,
701 "recall-audio", fx_playback_audio,
702 "recall-container", recall_container,
703 NULL);
704 ags_recall_set_flags((AgsRecall *) fx_playback_channel,
705 (AGS_RECALL_TEMPLATE));
706 ags_recall_set_ability_flags((AgsRecall *) fx_playback_channel,
707 (AGS_SOUND_ABILITY_PLAYBACK |
708 AGS_SOUND_ABILITY_SEQUENCER |
709 AGS_SOUND_ABILITY_NOTATION |
710 AGS_SOUND_ABILITY_WAVE |
711 AGS_SOUND_ABILITY_MIDI));
712 ags_recall_set_behaviour_flags((AgsRecall *) fx_playback_channel,
713 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
714
715 ags_channel_insert_recall(channel, (GObject *) fx_playback_channel,
716 FALSE,
717 channel_position);
718 ags_recall_container_add(recall_container,
719 fx_playback_channel);
720
721 start_recall = g_list_prepend(start_recall,
722 fx_playback_channel);
723
724 ags_connectable_connect(AGS_CONNECTABLE(fx_playback_channel));
725
726 /* AgsFxPlaybackChannelProcessor */
727 fx_playback_channel_processor = (AgsFxPlaybackChannelProcessor *) g_object_new(AGS_TYPE_FX_PLAYBACK_CHANNEL_PROCESSOR,
728 "output-soundcard", output_soundcard,
729 "source", channel,
730 "recall-audio", fx_playback_audio,
731 "recall-audio-run", fx_playback_audio_processor,
732 "recall-channel", fx_playback_channel,
733 "recall-container", recall_container,
734 NULL);
735 ags_recall_set_flags((AgsRecall *) fx_playback_channel_processor,
736 (AGS_RECALL_TEMPLATE));
737 ags_recall_set_ability_flags((AgsRecall *) fx_playback_channel_processor,
738 (AGS_SOUND_ABILITY_PLAYBACK |
739 AGS_SOUND_ABILITY_SEQUENCER |
740 AGS_SOUND_ABILITY_NOTATION |
741 AGS_SOUND_ABILITY_WAVE |
742 AGS_SOUND_ABILITY_MIDI));
743 ags_recall_set_behaviour_flags((AgsRecall *) fx_playback_channel_processor,
744 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
745
746 ags_channel_insert_recall(channel, (GObject *) fx_playback_channel_processor,
747 FALSE,
748 channel_position);
749 ags_recall_container_add(recall_container,
750 fx_playback_channel_processor);
751
752 start_recall = g_list_prepend(start_recall,
753 fx_playback_channel_processor);
754
755 ags_connectable_connect(AGS_CONNECTABLE(fx_playback_channel_processor));
756
757 /* iterate */
758 next_channel = ags_channel_next(channel);
759
760 g_object_unref(channel);
761
762 channel = next_channel;
763 }
764
765 if(channel != NULL){
766 g_object_unref(channel);
767 }
768 }
769
770 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
771 if(fx_playback_audio != NULL){
772 g_object_unref(fx_playback_audio);
773 }
774
775 if(fx_playback_audio_processor != NULL){
776 g_object_unref(fx_playback_audio_processor);
777 }
778 }
779
780 if(output_soundcard != NULL){
781 g_object_unref(output_soundcard);
782 }
783
784 if(input_sequencer != NULL){
785 g_object_unref(input_sequencer);
786 }
787
788 if(start_input != NULL){
789 g_object_unref(start_input);
790 }
791
792 return(start_recall);
793 }
794
795 GList*
ags_fx_factory_create_buffer(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)796 ags_fx_factory_create_buffer(AgsAudio *audio,
797 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
798 gchar *plugin_name,
799 gchar *filename,
800 gchar *effect,
801 guint start_audio_channel, guint stop_audio_channel,
802 guint start_pad, guint stop_pad,
803 gint position,
804 guint create_flags, guint recall_flags)
805 {
806 AgsChannel *start_input;
807 AgsChannel *channel, *next_channel;
808
809 AgsFxBufferAudio *fx_buffer_audio;
810 AgsFxBufferAudioProcessor *fx_buffer_audio_processor;
811 AgsFxBufferChannel *fx_buffer_channel;
812 AgsFxBufferChannelProcessor *fx_buffer_channel_processor;
813
814 GObject *output_soundcard;
815 GObject *input_sequencer;
816
817 GList *start_recall;
818
819 gint channel_position;
820 guint audio_channels;
821 guint i, j;
822
823 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
824 !AGS_IS_RECALL_CONTAINER(recall_container)){
825 g_warning("ags-fx-buffer recall container not provided");
826
827 return(NULL);
828 }
829
830 start_recall = NULL;
831
832 g_object_get(audio,
833 "output-soundcard", &output_soundcard,
834 "input-sequencer", &input_sequencer,
835 "input", &start_input,
836 "audio-channels", &audio_channels,
837 NULL);
838
839 channel_position = 0;
840
841 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
842 channel_position = ags_fx_factory_get_output_position(audio,
843 position);
844 }else{
845 channel_position = ags_fx_factory_get_input_position(audio,
846 position);
847 }
848
849 /* audio - play context */
850 fx_buffer_audio = NULL;
851 fx_buffer_audio_processor = NULL;
852
853 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
854 /* AgsFxBufferAudio */
855 fx_buffer_audio = (AgsFxBufferAudio *) g_object_new(AGS_TYPE_FX_BUFFER_AUDIO,
856 "output-soundcard", output_soundcard,
857 "audio", audio,
858 "recall-container", play_container,
859 NULL);
860 ags_recall_set_flags((AgsRecall *) fx_buffer_audio,
861 (AGS_RECALL_TEMPLATE));
862 ags_recall_set_ability_flags((AgsRecall *) fx_buffer_audio,
863 0);
864 ags_recall_set_behaviour_flags((AgsRecall *) fx_buffer_audio,
865 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
866
867 ags_audio_insert_recall(audio, (GObject *) fx_buffer_audio,
868 TRUE,
869 position);
870 ags_recall_container_add(play_container,
871 fx_buffer_audio);
872
873 start_recall = g_list_prepend(start_recall,
874 fx_buffer_audio);
875
876 ags_connectable_connect(AGS_CONNECTABLE(fx_buffer_audio));
877
878 /* AgsFxBufferAudioProcessor */
879 fx_buffer_audio_processor = (AgsFxBufferAudioProcessor *) g_object_new(AGS_TYPE_FX_BUFFER_AUDIO_PROCESSOR,
880 "output-soundcard", output_soundcard,
881 "audio", audio,
882 "recall-audio", fx_buffer_audio,
883 "recall-container", play_container,
884 NULL);
885 ags_recall_set_flags((AgsRecall *) fx_buffer_audio_processor,
886 (AGS_RECALL_TEMPLATE));
887 ags_recall_set_ability_flags((AgsRecall *) fx_buffer_audio_processor,
888 0);
889 ags_recall_set_behaviour_flags((AgsRecall *) fx_buffer_audio_processor,
890 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
891
892 ags_audio_insert_recall(audio, (GObject *) fx_buffer_audio_processor,
893 TRUE,
894 position);
895 ags_recall_container_add(play_container,
896 fx_buffer_audio_processor);
897
898 start_recall = g_list_prepend(start_recall,
899 fx_buffer_audio_processor);
900
901 ags_connectable_connect(AGS_CONNECTABLE(fx_buffer_audio_processor));
902 }else{
903 GList *start_recall_audio_run, *recall_audio_run;
904
905 fx_buffer_audio = ags_recall_container_get_recall_audio(play_container);
906
907 if(fx_buffer_audio != NULL){
908 g_object_ref(fx_buffer_audio);
909 }
910
911 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
912
913 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
914 fx_buffer_audio_processor = recall_audio_run->data;
915 g_object_ref(fx_buffer_audio_processor);
916 }
917 }
918
919 for(i = 0; i < stop_pad - start_pad; i++){
920 channel = ags_channel_pad_nth(start_input,
921 start_pad + i);
922
923 next_channel = ags_channel_nth(channel,
924 start_audio_channel);
925
926 if(channel != NULL){
927 g_object_unref(channel);
928 }
929
930 channel = next_channel;
931
932 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
933 /* add recall container */
934 ags_channel_add_recall_container(channel,
935 (GObject *) play_container);
936
937 /* AgsFxBufferChannel */
938 fx_buffer_channel = (AgsFxBufferChannel *) g_object_new(AGS_TYPE_FX_BUFFER_CHANNEL,
939 "output-soundcard", output_soundcard,
940 "source", channel,
941 "recall-audio", fx_buffer_audio,
942 "recall-container", play_container,
943 NULL);
944 ags_recall_set_flags((AgsRecall *) fx_buffer_channel,
945 (AGS_RECALL_TEMPLATE));
946 ags_recall_set_ability_flags((AgsRecall *) fx_buffer_channel,
947 0);
948 ags_recall_set_behaviour_flags((AgsRecall *) fx_buffer_channel,
949 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
950
951 ags_channel_insert_recall(channel, (GObject *) fx_buffer_channel,
952 TRUE,
953 channel_position);
954 ags_recall_container_add(play_container,
955 fx_buffer_channel);
956
957 start_recall = g_list_prepend(start_recall,
958 fx_buffer_channel);
959
960 ags_connectable_connect(AGS_CONNECTABLE(fx_buffer_channel));
961
962 /* AgsFxBufferChannelProcessor */
963 fx_buffer_channel_processor = (AgsFxBufferChannelProcessor *) g_object_new(AGS_TYPE_FX_BUFFER_CHANNEL_PROCESSOR,
964 "output-soundcard", output_soundcard,
965 "source", channel,
966 "recall-audio", fx_buffer_audio,
967 "recall-audio-run", fx_buffer_audio_processor,
968 "recall-channel", fx_buffer_channel,
969 "recall-container", play_container,
970 NULL);
971 ags_recall_set_flags((AgsRecall *) fx_buffer_channel_processor,
972 (AGS_RECALL_TEMPLATE));
973 ags_recall_set_ability_flags((AgsRecall *) fx_buffer_channel_processor,
974 0);
975 ags_recall_set_behaviour_flags((AgsRecall *) fx_buffer_channel_processor,
976 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
977
978 ags_channel_insert_recall(channel, (GObject *) fx_buffer_channel_processor,
979 TRUE,
980 channel_position);
981 ags_recall_container_add(play_container,
982 fx_buffer_channel_processor);
983
984 start_recall = g_list_prepend(start_recall,
985 fx_buffer_channel_processor);
986
987 ags_connectable_connect(AGS_CONNECTABLE(fx_buffer_channel_processor));
988
989 /* iterate */
990 next_channel = ags_channel_next(channel);
991
992 g_object_unref(channel);
993
994 channel = next_channel;
995 }
996
997 if(channel != NULL){
998 g_object_unref(channel);
999 }
1000 }
1001
1002 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
1003 if(fx_buffer_audio != NULL){
1004 g_object_unref(fx_buffer_audio);
1005 }
1006
1007 if(fx_buffer_audio_processor != NULL){
1008 g_object_unref(fx_buffer_audio_processor);
1009 }
1010 }
1011
1012 /* audio - recall context */
1013 fx_buffer_audio = NULL;
1014 fx_buffer_audio_processor = NULL;
1015
1016 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
1017 /* AgsFxBufferAudio */
1018 fx_buffer_audio = (AgsFxBufferAudio *) g_object_new(AGS_TYPE_FX_BUFFER_AUDIO,
1019 "output-soundcard", output_soundcard,
1020 "audio", audio,
1021 "recall-container", recall_container,
1022 NULL);
1023 ags_recall_set_flags((AgsRecall *) fx_buffer_audio,
1024 (AGS_RECALL_TEMPLATE));
1025 ags_recall_set_ability_flags((AgsRecall *) fx_buffer_audio,
1026 (AGS_SOUND_ABILITY_PLAYBACK |
1027 AGS_SOUND_ABILITY_NOTATION |
1028 AGS_SOUND_ABILITY_SEQUENCER |
1029 AGS_SOUND_ABILITY_MIDI |
1030 AGS_SOUND_ABILITY_WAVE));
1031 ags_recall_set_behaviour_flags((AgsRecall *) fx_buffer_audio,
1032 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1033
1034 ags_audio_insert_recall(audio, (GObject *) fx_buffer_audio,
1035 FALSE,
1036 position);
1037 ags_recall_container_add(recall_container,
1038 fx_buffer_audio);
1039
1040 start_recall = g_list_prepend(start_recall,
1041 fx_buffer_audio);
1042
1043 ags_connectable_connect(AGS_CONNECTABLE(fx_buffer_audio));
1044
1045 /* AgsFxBufferAudioProcessor */
1046 fx_buffer_audio_processor = (AgsFxBufferAudioProcessor *) g_object_new(AGS_TYPE_FX_BUFFER_AUDIO_PROCESSOR,
1047 "output-soundcard", output_soundcard,
1048 "audio", audio,
1049 "recall-audio", fx_buffer_audio,
1050 "recall-container", recall_container,
1051 NULL);
1052 ags_recall_set_flags((AgsRecall *) fx_buffer_audio_processor,
1053 (AGS_RECALL_TEMPLATE));
1054 ags_recall_set_ability_flags((AgsRecall *) fx_buffer_audio_processor,
1055 (AGS_SOUND_ABILITY_PLAYBACK |
1056 AGS_SOUND_ABILITY_NOTATION |
1057 AGS_SOUND_ABILITY_SEQUENCER |
1058 AGS_SOUND_ABILITY_MIDI |
1059 AGS_SOUND_ABILITY_WAVE));
1060 ags_recall_set_behaviour_flags((AgsRecall *) fx_buffer_audio_processor,
1061 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1062
1063 ags_audio_insert_recall(audio, (GObject *) fx_buffer_audio_processor,
1064 FALSE,
1065 position);
1066 ags_recall_container_add(recall_container,
1067 fx_buffer_audio_processor);
1068
1069 start_recall = g_list_prepend(start_recall,
1070 fx_buffer_audio_processor);
1071
1072 ags_connectable_connect(AGS_CONNECTABLE(fx_buffer_audio_processor));
1073 }else{
1074 GList *start_recall_audio_run, *recall_audio_run;
1075
1076 fx_buffer_audio = ags_recall_container_get_recall_audio(recall_container);
1077
1078 if(fx_buffer_audio != NULL){
1079 g_object_ref(fx_buffer_audio);
1080 }
1081
1082 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
1083
1084 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
1085 fx_buffer_audio_processor = recall_audio_run->data;
1086 g_object_ref(fx_buffer_audio_processor);
1087 }
1088 }
1089
1090 for(i = 0; i < stop_pad - start_pad; i++){
1091 channel = ags_channel_pad_nth(start_input,
1092 start_pad + i);
1093
1094 next_channel = ags_channel_nth(channel,
1095 start_audio_channel);
1096
1097 if(channel != NULL){
1098 g_object_unref(channel);
1099 }
1100
1101 channel = next_channel;
1102
1103 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
1104 /* add recall container */
1105 ags_channel_add_recall_container(channel,
1106 (GObject *) recall_container);
1107
1108 /* AgsFxBufferChannel */
1109 fx_buffer_channel = (AgsFxBufferChannel *) g_object_new(AGS_TYPE_FX_BUFFER_CHANNEL,
1110 "output-soundcard", output_soundcard,
1111 "source", channel,
1112 "recall-audio", fx_buffer_audio,
1113 "recall-container", recall_container,
1114 NULL);
1115 ags_recall_set_flags((AgsRecall *) fx_buffer_channel,
1116 (AGS_RECALL_TEMPLATE));
1117 ags_recall_set_ability_flags((AgsRecall *) fx_buffer_channel,
1118 (AGS_SOUND_ABILITY_PLAYBACK |
1119 AGS_SOUND_ABILITY_NOTATION |
1120 AGS_SOUND_ABILITY_SEQUENCER |
1121 AGS_SOUND_ABILITY_MIDI |
1122 AGS_SOUND_ABILITY_WAVE));
1123 ags_recall_set_behaviour_flags((AgsRecall *) fx_buffer_channel,
1124 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1125
1126 ags_channel_insert_recall(channel, (GObject *) fx_buffer_channel,
1127 FALSE,
1128 channel_position);
1129 ags_recall_container_add(recall_container,
1130 fx_buffer_channel);
1131
1132 start_recall = g_list_prepend(start_recall,
1133 fx_buffer_channel);
1134
1135 ags_connectable_connect(AGS_CONNECTABLE(fx_buffer_channel));
1136
1137 /* AgsFxBufferChannelProcessor */
1138 fx_buffer_channel_processor = (AgsFxBufferChannelProcessor *) g_object_new(AGS_TYPE_FX_BUFFER_CHANNEL_PROCESSOR,
1139 "output-soundcard", output_soundcard,
1140 "source", channel,
1141 "recall-audio", fx_buffer_audio,
1142 "recall-audio-run", fx_buffer_audio_processor,
1143 "recall-channel", fx_buffer_channel,
1144 "recall-container", recall_container,
1145 NULL);
1146 ags_recall_set_flags((AgsRecall *) fx_buffer_channel_processor,
1147 (AGS_RECALL_TEMPLATE));
1148 ags_recall_set_ability_flags((AgsRecall *) fx_buffer_channel_processor,
1149 (AGS_SOUND_ABILITY_PLAYBACK |
1150 AGS_SOUND_ABILITY_NOTATION |
1151 AGS_SOUND_ABILITY_SEQUENCER |
1152 AGS_SOUND_ABILITY_MIDI |
1153 AGS_SOUND_ABILITY_WAVE));
1154 ags_recall_set_behaviour_flags((AgsRecall *) fx_buffer_channel_processor,
1155 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1156
1157 ags_channel_insert_recall(channel, (GObject *) fx_buffer_channel_processor,
1158 FALSE,
1159 channel_position);
1160 ags_recall_container_add(recall_container,
1161 fx_buffer_channel_processor);
1162
1163 start_recall = g_list_prepend(start_recall,
1164 fx_buffer_channel_processor);
1165
1166 ags_connectable_connect(AGS_CONNECTABLE(fx_buffer_channel_processor));
1167
1168 /* iterate */
1169 next_channel = ags_channel_next(channel);
1170
1171 g_object_unref(channel);
1172
1173 channel = next_channel;
1174 }
1175
1176 if(channel != NULL){
1177 g_object_unref(channel);
1178 }
1179 }
1180
1181 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
1182 if(fx_buffer_audio != NULL){
1183 g_object_unref(fx_buffer_audio);
1184 }
1185
1186 if(fx_buffer_audio_processor != NULL){
1187 g_object_unref(fx_buffer_audio_processor);
1188 }
1189 }
1190
1191 if(output_soundcard != NULL){
1192 g_object_unref(output_soundcard);
1193 }
1194
1195 if(input_sequencer != NULL){
1196 g_object_unref(input_sequencer);
1197 }
1198
1199 if(start_input != NULL){
1200 g_object_unref(start_input);
1201 }
1202
1203 return(start_recall);
1204 }
1205
1206 GList*
ags_fx_factory_create_volume(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)1207 ags_fx_factory_create_volume(AgsAudio *audio,
1208 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
1209 gchar *plugin_name,
1210 gchar *filename,
1211 gchar *effect,
1212 guint start_audio_channel, guint stop_audio_channel,
1213 guint start_pad, guint stop_pad,
1214 gint position,
1215 guint create_flags, guint recall_flags)
1216 {
1217 AgsChannel *start_input;
1218 AgsChannel *channel, *next_channel;
1219
1220 AgsFxVolumeAudio *fx_volume_audio;
1221 AgsFxVolumeAudioProcessor *fx_volume_audio_processor;
1222 AgsFxVolumeChannel *fx_volume_channel;
1223 AgsFxVolumeChannelProcessor *fx_volume_channel_processor;
1224
1225 GObject *output_soundcard;
1226 GObject *input_sequencer;
1227
1228 GList *start_recall;
1229
1230 gint channel_position;
1231 guint audio_channels;
1232 guint i, j;
1233
1234 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
1235 !AGS_IS_RECALL_CONTAINER(recall_container)){
1236 g_warning("ags-fx-volume recall container not provided");
1237
1238 return(NULL);
1239 }
1240
1241 start_recall = NULL;
1242
1243 g_object_get(audio,
1244 "output-soundcard", &output_soundcard,
1245 "input-sequencer", &input_sequencer,
1246 "input", &start_input,
1247 "audio-channels", &audio_channels,
1248 NULL);
1249
1250 channel_position = 0;
1251
1252 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
1253 channel_position = ags_fx_factory_get_output_position(audio,
1254 position);
1255 }else{
1256 channel_position = ags_fx_factory_get_input_position(audio,
1257 position);
1258 }
1259
1260 /* audio - play context */
1261 fx_volume_audio = NULL;
1262 fx_volume_audio_processor = NULL;
1263
1264 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
1265 /* AgsFxVolumeAudio */
1266 fx_volume_audio = (AgsFxVolumeAudio *) g_object_new(AGS_TYPE_FX_VOLUME_AUDIO,
1267 "output-soundcard", output_soundcard,
1268 "audio", audio,
1269 "recall-container", play_container,
1270 NULL);
1271 ags_recall_set_flags((AgsRecall *) fx_volume_audio,
1272 (AGS_RECALL_TEMPLATE));
1273 ags_recall_set_ability_flags((AgsRecall *) fx_volume_audio,
1274 (AGS_SOUND_ABILITY_PLAYBACK |
1275 AGS_SOUND_ABILITY_SEQUENCER |
1276 AGS_SOUND_ABILITY_NOTATION |
1277 AGS_SOUND_ABILITY_WAVE |
1278 AGS_SOUND_ABILITY_MIDI));
1279 ags_recall_set_behaviour_flags((AgsRecall *) fx_volume_audio,
1280 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1281
1282 ags_audio_insert_recall(audio, (GObject *) fx_volume_audio,
1283 TRUE,
1284 position);
1285 ags_recall_container_add(play_container,
1286 fx_volume_audio);
1287
1288 start_recall = g_list_prepend(start_recall,
1289 fx_volume_audio);
1290
1291 ags_connectable_connect(AGS_CONNECTABLE(fx_volume_audio));
1292
1293 /* AgsFxVolumeAudioProcessor */
1294 fx_volume_audio_processor = (AgsFxVolumeAudioProcessor *) g_object_new(AGS_TYPE_FX_VOLUME_AUDIO_PROCESSOR,
1295 "output-soundcard", output_soundcard,
1296 "audio", audio,
1297 "recall-audio", fx_volume_audio,
1298 "recall-container", play_container,
1299 NULL);
1300 ags_recall_set_flags((AgsRecall *) fx_volume_audio_processor,
1301 (AGS_RECALL_TEMPLATE));
1302 ags_recall_set_ability_flags((AgsRecall *) fx_volume_audio_processor,
1303 (AGS_SOUND_ABILITY_PLAYBACK |
1304 AGS_SOUND_ABILITY_SEQUENCER |
1305 AGS_SOUND_ABILITY_NOTATION |
1306 AGS_SOUND_ABILITY_WAVE |
1307 AGS_SOUND_ABILITY_MIDI));
1308 ags_recall_set_behaviour_flags((AgsRecall *) fx_volume_audio_processor,
1309 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1310
1311 ags_audio_insert_recall(audio, (GObject *) fx_volume_audio_processor,
1312 TRUE,
1313 position);
1314 ags_recall_container_add(play_container,
1315 fx_volume_audio_processor);
1316
1317 start_recall = g_list_prepend(start_recall,
1318 fx_volume_audio_processor);
1319
1320 ags_connectable_connect(AGS_CONNECTABLE(fx_volume_audio_processor));
1321 }else{
1322 GList *start_recall_audio_run, *recall_audio_run;
1323
1324 fx_volume_audio = ags_recall_container_get_recall_audio(play_container);
1325
1326 if(fx_volume_audio != NULL){
1327 g_object_ref(fx_volume_audio);
1328 }
1329
1330 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
1331
1332 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
1333 fx_volume_audio_processor = recall_audio_run->data;
1334 g_object_ref(fx_volume_audio_processor);
1335 }
1336 }
1337
1338 /* channel - play context */
1339 for(i = 0; i < stop_pad - start_pad; i++){
1340 channel = ags_channel_pad_nth(start_input,
1341 start_pad + i);
1342
1343 next_channel = ags_channel_nth(channel,
1344 start_audio_channel);
1345
1346 if(channel != NULL){
1347 g_object_unref(channel);
1348 }
1349
1350 channel = next_channel;
1351
1352 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
1353 /* AgsFxVolumeChannel */
1354 fx_volume_channel = (AgsFxVolumeChannel *) g_object_new(AGS_TYPE_FX_VOLUME_CHANNEL,
1355 "output-soundcard", output_soundcard,
1356 "source", channel,
1357 "recall-audio", fx_volume_audio,
1358 "recall-container", play_container,
1359 NULL);
1360 ags_recall_set_flags((AgsRecall *) fx_volume_channel,
1361 (AGS_RECALL_TEMPLATE));
1362 ags_recall_set_ability_flags((AgsRecall *) fx_volume_channel,
1363 (AGS_SOUND_ABILITY_PLAYBACK |
1364 AGS_SOUND_ABILITY_SEQUENCER |
1365 AGS_SOUND_ABILITY_NOTATION |
1366 AGS_SOUND_ABILITY_WAVE |
1367 AGS_SOUND_ABILITY_MIDI));
1368 ags_recall_set_behaviour_flags((AgsRecall *) fx_volume_channel,
1369 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1370
1371 ags_channel_insert_recall(channel, (GObject *) fx_volume_channel,
1372 TRUE,
1373 channel_position);
1374 ags_recall_container_add(play_container,
1375 fx_volume_channel);
1376
1377 start_recall = g_list_prepend(start_recall,
1378 fx_volume_channel);
1379
1380 ags_connectable_connect(AGS_CONNECTABLE(fx_volume_channel));
1381
1382 /* AgsFxVolumeChannelProcessor */
1383 fx_volume_channel_processor = (AgsFxVolumeChannelProcessor *) g_object_new(AGS_TYPE_FX_VOLUME_CHANNEL_PROCESSOR,
1384 "output-soundcard", output_soundcard,
1385 "source", channel,
1386 "recall-audio", fx_volume_audio,
1387 "recall-audio-run", fx_volume_audio_processor,
1388 "recall-channel", fx_volume_channel,
1389 "recall-container", play_container,
1390 NULL);
1391 ags_recall_set_flags((AgsRecall *) fx_volume_channel_processor,
1392 (AGS_RECALL_TEMPLATE));
1393 ags_recall_set_ability_flags((AgsRecall *) fx_volume_channel_processor,
1394 (AGS_SOUND_ABILITY_PLAYBACK |
1395 AGS_SOUND_ABILITY_SEQUENCER |
1396 AGS_SOUND_ABILITY_NOTATION |
1397 AGS_SOUND_ABILITY_WAVE |
1398 AGS_SOUND_ABILITY_MIDI));
1399 ags_recall_set_behaviour_flags((AgsRecall *) fx_volume_channel_processor,
1400 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1401
1402 ags_channel_insert_recall(channel, (GObject *) fx_volume_channel_processor,
1403 TRUE,
1404 channel_position);
1405 ags_recall_container_add(play_container,
1406 fx_volume_channel_processor);
1407
1408 start_recall = g_list_prepend(start_recall,
1409 fx_volume_channel_processor);
1410
1411 ags_connectable_connect(AGS_CONNECTABLE(fx_volume_channel_processor));
1412
1413 /* iterate */
1414 next_channel = ags_channel_next(channel);
1415
1416 g_object_unref(channel);
1417
1418 channel = next_channel;
1419 }
1420
1421 if(channel != NULL){
1422 g_object_unref(channel);
1423 }
1424 }
1425
1426 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
1427 if(fx_volume_audio != NULL){
1428 g_object_unref(fx_volume_audio);
1429 }
1430
1431 if(fx_volume_audio_processor != NULL){
1432 g_object_unref(fx_volume_audio_processor);
1433 }
1434 }
1435
1436 /* audio - recall context */
1437 fx_volume_audio = NULL;
1438 fx_volume_audio_processor = NULL;
1439
1440 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
1441 /* AgsFxVolumeAudio */
1442 fx_volume_audio = (AgsFxVolumeAudio *) g_object_new(AGS_TYPE_FX_VOLUME_AUDIO,
1443 "output-soundcard", output_soundcard,
1444 "audio", audio,
1445 "recall-container", play_container,
1446 NULL);
1447 ags_recall_set_flags((AgsRecall *) fx_volume_audio,
1448 (AGS_RECALL_TEMPLATE));
1449 ags_recall_set_ability_flags((AgsRecall *) fx_volume_audio,
1450 (AGS_SOUND_ABILITY_PLAYBACK |
1451 AGS_SOUND_ABILITY_SEQUENCER |
1452 AGS_SOUND_ABILITY_NOTATION |
1453 AGS_SOUND_ABILITY_WAVE |
1454 AGS_SOUND_ABILITY_MIDI));
1455 ags_recall_set_behaviour_flags((AgsRecall *) fx_volume_audio,
1456 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1457
1458 ags_audio_insert_recall(audio, (GObject *) fx_volume_audio,
1459 FALSE,
1460 position);
1461 ags_recall_container_add(recall_container,
1462 fx_volume_audio);
1463
1464 start_recall = g_list_prepend(start_recall,
1465 fx_volume_audio);
1466
1467 ags_connectable_connect(AGS_CONNECTABLE(fx_volume_audio));
1468
1469 /* AgsFxVolumeAudioProcessor */
1470 fx_volume_audio_processor = (AgsFxVolumeAudioProcessor *) g_object_new(AGS_TYPE_FX_VOLUME_AUDIO_PROCESSOR,
1471 "output-soundcard", output_soundcard,
1472 "audio", audio,
1473 "recall-audio", fx_volume_audio,
1474 "recall-container", play_container,
1475 NULL);
1476 ags_recall_set_flags((AgsRecall *) fx_volume_audio_processor,
1477 (AGS_RECALL_TEMPLATE));
1478 ags_recall_set_ability_flags((AgsRecall *) fx_volume_audio_processor,
1479 (AGS_SOUND_ABILITY_PLAYBACK |
1480 AGS_SOUND_ABILITY_SEQUENCER |
1481 AGS_SOUND_ABILITY_NOTATION |
1482 AGS_SOUND_ABILITY_WAVE |
1483 AGS_SOUND_ABILITY_MIDI));
1484 ags_recall_set_behaviour_flags((AgsRecall *) fx_volume_audio_processor,
1485 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1486
1487 ags_audio_insert_recall(audio, (GObject *) fx_volume_audio_processor,
1488 FALSE,
1489 position);
1490 ags_recall_container_add(recall_container,
1491 fx_volume_audio_processor);
1492
1493 start_recall = g_list_prepend(start_recall,
1494 fx_volume_audio_processor);
1495
1496 ags_connectable_connect(AGS_CONNECTABLE(fx_volume_audio_processor));
1497 }else{
1498 GList *start_recall_audio_run, *recall_audio_run;
1499
1500 fx_volume_audio = ags_recall_container_get_recall_audio(recall_container);
1501
1502 if(fx_volume_audio != NULL){
1503 g_object_ref(fx_volume_audio);
1504 }
1505
1506 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
1507
1508 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
1509 fx_volume_audio_processor = recall_audio_run->data;
1510 g_object_ref(fx_volume_audio_processor);
1511 }
1512 }
1513
1514 for(i = 0; i < stop_pad - start_pad; i++){
1515 channel = ags_channel_pad_nth(start_input,
1516 start_pad + i);
1517
1518 next_channel = ags_channel_nth(channel,
1519 start_audio_channel);
1520
1521 if(channel != NULL){
1522 g_object_unref(channel);
1523 }
1524
1525 channel = next_channel;
1526
1527 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
1528 /* AgsFxVolumeChannel */
1529 fx_volume_channel = (AgsFxVolumeChannel *) g_object_new(AGS_TYPE_FX_VOLUME_CHANNEL,
1530 "output-soundcard", output_soundcard,
1531 "source", channel,
1532 "recall-audio", fx_volume_audio,
1533 "recall-container", recall_container,
1534 NULL);
1535 ags_recall_set_flags((AgsRecall *) fx_volume_channel,
1536 (AGS_RECALL_TEMPLATE));
1537 ags_recall_set_ability_flags((AgsRecall *) fx_volume_channel,
1538 (AGS_SOUND_ABILITY_PLAYBACK |
1539 AGS_SOUND_ABILITY_SEQUENCER |
1540 AGS_SOUND_ABILITY_NOTATION |
1541 AGS_SOUND_ABILITY_WAVE |
1542 AGS_SOUND_ABILITY_MIDI));
1543 ags_recall_set_behaviour_flags((AgsRecall *) fx_volume_channel,
1544 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1545
1546 ags_channel_insert_recall(channel, (GObject *) fx_volume_channel,
1547 FALSE,
1548 channel_position);
1549 ags_recall_container_add(recall_container,
1550 fx_volume_channel);
1551
1552 start_recall = g_list_prepend(start_recall,
1553 fx_volume_channel);
1554
1555 ags_connectable_connect(AGS_CONNECTABLE(fx_volume_channel));
1556
1557 /* AgsFxVolumeChannelProcessor */
1558 fx_volume_channel_processor = (AgsFxVolumeChannelProcessor *) g_object_new(AGS_TYPE_FX_VOLUME_CHANNEL_PROCESSOR,
1559 "output-soundcard", output_soundcard,
1560 "source", channel,
1561 "recall-audio", fx_volume_audio,
1562 "recall-audio-run", fx_volume_audio_processor,
1563 "recall-channel", fx_volume_channel,
1564 "recall-container", recall_container,
1565 NULL);
1566 ags_recall_set_flags((AgsRecall *) fx_volume_channel_processor,
1567 (AGS_RECALL_TEMPLATE));
1568 ags_recall_set_ability_flags((AgsRecall *) fx_volume_channel_processor,
1569 (AGS_SOUND_ABILITY_PLAYBACK |
1570 AGS_SOUND_ABILITY_SEQUENCER |
1571 AGS_SOUND_ABILITY_NOTATION |
1572 AGS_SOUND_ABILITY_WAVE |
1573 AGS_SOUND_ABILITY_MIDI));
1574 ags_recall_set_behaviour_flags((AgsRecall *) fx_volume_channel_processor,
1575 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1576
1577 ags_channel_insert_recall(channel, (GObject *) fx_volume_channel_processor,
1578 FALSE,
1579 channel_position);
1580 ags_recall_container_add(recall_container,
1581 fx_volume_channel_processor);
1582
1583 start_recall = g_list_prepend(start_recall,
1584 fx_volume_channel_processor);
1585
1586 ags_connectable_connect(AGS_CONNECTABLE(fx_volume_channel_processor));
1587
1588 /* iterate */
1589 next_channel = ags_channel_nth(channel,
1590 audio_channels - stop_audio_channel + 1);
1591
1592 if(channel != NULL){
1593 g_object_unref(channel);
1594 }
1595
1596 channel = next_channel;
1597 }
1598
1599 if(channel != NULL){
1600 g_object_unref(channel);
1601 }
1602 }
1603
1604 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
1605 if(fx_volume_audio != NULL){
1606 g_object_unref(fx_volume_audio);
1607 }
1608
1609 if(fx_volume_audio_processor != NULL){
1610 g_object_unref(fx_volume_audio_processor);
1611 }
1612 }
1613
1614 if(output_soundcard != NULL){
1615 g_object_unref(output_soundcard);
1616 }
1617
1618 if(input_sequencer != NULL){
1619 g_object_unref(input_sequencer);
1620 }
1621
1622 if(start_input != NULL){
1623 g_object_unref(start_input);
1624 }
1625
1626 return(start_recall);
1627 }
1628
1629 GList*
ags_fx_factory_create_peak(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)1630 ags_fx_factory_create_peak(AgsAudio *audio,
1631 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
1632 gchar *plugin_name,
1633 gchar *filename,
1634 gchar *effect,
1635 guint start_audio_channel, guint stop_audio_channel,
1636 guint start_pad, guint stop_pad,
1637 gint position,
1638 guint create_flags, guint recall_flags)
1639 {
1640 AgsChannel *start_input;
1641 AgsChannel *channel, *next_channel;
1642
1643 AgsFxPeakAudio *fx_peak_audio;
1644 AgsFxPeakAudioProcessor *fx_peak_audio_processor;
1645 AgsFxPeakChannel *fx_peak_channel;
1646 AgsFxPeakChannelProcessor *fx_peak_channel_processor;
1647
1648 GObject *output_soundcard;
1649 GObject *input_sequencer;
1650
1651 GList *start_recall;
1652
1653 gint channel_position;
1654 guint audio_channels;
1655 guint i, j;
1656
1657 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
1658 !AGS_IS_RECALL_CONTAINER(recall_container)){
1659 g_warning("ags-fx-peak recall container not provided");
1660
1661 return(NULL);
1662 }
1663
1664 start_recall = NULL;
1665
1666 g_object_get(audio,
1667 "output-soundcard", &output_soundcard,
1668 "input-sequencer", &input_sequencer,
1669 "input", &start_input,
1670 "audio-channels", &audio_channels,
1671 NULL);
1672
1673 channel_position = 0;
1674
1675 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
1676 channel_position = ags_fx_factory_get_output_position(audio,
1677 position);
1678 }else{
1679 channel_position = ags_fx_factory_get_input_position(audio,
1680 position);
1681 }
1682
1683 /* audio - play context */
1684 fx_peak_audio = NULL;
1685 fx_peak_audio_processor = NULL;
1686
1687 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
1688 /* AgsFxPeakAudio */
1689 fx_peak_audio = (AgsFxPeakAudio *) g_object_new(AGS_TYPE_FX_PEAK_AUDIO,
1690 "output-soundcard", output_soundcard,
1691 "audio", audio,
1692 "recall-container", play_container,
1693 NULL);
1694 ags_recall_set_flags((AgsRecall *) fx_peak_audio,
1695 (AGS_RECALL_TEMPLATE));
1696 ags_recall_set_ability_flags((AgsRecall *) fx_peak_audio,
1697 (AGS_SOUND_ABILITY_PLAYBACK |
1698 AGS_SOUND_ABILITY_SEQUENCER |
1699 AGS_SOUND_ABILITY_NOTATION |
1700 AGS_SOUND_ABILITY_WAVE |
1701 AGS_SOUND_ABILITY_MIDI));
1702 ags_recall_set_behaviour_flags((AgsRecall *) fx_peak_audio,
1703 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1704
1705 ags_audio_insert_recall(audio, (GObject *) fx_peak_audio,
1706 TRUE,
1707 position);
1708 ags_recall_container_add(play_container,
1709 fx_peak_audio);
1710
1711 start_recall = g_list_prepend(start_recall,
1712 fx_peak_audio);
1713
1714 ags_connectable_connect(AGS_CONNECTABLE(fx_peak_audio));
1715
1716 /* AgsFxPeakAudioProcessor */
1717 fx_peak_audio_processor = (AgsFxPeakAudioProcessor *) g_object_new(AGS_TYPE_FX_PEAK_AUDIO_PROCESSOR,
1718 "output-soundcard", output_soundcard,
1719 "audio", audio,
1720 "recall-audio", fx_peak_audio,
1721 "recall-container", play_container,
1722 NULL);
1723 ags_recall_set_flags((AgsRecall *) fx_peak_audio_processor,
1724 (AGS_RECALL_TEMPLATE));
1725 ags_recall_set_ability_flags((AgsRecall *) fx_peak_audio_processor,
1726 (AGS_SOUND_ABILITY_PLAYBACK |
1727 AGS_SOUND_ABILITY_SEQUENCER |
1728 AGS_SOUND_ABILITY_NOTATION |
1729 AGS_SOUND_ABILITY_WAVE |
1730 AGS_SOUND_ABILITY_MIDI));
1731 ags_recall_set_behaviour_flags((AgsRecall *) fx_peak_audio_processor,
1732 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1733
1734 ags_audio_insert_recall(audio, (GObject *) fx_peak_audio_processor,
1735 TRUE,
1736 position);
1737 ags_recall_container_add(play_container,
1738 fx_peak_audio_processor);
1739
1740 start_recall = g_list_prepend(start_recall,
1741 fx_peak_audio_processor);
1742
1743 ags_connectable_connect(AGS_CONNECTABLE(fx_peak_audio_processor));
1744 }else{
1745 GList *start_recall_audio_run, *recall_audio_run;
1746
1747 fx_peak_audio = ags_recall_container_get_recall_audio(play_container);
1748
1749 if(fx_peak_audio != NULL){
1750 g_object_ref(fx_peak_audio);
1751 }
1752
1753 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
1754
1755 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
1756 fx_peak_audio_processor = recall_audio_run->data;
1757 g_object_ref(fx_peak_audio_processor);
1758 }
1759 }
1760
1761 /* channel - play context */
1762 for(i = 0; i < stop_pad - start_pad; i++){
1763 channel = ags_channel_pad_nth(start_input,
1764 start_pad + i);
1765
1766 next_channel = ags_channel_nth(channel,
1767 start_audio_channel);
1768
1769 if(channel != NULL){
1770 g_object_unref(channel);
1771 }
1772
1773 channel = next_channel;
1774
1775 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
1776 /* AgsFxPeakChannel */
1777 fx_peak_channel = (AgsFxPeakChannel *) g_object_new(AGS_TYPE_FX_PEAK_CHANNEL,
1778 "output-soundcard", output_soundcard,
1779 "source", channel,
1780 "recall-audio", fx_peak_audio,
1781 "recall-container", play_container,
1782 NULL);
1783 ags_recall_set_flags((AgsRecall *) fx_peak_channel,
1784 (AGS_RECALL_TEMPLATE));
1785 ags_recall_set_ability_flags((AgsRecall *) fx_peak_channel,
1786 (AGS_SOUND_ABILITY_PLAYBACK |
1787 AGS_SOUND_ABILITY_SEQUENCER |
1788 AGS_SOUND_ABILITY_NOTATION |
1789 AGS_SOUND_ABILITY_WAVE |
1790 AGS_SOUND_ABILITY_MIDI));
1791 ags_recall_set_behaviour_flags((AgsRecall *) fx_peak_channel,
1792 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1793
1794 ags_channel_insert_recall(channel, (GObject *) fx_peak_channel,
1795 TRUE,
1796 channel_position);
1797 ags_recall_container_add(play_container,
1798 fx_peak_channel);
1799
1800 start_recall = g_list_prepend(start_recall,
1801 fx_peak_channel);
1802
1803 ags_connectable_connect(AGS_CONNECTABLE(fx_peak_channel));
1804
1805 /* AgsFxPeakChannelProcessor */
1806 fx_peak_channel_processor = (AgsFxPeakChannelProcessor *) g_object_new(AGS_TYPE_FX_PEAK_CHANNEL_PROCESSOR,
1807 "output-soundcard", output_soundcard,
1808 "source", channel,
1809 "recall-audio", fx_peak_audio,
1810 "recall-audio-run", fx_peak_audio_processor,
1811 "recall-channel", fx_peak_channel,
1812 "recall-container", play_container,
1813 NULL);
1814 ags_recall_set_flags((AgsRecall *) fx_peak_channel_processor,
1815 (AGS_RECALL_TEMPLATE));
1816 ags_recall_set_ability_flags((AgsRecall *) fx_peak_channel_processor,
1817 (AGS_SOUND_ABILITY_PLAYBACK |
1818 AGS_SOUND_ABILITY_SEQUENCER |
1819 AGS_SOUND_ABILITY_NOTATION |
1820 AGS_SOUND_ABILITY_WAVE |
1821 AGS_SOUND_ABILITY_MIDI));
1822 ags_recall_set_behaviour_flags((AgsRecall *) fx_peak_channel_processor,
1823 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1824
1825 ags_channel_insert_recall(channel, (GObject *) fx_peak_channel_processor,
1826 TRUE,
1827 channel_position);
1828 ags_recall_container_add(play_container,
1829 fx_peak_channel_processor);
1830
1831 start_recall = g_list_prepend(start_recall,
1832 fx_peak_channel_processor);
1833
1834 ags_connectable_connect(AGS_CONNECTABLE(fx_peak_channel_processor));
1835
1836 /* iterate */
1837 next_channel = ags_channel_next(channel);
1838
1839 g_object_unref(channel);
1840
1841 channel = next_channel;
1842 }
1843
1844 if(channel != NULL){
1845 g_object_unref(channel);
1846 }
1847 }
1848
1849 /* audio - recall context */
1850 fx_peak_audio = NULL;
1851 fx_peak_audio_processor = NULL;
1852
1853 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
1854 /* AgsFxPeakAudio */
1855 fx_peak_audio = (AgsFxPeakAudio *) g_object_new(AGS_TYPE_FX_PEAK_AUDIO,
1856 "output-soundcard", output_soundcard,
1857 "audio", audio,
1858 "recall-container", recall_container,
1859 NULL);
1860 ags_recall_set_flags((AgsRecall *) fx_peak_audio,
1861 (AGS_RECALL_TEMPLATE));
1862 ags_recall_set_ability_flags((AgsRecall *) fx_peak_audio,
1863 (AGS_SOUND_ABILITY_PLAYBACK |
1864 AGS_SOUND_ABILITY_SEQUENCER |
1865 AGS_SOUND_ABILITY_NOTATION |
1866 AGS_SOUND_ABILITY_WAVE |
1867 AGS_SOUND_ABILITY_MIDI));
1868 ags_recall_set_behaviour_flags((AgsRecall *) fx_peak_audio,
1869 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1870
1871 ags_audio_insert_recall(audio, (GObject *) fx_peak_audio,
1872 FALSE,
1873 position);
1874 ags_recall_container_add(recall_container,
1875 fx_peak_audio);
1876
1877 start_recall = g_list_prepend(start_recall,
1878 fx_peak_audio);
1879
1880 ags_connectable_connect(AGS_CONNECTABLE(fx_peak_audio));
1881
1882 /* AgsFxPeakAudioProcessor */
1883 fx_peak_audio_processor = (AgsFxPeakAudioProcessor *) g_object_new(AGS_TYPE_FX_PEAK_AUDIO_PROCESSOR,
1884 "output-soundcard", output_soundcard,
1885 "audio", audio,
1886 "recall-audio", fx_peak_audio,
1887 "recall-container", recall_container,
1888 NULL);
1889 ags_recall_set_flags((AgsRecall *) fx_peak_audio_processor,
1890 (AGS_RECALL_TEMPLATE));
1891 ags_recall_set_ability_flags((AgsRecall *) fx_peak_audio_processor,
1892 (AGS_SOUND_ABILITY_PLAYBACK |
1893 AGS_SOUND_ABILITY_SEQUENCER |
1894 AGS_SOUND_ABILITY_NOTATION |
1895 AGS_SOUND_ABILITY_WAVE |
1896 AGS_SOUND_ABILITY_MIDI));
1897 ags_recall_set_behaviour_flags((AgsRecall *) fx_peak_audio_processor,
1898 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1899
1900 ags_audio_insert_recall(audio, (GObject *) fx_peak_audio_processor,
1901 FALSE,
1902 position);
1903 ags_recall_container_add(recall_container,
1904 fx_peak_audio_processor);
1905
1906 start_recall = g_list_prepend(start_recall,
1907 fx_peak_audio_processor);
1908
1909 ags_connectable_connect(AGS_CONNECTABLE(fx_peak_audio_processor));
1910 }else{
1911 GList *start_recall_audio_run, *recall_audio_run;
1912
1913 fx_peak_audio = ags_recall_container_get_recall_audio(recall_container);
1914
1915 if(fx_peak_audio != NULL){
1916 g_object_ref(fx_peak_audio);
1917 }
1918
1919 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
1920
1921 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
1922 fx_peak_audio_processor = recall_audio_run->data;
1923 g_object_ref(fx_peak_audio_processor);
1924 }
1925 }
1926
1927 for(i = 0; i < stop_pad - start_pad; i++){
1928 channel = ags_channel_pad_nth(start_input,
1929 start_pad + i);
1930
1931 next_channel = ags_channel_nth(channel,
1932 start_audio_channel);
1933
1934 if(channel != NULL){
1935 g_object_unref(channel);
1936 }
1937
1938 channel = next_channel;
1939
1940 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
1941 /* AgsFxPeakChannel */
1942 fx_peak_channel = (AgsFxPeakChannel *) g_object_new(AGS_TYPE_FX_PEAK_CHANNEL,
1943 "output-soundcard", output_soundcard,
1944 "source", channel,
1945 "recall-audio", fx_peak_audio,
1946 "recall-container", recall_container,
1947 NULL);
1948 ags_recall_set_flags((AgsRecall *) fx_peak_channel,
1949 (AGS_RECALL_TEMPLATE));
1950 ags_recall_set_ability_flags((AgsRecall *) fx_peak_channel,
1951 (AGS_SOUND_ABILITY_PLAYBACK |
1952 AGS_SOUND_ABILITY_SEQUENCER |
1953 AGS_SOUND_ABILITY_NOTATION |
1954 AGS_SOUND_ABILITY_WAVE |
1955 AGS_SOUND_ABILITY_MIDI));
1956 ags_recall_set_behaviour_flags((AgsRecall *) fx_peak_channel,
1957 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1958
1959 ags_channel_insert_recall(channel, (GObject *) fx_peak_channel,
1960 FALSE,
1961 channel_position);
1962 ags_recall_container_add(recall_container,
1963 fx_peak_channel);
1964
1965 start_recall = g_list_prepend(start_recall,
1966 fx_peak_channel);
1967
1968 ags_connectable_connect(AGS_CONNECTABLE(fx_peak_channel));
1969
1970 /* AgsFxPeakChannelProcessor */
1971 fx_peak_channel_processor = (AgsFxPeakChannelProcessor *) g_object_new(AGS_TYPE_FX_PEAK_CHANNEL_PROCESSOR,
1972 "output-soundcard", output_soundcard,
1973 "source", channel,
1974 "recall-audio", fx_peak_audio,
1975 "recall-audio-run", fx_peak_audio_processor,
1976 "recall-channel", fx_peak_channel,
1977 "recall-container", recall_container,
1978 NULL);
1979 ags_recall_set_flags((AgsRecall *) fx_peak_channel_processor,
1980 (AGS_RECALL_TEMPLATE));
1981 ags_recall_set_ability_flags((AgsRecall *) fx_peak_channel_processor,
1982 (AGS_SOUND_ABILITY_PLAYBACK |
1983 AGS_SOUND_ABILITY_SEQUENCER |
1984 AGS_SOUND_ABILITY_NOTATION |
1985 AGS_SOUND_ABILITY_WAVE |
1986 AGS_SOUND_ABILITY_MIDI));
1987 ags_recall_set_behaviour_flags((AgsRecall *) fx_peak_channel_processor,
1988 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1989
1990 ags_channel_insert_recall(channel, (GObject *) fx_peak_channel_processor,
1991 FALSE,
1992 channel_position);
1993 ags_recall_container_add(recall_container,
1994 fx_peak_channel_processor);
1995
1996 start_recall = g_list_prepend(start_recall,
1997 fx_peak_channel_processor);
1998
1999 ags_connectable_connect(AGS_CONNECTABLE(fx_peak_channel_processor));
2000
2001 /* iterate */
2002 next_channel = ags_channel_next(channel);
2003
2004 g_object_unref(channel);
2005
2006 channel = next_channel;
2007 }
2008
2009 if(channel != NULL){
2010 g_object_unref(channel);
2011 }
2012 }
2013
2014 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
2015 if(fx_peak_audio != NULL){
2016 g_object_unref(fx_peak_audio);
2017 }
2018
2019 if(fx_peak_audio_processor != NULL){
2020 g_object_unref(fx_peak_audio_processor);
2021 }
2022 }
2023
2024 if(output_soundcard != NULL){
2025 g_object_unref(output_soundcard);
2026 }
2027
2028 if(input_sequencer != NULL){
2029 g_object_unref(input_sequencer);
2030 }
2031
2032 if(start_input != NULL){
2033 g_object_unref(start_input);
2034 }
2035
2036 return(start_recall);
2037 }
2038
2039 GList*
ags_fx_factory_create_eq10(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)2040 ags_fx_factory_create_eq10(AgsAudio *audio,
2041 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
2042 gchar *plugin_name,
2043 gchar *filename,
2044 gchar *effect,
2045 guint start_audio_channel, guint stop_audio_channel,
2046 guint start_pad, guint stop_pad,
2047 gint position,
2048 guint create_flags, guint recall_flags)
2049 {
2050 AgsChannel *start_input;
2051 AgsChannel *channel, *next_channel;
2052
2053 AgsFxEq10Audio *fx_eq10_audio;
2054 AgsFxEq10AudioProcessor *fx_eq10_audio_processor;
2055 AgsFxEq10Channel *fx_eq10_channel;
2056 AgsFxEq10ChannelProcessor *fx_eq10_channel_processor;
2057
2058 GObject *output_soundcard;
2059 GObject *input_sequencer;
2060
2061 GList *start_recall;
2062
2063 gint channel_position;
2064 guint audio_channels;
2065 guint i, j;
2066
2067 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
2068 !AGS_IS_RECALL_CONTAINER(recall_container)){
2069 g_warning("ags-fx-eq10 recall container not provided");
2070
2071 return(NULL);
2072 }
2073
2074 start_recall = NULL;
2075
2076 g_object_get(audio,
2077 "output-soundcard", &output_soundcard,
2078 "input-sequencer", &input_sequencer,
2079 "input", &start_input,
2080 "audio-channels", &audio_channels,
2081 NULL);
2082
2083 channel_position = 0;
2084
2085 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
2086 channel_position = ags_fx_factory_get_output_position(audio,
2087 position);
2088 }else{
2089 channel_position = ags_fx_factory_get_input_position(audio,
2090 position);
2091 }
2092
2093 /* audio - play context */
2094 fx_eq10_audio = NULL;
2095 fx_eq10_audio_processor = NULL;
2096
2097 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
2098 /* AgsFxEq10Audio */
2099 fx_eq10_audio = (AgsFxEq10Audio *) g_object_new(AGS_TYPE_FX_EQ10_AUDIO,
2100 "output-soundcard", output_soundcard,
2101 "audio", audio,
2102 "recall-container", play_container,
2103 NULL);
2104 ags_recall_set_flags((AgsRecall *) fx_eq10_audio,
2105 (AGS_RECALL_TEMPLATE));
2106 ags_recall_set_ability_flags((AgsRecall *) fx_eq10_audio,
2107 (AGS_SOUND_ABILITY_PLAYBACK |
2108 AGS_SOUND_ABILITY_SEQUENCER |
2109 AGS_SOUND_ABILITY_NOTATION |
2110 AGS_SOUND_ABILITY_WAVE |
2111 AGS_SOUND_ABILITY_MIDI));
2112 ags_recall_set_behaviour_flags((AgsRecall *) fx_eq10_audio,
2113 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2114
2115 ags_audio_insert_recall(audio, (GObject *) fx_eq10_audio,
2116 TRUE,
2117 position);
2118 ags_recall_container_add(play_container,
2119 fx_eq10_audio);
2120
2121 start_recall = g_list_prepend(start_recall,
2122 fx_eq10_audio);
2123
2124 ags_connectable_connect(AGS_CONNECTABLE(fx_eq10_audio));
2125
2126 /* AgsFxEq10AudioProcessor */
2127 fx_eq10_audio_processor = (AgsFxEq10AudioProcessor *) g_object_new(AGS_TYPE_FX_EQ10_AUDIO_PROCESSOR,
2128 "output-soundcard", output_soundcard,
2129 "audio", audio,
2130 "recall-audio", fx_eq10_audio,
2131 "recall-container", play_container,
2132 NULL);
2133 ags_recall_set_flags((AgsRecall *) fx_eq10_audio_processor,
2134 (AGS_RECALL_TEMPLATE));
2135 ags_recall_set_ability_flags((AgsRecall *) fx_eq10_audio_processor,
2136 (AGS_SOUND_ABILITY_PLAYBACK |
2137 AGS_SOUND_ABILITY_SEQUENCER |
2138 AGS_SOUND_ABILITY_NOTATION |
2139 AGS_SOUND_ABILITY_WAVE |
2140 AGS_SOUND_ABILITY_MIDI));
2141 ags_recall_set_behaviour_flags((AgsRecall *) fx_eq10_audio_processor,
2142 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2143
2144 ags_audio_insert_recall(audio, (GObject *) fx_eq10_audio_processor,
2145 TRUE,
2146 position);
2147 ags_recall_container_add(play_container,
2148 fx_eq10_audio_processor);
2149
2150 start_recall = g_list_prepend(start_recall,
2151 fx_eq10_audio_processor);
2152
2153 ags_connectable_connect(AGS_CONNECTABLE(fx_eq10_audio_processor));
2154 }else{
2155 GList *start_recall_audio_run, *recall_audio_run;
2156
2157 fx_eq10_audio = ags_recall_container_get_recall_audio(play_container);
2158
2159 if(fx_eq10_audio != NULL){
2160 g_object_ref(fx_eq10_audio);
2161 }
2162
2163 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
2164
2165 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
2166 fx_eq10_audio_processor = recall_audio_run->data;
2167 g_object_ref(fx_eq10_audio_processor);
2168 }
2169 }
2170
2171 /* channel - play context */
2172 for(i = 0; i < stop_pad - start_pad; i++){
2173 channel = ags_channel_pad_nth(start_input,
2174 start_pad + i);
2175
2176 next_channel = ags_channel_nth(channel,
2177 start_audio_channel);
2178
2179 if(channel != NULL){
2180 g_object_unref(channel);
2181 }
2182
2183 channel = next_channel;
2184
2185 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2186 /* AgsFxEq10Channel */
2187 fx_eq10_channel = (AgsFxEq10Channel *) g_object_new(AGS_TYPE_FX_EQ10_CHANNEL,
2188 "output-soundcard", output_soundcard,
2189 "source", channel,
2190 "recall-audio", fx_eq10_audio,
2191 "recall-container", play_container,
2192 NULL);
2193 ags_recall_set_flags((AgsRecall *) fx_eq10_channel,
2194 (AGS_RECALL_TEMPLATE));
2195 ags_recall_set_ability_flags((AgsRecall *) fx_eq10_channel,
2196 (AGS_SOUND_ABILITY_PLAYBACK |
2197 AGS_SOUND_ABILITY_SEQUENCER |
2198 AGS_SOUND_ABILITY_NOTATION |
2199 AGS_SOUND_ABILITY_WAVE |
2200 AGS_SOUND_ABILITY_MIDI));
2201 ags_recall_set_behaviour_flags((AgsRecall *) fx_eq10_channel,
2202 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2203
2204 ags_channel_insert_recall(channel, (GObject *) fx_eq10_channel,
2205 TRUE,
2206 channel_position);
2207 ags_recall_container_add(play_container,
2208 fx_eq10_channel);
2209
2210 start_recall = g_list_prepend(start_recall,
2211 fx_eq10_channel);
2212
2213 ags_connectable_connect(AGS_CONNECTABLE(fx_eq10_channel));
2214
2215 /* AgsFxEq10ChannelProcessor */
2216 fx_eq10_channel_processor = (AgsFxEq10ChannelProcessor *) g_object_new(AGS_TYPE_FX_EQ10_CHANNEL_PROCESSOR,
2217 "output-soundcard", output_soundcard,
2218 "source", channel,
2219 "recall-audio", fx_eq10_audio,
2220 "recall-audio-run", fx_eq10_audio_processor,
2221 "recall-channel", fx_eq10_channel,
2222 "recall-container", play_container,
2223 NULL);
2224 ags_recall_set_flags((AgsRecall *) fx_eq10_channel_processor,
2225 (AGS_RECALL_TEMPLATE));
2226 ags_recall_set_ability_flags((AgsRecall *) fx_eq10_channel_processor,
2227 (AGS_SOUND_ABILITY_PLAYBACK |
2228 AGS_SOUND_ABILITY_SEQUENCER |
2229 AGS_SOUND_ABILITY_NOTATION |
2230 AGS_SOUND_ABILITY_WAVE |
2231 AGS_SOUND_ABILITY_MIDI));
2232 ags_recall_set_behaviour_flags((AgsRecall *) fx_eq10_channel_processor,
2233 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2234
2235 ags_channel_insert_recall(channel, (GObject *) fx_eq10_channel_processor,
2236 TRUE,
2237 channel_position);
2238 ags_recall_container_add(play_container,
2239 fx_eq10_channel_processor);
2240
2241 start_recall = g_list_prepend(start_recall,
2242 fx_eq10_channel_processor);
2243
2244 ags_connectable_connect(AGS_CONNECTABLE(fx_eq10_channel_processor));
2245
2246 /* iterate */
2247 next_channel = ags_channel_next(channel);
2248
2249 g_object_unref(channel);
2250
2251 channel = next_channel;
2252 }
2253
2254 if(channel != NULL){
2255 g_object_unref(channel);
2256 }
2257 }
2258
2259 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
2260 if(fx_eq10_audio != NULL){
2261 g_object_unref(fx_eq10_audio);
2262 }
2263
2264 if(fx_eq10_audio_processor != NULL){
2265 g_object_unref(fx_eq10_audio_processor);
2266 }
2267 }
2268
2269 /* audio - recall context */
2270 fx_eq10_audio = NULL;
2271 fx_eq10_audio_processor = NULL;
2272
2273 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
2274 /* AgsFxEq10Audio */
2275 fx_eq10_audio = (AgsFxEq10Audio *) g_object_new(AGS_TYPE_FX_EQ10_AUDIO,
2276 "output-soundcard", output_soundcard,
2277 "audio", audio,
2278 "recall-container", recall_container,
2279 NULL);
2280 ags_recall_set_flags((AgsRecall *) fx_eq10_audio,
2281 (AGS_RECALL_TEMPLATE));
2282 ags_recall_set_ability_flags((AgsRecall *) fx_eq10_audio,
2283 (AGS_SOUND_ABILITY_PLAYBACK |
2284 AGS_SOUND_ABILITY_SEQUENCER |
2285 AGS_SOUND_ABILITY_NOTATION |
2286 AGS_SOUND_ABILITY_WAVE |
2287 AGS_SOUND_ABILITY_MIDI));
2288 ags_recall_set_behaviour_flags((AgsRecall *) fx_eq10_audio,
2289 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2290
2291 ags_audio_insert_recall(audio, (GObject *) fx_eq10_audio,
2292 FALSE,
2293 position);
2294 ags_recall_container_add(recall_container,
2295 fx_eq10_audio);
2296
2297 start_recall = g_list_prepend(start_recall,
2298 fx_eq10_audio);
2299
2300 ags_connectable_connect(AGS_CONNECTABLE(fx_eq10_audio));
2301
2302 /* AgsFxEq10AudioProcessor */
2303 fx_eq10_audio_processor = (AgsFxEq10AudioProcessor *) g_object_new(AGS_TYPE_FX_EQ10_AUDIO_PROCESSOR,
2304 "output-soundcard", output_soundcard,
2305 "audio", audio,
2306 "recall-audio", fx_eq10_audio,
2307 "recall-container", recall_container,
2308 NULL);
2309 ags_recall_set_flags((AgsRecall *) fx_eq10_audio_processor,
2310 (AGS_RECALL_TEMPLATE));
2311 ags_recall_set_ability_flags((AgsRecall *) fx_eq10_audio_processor,
2312 (AGS_SOUND_ABILITY_PLAYBACK |
2313 AGS_SOUND_ABILITY_SEQUENCER |
2314 AGS_SOUND_ABILITY_NOTATION |
2315 AGS_SOUND_ABILITY_WAVE |
2316 AGS_SOUND_ABILITY_MIDI));
2317 ags_recall_set_behaviour_flags((AgsRecall *) fx_eq10_audio_processor,
2318 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2319
2320 ags_audio_insert_recall(audio, (GObject *) fx_eq10_audio_processor,
2321 FALSE,
2322 position);
2323 ags_recall_container_add(recall_container,
2324 fx_eq10_audio_processor);
2325
2326 start_recall = g_list_prepend(start_recall,
2327 fx_eq10_audio_processor);
2328
2329 ags_connectable_connect(AGS_CONNECTABLE(fx_eq10_audio_processor));
2330 }else{
2331 GList *start_recall_audio_run, *recall_audio_run;
2332
2333 fx_eq10_audio = ags_recall_container_get_recall_audio(recall_container);
2334
2335 if(fx_eq10_audio != NULL){
2336 g_object_ref(fx_eq10_audio);
2337 }
2338
2339 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
2340
2341 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
2342 fx_eq10_audio_processor = recall_audio_run->data;
2343 g_object_ref(fx_eq10_audio_processor);
2344 }
2345 }
2346
2347 /* channel - recall context */
2348 for(i = 0; i < stop_pad - start_pad; i++){
2349 channel = ags_channel_pad_nth(start_input,
2350 start_pad + i);
2351
2352 next_channel = ags_channel_nth(channel,
2353 start_audio_channel);
2354
2355 if(channel != NULL){
2356 g_object_unref(channel);
2357 }
2358
2359 channel = next_channel;
2360
2361 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2362 /* AgsFxEq10Channel */
2363 fx_eq10_channel = (AgsFxEq10Channel *) g_object_new(AGS_TYPE_FX_EQ10_CHANNEL,
2364 "output-soundcard", output_soundcard,
2365 "source", channel,
2366 "recall-audio", fx_eq10_audio,
2367 "recall-container", recall_container,
2368 NULL);
2369 ags_recall_set_flags((AgsRecall *) fx_eq10_channel,
2370 (AGS_RECALL_TEMPLATE));
2371 ags_recall_set_ability_flags((AgsRecall *) fx_eq10_channel,
2372 (AGS_SOUND_ABILITY_PLAYBACK |
2373 AGS_SOUND_ABILITY_SEQUENCER |
2374 AGS_SOUND_ABILITY_NOTATION |
2375 AGS_SOUND_ABILITY_WAVE |
2376 AGS_SOUND_ABILITY_MIDI));
2377 ags_recall_set_behaviour_flags((AgsRecall *) fx_eq10_channel,
2378 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2379
2380 ags_channel_insert_recall(channel, (GObject *) fx_eq10_channel,
2381 FALSE,
2382 channel_position);
2383 ags_recall_container_add(recall_container,
2384 fx_eq10_channel);
2385
2386 start_recall = g_list_prepend(start_recall,
2387 fx_eq10_channel);
2388
2389 ags_connectable_connect(AGS_CONNECTABLE(fx_eq10_channel));
2390
2391 /* AgsFxEq10ChannelProcessor */
2392 fx_eq10_channel_processor = (AgsFxEq10ChannelProcessor *) g_object_new(AGS_TYPE_FX_EQ10_CHANNEL_PROCESSOR,
2393 "output-soundcard", output_soundcard,
2394 "source", channel,
2395 "recall-audio", fx_eq10_audio,
2396 "recall-audio-run", fx_eq10_audio_processor,
2397 "recall-channel", fx_eq10_channel,
2398 "recall-container", recall_container,
2399 NULL);
2400 ags_recall_set_flags((AgsRecall *) fx_eq10_channel_processor,
2401 (AGS_RECALL_TEMPLATE));
2402 ags_recall_set_ability_flags((AgsRecall *) fx_eq10_channel_processor,
2403 (AGS_SOUND_ABILITY_PLAYBACK |
2404 AGS_SOUND_ABILITY_SEQUENCER |
2405 AGS_SOUND_ABILITY_NOTATION |
2406 AGS_SOUND_ABILITY_WAVE |
2407 AGS_SOUND_ABILITY_MIDI));
2408 ags_recall_set_behaviour_flags((AgsRecall *) fx_eq10_channel_processor,
2409 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2410
2411 ags_channel_insert_recall(channel, (GObject *) fx_eq10_channel_processor,
2412 FALSE,
2413 channel_position);
2414 ags_recall_container_add(recall_container,
2415 fx_eq10_channel_processor);
2416
2417 start_recall = g_list_prepend(start_recall,
2418 fx_eq10_channel_processor);
2419
2420 ags_connectable_connect(AGS_CONNECTABLE(fx_eq10_channel_processor));
2421
2422 /* iterate */
2423 next_channel = ags_channel_next(channel);
2424
2425 g_object_unref(channel);
2426
2427 channel = next_channel;
2428 }
2429
2430 if(channel != NULL){
2431 g_object_unref(channel);
2432 }
2433 }
2434
2435 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
2436 if(fx_eq10_audio != NULL){
2437 g_object_unref(fx_eq10_audio);
2438 }
2439
2440 if(fx_eq10_audio_processor != NULL){
2441 g_object_unref(fx_eq10_audio_processor);
2442 }
2443 }
2444
2445 if(output_soundcard != NULL){
2446 g_object_unref(output_soundcard);
2447 }
2448
2449 if(input_sequencer != NULL){
2450 g_object_unref(input_sequencer);
2451 }
2452
2453 if(start_input != NULL){
2454 g_object_unref(start_input);
2455 }
2456
2457 return(start_recall);
2458 }
2459
2460 GList*
ags_fx_factory_create_analyse(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)2461 ags_fx_factory_create_analyse(AgsAudio *audio,
2462 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
2463 gchar *plugin_name,
2464 gchar *filename,
2465 gchar *effect,
2466 guint start_audio_channel, guint stop_audio_channel,
2467 guint start_pad, guint stop_pad,
2468 gint position,
2469 guint create_flags, guint recall_flags)
2470 {
2471 AgsChannel *start_input;
2472 AgsChannel *channel, *next_channel;
2473
2474 AgsFxAnalyseAudio *fx_analyse_audio;
2475 AgsFxAnalyseAudioProcessor *fx_analyse_audio_processor;
2476 AgsFxAnalyseChannel *fx_analyse_channel;
2477 AgsFxAnalyseChannelProcessor *fx_analyse_channel_processor;
2478
2479 GObject *output_soundcard;
2480 GObject *input_sequencer;
2481
2482 GList *start_recall;
2483
2484 gint channel_position;
2485 guint audio_channels;
2486 guint i, j;
2487
2488 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
2489 !AGS_IS_RECALL_CONTAINER(recall_container)){
2490 g_warning("ags-fx-analyse recall container not provided");
2491
2492 return(NULL);
2493 }
2494
2495 start_recall = NULL;
2496
2497 g_object_get(audio,
2498 "output-soundcard", &output_soundcard,
2499 "input-sequencer", &input_sequencer,
2500 "input", &start_input,
2501 "audio-channels", &audio_channels,
2502 NULL);
2503
2504 channel_position = 0;
2505
2506 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
2507 channel_position = ags_fx_factory_get_output_position(audio,
2508 position);
2509 }else{
2510 channel_position = ags_fx_factory_get_input_position(audio,
2511 position);
2512 }
2513
2514 /* audio - play context */
2515 fx_analyse_audio = NULL;
2516 fx_analyse_audio_processor = NULL;
2517
2518 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
2519 /* AgsFxAnalyseAudio */
2520 fx_analyse_audio = (AgsFxAnalyseAudio *) g_object_new(AGS_TYPE_FX_ANALYSE_AUDIO,
2521 "output-soundcard", output_soundcard,
2522 "audio", audio,
2523 "recall-container", play_container,
2524 NULL);
2525 ags_recall_set_flags((AgsRecall *) fx_analyse_audio,
2526 (AGS_RECALL_TEMPLATE));
2527 ags_recall_set_ability_flags((AgsRecall *) fx_analyse_audio,
2528 (AGS_SOUND_ABILITY_PLAYBACK |
2529 AGS_SOUND_ABILITY_SEQUENCER |
2530 AGS_SOUND_ABILITY_NOTATION |
2531 AGS_SOUND_ABILITY_WAVE |
2532 AGS_SOUND_ABILITY_MIDI));
2533 ags_recall_set_behaviour_flags((AgsRecall *) fx_analyse_audio,
2534 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2535
2536 ags_audio_insert_recall(audio, (GObject *) fx_analyse_audio,
2537 TRUE,
2538 position);
2539 ags_recall_container_add(play_container,
2540 fx_analyse_audio);
2541
2542 start_recall = g_list_prepend(start_recall,
2543 fx_analyse_audio);
2544
2545 ags_connectable_connect(AGS_CONNECTABLE(fx_analyse_audio));
2546
2547 /* AgsFxAnalyseAudioProcessor */
2548 fx_analyse_audio_processor = (AgsFxAnalyseAudioProcessor *) g_object_new(AGS_TYPE_FX_ANALYSE_AUDIO_PROCESSOR,
2549 "output-soundcard", output_soundcard,
2550 "audio", audio,
2551 "recall-audio", fx_analyse_audio,
2552 "recall-container", play_container,
2553 NULL);
2554 ags_recall_set_flags((AgsRecall *) fx_analyse_audio_processor,
2555 (AGS_RECALL_TEMPLATE));
2556 ags_recall_set_ability_flags((AgsRecall *) fx_analyse_audio_processor,
2557 (AGS_SOUND_ABILITY_PLAYBACK |
2558 AGS_SOUND_ABILITY_SEQUENCER |
2559 AGS_SOUND_ABILITY_NOTATION |
2560 AGS_SOUND_ABILITY_WAVE |
2561 AGS_SOUND_ABILITY_MIDI));
2562 ags_recall_set_behaviour_flags((AgsRecall *) fx_analyse_audio_processor,
2563 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2564
2565 ags_audio_insert_recall(audio, (GObject *) fx_analyse_audio_processor,
2566 TRUE,
2567 position);
2568 ags_recall_container_add(play_container,
2569 fx_analyse_audio_processor);
2570
2571 start_recall = g_list_prepend(start_recall,
2572 fx_analyse_audio_processor);
2573
2574 ags_connectable_connect(AGS_CONNECTABLE(fx_analyse_audio_processor));
2575 }else{
2576 GList *start_recall_audio_run, *recall_audio_run;
2577
2578 fx_analyse_audio = ags_recall_container_get_recall_audio(play_container);
2579
2580 if(fx_analyse_audio != NULL){
2581 g_object_ref(fx_analyse_audio);
2582 }
2583
2584 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
2585
2586 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
2587 fx_analyse_audio_processor = recall_audio_run->data;
2588 g_object_ref(fx_analyse_audio_processor);
2589 }
2590 }
2591
2592 /* channel - play context */
2593 for(i = 0; i < stop_pad - start_pad; i++){
2594 channel = ags_channel_pad_nth(start_input,
2595 start_pad + i);
2596
2597 next_channel = ags_channel_nth(channel,
2598 start_audio_channel);
2599
2600 if(channel != NULL){
2601 g_object_unref(channel);
2602 }
2603
2604 channel = next_channel;
2605
2606 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2607 /* AgsFxAnalyseChannel */
2608 fx_analyse_channel = (AgsFxAnalyseChannel *) g_object_new(AGS_TYPE_FX_ANALYSE_CHANNEL,
2609 "output-soundcard", output_soundcard,
2610 "source", channel,
2611 "recall-audio", fx_analyse_audio,
2612 "recall-container", play_container,
2613 NULL);
2614 ags_recall_set_flags((AgsRecall *) fx_analyse_channel,
2615 (AGS_RECALL_TEMPLATE));
2616 ags_recall_set_ability_flags((AgsRecall *) fx_analyse_channel,
2617 (AGS_SOUND_ABILITY_PLAYBACK |
2618 AGS_SOUND_ABILITY_SEQUENCER |
2619 AGS_SOUND_ABILITY_NOTATION |
2620 AGS_SOUND_ABILITY_WAVE |
2621 AGS_SOUND_ABILITY_MIDI));
2622 ags_recall_set_behaviour_flags((AgsRecall *) fx_analyse_channel,
2623 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2624
2625 ags_channel_insert_recall(channel, (GObject *) fx_analyse_channel,
2626 TRUE,
2627 channel_position);
2628 ags_recall_container_add(play_container,
2629 fx_analyse_channel);
2630
2631 start_recall = g_list_prepend(start_recall,
2632 fx_analyse_channel);
2633
2634 ags_connectable_connect(AGS_CONNECTABLE(fx_analyse_channel));
2635
2636 /* AgsFxAnalyseChannelProcessor */
2637 fx_analyse_channel_processor = (AgsFxAnalyseChannelProcessor *) g_object_new(AGS_TYPE_FX_ANALYSE_CHANNEL_PROCESSOR,
2638 "output-soundcard", output_soundcard,
2639 "source", channel,
2640 "recall-audio", fx_analyse_audio,
2641 "recall-audio-run", fx_analyse_audio_processor,
2642 "recall-channel", fx_analyse_channel,
2643 "recall-container", play_container,
2644 NULL);
2645 ags_recall_set_flags((AgsRecall *) fx_analyse_channel_processor,
2646 (AGS_RECALL_TEMPLATE));
2647 ags_recall_set_ability_flags((AgsRecall *) fx_analyse_channel_processor,
2648 (AGS_SOUND_ABILITY_PLAYBACK |
2649 AGS_SOUND_ABILITY_SEQUENCER |
2650 AGS_SOUND_ABILITY_NOTATION |
2651 AGS_SOUND_ABILITY_WAVE |
2652 AGS_SOUND_ABILITY_MIDI));
2653 ags_recall_set_behaviour_flags((AgsRecall *) fx_analyse_channel_processor,
2654 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2655
2656 ags_channel_insert_recall(channel, (GObject *) fx_analyse_channel_processor,
2657 TRUE,
2658 channel_position);
2659 ags_recall_container_add(play_container,
2660 fx_analyse_channel_processor);
2661
2662 start_recall = g_list_prepend(start_recall,
2663 fx_analyse_channel_processor);
2664
2665 ags_connectable_connect(AGS_CONNECTABLE(fx_analyse_channel_processor));
2666
2667 /* iterate */
2668 next_channel = ags_channel_next(channel);
2669
2670 g_object_unref(channel);
2671
2672 channel = next_channel;
2673 }
2674
2675 if(channel != NULL){
2676 g_object_unref(channel);
2677 }
2678 }
2679
2680 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
2681 if(fx_analyse_audio != NULL){
2682 g_object_unref(fx_analyse_audio);
2683 }
2684
2685 if(fx_analyse_audio_processor != NULL){
2686 g_object_unref(fx_analyse_audio_processor);
2687 }
2688 }
2689
2690 /* audio - recall context */
2691 fx_analyse_audio = NULL;
2692 fx_analyse_audio_processor = NULL;
2693
2694 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
2695 /* AgsFxAnalyseAudio */
2696 fx_analyse_audio = (AgsFxAnalyseAudio *) g_object_new(AGS_TYPE_FX_ANALYSE_AUDIO,
2697 "output-soundcard", output_soundcard,
2698 "audio", audio,
2699 "recall-container", recall_container,
2700 NULL);
2701 ags_recall_set_flags((AgsRecall *) fx_analyse_audio,
2702 (AGS_RECALL_TEMPLATE));
2703 ags_recall_set_ability_flags((AgsRecall *) fx_analyse_audio,
2704 (AGS_SOUND_ABILITY_PLAYBACK |
2705 AGS_SOUND_ABILITY_SEQUENCER |
2706 AGS_SOUND_ABILITY_NOTATION |
2707 AGS_SOUND_ABILITY_WAVE |
2708 AGS_SOUND_ABILITY_MIDI));
2709 ags_recall_set_behaviour_flags((AgsRecall *) fx_analyse_audio,
2710 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2711
2712 ags_audio_insert_recall(audio, (GObject *) fx_analyse_audio,
2713 FALSE,
2714 position);
2715 ags_recall_container_add(recall_container,
2716 fx_analyse_audio);
2717
2718 start_recall = g_list_prepend(start_recall,
2719 fx_analyse_audio);
2720
2721 ags_connectable_connect(AGS_CONNECTABLE(fx_analyse_audio));
2722
2723 /* AgsFxAnalyseAudioProcessor */
2724 fx_analyse_audio_processor = (AgsFxAnalyseAudioProcessor *) g_object_new(AGS_TYPE_FX_ANALYSE_AUDIO_PROCESSOR,
2725 "output-soundcard", output_soundcard,
2726 "audio", audio,
2727 "recall-audio", fx_analyse_audio,
2728 "recall-container", recall_container,
2729 NULL);
2730 ags_recall_set_flags((AgsRecall *) fx_analyse_audio_processor,
2731 (AGS_RECALL_TEMPLATE));
2732 ags_recall_set_ability_flags((AgsRecall *) fx_analyse_audio_processor,
2733 (AGS_SOUND_ABILITY_PLAYBACK |
2734 AGS_SOUND_ABILITY_SEQUENCER |
2735 AGS_SOUND_ABILITY_NOTATION |
2736 AGS_SOUND_ABILITY_WAVE |
2737 AGS_SOUND_ABILITY_MIDI));
2738 ags_recall_set_behaviour_flags((AgsRecall *) fx_analyse_audio_processor,
2739 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2740
2741 ags_audio_insert_recall(audio, (GObject *) fx_analyse_audio_processor,
2742 FALSE,
2743 position);
2744 ags_recall_container_add(recall_container,
2745 fx_analyse_audio_processor);
2746
2747 start_recall = g_list_prepend(start_recall,
2748 fx_analyse_audio_processor);
2749
2750 ags_connectable_connect(AGS_CONNECTABLE(fx_analyse_audio_processor));
2751 }else{
2752 GList *start_recall_audio_run, *recall_audio_run;
2753
2754 fx_analyse_audio = ags_recall_container_get_recall_audio(recall_container);
2755
2756 if(fx_analyse_audio != NULL){
2757 g_object_ref(fx_analyse_audio);
2758 }
2759
2760 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
2761
2762 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
2763 fx_analyse_audio_processor = recall_audio_run->data;
2764 g_object_ref(fx_analyse_audio_processor);
2765 }
2766 }
2767
2768 /* channel - recall context */
2769 for(i = 0; i < stop_pad - start_pad; i++){
2770 channel = ags_channel_pad_nth(start_input,
2771 start_pad + i);
2772
2773 next_channel = ags_channel_nth(channel,
2774 start_audio_channel);
2775
2776 if(channel != NULL){
2777 g_object_unref(channel);
2778 }
2779
2780 channel = next_channel;
2781
2782 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2783 /* AgsFxAnalyseChannel */
2784 fx_analyse_channel = (AgsFxAnalyseChannel *) g_object_new(AGS_TYPE_FX_ANALYSE_CHANNEL,
2785 "output-soundcard", output_soundcard,
2786 "source", channel,
2787 "recall-audio", fx_analyse_audio,
2788 "recall-container", recall_container,
2789 NULL);
2790 ags_recall_set_flags((AgsRecall *) fx_analyse_channel,
2791 (AGS_RECALL_TEMPLATE));
2792 ags_recall_set_ability_flags((AgsRecall *) fx_analyse_channel,
2793 (AGS_SOUND_ABILITY_PLAYBACK |
2794 AGS_SOUND_ABILITY_SEQUENCER |
2795 AGS_SOUND_ABILITY_NOTATION |
2796 AGS_SOUND_ABILITY_WAVE |
2797 AGS_SOUND_ABILITY_MIDI));
2798 ags_recall_set_behaviour_flags((AgsRecall *) fx_analyse_channel,
2799 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2800
2801 ags_channel_insert_recall(channel, (GObject *) fx_analyse_channel,
2802 FALSE,
2803 channel_position);
2804 ags_recall_container_add(recall_container,
2805 fx_analyse_channel);
2806
2807 start_recall = g_list_prepend(start_recall,
2808 fx_analyse_channel);
2809
2810 ags_connectable_connect(AGS_CONNECTABLE(fx_analyse_channel));
2811
2812 /* AgsFxAnalyseChannelProcessor */
2813 fx_analyse_channel_processor = (AgsFxAnalyseChannelProcessor *) g_object_new(AGS_TYPE_FX_ANALYSE_CHANNEL_PROCESSOR,
2814 "output-soundcard", output_soundcard,
2815 "source", channel,
2816 "recall-audio", fx_analyse_audio,
2817 "recall-audio-run", fx_analyse_audio_processor,
2818 "recall-channel", fx_analyse_channel,
2819 "recall-container", recall_container,
2820 NULL);
2821 ags_recall_set_flags((AgsRecall *) fx_analyse_channel_processor,
2822 (AGS_RECALL_TEMPLATE));
2823 ags_recall_set_ability_flags((AgsRecall *) fx_analyse_channel_processor,
2824 (AGS_SOUND_ABILITY_PLAYBACK |
2825 AGS_SOUND_ABILITY_SEQUENCER |
2826 AGS_SOUND_ABILITY_NOTATION |
2827 AGS_SOUND_ABILITY_WAVE |
2828 AGS_SOUND_ABILITY_MIDI));
2829 ags_recall_set_behaviour_flags((AgsRecall *) fx_analyse_channel_processor,
2830 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2831
2832 ags_channel_insert_recall(channel, (GObject *) fx_analyse_channel_processor,
2833 FALSE,
2834 channel_position);
2835 ags_recall_container_add(recall_container,
2836 fx_analyse_channel_processor);
2837
2838 start_recall = g_list_prepend(start_recall,
2839 fx_analyse_channel_processor);
2840
2841 ags_connectable_connect(AGS_CONNECTABLE(fx_analyse_channel_processor));
2842
2843 /* iterate */
2844 next_channel = ags_channel_next(channel);
2845
2846 g_object_unref(channel);
2847
2848 channel = next_channel;
2849 }
2850
2851 if(channel != NULL){
2852 g_object_unref(channel);
2853 }
2854 }
2855
2856 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
2857 if(fx_analyse_audio != NULL){
2858 g_object_unref(fx_analyse_audio);
2859 }
2860
2861 if(fx_analyse_audio_processor != NULL){
2862 g_object_unref(fx_analyse_audio_processor);
2863 }
2864 }
2865
2866 if(output_soundcard != NULL){
2867 g_object_unref(output_soundcard);
2868 }
2869
2870 if(input_sequencer != NULL){
2871 g_object_unref(input_sequencer);
2872 }
2873
2874 if(start_input != NULL){
2875 g_object_unref(start_input);
2876 }
2877
2878 return(start_recall);
2879 }
2880
2881 GList*
ags_fx_factory_create_two_pass_aliase(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)2882 ags_fx_factory_create_two_pass_aliase(AgsAudio *audio,
2883 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
2884 gchar *plugin_name,
2885 gchar *filename,
2886 gchar *effect,
2887 guint start_audio_channel, guint stop_audio_channel,
2888 guint start_pad, guint stop_pad,
2889 gint position,
2890 guint create_flags, guint recall_flags)
2891 {
2892 AgsChannel *start_input;
2893 AgsChannel *channel, *next_channel;
2894
2895 AgsFxTwoPassAliaseAudio *fx_two_pass_aliase_audio;
2896 AgsFxTwoPassAliaseAudioProcessor *fx_two_pass_aliase_audio_processor;
2897 AgsFxTwoPassAliaseChannel *fx_two_pass_aliase_channel;
2898 AgsFxTwoPassAliaseChannelProcessor *fx_two_pass_aliase_channel_processor;
2899
2900 GObject *output_soundcard;
2901 GObject *input_sequencer;
2902
2903 GList *start_recall;
2904
2905 gint channel_position;
2906 guint audio_channels;
2907 guint i, j;
2908
2909 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
2910 !AGS_IS_RECALL_CONTAINER(recall_container)){
2911 g_warning("ags-fx-two-pass-aliase recall container not provided");
2912
2913 return(NULL);
2914 }
2915
2916 start_recall = NULL;
2917
2918 g_object_get(audio,
2919 "output-soundcard", &output_soundcard,
2920 "input-sequencer", &input_sequencer,
2921 "input", &start_input,
2922 "audio-channels", &audio_channels,
2923 NULL);
2924
2925 channel_position = 0;
2926
2927 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
2928 channel_position = ags_fx_factory_get_output_position(audio,
2929 position);
2930 }else{
2931 channel_position = ags_fx_factory_get_input_position(audio,
2932 position);
2933 }
2934
2935 /* audio - play context */
2936 fx_two_pass_aliase_audio = NULL;
2937 fx_two_pass_aliase_audio_processor = NULL;
2938
2939 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
2940 /* AgsFxTwoPassAliaseAudio */
2941 fx_two_pass_aliase_audio = (AgsFxTwoPassAliaseAudio *) g_object_new(AGS_TYPE_FX_TWO_PASS_ALIASE_AUDIO,
2942 "output-soundcard", output_soundcard,
2943 "audio", audio,
2944 "recall-container", play_container,
2945 NULL);
2946 ags_recall_set_flags((AgsRecall *) fx_two_pass_aliase_audio,
2947 (AGS_RECALL_TEMPLATE));
2948 ags_recall_set_ability_flags((AgsRecall *) fx_two_pass_aliase_audio,
2949 (AGS_SOUND_ABILITY_PLAYBACK |
2950 AGS_SOUND_ABILITY_SEQUENCER |
2951 AGS_SOUND_ABILITY_NOTATION |
2952 AGS_SOUND_ABILITY_WAVE |
2953 AGS_SOUND_ABILITY_MIDI));
2954 ags_recall_set_behaviour_flags((AgsRecall *) fx_two_pass_aliase_audio,
2955 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2956
2957 ags_audio_insert_recall(audio, (GObject *) fx_two_pass_aliase_audio,
2958 TRUE,
2959 position);
2960 ags_recall_container_add(play_container,
2961 fx_two_pass_aliase_audio);
2962
2963 start_recall = g_list_prepend(start_recall,
2964 fx_two_pass_aliase_audio);
2965
2966 ags_connectable_connect(AGS_CONNECTABLE(fx_two_pass_aliase_audio));
2967
2968 /* AgsFxTwoPassAliaseAudioProcessor */
2969 fx_two_pass_aliase_audio_processor = (AgsFxTwoPassAliaseAudioProcessor *) g_object_new(AGS_TYPE_FX_TWO_PASS_ALIASE_AUDIO_PROCESSOR,
2970 "output-soundcard", output_soundcard,
2971 "audio", audio,
2972 "recall-audio", fx_two_pass_aliase_audio,
2973 "recall-container", play_container,
2974 NULL);
2975 ags_recall_set_flags((AgsRecall *) fx_two_pass_aliase_audio_processor,
2976 (AGS_RECALL_TEMPLATE));
2977 ags_recall_set_ability_flags((AgsRecall *) fx_two_pass_aliase_audio_processor,
2978 (AGS_SOUND_ABILITY_PLAYBACK |
2979 AGS_SOUND_ABILITY_SEQUENCER |
2980 AGS_SOUND_ABILITY_NOTATION |
2981 AGS_SOUND_ABILITY_WAVE |
2982 AGS_SOUND_ABILITY_MIDI));
2983 ags_recall_set_behaviour_flags((AgsRecall *) fx_two_pass_aliase_audio_processor,
2984 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2985
2986 ags_audio_insert_recall(audio, (GObject *) fx_two_pass_aliase_audio_processor,
2987 TRUE,
2988 position);
2989 ags_recall_container_add(play_container,
2990 fx_two_pass_aliase_audio_processor);
2991
2992 start_recall = g_list_prepend(start_recall,
2993 fx_two_pass_aliase_audio_processor);
2994
2995 ags_connectable_connect(AGS_CONNECTABLE(fx_two_pass_aliase_audio_processor));
2996 }else{
2997 GList *start_recall_audio_run, *recall_audio_run;
2998
2999 fx_two_pass_aliase_audio = ags_recall_container_get_recall_audio(play_container);
3000
3001 if(fx_two_pass_aliase_audio != NULL){
3002 g_object_ref(fx_two_pass_aliase_audio);
3003 }
3004
3005 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
3006
3007 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
3008 fx_two_pass_aliase_audio_processor = recall_audio_run->data;
3009 g_object_ref(fx_two_pass_aliase_audio_processor);
3010 }
3011 }
3012
3013 /* channel - play context */
3014 for(i = 0; i < stop_pad - start_pad; i++){
3015 channel = ags_channel_pad_nth(start_input,
3016 start_pad + i);
3017
3018 next_channel = ags_channel_nth(channel,
3019 start_audio_channel);
3020
3021 if(channel != NULL){
3022 g_object_unref(channel);
3023 }
3024
3025 channel = next_channel;
3026
3027 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
3028 /* AgsFxTwoPassAliaseChannel */
3029 fx_two_pass_aliase_channel = (AgsFxTwoPassAliaseChannel *) g_object_new(AGS_TYPE_FX_TWO_PASS_ALIASE_CHANNEL,
3030 "output-soundcard", output_soundcard,
3031 "source", channel,
3032 "recall-audio", fx_two_pass_aliase_audio,
3033 "recall-container", play_container,
3034 NULL);
3035 ags_recall_set_flags((AgsRecall *) fx_two_pass_aliase_channel,
3036 (AGS_RECALL_TEMPLATE));
3037 ags_recall_set_ability_flags((AgsRecall *) fx_two_pass_aliase_channel,
3038 (AGS_SOUND_ABILITY_PLAYBACK |
3039 AGS_SOUND_ABILITY_SEQUENCER |
3040 AGS_SOUND_ABILITY_NOTATION |
3041 AGS_SOUND_ABILITY_WAVE |
3042 AGS_SOUND_ABILITY_MIDI));
3043 ags_recall_set_behaviour_flags((AgsRecall *) fx_two_pass_aliase_channel,
3044 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3045
3046 ags_channel_insert_recall(channel, (GObject *) fx_two_pass_aliase_channel,
3047 TRUE,
3048 channel_position);
3049 ags_recall_container_add(play_container,
3050 fx_two_pass_aliase_channel);
3051
3052 start_recall = g_list_prepend(start_recall,
3053 fx_two_pass_aliase_channel);
3054
3055 ags_connectable_connect(AGS_CONNECTABLE(fx_two_pass_aliase_channel));
3056
3057 /* AgsFxTwoPassAliaseChannelProcessor */
3058 fx_two_pass_aliase_channel_processor = (AgsFxTwoPassAliaseChannelProcessor *) g_object_new(AGS_TYPE_FX_TWO_PASS_ALIASE_CHANNEL_PROCESSOR,
3059 "output-soundcard", output_soundcard,
3060 "source", channel,
3061 "recall-audio", fx_two_pass_aliase_audio,
3062 "recall-audio-run", fx_two_pass_aliase_audio_processor,
3063 "recall-channel", fx_two_pass_aliase_channel,
3064 "recall-container", play_container,
3065 NULL);
3066 ags_recall_set_flags((AgsRecall *) fx_two_pass_aliase_channel_processor,
3067 (AGS_RECALL_TEMPLATE));
3068 ags_recall_set_ability_flags((AgsRecall *) fx_two_pass_aliase_channel_processor,
3069 (AGS_SOUND_ABILITY_PLAYBACK |
3070 AGS_SOUND_ABILITY_SEQUENCER |
3071 AGS_SOUND_ABILITY_NOTATION |
3072 AGS_SOUND_ABILITY_WAVE |
3073 AGS_SOUND_ABILITY_MIDI));
3074 ags_recall_set_behaviour_flags((AgsRecall *) fx_two_pass_aliase_channel_processor,
3075 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3076
3077 ags_channel_insert_recall(channel, (GObject *) fx_two_pass_aliase_channel_processor,
3078 TRUE,
3079 channel_position);
3080 ags_recall_container_add(play_container,
3081 fx_two_pass_aliase_channel_processor);
3082
3083 start_recall = g_list_prepend(start_recall,
3084 fx_two_pass_aliase_channel_processor);
3085
3086 ags_connectable_connect(AGS_CONNECTABLE(fx_two_pass_aliase_channel_processor));
3087
3088 /* iterate */
3089 next_channel = ags_channel_next(channel);
3090
3091 g_object_unref(channel);
3092
3093 channel = next_channel;
3094 }
3095
3096 if(channel != NULL){
3097 g_object_unref(channel);
3098 }
3099 }
3100
3101 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
3102 if(fx_two_pass_aliase_audio != NULL){
3103 g_object_unref(fx_two_pass_aliase_audio);
3104 }
3105
3106 if(fx_two_pass_aliase_audio_processor != NULL){
3107 g_object_unref(fx_two_pass_aliase_audio_processor);
3108 }
3109 }
3110
3111 /* audio - recall context */
3112 fx_two_pass_aliase_audio = NULL;
3113 fx_two_pass_aliase_audio_processor = NULL;
3114
3115 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
3116 /* AgsFxTwoPassAliaseAudio */
3117 fx_two_pass_aliase_audio = (AgsFxTwoPassAliaseAudio *) g_object_new(AGS_TYPE_FX_TWO_PASS_ALIASE_AUDIO,
3118 "output-soundcard", output_soundcard,
3119 "audio", audio,
3120 "recall-container", play_container,
3121 NULL);
3122 ags_recall_set_flags((AgsRecall *) fx_two_pass_aliase_audio,
3123 (AGS_RECALL_TEMPLATE));
3124 ags_recall_set_ability_flags((AgsRecall *) fx_two_pass_aliase_audio,
3125 (AGS_SOUND_ABILITY_PLAYBACK |
3126 AGS_SOUND_ABILITY_SEQUENCER |
3127 AGS_SOUND_ABILITY_NOTATION |
3128 AGS_SOUND_ABILITY_WAVE |
3129 AGS_SOUND_ABILITY_MIDI));
3130 ags_recall_set_behaviour_flags((AgsRecall *) fx_two_pass_aliase_audio,
3131 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3132
3133 ags_audio_insert_recall(audio, (GObject *) fx_two_pass_aliase_audio,
3134 FALSE,
3135 position);
3136 ags_recall_container_add(recall_container,
3137 fx_two_pass_aliase_audio);
3138
3139 start_recall = g_list_prepend(start_recall,
3140 fx_two_pass_aliase_audio);
3141
3142 ags_connectable_connect(AGS_CONNECTABLE(fx_two_pass_aliase_audio));
3143
3144 /* AgsFxTwoPassAliaseAudioProcessor */
3145 fx_two_pass_aliase_audio_processor = (AgsFxTwoPassAliaseAudioProcessor *) g_object_new(AGS_TYPE_FX_TWO_PASS_ALIASE_AUDIO_PROCESSOR,
3146 "output-soundcard", output_soundcard,
3147 "audio", audio,
3148 "recall-audio", fx_two_pass_aliase_audio,
3149 "recall-container", play_container,
3150 NULL);
3151 ags_recall_set_flags((AgsRecall *) fx_two_pass_aliase_audio_processor,
3152 (AGS_RECALL_TEMPLATE));
3153 ags_recall_set_ability_flags((AgsRecall *) fx_two_pass_aliase_audio_processor,
3154 (AGS_SOUND_ABILITY_PLAYBACK |
3155 AGS_SOUND_ABILITY_SEQUENCER |
3156 AGS_SOUND_ABILITY_NOTATION |
3157 AGS_SOUND_ABILITY_WAVE |
3158 AGS_SOUND_ABILITY_MIDI));
3159 ags_recall_set_behaviour_flags((AgsRecall *) fx_two_pass_aliase_audio_processor,
3160 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3161
3162 ags_audio_insert_recall(audio, (GObject *) fx_two_pass_aliase_audio_processor,
3163 FALSE,
3164 position);
3165 ags_recall_container_add(recall_container,
3166 fx_two_pass_aliase_audio_processor);
3167
3168 start_recall = g_list_prepend(start_recall,
3169 fx_two_pass_aliase_audio_processor);
3170
3171 ags_connectable_connect(AGS_CONNECTABLE(fx_two_pass_aliase_audio_processor));
3172 }else{
3173 GList *start_recall_audio_run, *recall_audio_run;
3174
3175 fx_two_pass_aliase_audio = ags_recall_container_get_recall_audio(recall_container);
3176
3177 if(fx_two_pass_aliase_audio != NULL){
3178 g_object_ref(fx_two_pass_aliase_audio);
3179 }
3180
3181 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
3182
3183 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
3184 fx_two_pass_aliase_audio_processor = recall_audio_run->data;
3185 g_object_ref(fx_two_pass_aliase_audio_processor);
3186 }
3187 }
3188
3189 for(i = 0; i < stop_pad - start_pad; i++){
3190 channel = ags_channel_pad_nth(start_input,
3191 start_pad + i);
3192
3193 next_channel = ags_channel_nth(channel,
3194 start_audio_channel);
3195
3196 if(channel != NULL){
3197 g_object_unref(channel);
3198 }
3199
3200 channel = next_channel;
3201
3202 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
3203 /* AgsFxTwoPassAliaseChannel */
3204 fx_two_pass_aliase_channel = (AgsFxTwoPassAliaseChannel *) g_object_new(AGS_TYPE_FX_TWO_PASS_ALIASE_CHANNEL,
3205 "output-soundcard", output_soundcard,
3206 "source", channel,
3207 "recall-audio", fx_two_pass_aliase_audio,
3208 "recall-container", recall_container,
3209 NULL);
3210 ags_recall_set_flags((AgsRecall *) fx_two_pass_aliase_channel,
3211 (AGS_RECALL_TEMPLATE));
3212 ags_recall_set_ability_flags((AgsRecall *) fx_two_pass_aliase_channel,
3213 (AGS_SOUND_ABILITY_PLAYBACK |
3214 AGS_SOUND_ABILITY_SEQUENCER |
3215 AGS_SOUND_ABILITY_NOTATION |
3216 AGS_SOUND_ABILITY_WAVE |
3217 AGS_SOUND_ABILITY_MIDI));
3218 ags_recall_set_behaviour_flags((AgsRecall *) fx_two_pass_aliase_channel,
3219 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3220
3221 ags_channel_insert_recall(channel, (GObject *) fx_two_pass_aliase_channel,
3222 FALSE,
3223 channel_position);
3224 ags_recall_container_add(recall_container,
3225 fx_two_pass_aliase_channel);
3226
3227 start_recall = g_list_prepend(start_recall,
3228 fx_two_pass_aliase_channel);
3229
3230 ags_connectable_connect(AGS_CONNECTABLE(fx_two_pass_aliase_channel));
3231
3232 /* AgsFxTwoPassAliaseChannelProcessor */
3233 fx_two_pass_aliase_channel_processor = (AgsFxTwoPassAliaseChannelProcessor *) g_object_new(AGS_TYPE_FX_TWO_PASS_ALIASE_CHANNEL_PROCESSOR,
3234 "output-soundcard", output_soundcard,
3235 "source", channel,
3236 "recall-audio", fx_two_pass_aliase_audio,
3237 "recall-audio-run", fx_two_pass_aliase_audio_processor,
3238 "recall-channel", fx_two_pass_aliase_channel,
3239 "recall-container", recall_container,
3240 NULL);
3241 ags_recall_set_flags((AgsRecall *) fx_two_pass_aliase_channel_processor,
3242 (AGS_RECALL_TEMPLATE));
3243 ags_recall_set_ability_flags((AgsRecall *) fx_two_pass_aliase_channel_processor,
3244 (AGS_SOUND_ABILITY_PLAYBACK |
3245 AGS_SOUND_ABILITY_SEQUENCER |
3246 AGS_SOUND_ABILITY_NOTATION |
3247 AGS_SOUND_ABILITY_WAVE |
3248 AGS_SOUND_ABILITY_MIDI));
3249 ags_recall_set_behaviour_flags((AgsRecall *) fx_two_pass_aliase_channel_processor,
3250 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3251
3252 ags_channel_insert_recall(channel, (GObject *) fx_two_pass_aliase_channel_processor,
3253 FALSE,
3254 channel_position);
3255 ags_recall_container_add(recall_container,
3256 fx_two_pass_aliase_channel_processor);
3257
3258 start_recall = g_list_prepend(start_recall,
3259 fx_two_pass_aliase_channel_processor);
3260
3261 ags_connectable_connect(AGS_CONNECTABLE(fx_two_pass_aliase_channel_processor));
3262
3263 /* iterate */
3264 next_channel = ags_channel_nth(channel,
3265 audio_channels - stop_audio_channel + 1);
3266
3267 if(channel != NULL){
3268 g_object_unref(channel);
3269 }
3270
3271 channel = next_channel;
3272 }
3273 }
3274
3275 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
3276 if(fx_two_pass_aliase_audio != NULL){
3277 g_object_unref(fx_two_pass_aliase_audio);
3278 }
3279
3280 if(fx_two_pass_aliase_audio_processor != NULL){
3281 g_object_unref(fx_two_pass_aliase_audio_processor);
3282 }
3283 }
3284
3285 if(output_soundcard != NULL){
3286 g_object_unref(output_soundcard);
3287 }
3288
3289 if(input_sequencer != NULL){
3290 g_object_unref(input_sequencer);
3291 }
3292
3293 if(start_input != NULL){
3294 g_object_unref(start_input);
3295 }
3296
3297 return(start_recall);
3298 }
3299
3300 GList*
ags_fx_factory_create_lfo(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)3301 ags_fx_factory_create_lfo(AgsAudio *audio,
3302 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
3303 gchar *plugin_name,
3304 gchar *filename,
3305 gchar *effect,
3306 guint start_audio_channel, guint stop_audio_channel,
3307 guint start_pad, guint stop_pad,
3308 gint position,
3309 guint create_flags, guint recall_flags)
3310 {
3311 AgsChannel *start_input;
3312 AgsChannel *channel, *next_channel;
3313
3314 AgsFxLfoAudio *fx_lfo_audio;
3315 AgsFxLfoAudioProcessor *fx_lfo_audio_processor;
3316 AgsFxLfoChannel *fx_lfo_channel;
3317 AgsFxLfoChannelProcessor *fx_lfo_channel_processor;
3318
3319 GObject *output_soundcard;
3320 GObject *input_sequencer;
3321
3322 GList *start_recall;
3323
3324 gint channel_position;
3325 guint audio_channels;
3326 guint i, j;
3327
3328 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
3329 !AGS_IS_RECALL_CONTAINER(recall_container)){
3330 g_warning("ags-fx-lfo recall container not provided");
3331
3332 return(NULL);
3333 }
3334
3335 start_recall = NULL;
3336
3337 g_object_get(audio,
3338 "output-soundcard", &output_soundcard,
3339 "input-sequencer", &input_sequencer,
3340 "input", &start_input,
3341 "audio-channels", &audio_channels,
3342 NULL);
3343
3344 channel_position = 0;
3345
3346 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
3347 channel_position = ags_fx_factory_get_output_position(audio,
3348 position);
3349 }else{
3350 channel_position = ags_fx_factory_get_input_position(audio,
3351 position);
3352 }
3353
3354 /* audio - play context */
3355 fx_lfo_audio = NULL;
3356 fx_lfo_audio_processor = NULL;
3357
3358 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
3359 /* AgsFxLfoAudio */
3360 fx_lfo_audio = (AgsFxLfoAudio *) g_object_new(AGS_TYPE_FX_LFO_AUDIO,
3361 "output-soundcard", output_soundcard,
3362 "audio", audio,
3363 "recall-container", play_container,
3364 NULL);
3365 ags_recall_set_flags((AgsRecall *) fx_lfo_audio,
3366 (AGS_RECALL_TEMPLATE));
3367 ags_recall_set_ability_flags((AgsRecall *) fx_lfo_audio,
3368 (AGS_SOUND_ABILITY_PLAYBACK |
3369 AGS_SOUND_ABILITY_SEQUENCER |
3370 AGS_SOUND_ABILITY_NOTATION |
3371 AGS_SOUND_ABILITY_WAVE |
3372 AGS_SOUND_ABILITY_MIDI));
3373 ags_recall_set_behaviour_flags((AgsRecall *) fx_lfo_audio,
3374 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3375
3376 ags_audio_insert_recall(audio, (GObject *) fx_lfo_audio,
3377 TRUE,
3378 position);
3379 ags_recall_container_add(play_container,
3380 fx_lfo_audio);
3381
3382 start_recall = g_list_prepend(start_recall,
3383 fx_lfo_audio);
3384
3385 ags_connectable_connect(AGS_CONNECTABLE(fx_lfo_audio));
3386
3387 /* AgsFxLfoAudioProcessor */
3388 fx_lfo_audio_processor = (AgsFxLfoAudioProcessor *) g_object_new(AGS_TYPE_FX_LFO_AUDIO_PROCESSOR,
3389 "output-soundcard", output_soundcard,
3390 "audio", audio,
3391 "recall-audio", fx_lfo_audio,
3392 "recall-container", play_container,
3393 NULL);
3394 ags_recall_set_flags((AgsRecall *) fx_lfo_audio_processor,
3395 (AGS_RECALL_TEMPLATE));
3396 ags_recall_set_ability_flags((AgsRecall *) fx_lfo_audio_processor,
3397 (AGS_SOUND_ABILITY_PLAYBACK |
3398 AGS_SOUND_ABILITY_SEQUENCER |
3399 AGS_SOUND_ABILITY_NOTATION |
3400 AGS_SOUND_ABILITY_WAVE |
3401 AGS_SOUND_ABILITY_MIDI));
3402 ags_recall_set_behaviour_flags((AgsRecall *) fx_lfo_audio_processor,
3403 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3404
3405 ags_audio_insert_recall(audio, (GObject *) fx_lfo_audio_processor,
3406 TRUE,
3407 position);
3408 ags_recall_container_add(play_container,
3409 fx_lfo_audio_processor);
3410
3411 start_recall = g_list_prepend(start_recall,
3412 fx_lfo_audio_processor);
3413
3414 ags_connectable_connect(AGS_CONNECTABLE(fx_lfo_audio_processor));
3415 }else{
3416 GList *start_recall_audio_run, *recall_audio_run;
3417
3418 fx_lfo_audio = ags_recall_container_get_recall_audio(play_container);
3419
3420 if(fx_lfo_audio != NULL){
3421 g_object_ref(fx_lfo_audio);
3422 }
3423
3424 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
3425
3426 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
3427 fx_lfo_audio_processor = recall_audio_run->data;
3428 g_object_ref(fx_lfo_audio_processor);
3429 }
3430 }
3431
3432 /* channel - play context */
3433 for(i = 0; i < stop_pad - start_pad; i++){
3434 channel = ags_channel_pad_nth(start_input,
3435 start_pad + i);
3436
3437 next_channel = ags_channel_nth(channel,
3438 start_audio_channel);
3439
3440 if(channel != NULL){
3441 g_object_unref(channel);
3442 }
3443
3444 channel = next_channel;
3445
3446 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
3447 /* AgsFxLfoChannel */
3448 fx_lfo_channel = (AgsFxLfoChannel *) g_object_new(AGS_TYPE_FX_LFO_CHANNEL,
3449 "output-soundcard", output_soundcard,
3450 "source", channel,
3451 "recall-audio", fx_lfo_audio,
3452 "recall-container", play_container,
3453 NULL);
3454 ags_recall_set_flags((AgsRecall *) fx_lfo_channel,
3455 (AGS_RECALL_TEMPLATE));
3456 ags_recall_set_ability_flags((AgsRecall *) fx_lfo_channel,
3457 (AGS_SOUND_ABILITY_PLAYBACK |
3458 AGS_SOUND_ABILITY_SEQUENCER |
3459 AGS_SOUND_ABILITY_NOTATION |
3460 AGS_SOUND_ABILITY_WAVE |
3461 AGS_SOUND_ABILITY_MIDI));
3462 ags_recall_set_behaviour_flags((AgsRecall *) fx_lfo_channel,
3463 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3464
3465 ags_channel_insert_recall(channel, (GObject *) fx_lfo_channel,
3466 TRUE,
3467 channel_position);
3468 ags_recall_container_add(play_container,
3469 fx_lfo_channel);
3470
3471 start_recall = g_list_prepend(start_recall,
3472 fx_lfo_channel);
3473
3474 ags_connectable_connect(AGS_CONNECTABLE(fx_lfo_channel));
3475
3476 /* AgsFxLfoChannelProcessor */
3477 fx_lfo_channel_processor = (AgsFxLfoChannelProcessor *) g_object_new(AGS_TYPE_FX_LFO_CHANNEL_PROCESSOR,
3478 "output-soundcard", output_soundcard,
3479 "source", channel,
3480 "recall-audio", fx_lfo_audio,
3481 "recall-audio-run", fx_lfo_audio_processor,
3482 "recall-channel", fx_lfo_channel,
3483 "recall-container", play_container,
3484 NULL);
3485 ags_recall_set_flags((AgsRecall *) fx_lfo_channel_processor,
3486 (AGS_RECALL_TEMPLATE));
3487 ags_recall_set_ability_flags((AgsRecall *) fx_lfo_channel_processor,
3488 (AGS_SOUND_ABILITY_PLAYBACK |
3489 AGS_SOUND_ABILITY_SEQUENCER |
3490 AGS_SOUND_ABILITY_NOTATION |
3491 AGS_SOUND_ABILITY_WAVE |
3492 AGS_SOUND_ABILITY_MIDI));
3493 ags_recall_set_behaviour_flags((AgsRecall *) fx_lfo_channel_processor,
3494 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3495
3496 ags_channel_insert_recall(channel, (GObject *) fx_lfo_channel_processor,
3497 TRUE,
3498 channel_position);
3499 ags_recall_container_add(play_container,
3500 fx_lfo_channel_processor);
3501
3502 start_recall = g_list_prepend(start_recall,
3503 fx_lfo_channel_processor);
3504
3505 ags_connectable_connect(AGS_CONNECTABLE(fx_lfo_channel_processor));
3506
3507 /* iterate */
3508 next_channel = ags_channel_next(channel);
3509
3510 g_object_unref(channel);
3511
3512 channel = next_channel;
3513 }
3514
3515 if(channel != NULL){
3516 g_object_unref(channel);
3517 }
3518 }
3519
3520 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
3521 if(fx_lfo_audio != NULL){
3522 g_object_unref(fx_lfo_audio);
3523 }
3524
3525 if(fx_lfo_audio_processor != NULL){
3526 g_object_unref(fx_lfo_audio_processor);
3527 }
3528 }
3529
3530 /* audio - recall context */
3531 fx_lfo_audio = NULL;
3532 fx_lfo_audio_processor = NULL;
3533
3534 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
3535 /* AgsFxLfoAudio */
3536 fx_lfo_audio = (AgsFxLfoAudio *) g_object_new(AGS_TYPE_FX_LFO_AUDIO,
3537 "output-soundcard", output_soundcard,
3538 "audio", audio,
3539 "recall-container", play_container,
3540 NULL);
3541 ags_recall_set_flags((AgsRecall *) fx_lfo_audio,
3542 (AGS_RECALL_TEMPLATE));
3543 ags_recall_set_ability_flags((AgsRecall *) fx_lfo_audio,
3544 (AGS_SOUND_ABILITY_PLAYBACK |
3545 AGS_SOUND_ABILITY_SEQUENCER |
3546 AGS_SOUND_ABILITY_NOTATION |
3547 AGS_SOUND_ABILITY_WAVE |
3548 AGS_SOUND_ABILITY_MIDI));
3549 ags_recall_set_behaviour_flags((AgsRecall *) fx_lfo_audio,
3550 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3551
3552 ags_audio_insert_recall(audio, (GObject *) fx_lfo_audio,
3553 FALSE,
3554 position);
3555 ags_recall_container_add(recall_container,
3556 fx_lfo_audio);
3557
3558 start_recall = g_list_prepend(start_recall,
3559 fx_lfo_audio);
3560
3561 ags_connectable_connect(AGS_CONNECTABLE(fx_lfo_audio));
3562
3563 /* AgsFxLfoAudioProcessor */
3564 fx_lfo_audio_processor = (AgsFxLfoAudioProcessor *) g_object_new(AGS_TYPE_FX_LFO_AUDIO_PROCESSOR,
3565 "output-soundcard", output_soundcard,
3566 "audio", audio,
3567 "recall-audio", fx_lfo_audio,
3568 "recall-container", play_container,
3569 NULL);
3570 ags_recall_set_flags((AgsRecall *) fx_lfo_audio_processor,
3571 (AGS_RECALL_TEMPLATE));
3572 ags_recall_set_ability_flags((AgsRecall *) fx_lfo_audio_processor,
3573 (AGS_SOUND_ABILITY_PLAYBACK |
3574 AGS_SOUND_ABILITY_SEQUENCER |
3575 AGS_SOUND_ABILITY_NOTATION |
3576 AGS_SOUND_ABILITY_WAVE |
3577 AGS_SOUND_ABILITY_MIDI));
3578 ags_recall_set_behaviour_flags((AgsRecall *) fx_lfo_audio_processor,
3579 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3580
3581 ags_audio_insert_recall(audio, (GObject *) fx_lfo_audio_processor,
3582 FALSE,
3583 position);
3584 ags_recall_container_add(recall_container,
3585 fx_lfo_audio_processor);
3586
3587 start_recall = g_list_prepend(start_recall,
3588 fx_lfo_audio_processor);
3589
3590 ags_connectable_connect(AGS_CONNECTABLE(fx_lfo_audio_processor));
3591 }else{
3592 GList *start_recall_audio_run, *recall_audio_run;
3593
3594 fx_lfo_audio = ags_recall_container_get_recall_audio(recall_container);
3595
3596 if(fx_lfo_audio != NULL){
3597 g_object_ref(fx_lfo_audio);
3598 }
3599
3600 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
3601
3602 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
3603 fx_lfo_audio_processor = recall_audio_run->data;
3604 g_object_ref(fx_lfo_audio_processor);
3605 }
3606 }
3607
3608 for(i = 0; i < stop_pad - start_pad; i++){
3609 channel = ags_channel_pad_nth(start_input,
3610 start_pad + i);
3611
3612 next_channel = ags_channel_nth(channel,
3613 start_audio_channel);
3614
3615 if(channel != NULL){
3616 g_object_unref(channel);
3617 }
3618
3619 channel = next_channel;
3620
3621 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
3622 /* AgsFxLfoChannel */
3623 fx_lfo_channel = (AgsFxLfoChannel *) g_object_new(AGS_TYPE_FX_LFO_CHANNEL,
3624 "output-soundcard", output_soundcard,
3625 "source", channel,
3626 "recall-audio", fx_lfo_audio,
3627 "recall-container", recall_container,
3628 NULL);
3629 ags_recall_set_flags((AgsRecall *) fx_lfo_channel,
3630 (AGS_RECALL_TEMPLATE));
3631 ags_recall_set_ability_flags((AgsRecall *) fx_lfo_channel,
3632 (AGS_SOUND_ABILITY_PLAYBACK |
3633 AGS_SOUND_ABILITY_SEQUENCER |
3634 AGS_SOUND_ABILITY_NOTATION |
3635 AGS_SOUND_ABILITY_WAVE |
3636 AGS_SOUND_ABILITY_MIDI));
3637 ags_recall_set_behaviour_flags((AgsRecall *) fx_lfo_channel,
3638 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3639
3640 ags_channel_insert_recall(channel, (GObject *) fx_lfo_channel,
3641 FALSE,
3642 channel_position);
3643 ags_recall_container_add(recall_container,
3644 fx_lfo_channel);
3645
3646 start_recall = g_list_prepend(start_recall,
3647 fx_lfo_channel);
3648
3649 ags_connectable_connect(AGS_CONNECTABLE(fx_lfo_channel));
3650
3651 /* AgsFxLfoChannelProcessor */
3652 fx_lfo_channel_processor = (AgsFxLfoChannelProcessor *) g_object_new(AGS_TYPE_FX_LFO_CHANNEL_PROCESSOR,
3653 "output-soundcard", output_soundcard,
3654 "source", channel,
3655 "recall-audio", fx_lfo_audio,
3656 "recall-audio-run", fx_lfo_audio_processor,
3657 "recall-channel", fx_lfo_channel,
3658 "recall-container", recall_container,
3659 NULL);
3660 ags_recall_set_flags((AgsRecall *) fx_lfo_channel_processor,
3661 (AGS_RECALL_TEMPLATE));
3662 ags_recall_set_ability_flags((AgsRecall *) fx_lfo_channel_processor,
3663 (AGS_SOUND_ABILITY_PLAYBACK |
3664 AGS_SOUND_ABILITY_SEQUENCER |
3665 AGS_SOUND_ABILITY_NOTATION |
3666 AGS_SOUND_ABILITY_WAVE |
3667 AGS_SOUND_ABILITY_MIDI));
3668 ags_recall_set_behaviour_flags((AgsRecall *) fx_lfo_channel_processor,
3669 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3670
3671 ags_channel_insert_recall(channel, (GObject *) fx_lfo_channel_processor,
3672 FALSE,
3673 channel_position);
3674 ags_recall_container_add(recall_container,
3675 fx_lfo_channel_processor);
3676
3677 start_recall = g_list_prepend(start_recall,
3678 fx_lfo_channel_processor);
3679
3680 ags_connectable_connect(AGS_CONNECTABLE(fx_lfo_channel_processor));
3681
3682 /* iterate */
3683 next_channel = ags_channel_nth(channel,
3684 audio_channels - stop_audio_channel + 1);
3685
3686 if(channel != NULL){
3687 g_object_unref(channel);
3688 }
3689
3690 channel = next_channel;
3691 }
3692
3693 if(channel != NULL){
3694 g_object_unref(channel);
3695 }
3696 }
3697
3698 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
3699 if(fx_lfo_audio != NULL){
3700 g_object_unref(fx_lfo_audio);
3701 }
3702
3703 if(fx_lfo_audio_processor != NULL){
3704 g_object_unref(fx_lfo_audio_processor);
3705 }
3706 }
3707
3708 if(output_soundcard != NULL){
3709 g_object_unref(output_soundcard);
3710 }
3711
3712 if(input_sequencer != NULL){
3713 g_object_unref(input_sequencer);
3714 }
3715
3716 if(start_input != NULL){
3717 g_object_unref(start_input);
3718 }
3719
3720 return(start_recall);
3721 }
3722
3723 GList*
ags_fx_factory_create_envelope(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)3724 ags_fx_factory_create_envelope(AgsAudio *audio,
3725 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
3726 gchar *plugin_name,
3727 gchar *filename,
3728 gchar *effect,
3729 guint start_audio_channel, guint stop_audio_channel,
3730 guint start_pad, guint stop_pad,
3731 gint position,
3732 guint create_flags, guint recall_flags)
3733 {
3734 AgsChannel *start_input;
3735 AgsChannel *channel, *next_channel;
3736
3737 AgsFxEnvelopeAudio *fx_envelope_audio;
3738 AgsFxEnvelopeAudioProcessor *fx_envelope_audio_processor;
3739 AgsFxEnvelopeChannel *fx_envelope_channel;
3740 AgsFxEnvelopeChannelProcessor *fx_envelope_channel_processor;
3741
3742 GObject *output_soundcard;
3743 GObject *input_sequencer;
3744
3745 GList *start_recall;
3746
3747 gint channel_position;
3748 guint audio_channels;
3749 guint i, j;
3750
3751 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
3752 !AGS_IS_RECALL_CONTAINER(recall_container)){
3753 g_warning("ags-fx-envelope recall container not provided");
3754
3755 return(NULL);
3756 }
3757
3758 start_recall = NULL;
3759
3760 g_object_get(audio,
3761 "output-soundcard", &output_soundcard,
3762 "input-sequencer", &input_sequencer,
3763 "input", &start_input,
3764 "audio-channels", &audio_channels,
3765 NULL);
3766
3767 channel_position = 0;
3768
3769 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
3770 channel_position = ags_fx_factory_get_output_position(audio,
3771 position);
3772 }else{
3773 channel_position = ags_fx_factory_get_input_position(audio,
3774 position);
3775 }
3776
3777 /* audio - play context */
3778 fx_envelope_audio = NULL;
3779 fx_envelope_audio_processor = NULL;
3780
3781 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
3782 /* AgsFxEnvelopeAudio */
3783 fx_envelope_audio = (AgsFxEnvelopeAudio *) g_object_new(AGS_TYPE_FX_ENVELOPE_AUDIO,
3784 "output-soundcard", output_soundcard,
3785 "audio", audio,
3786 "recall-container", play_container,
3787 NULL);
3788 ags_recall_set_flags((AgsRecall *) fx_envelope_audio,
3789 (AGS_RECALL_TEMPLATE));
3790 ags_recall_set_ability_flags((AgsRecall *) fx_envelope_audio,
3791 (AGS_SOUND_ABILITY_PLAYBACK |
3792 AGS_SOUND_ABILITY_SEQUENCER |
3793 AGS_SOUND_ABILITY_NOTATION |
3794 AGS_SOUND_ABILITY_WAVE |
3795 AGS_SOUND_ABILITY_MIDI));
3796 ags_recall_set_behaviour_flags((AgsRecall *) fx_envelope_audio,
3797 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3798
3799 ags_audio_insert_recall(audio, (GObject *) fx_envelope_audio,
3800 TRUE,
3801 position);
3802 ags_recall_container_add(play_container,
3803 fx_envelope_audio);
3804
3805 start_recall = g_list_prepend(start_recall,
3806 fx_envelope_audio);
3807
3808 ags_connectable_connect(AGS_CONNECTABLE(fx_envelope_audio));
3809
3810 /* AgsFxEnvelopeAudioProcessor */
3811 fx_envelope_audio_processor = (AgsFxEnvelopeAudioProcessor *) g_object_new(AGS_TYPE_FX_ENVELOPE_AUDIO_PROCESSOR,
3812 "output-soundcard", output_soundcard,
3813 "audio", audio,
3814 "recall-audio", fx_envelope_audio,
3815 "recall-container", play_container,
3816 NULL);
3817 ags_recall_set_flags((AgsRecall *) fx_envelope_audio_processor,
3818 (AGS_RECALL_TEMPLATE));
3819 ags_recall_set_ability_flags((AgsRecall *) fx_envelope_audio_processor,
3820 (AGS_SOUND_ABILITY_PLAYBACK |
3821 AGS_SOUND_ABILITY_SEQUENCER |
3822 AGS_SOUND_ABILITY_NOTATION |
3823 AGS_SOUND_ABILITY_WAVE |
3824 AGS_SOUND_ABILITY_MIDI));
3825 ags_recall_set_behaviour_flags((AgsRecall *) fx_envelope_audio_processor,
3826 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3827
3828 ags_audio_insert_recall(audio, (GObject *) fx_envelope_audio_processor,
3829 TRUE,
3830 position);
3831 ags_recall_container_add(play_container,
3832 fx_envelope_audio_processor);
3833
3834 start_recall = g_list_prepend(start_recall,
3835 fx_envelope_audio_processor);
3836
3837 ags_connectable_connect(AGS_CONNECTABLE(fx_envelope_audio_processor));
3838 }else{
3839 GList *start_recall_audio_run, *recall_audio_run;
3840
3841 fx_envelope_audio = ags_recall_container_get_recall_audio(play_container);
3842
3843 if(fx_envelope_audio != NULL){
3844 g_object_ref(fx_envelope_audio);
3845 }
3846
3847 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
3848
3849 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
3850 fx_envelope_audio_processor = recall_audio_run->data;
3851 g_object_ref(fx_envelope_audio_processor);
3852 }
3853 }
3854
3855 /* channel - play context */
3856 for(i = 0; i < stop_pad - start_pad; i++){
3857 channel = ags_channel_pad_nth(start_input,
3858 start_pad + i);
3859
3860 next_channel = ags_channel_nth(channel,
3861 start_audio_channel);
3862
3863 if(channel != NULL){
3864 g_object_unref(channel);
3865 }
3866
3867 channel = next_channel;
3868
3869 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
3870 /* AgsFxEnvelopeChannel */
3871 fx_envelope_channel = (AgsFxEnvelopeChannel *) g_object_new(AGS_TYPE_FX_ENVELOPE_CHANNEL,
3872 "output-soundcard", output_soundcard,
3873 "source", channel,
3874 "recall-audio", fx_envelope_audio,
3875 "recall-container", play_container,
3876 NULL);
3877 ags_recall_set_flags((AgsRecall *) fx_envelope_channel,
3878 (AGS_RECALL_TEMPLATE));
3879 ags_recall_set_ability_flags((AgsRecall *) fx_envelope_channel,
3880 (AGS_SOUND_ABILITY_PLAYBACK |
3881 AGS_SOUND_ABILITY_SEQUENCER |
3882 AGS_SOUND_ABILITY_NOTATION |
3883 AGS_SOUND_ABILITY_WAVE |
3884 AGS_SOUND_ABILITY_MIDI));
3885 ags_recall_set_behaviour_flags((AgsRecall *) fx_envelope_channel,
3886 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3887
3888 ags_channel_insert_recall(channel, (GObject *) fx_envelope_channel,
3889 TRUE,
3890 channel_position);
3891 ags_recall_container_add(play_container,
3892 fx_envelope_channel);
3893
3894 start_recall = g_list_prepend(start_recall,
3895 fx_envelope_channel);
3896
3897 ags_connectable_connect(AGS_CONNECTABLE(fx_envelope_channel));
3898
3899 /* AgsFxEnvelopeChannelProcessor */
3900 fx_envelope_channel_processor = (AgsFxEnvelopeChannelProcessor *) g_object_new(AGS_TYPE_FX_ENVELOPE_CHANNEL_PROCESSOR,
3901 "output-soundcard", output_soundcard,
3902 "source", channel,
3903 "recall-audio", fx_envelope_audio,
3904 "recall-audio-run", fx_envelope_audio_processor,
3905 "recall-channel", fx_envelope_channel,
3906 "recall-container", play_container,
3907 NULL);
3908 ags_recall_set_flags((AgsRecall *) fx_envelope_channel_processor,
3909 (AGS_RECALL_TEMPLATE));
3910 ags_recall_set_ability_flags((AgsRecall *) fx_envelope_channel_processor,
3911 (AGS_SOUND_ABILITY_PLAYBACK |
3912 AGS_SOUND_ABILITY_SEQUENCER |
3913 AGS_SOUND_ABILITY_NOTATION |
3914 AGS_SOUND_ABILITY_WAVE |
3915 AGS_SOUND_ABILITY_MIDI));
3916 ags_recall_set_behaviour_flags((AgsRecall *) fx_envelope_channel_processor,
3917 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3918
3919 ags_channel_insert_recall(channel, (GObject *) fx_envelope_channel_processor,
3920 TRUE,
3921 channel_position);
3922 ags_recall_container_add(play_container,
3923 fx_envelope_channel_processor);
3924
3925 start_recall = g_list_prepend(start_recall,
3926 fx_envelope_channel_processor);
3927
3928 ags_connectable_connect(AGS_CONNECTABLE(fx_envelope_channel_processor));
3929
3930 /* iterate */
3931 next_channel = ags_channel_next(channel);
3932
3933 g_object_unref(channel);
3934
3935 channel = next_channel;
3936 }
3937
3938 if(channel != NULL){
3939 g_object_unref(channel);
3940 }
3941 }
3942
3943 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
3944 if(fx_envelope_audio != NULL){
3945 g_object_unref(fx_envelope_audio);
3946 }
3947
3948 if(fx_envelope_audio_processor != NULL){
3949 g_object_unref(fx_envelope_audio_processor);
3950 }
3951 }
3952
3953 /* audio - recall context */
3954 fx_envelope_audio = NULL;
3955 fx_envelope_audio_processor = NULL;
3956
3957 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
3958 /* AgsFxEnvelopeAudio */
3959 fx_envelope_audio = (AgsFxEnvelopeAudio *) g_object_new(AGS_TYPE_FX_ENVELOPE_AUDIO,
3960 "output-soundcard", output_soundcard,
3961 "audio", audio,
3962 "recall-container", recall_container,
3963 NULL);
3964 ags_recall_set_flags((AgsRecall *) fx_envelope_audio,
3965 (AGS_RECALL_TEMPLATE));
3966 ags_recall_set_ability_flags((AgsRecall *) fx_envelope_audio,
3967 (AGS_SOUND_ABILITY_PLAYBACK |
3968 AGS_SOUND_ABILITY_SEQUENCER |
3969 AGS_SOUND_ABILITY_NOTATION |
3970 AGS_SOUND_ABILITY_WAVE |
3971 AGS_SOUND_ABILITY_MIDI));
3972 ags_recall_set_behaviour_flags((AgsRecall *) fx_envelope_audio,
3973 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3974
3975 ags_audio_insert_recall(audio, (GObject *) fx_envelope_audio,
3976 FALSE,
3977 position);
3978 ags_recall_container_add(recall_container,
3979 fx_envelope_audio);
3980
3981 start_recall = g_list_prepend(start_recall,
3982 fx_envelope_audio);
3983
3984 ags_connectable_connect(AGS_CONNECTABLE(fx_envelope_audio));
3985
3986 /* AgsFxEnvelopeAudioProcessor */
3987 fx_envelope_audio_processor = (AgsFxEnvelopeAudioProcessor *) g_object_new(AGS_TYPE_FX_ENVELOPE_AUDIO_PROCESSOR,
3988 "output-soundcard", output_soundcard,
3989 "audio", audio,
3990 "recall-audio", fx_envelope_audio,
3991 "recall-container", recall_container,
3992 NULL);
3993 ags_recall_set_flags((AgsRecall *) fx_envelope_audio_processor,
3994 (AGS_RECALL_TEMPLATE));
3995 ags_recall_set_ability_flags((AgsRecall *) fx_envelope_audio_processor,
3996 (AGS_SOUND_ABILITY_PLAYBACK |
3997 AGS_SOUND_ABILITY_SEQUENCER |
3998 AGS_SOUND_ABILITY_NOTATION |
3999 AGS_SOUND_ABILITY_WAVE |
4000 AGS_SOUND_ABILITY_MIDI));
4001 ags_recall_set_behaviour_flags((AgsRecall *) fx_envelope_audio_processor,
4002 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4003
4004 ags_audio_insert_recall(audio, (GObject *) fx_envelope_audio_processor,
4005 FALSE,
4006 position);
4007 ags_recall_container_add(recall_container,
4008 fx_envelope_audio_processor);
4009
4010 start_recall = g_list_prepend(start_recall,
4011 fx_envelope_audio_processor);
4012
4013 ags_connectable_connect(AGS_CONNECTABLE(fx_envelope_audio_processor));
4014 }else{
4015 GList *start_recall_audio_run, *recall_audio_run;
4016
4017 fx_envelope_audio = ags_recall_container_get_recall_audio(recall_container);
4018
4019 if(fx_envelope_audio != NULL){
4020 g_object_ref(fx_envelope_audio);
4021 }
4022
4023 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
4024
4025 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
4026 fx_envelope_audio_processor = recall_audio_run->data;
4027 g_object_ref(fx_envelope_audio_processor);
4028 }
4029 }
4030
4031 /* channel - recall context */
4032 for(i = 0; i < stop_pad - start_pad; i++){
4033 channel = ags_channel_pad_nth(start_input,
4034 start_pad + i);
4035
4036 next_channel = ags_channel_nth(channel,
4037 start_audio_channel);
4038
4039 if(channel != NULL){
4040 g_object_unref(channel);
4041 }
4042
4043 channel = next_channel;
4044
4045 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
4046 /* AgsFxEnvelopeChannel */
4047 fx_envelope_channel = (AgsFxEnvelopeChannel *) g_object_new(AGS_TYPE_FX_ENVELOPE_CHANNEL,
4048 "output-soundcard", output_soundcard,
4049 "source", channel,
4050 "recall-audio", fx_envelope_audio,
4051 "recall-container", recall_container,
4052 NULL);
4053 ags_recall_set_flags((AgsRecall *) fx_envelope_channel,
4054 (AGS_RECALL_TEMPLATE));
4055 ags_recall_set_ability_flags((AgsRecall *) fx_envelope_channel,
4056 (AGS_SOUND_ABILITY_PLAYBACK |
4057 AGS_SOUND_ABILITY_SEQUENCER |
4058 AGS_SOUND_ABILITY_NOTATION |
4059 AGS_SOUND_ABILITY_WAVE |
4060 AGS_SOUND_ABILITY_MIDI));
4061 ags_recall_set_behaviour_flags((AgsRecall *) fx_envelope_channel,
4062 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4063
4064 ags_channel_insert_recall(channel, (GObject *) fx_envelope_channel,
4065 FALSE,
4066 channel_position);
4067 ags_recall_container_add(recall_container,
4068 fx_envelope_channel);
4069
4070 start_recall = g_list_prepend(start_recall,
4071 fx_envelope_channel);
4072
4073 ags_connectable_connect(AGS_CONNECTABLE(fx_envelope_channel));
4074
4075 /* AgsFxEnvelopeChannelProcessor */
4076 fx_envelope_channel_processor = (AgsFxEnvelopeChannelProcessor *) g_object_new(AGS_TYPE_FX_ENVELOPE_CHANNEL_PROCESSOR,
4077 "output-soundcard", output_soundcard,
4078 "source", channel,
4079 "recall-audio", fx_envelope_audio,
4080 "recall-audio-run", fx_envelope_audio_processor,
4081 "recall-channel", fx_envelope_channel,
4082 "recall-container", recall_container,
4083 NULL);
4084 ags_recall_set_flags((AgsRecall *) fx_envelope_channel_processor,
4085 (AGS_RECALL_TEMPLATE));
4086 ags_recall_set_ability_flags((AgsRecall *) fx_envelope_channel_processor,
4087 (AGS_SOUND_ABILITY_PLAYBACK |
4088 AGS_SOUND_ABILITY_SEQUENCER |
4089 AGS_SOUND_ABILITY_NOTATION |
4090 AGS_SOUND_ABILITY_WAVE |
4091 AGS_SOUND_ABILITY_MIDI));
4092 ags_recall_set_behaviour_flags((AgsRecall *) fx_envelope_channel_processor,
4093 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4094
4095 ags_channel_insert_recall(channel, (GObject *) fx_envelope_channel_processor,
4096 FALSE,
4097 channel_position);
4098 ags_recall_container_add(recall_container,
4099 fx_envelope_channel_processor);
4100
4101 start_recall = g_list_prepend(start_recall,
4102 fx_envelope_channel_processor);
4103
4104 ags_connectable_connect(AGS_CONNECTABLE(fx_envelope_channel_processor));
4105
4106 /* iterate */
4107 next_channel = ags_channel_next(channel);
4108
4109 g_object_unref(channel);
4110
4111 channel = next_channel;
4112 }
4113
4114 if(channel != NULL){
4115 g_object_unref(channel);
4116 }
4117 }
4118
4119 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
4120 if(fx_envelope_audio != NULL){
4121 g_object_unref(fx_envelope_audio);
4122 }
4123
4124 if(fx_envelope_audio_processor != NULL){
4125 g_object_unref(fx_envelope_audio_processor);
4126 }
4127 }
4128
4129 if(output_soundcard != NULL){
4130 g_object_unref(output_soundcard);
4131 }
4132
4133 if(input_sequencer != NULL){
4134 g_object_unref(input_sequencer);
4135 }
4136
4137 if(start_input != NULL){
4138 g_object_unref(start_input);
4139 }
4140
4141 return(start_recall);
4142 }
4143
4144 GList*
ags_fx_factory_create_pattern(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)4145 ags_fx_factory_create_pattern(AgsAudio *audio,
4146 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
4147 gchar *plugin_name,
4148 gchar *filename,
4149 gchar *effect,
4150 guint start_audio_channel, guint stop_audio_channel,
4151 guint start_pad, guint stop_pad,
4152 gint position,
4153 guint create_flags, guint recall_flags)
4154 {
4155 AgsChannel *start_input;
4156 AgsChannel *channel, *next_channel;
4157
4158 AgsFxPatternAudio *fx_pattern_audio;
4159 AgsFxPatternAudioProcessor *fx_pattern_audio_processor;
4160 AgsFxPatternChannel *fx_pattern_channel;
4161 AgsFxPatternChannelProcessor *fx_pattern_channel_processor;
4162
4163 GObject *output_soundcard;
4164 GObject *input_sequencer;
4165
4166 GList *start_recall;
4167
4168 gint channel_position;
4169 guint audio_channels;
4170 guint i, j;
4171
4172 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
4173 !AGS_IS_RECALL_CONTAINER(recall_container)){
4174 g_warning("ags-fx-pattern recall container not provided");
4175
4176 return(NULL);
4177 }
4178
4179 start_recall = NULL;
4180
4181 g_object_get(audio,
4182 "output-soundcard", &output_soundcard,
4183 "input-sequencer", &input_sequencer,
4184 "input", &start_input,
4185 "audio-channels", &audio_channels,
4186 NULL);
4187
4188 channel_position = 0;
4189
4190 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
4191 channel_position = ags_fx_factory_get_output_position(audio,
4192 position);
4193 }else{
4194 channel_position = ags_fx_factory_get_input_position(audio,
4195 position);
4196 }
4197
4198 /* audio - play context */
4199 fx_pattern_audio = NULL;
4200 fx_pattern_audio_processor = NULL;
4201
4202 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
4203 /* AgsFxPatternAudio */
4204 fx_pattern_audio = (AgsFxPatternAudio *) g_object_new(AGS_TYPE_FX_PATTERN_AUDIO,
4205 "output-soundcard", output_soundcard,
4206 "audio", audio,
4207 "recall-container", play_container,
4208 NULL);
4209 ags_recall_set_flags((AgsRecall *) fx_pattern_audio,
4210 (AGS_RECALL_TEMPLATE));
4211 ags_recall_set_ability_flags((AgsRecall *) fx_pattern_audio,
4212 (AGS_SOUND_ABILITY_SEQUENCER));
4213 ags_recall_set_behaviour_flags((AgsRecall *) fx_pattern_audio,
4214 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4215
4216 ags_audio_insert_recall(audio, (GObject *) fx_pattern_audio,
4217 TRUE,
4218 position);
4219 ags_recall_container_add(play_container,
4220 fx_pattern_audio);
4221
4222 start_recall = g_list_prepend(start_recall,
4223 fx_pattern_audio);
4224
4225 ags_connectable_connect(AGS_CONNECTABLE(fx_pattern_audio));
4226
4227 /* AgsFxPatternAudioProcessor */
4228 fx_pattern_audio_processor = (AgsFxPatternAudioProcessor *) g_object_new(AGS_TYPE_FX_PATTERN_AUDIO_PROCESSOR,
4229 "output-soundcard", output_soundcard,
4230 "audio", audio,
4231 "recall-audio", fx_pattern_audio,
4232 "recall-container", play_container,
4233 NULL);
4234 ags_recall_set_flags((AgsRecall *) fx_pattern_audio_processor,
4235 (AGS_RECALL_TEMPLATE));
4236 ags_recall_set_ability_flags((AgsRecall *) fx_pattern_audio_processor,
4237 (AGS_SOUND_ABILITY_SEQUENCER));
4238 ags_recall_set_behaviour_flags((AgsRecall *) fx_pattern_audio_processor,
4239 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4240
4241 ags_audio_insert_recall(audio, (GObject *) fx_pattern_audio_processor,
4242 TRUE,
4243 position);
4244 ags_recall_container_add(play_container,
4245 fx_pattern_audio_processor);
4246
4247 start_recall = g_list_prepend(start_recall,
4248 fx_pattern_audio_processor);
4249
4250 ags_connectable_connect(AGS_CONNECTABLE(fx_pattern_audio_processor));
4251 }else{
4252 GList *start_recall_audio_run, *recall_audio_run;
4253
4254 fx_pattern_audio = ags_recall_container_get_recall_audio(play_container);
4255
4256 if(fx_pattern_audio != NULL){
4257 g_object_ref(fx_pattern_audio);
4258 }
4259
4260 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
4261
4262 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
4263 fx_pattern_audio_processor = recall_audio_run->data;
4264 g_object_ref(fx_pattern_audio_processor);
4265 }
4266 }
4267
4268 for(i = 0; i < stop_pad - start_pad; i++){
4269 channel = ags_channel_pad_nth(start_input,
4270 start_pad + i);
4271
4272 next_channel = ags_channel_nth(channel,
4273 start_audio_channel);
4274
4275 if(channel != NULL){
4276 g_object_unref(channel);
4277 }
4278
4279 channel = next_channel;
4280
4281 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
4282 ags_channel_add_recall_container(channel,
4283 (GObject *) recall_container);
4284
4285 /* AgsFxPatternChannel */
4286 fx_pattern_channel = (AgsFxPatternChannel *) g_object_new(AGS_TYPE_FX_PATTERN_CHANNEL,
4287 "output-soundcard", output_soundcard,
4288 "source", channel,
4289 "recall-audio", fx_pattern_audio,
4290 "recall-container", play_container,
4291 NULL);
4292 ags_recall_set_flags((AgsRecall *) fx_pattern_channel,
4293 (AGS_RECALL_TEMPLATE));
4294 ags_recall_set_ability_flags((AgsRecall *) fx_pattern_channel,
4295 (AGS_SOUND_ABILITY_SEQUENCER));
4296 ags_recall_set_behaviour_flags((AgsRecall *) fx_pattern_channel,
4297 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4298
4299 ags_channel_insert_recall(channel, (GObject *) fx_pattern_channel,
4300 TRUE,
4301 channel_position);
4302 ags_recall_container_add(play_container,
4303 fx_pattern_channel);
4304
4305 start_recall = g_list_prepend(start_recall,
4306 fx_pattern_channel);
4307
4308 ags_connectable_connect(AGS_CONNECTABLE(fx_pattern_channel));
4309
4310 /* AgsFxPatternChannelProcessor */
4311 fx_pattern_channel_processor = (AgsFxPatternChannelProcessor *) g_object_new(AGS_TYPE_FX_PATTERN_CHANNEL_PROCESSOR,
4312 "output-soundcard", output_soundcard,
4313 "source", channel,
4314 "recall-audio", fx_pattern_audio,
4315 "recall-audio-run", fx_pattern_audio_processor,
4316 "recall-channel", fx_pattern_channel,
4317 "recall-container", play_container,
4318 NULL);
4319 ags_recall_set_flags((AgsRecall *) fx_pattern_channel_processor,
4320 (AGS_RECALL_TEMPLATE));
4321 ags_recall_set_ability_flags((AgsRecall *) fx_pattern_channel_processor,
4322 (AGS_SOUND_ABILITY_SEQUENCER));
4323 ags_recall_set_behaviour_flags((AgsRecall *) fx_pattern_channel_processor,
4324 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4325
4326 ags_channel_insert_recall(channel, (GObject *) fx_pattern_channel_processor,
4327 TRUE,
4328 channel_position);
4329 ags_recall_container_add(play_container,
4330 fx_pattern_channel_processor);
4331
4332 start_recall = g_list_prepend(start_recall,
4333 fx_pattern_channel_processor);
4334
4335 ags_connectable_connect(AGS_CONNECTABLE(fx_pattern_channel_processor));
4336
4337 /* iterate */
4338 next_channel = ags_channel_next(channel);
4339
4340 g_object_unref(channel);
4341
4342 channel = next_channel;
4343 }
4344
4345 if(channel != NULL){
4346 g_object_unref(channel);
4347 }
4348 }
4349
4350 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
4351 if(fx_pattern_audio != NULL){
4352 g_object_unref(fx_pattern_audio);
4353 }
4354
4355 if(fx_pattern_audio_processor != NULL){
4356 g_object_unref(fx_pattern_audio_processor);
4357 }
4358 }
4359
4360 /* audio - recall context */
4361 fx_pattern_audio = NULL;
4362 fx_pattern_audio_processor = NULL;
4363
4364 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
4365 /* AgsFxPatternAudio */
4366 fx_pattern_audio = (AgsFxPatternAudio *) g_object_new(AGS_TYPE_FX_PATTERN_AUDIO,
4367 "output-soundcard", output_soundcard,
4368 "audio", audio,
4369 "recall-container", recall_container,
4370 NULL);
4371 ags_recall_set_flags((AgsRecall *) fx_pattern_audio,
4372 (AGS_RECALL_TEMPLATE));
4373 ags_recall_set_ability_flags((AgsRecall *) fx_pattern_audio,
4374 (AGS_SOUND_ABILITY_SEQUENCER));
4375 ags_recall_set_behaviour_flags((AgsRecall *) fx_pattern_audio,
4376 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4377
4378 ags_audio_insert_recall(audio, (GObject *) fx_pattern_audio,
4379 FALSE,
4380 position);
4381 ags_recall_container_add(recall_container,
4382 fx_pattern_audio);
4383
4384 start_recall = g_list_prepend(start_recall,
4385 fx_pattern_audio);
4386 ags_connectable_connect(AGS_CONNECTABLE(fx_pattern_audio));
4387
4388 /* AgsFxPatternAudioProcessor */
4389 fx_pattern_audio_processor = (AgsFxPatternAudioProcessor *) g_object_new(AGS_TYPE_FX_PATTERN_AUDIO_PROCESSOR,
4390 "output-soundcard", output_soundcard,
4391 "audio", audio,
4392 "recall-audio", fx_pattern_audio,
4393 "recall-container", recall_container,
4394 NULL);
4395 ags_recall_set_flags((AgsRecall *) fx_pattern_audio_processor,
4396 (AGS_RECALL_TEMPLATE));
4397 ags_recall_set_ability_flags((AgsRecall *) fx_pattern_audio_processor,
4398 (AGS_SOUND_ABILITY_SEQUENCER));
4399 ags_recall_set_behaviour_flags((AgsRecall *) fx_pattern_audio_processor,
4400 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4401
4402 ags_audio_insert_recall(audio, (GObject *) fx_pattern_audio_processor,
4403 FALSE,
4404 position);
4405 ags_recall_container_add(recall_container,
4406 fx_pattern_audio_processor);
4407
4408 start_recall = g_list_prepend(start_recall,
4409 fx_pattern_audio_processor);
4410
4411 ags_connectable_connect(AGS_CONNECTABLE(fx_pattern_audio_processor));
4412 }else{
4413 GList *start_recall_audio_run, *recall_audio_run;
4414
4415 fx_pattern_audio = ags_recall_container_get_recall_audio(recall_container);
4416
4417 if(fx_pattern_audio != NULL){
4418 g_object_ref(fx_pattern_audio);
4419 }
4420
4421 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
4422
4423 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
4424 fx_pattern_audio_processor = recall_audio_run->data;
4425 g_object_ref(fx_pattern_audio_processor);
4426 }
4427 }
4428
4429 for(i = 0; i < stop_pad - start_pad; i++){
4430 channel = ags_channel_pad_nth(start_input,
4431 start_pad + i);
4432
4433 next_channel = ags_channel_nth(channel,
4434 start_audio_channel);
4435
4436 if(channel != NULL){
4437 g_object_unref(channel);
4438 }
4439
4440 channel = next_channel;
4441
4442 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
4443 ags_channel_add_recall_container(channel,
4444 (GObject *) recall_container);
4445
4446 /* AgsFxPatternChannel */
4447 fx_pattern_channel = (AgsFxPatternChannel *) g_object_new(AGS_TYPE_FX_PATTERN_CHANNEL,
4448 "output-soundcard", output_soundcard,
4449 "source", channel,
4450 "recall-audio", fx_pattern_audio,
4451 "recall-container", recall_container,
4452 NULL);
4453 ags_recall_set_flags((AgsRecall *) fx_pattern_channel,
4454 (AGS_RECALL_TEMPLATE));
4455 ags_recall_set_ability_flags((AgsRecall *) fx_pattern_channel,
4456 (AGS_SOUND_ABILITY_SEQUENCER));
4457 ags_recall_set_behaviour_flags((AgsRecall *) fx_pattern_channel,
4458 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4459
4460 ags_channel_insert_recall(channel, (GObject *) fx_pattern_channel,
4461 FALSE,
4462 channel_position);
4463 ags_recall_container_add(recall_container,
4464 fx_pattern_channel);
4465
4466 start_recall = g_list_prepend(start_recall,
4467 fx_pattern_channel);
4468
4469 ags_connectable_connect(AGS_CONNECTABLE(fx_pattern_channel));
4470
4471 /* AgsFxPatternChannelProcessor */
4472 fx_pattern_channel_processor = (AgsFxPatternChannelProcessor *) g_object_new(AGS_TYPE_FX_PATTERN_CHANNEL_PROCESSOR,
4473 "output-soundcard", output_soundcard,
4474 "source", channel,
4475 "recall-audio", fx_pattern_audio,
4476 "recall-audio-run", fx_pattern_audio_processor,
4477 "recall-channel", fx_pattern_channel,
4478 "recall-container", recall_container,
4479 NULL);
4480 ags_recall_set_flags((AgsRecall *) fx_pattern_channel_processor,
4481 (AGS_RECALL_TEMPLATE));
4482 ags_recall_set_ability_flags((AgsRecall *) fx_pattern_channel_processor,
4483 (AGS_SOUND_ABILITY_SEQUENCER));
4484 ags_recall_set_behaviour_flags((AgsRecall *) fx_pattern_channel_processor,
4485 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4486
4487 ags_channel_insert_recall(channel, (GObject *) fx_pattern_channel_processor,
4488 FALSE,
4489 channel_position);
4490 ags_recall_container_add(recall_container,
4491 fx_pattern_channel_processor);
4492
4493 start_recall = g_list_prepend(start_recall,
4494 fx_pattern_channel_processor);
4495
4496 ags_connectable_connect(AGS_CONNECTABLE(fx_pattern_channel_processor));
4497
4498 /* iterate */
4499 next_channel = ags_channel_next(channel);
4500
4501 g_object_unref(channel);
4502
4503 channel = next_channel;
4504 }
4505
4506 if(channel != NULL){
4507 g_object_unref(channel);
4508 }
4509 }
4510
4511 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
4512 if(fx_pattern_audio != NULL){
4513 g_object_unref(fx_pattern_audio);
4514 }
4515
4516 if(fx_pattern_audio_processor != NULL){
4517 g_object_unref(fx_pattern_audio_processor);
4518 }
4519 }
4520
4521 if(output_soundcard != NULL){
4522 g_object_unref(output_soundcard);
4523 }
4524
4525 if(input_sequencer != NULL){
4526 g_object_unref(input_sequencer);
4527 }
4528
4529 if(start_input != NULL){
4530 g_object_unref(start_input);
4531 }
4532
4533 return(start_recall);
4534 }
4535
4536 GList*
ags_fx_factory_create_notation(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)4537 ags_fx_factory_create_notation(AgsAudio *audio,
4538 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
4539 gchar *plugin_name,
4540 gchar *filename,
4541 gchar *effect,
4542 guint start_audio_channel, guint stop_audio_channel,
4543 guint start_pad, guint stop_pad,
4544 gint position,
4545 guint create_flags, guint recall_flags)
4546 {
4547 AgsChannel *start_input;
4548 AgsChannel *channel, *next_channel;
4549
4550 AgsFxNotationAudio *fx_notation_audio;
4551 AgsFxNotationAudioProcessor *fx_notation_audio_processor;
4552 AgsFxNotationChannel *fx_notation_channel;
4553 AgsFxNotationChannelProcessor *fx_notation_channel_processor;
4554
4555 GObject *output_soundcard;
4556 GObject *input_sequencer;
4557
4558 GList *start_recall;
4559
4560 gint channel_position;
4561 guint audio_channels;
4562 guint i, j;
4563
4564 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
4565 !AGS_IS_RECALL_CONTAINER(recall_container)){
4566 g_warning("ags-fx-notation recall container not provided");
4567
4568 return(NULL);
4569 }
4570
4571 start_recall = NULL;
4572
4573 g_object_get(audio,
4574 "output-soundcard", &output_soundcard,
4575 "input-sequencer", &input_sequencer,
4576 "input", &start_input,
4577 "audio-channels", &audio_channels,
4578 NULL);
4579
4580 channel_position = 0;
4581
4582 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
4583 channel_position = ags_fx_factory_get_output_position(audio,
4584 position);
4585 }else{
4586 channel_position = ags_fx_factory_get_input_position(audio,
4587 position);
4588 }
4589
4590 /* audio - play context */
4591 fx_notation_audio = NULL;
4592 fx_notation_audio_processor = NULL;
4593
4594 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
4595 /* AgsFxNotationAudio */
4596 fx_notation_audio = (AgsFxNotationAudio *) g_object_new(AGS_TYPE_FX_NOTATION_AUDIO,
4597 "output-soundcard", output_soundcard,
4598 "audio", audio,
4599 "recall-container", play_container,
4600 NULL);
4601 ags_recall_set_flags((AgsRecall *) fx_notation_audio,
4602 (AGS_RECALL_TEMPLATE));
4603 ags_recall_set_ability_flags((AgsRecall *) fx_notation_audio,
4604 (AGS_SOUND_ABILITY_PLAYBACK |
4605 AGS_SOUND_ABILITY_NOTATION |
4606 AGS_SOUND_ABILITY_MIDI));
4607 ags_recall_set_behaviour_flags((AgsRecall *) fx_notation_audio,
4608 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4609
4610 ags_audio_insert_recall(audio, (GObject *) fx_notation_audio,
4611 TRUE,
4612 position);
4613 ags_recall_container_add(play_container,
4614 fx_notation_audio);
4615
4616 start_recall = g_list_prepend(start_recall,
4617 fx_notation_audio);
4618
4619 ags_connectable_connect(AGS_CONNECTABLE(fx_notation_audio));
4620
4621 /* AgsFxNotationAudioProcessor */
4622 fx_notation_audio_processor = (AgsFxNotationAudioProcessor *) g_object_new(AGS_TYPE_FX_NOTATION_AUDIO_PROCESSOR,
4623 "output-soundcard", output_soundcard,
4624 "audio", audio,
4625 "recall-audio", fx_notation_audio,
4626 "recall-container", play_container,
4627 NULL);
4628 ags_recall_set_flags((AgsRecall *) fx_notation_audio_processor,
4629 (AGS_RECALL_TEMPLATE));
4630 ags_recall_set_ability_flags((AgsRecall *) fx_notation_audio_processor,
4631 (AGS_SOUND_ABILITY_PLAYBACK |
4632 AGS_SOUND_ABILITY_NOTATION |
4633 AGS_SOUND_ABILITY_MIDI));
4634 ags_recall_set_behaviour_flags((AgsRecall *) fx_notation_audio_processor,
4635 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4636
4637 ags_audio_insert_recall(audio, (GObject *) fx_notation_audio_processor,
4638 TRUE,
4639 position);
4640 ags_recall_container_add(play_container,
4641 fx_notation_audio_processor);
4642
4643 start_recall = g_list_prepend(start_recall,
4644 fx_notation_audio_processor);
4645 ags_connectable_connect(AGS_CONNECTABLE(fx_notation_audio_processor));
4646 }else{
4647 GList *start_recall_audio_run, *recall_audio_run;
4648
4649 fx_notation_audio = ags_recall_container_get_recall_audio(play_container);
4650
4651 if(fx_notation_audio != NULL){
4652 g_object_ref(fx_notation_audio);
4653 }
4654
4655 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
4656
4657 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
4658 fx_notation_audio_processor = recall_audio_run->data;
4659 g_object_ref(fx_notation_audio_processor);
4660 }
4661 }
4662
4663 for(i = 0; i < stop_pad - start_pad; i++){
4664 channel = ags_channel_pad_nth(start_input,
4665 start_pad + i);
4666
4667 next_channel = ags_channel_nth(channel,
4668 start_audio_channel);
4669
4670 if(channel != NULL){
4671 g_object_unref(channel);
4672 }
4673
4674 channel = next_channel;
4675
4676 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
4677 /* add recall container */
4678 ags_channel_add_recall_container(channel,
4679 (GObject *) recall_container);
4680
4681 /* AgsFxNotationChannel */
4682 fx_notation_channel = (AgsFxNotationChannel *) g_object_new(AGS_TYPE_FX_NOTATION_CHANNEL,
4683 "output-soundcard", output_soundcard,
4684 "source", channel,
4685 "recall-audio", fx_notation_audio,
4686 "recall-container", play_container,
4687 NULL);
4688 ags_recall_set_flags((AgsRecall *) fx_notation_channel,
4689 (AGS_RECALL_TEMPLATE));
4690 ags_recall_set_ability_flags((AgsRecall *) fx_notation_channel,
4691 (AGS_SOUND_ABILITY_PLAYBACK |
4692 AGS_SOUND_ABILITY_NOTATION |
4693 AGS_SOUND_ABILITY_MIDI));
4694 ags_recall_set_behaviour_flags((AgsRecall *) fx_notation_channel,
4695 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4696
4697 ags_channel_insert_recall(channel, (GObject *) fx_notation_channel,
4698 TRUE,
4699 channel_position);
4700 ags_recall_container_add(play_container,
4701 fx_notation_channel);
4702
4703 start_recall = g_list_prepend(start_recall,
4704 fx_notation_channel);
4705
4706 ags_connectable_connect(AGS_CONNECTABLE(fx_notation_channel));
4707
4708 /* AgsFxNotationChannelProcessor */
4709 fx_notation_channel_processor = (AgsFxNotationChannelProcessor *) g_object_new(AGS_TYPE_FX_NOTATION_CHANNEL_PROCESSOR,
4710 "output-soundcard", output_soundcard,
4711 "source", channel,
4712 "recall-audio", fx_notation_audio,
4713 "recall-audio-run", fx_notation_audio_processor,
4714 "recall-channel", fx_notation_channel,
4715 "recall-container", play_container,
4716 NULL);
4717 ags_recall_set_flags((AgsRecall *) fx_notation_channel_processor,
4718 (AGS_RECALL_TEMPLATE));
4719 ags_recall_set_ability_flags((AgsRecall *) fx_notation_channel_processor,
4720 (AGS_SOUND_ABILITY_PLAYBACK |
4721 AGS_SOUND_ABILITY_NOTATION |
4722 AGS_SOUND_ABILITY_MIDI));
4723 ags_recall_set_behaviour_flags((AgsRecall *) fx_notation_channel_processor,
4724 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4725
4726 ags_channel_insert_recall(channel, (GObject *) fx_notation_channel_processor,
4727 TRUE,
4728 channel_position);
4729 ags_recall_container_add(play_container,
4730 fx_notation_channel_processor);
4731
4732 start_recall = g_list_prepend(start_recall,
4733 fx_notation_channel_processor);
4734
4735 ags_connectable_connect(AGS_CONNECTABLE(fx_notation_channel_processor));
4736
4737 /* iterate */
4738 next_channel = ags_channel_next(channel);
4739
4740 g_object_unref(channel);
4741
4742 channel = next_channel;
4743 }
4744
4745 if(channel != NULL){
4746 g_object_unref(channel);
4747 }
4748 }
4749
4750 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
4751 if(fx_notation_audio != NULL){
4752 g_object_unref(fx_notation_audio);
4753 }
4754
4755 if(fx_notation_audio_processor != NULL){
4756 g_object_unref(fx_notation_audio_processor);
4757 }
4758 }
4759
4760 /* audio - recall context */
4761 fx_notation_audio = NULL;
4762 fx_notation_audio_processor = NULL;
4763
4764 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
4765 /* AgsFxNotationAudio */
4766 fx_notation_audio = (AgsFxNotationAudio *) g_object_new(AGS_TYPE_FX_NOTATION_AUDIO,
4767 "output-soundcard", output_soundcard,
4768 "audio", audio,
4769 "recall-container", recall_container,
4770 NULL);
4771 ags_recall_set_flags((AgsRecall *) fx_notation_audio,
4772 (AGS_RECALL_TEMPLATE));
4773 ags_recall_set_ability_flags((AgsRecall *) fx_notation_audio,
4774 (AGS_SOUND_ABILITY_PLAYBACK |
4775 AGS_SOUND_ABILITY_NOTATION |
4776 AGS_SOUND_ABILITY_MIDI));
4777 ags_recall_set_behaviour_flags((AgsRecall *) fx_notation_audio,
4778 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4779
4780 ags_audio_insert_recall(audio, (GObject *) fx_notation_audio,
4781 FALSE,
4782 position);
4783 ags_recall_container_add(recall_container,
4784 fx_notation_audio);
4785
4786 start_recall = g_list_prepend(start_recall,
4787 fx_notation_audio);
4788
4789 ags_connectable_connect(AGS_CONNECTABLE(fx_notation_audio));
4790
4791 /* AgsFxNotationAudioProcessor */
4792 fx_notation_audio_processor = (AgsFxNotationAudioProcessor *) g_object_new(AGS_TYPE_FX_NOTATION_AUDIO_PROCESSOR,
4793 "output-soundcard", output_soundcard,
4794 "audio", audio,
4795 "recall-audio", fx_notation_audio,
4796 "recall-container", recall_container,
4797 NULL);
4798 ags_recall_set_flags((AgsRecall *) fx_notation_audio_processor,
4799 (AGS_RECALL_TEMPLATE));
4800 ags_recall_set_ability_flags((AgsRecall *) fx_notation_audio_processor,
4801 (AGS_SOUND_ABILITY_PLAYBACK |
4802 AGS_SOUND_ABILITY_NOTATION |
4803 AGS_SOUND_ABILITY_MIDI));
4804 ags_recall_set_behaviour_flags((AgsRecall *) fx_notation_audio_processor,
4805 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4806
4807 ags_audio_insert_recall(audio, (GObject *) fx_notation_audio_processor,
4808 FALSE,
4809 position);
4810 ags_recall_container_add(recall_container,
4811 fx_notation_audio_processor);
4812
4813 start_recall = g_list_prepend(start_recall,
4814 fx_notation_audio_processor);
4815
4816 ags_connectable_connect(AGS_CONNECTABLE(fx_notation_audio_processor));
4817 }else{
4818 GList *start_recall_audio_run, *recall_audio_run;
4819
4820 fx_notation_audio = ags_recall_container_get_recall_audio(recall_container);
4821
4822 if(fx_notation_audio != NULL){
4823 g_object_ref(fx_notation_audio);
4824 }
4825
4826 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
4827
4828 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
4829 fx_notation_audio_processor = recall_audio_run->data;
4830 g_object_ref(fx_notation_audio_processor);
4831 }
4832 }
4833
4834 for(i = 0; i < stop_pad - start_pad; i++){
4835 channel = ags_channel_pad_nth(start_input,
4836 start_pad + i);
4837
4838 next_channel = ags_channel_nth(channel,
4839 start_audio_channel);
4840
4841 if(channel != NULL){
4842 g_object_unref(channel);
4843 }
4844
4845 channel = next_channel;
4846
4847 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
4848 /* add recall container */
4849 ags_channel_add_recall_container(channel,
4850 (GObject *) recall_container);
4851
4852 /* AgsFxNotationChannel */
4853 fx_notation_channel = (AgsFxNotationChannel *) g_object_new(AGS_TYPE_FX_NOTATION_CHANNEL,
4854 "output-soundcard", output_soundcard,
4855 "source", channel,
4856 "recall-audio", fx_notation_audio,
4857 "recall-container", recall_container,
4858 NULL);
4859 ags_recall_set_flags((AgsRecall *) fx_notation_channel,
4860 (AGS_RECALL_TEMPLATE));
4861 ags_recall_set_ability_flags((AgsRecall *) fx_notation_channel,
4862 (AGS_SOUND_ABILITY_PLAYBACK |
4863 AGS_SOUND_ABILITY_NOTATION |
4864 AGS_SOUND_ABILITY_MIDI));
4865 ags_recall_set_behaviour_flags((AgsRecall *) fx_notation_channel,
4866 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4867
4868 ags_channel_insert_recall(channel, (GObject *) fx_notation_channel,
4869 FALSE,
4870 channel_position);
4871 ags_recall_container_add(recall_container,
4872 fx_notation_channel);
4873
4874 start_recall = g_list_prepend(start_recall,
4875 fx_notation_channel);
4876
4877 ags_connectable_connect(AGS_CONNECTABLE(fx_notation_channel));
4878
4879 /* AgsFxNotationChannelProcessor */
4880 fx_notation_channel_processor = (AgsFxNotationChannelProcessor *) g_object_new(AGS_TYPE_FX_NOTATION_CHANNEL_PROCESSOR,
4881 "output-soundcard", output_soundcard,
4882 "source", channel,
4883 "recall-audio", fx_notation_audio,
4884 "recall-audio-run", fx_notation_audio_processor,
4885 "recall-channel", fx_notation_channel,
4886 "recall-container", recall_container,
4887 NULL);
4888 ags_recall_set_flags((AgsRecall *) fx_notation_channel_processor,
4889 (AGS_RECALL_TEMPLATE));
4890 ags_recall_set_ability_flags((AgsRecall *) fx_notation_channel_processor,
4891 (AGS_SOUND_ABILITY_PLAYBACK |
4892 AGS_SOUND_ABILITY_NOTATION |
4893 AGS_SOUND_ABILITY_MIDI));
4894 ags_recall_set_behaviour_flags((AgsRecall *) fx_notation_channel_processor,
4895 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4896
4897 ags_channel_insert_recall(channel, (GObject *) fx_notation_channel_processor,
4898 FALSE,
4899 channel_position);
4900 ags_recall_container_add(recall_container,
4901 fx_notation_channel_processor);
4902
4903 start_recall = g_list_prepend(start_recall,
4904 fx_notation_channel_processor);
4905
4906 ags_connectable_connect(AGS_CONNECTABLE(fx_notation_channel_processor));
4907
4908 /* iterate */
4909 next_channel = ags_channel_next(channel);
4910
4911 g_object_unref(channel);
4912
4913 channel = next_channel;
4914 }
4915
4916 if(channel != NULL){
4917 g_object_unref(channel);
4918 }
4919 }
4920
4921 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
4922 if(fx_notation_audio != NULL){
4923 g_object_unref(fx_notation_audio);
4924 }
4925
4926 if(fx_notation_audio_processor != NULL){
4927 g_object_unref(fx_notation_audio_processor);
4928 }
4929 }
4930
4931 if(output_soundcard != NULL){
4932 g_object_unref(output_soundcard);
4933 }
4934
4935 if(input_sequencer != NULL){
4936 g_object_unref(input_sequencer);
4937 }
4938
4939 if(start_input != NULL){
4940 g_object_unref(start_input);
4941 }
4942
4943 return(start_recall);
4944 }
4945
4946 GList*
ags_fx_factory_create_ladspa(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)4947 ags_fx_factory_create_ladspa(AgsAudio *audio,
4948 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
4949 gchar *plugin_name,
4950 gchar *filename,
4951 gchar *effect,
4952 guint start_audio_channel, guint stop_audio_channel,
4953 guint start_pad, guint stop_pad,
4954 gint position,
4955 guint create_flags, guint recall_flags)
4956 {
4957 AgsChannel *start_input, *start_output;
4958 AgsChannel *channel, *next_channel;
4959
4960 AgsFxLadspaAudio *fx_ladspa_audio;
4961 AgsFxLadspaAudioProcessor *fx_ladspa_audio_processor;
4962 AgsFxLadspaChannel *fx_ladspa_channel;
4963 AgsFxLadspaChannelProcessor *fx_ladspa_channel_processor;
4964
4965 GObject *output_soundcard;
4966 GObject *input_sequencer;
4967
4968 GList *start_recall;
4969
4970 gint channel_position;
4971 guint audio_channels;
4972 guint i, j;
4973
4974 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
4975 !AGS_IS_RECALL_CONTAINER(recall_container)){
4976 g_warning("ags-fx-ladspa recall container not provided");
4977
4978 return(NULL);
4979 }
4980
4981 start_recall = NULL;
4982
4983 start_output = NULL;
4984
4985 start_input = NULL;
4986
4987 g_object_get(audio,
4988 "output-soundcard", &output_soundcard,
4989 "input-sequencer", &input_sequencer,
4990 "output", &start_output,
4991 "input", &start_input,
4992 "audio-channels", &audio_channels,
4993 NULL);
4994
4995 channel_position = 0;
4996
4997 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
4998 channel_position = ags_fx_factory_get_output_position(audio,
4999 position);
5000 }else{
5001 channel_position = ags_fx_factory_get_input_position(audio,
5002 position);
5003 }
5004
5005 /* audio - play context */
5006 fx_ladspa_audio = NULL;
5007 fx_ladspa_audio_processor = NULL;
5008
5009 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
5010 /* AgsFxLadspaAudio */
5011 fx_ladspa_audio = (AgsFxLadspaAudio *) g_object_new(AGS_TYPE_FX_LADSPA_AUDIO,
5012 "output-soundcard", output_soundcard,
5013 "audio", audio,
5014 "recall-container", play_container,
5015 "filename", filename,
5016 "effect", effect,
5017 NULL);
5018 ags_recall_set_flags((AgsRecall *) fx_ladspa_audio,
5019 (AGS_RECALL_TEMPLATE));
5020 ags_recall_set_ability_flags((AgsRecall *) fx_ladspa_audio,
5021 (AGS_SOUND_ABILITY_PLAYBACK |
5022 AGS_SOUND_ABILITY_SEQUENCER |
5023 AGS_SOUND_ABILITY_NOTATION |
5024 AGS_SOUND_ABILITY_WAVE |
5025 AGS_SOUND_ABILITY_MIDI));
5026 ags_recall_set_behaviour_flags((AgsRecall *) fx_ladspa_audio,
5027 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5028
5029 ags_audio_insert_recall(audio, (GObject *) fx_ladspa_audio,
5030 TRUE,
5031 position);
5032 ags_recall_container_add(play_container,
5033 fx_ladspa_audio);
5034
5035 start_recall = g_list_prepend(start_recall,
5036 fx_ladspa_audio);
5037
5038 ags_connectable_connect(AGS_CONNECTABLE(fx_ladspa_audio));
5039
5040 /* AgsFxLadspaAudioProcessor */
5041 fx_ladspa_audio_processor = (AgsFxLadspaAudioProcessor *) g_object_new(AGS_TYPE_FX_LADSPA_AUDIO_PROCESSOR,
5042 "output-soundcard", output_soundcard,
5043 "audio", audio,
5044 "recall-audio", fx_ladspa_audio,
5045 "recall-container", play_container,
5046 "filename", filename,
5047 "effect", effect,
5048 NULL);
5049 ags_recall_set_flags((AgsRecall *) fx_ladspa_audio_processor,
5050 (AGS_RECALL_TEMPLATE));
5051 ags_recall_set_ability_flags((AgsRecall *) fx_ladspa_audio_processor,
5052 (AGS_SOUND_ABILITY_PLAYBACK |
5053 AGS_SOUND_ABILITY_SEQUENCER |
5054 AGS_SOUND_ABILITY_NOTATION |
5055 AGS_SOUND_ABILITY_WAVE |
5056 AGS_SOUND_ABILITY_MIDI));
5057 ags_recall_set_behaviour_flags((AgsRecall *) fx_ladspa_audio_processor,
5058 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5059
5060 ags_audio_insert_recall(audio, (GObject *) fx_ladspa_audio_processor,
5061 TRUE,
5062 position);
5063 ags_recall_container_add(play_container,
5064 fx_ladspa_audio_processor);
5065
5066 start_recall = g_list_prepend(start_recall,
5067 fx_ladspa_audio_processor);
5068
5069 ags_connectable_connect(AGS_CONNECTABLE(fx_ladspa_audio_processor));
5070 }else{
5071 GList *start_recall_audio_run, *recall_audio_run;
5072
5073 fx_ladspa_audio = ags_recall_container_get_recall_audio(play_container);
5074
5075 if(fx_ladspa_audio != NULL){
5076 g_object_ref(fx_ladspa_audio);
5077 }
5078
5079 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
5080
5081 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
5082 fx_ladspa_audio_processor = recall_audio_run->data;
5083 g_object_ref(fx_ladspa_audio_processor);
5084 }
5085 }
5086
5087 /* channel - play context */
5088 for(i = 0; i < stop_pad - start_pad; i++){
5089 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
5090 channel = ags_channel_pad_nth(start_output,
5091 start_pad + i);
5092 }else{
5093 channel = ags_channel_pad_nth(start_input,
5094 start_pad + i);
5095 }
5096
5097 next_channel = ags_channel_nth(channel,
5098 start_audio_channel);
5099
5100 if(channel != NULL){
5101 g_object_unref(channel);
5102 }
5103
5104 channel = next_channel;
5105
5106 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
5107 /* AgsFxLadspaChannel */
5108 fx_ladspa_channel = (AgsFxLadspaChannel *) g_object_new(AGS_TYPE_FX_LADSPA_CHANNEL,
5109 "output-soundcard", output_soundcard,
5110 "source", channel,
5111 "recall-audio", fx_ladspa_audio,
5112 "recall-container", play_container,
5113 "filename", filename,
5114 "effect", effect,
5115 NULL);
5116 ags_recall_set_flags((AgsRecall *) fx_ladspa_channel,
5117 (AGS_RECALL_TEMPLATE));
5118 ags_recall_set_ability_flags((AgsRecall *) fx_ladspa_channel,
5119 (AGS_SOUND_ABILITY_PLAYBACK |
5120 AGS_SOUND_ABILITY_SEQUENCER |
5121 AGS_SOUND_ABILITY_NOTATION |
5122 AGS_SOUND_ABILITY_WAVE |
5123 AGS_SOUND_ABILITY_MIDI));
5124 ags_recall_set_behaviour_flags((AgsRecall *) fx_ladspa_channel,
5125 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5126
5127 ags_channel_insert_recall(channel, (GObject *) fx_ladspa_channel,
5128 TRUE,
5129 channel_position);
5130 ags_recall_container_add(play_container,
5131 fx_ladspa_channel);
5132
5133 start_recall = g_list_prepend(start_recall,
5134 fx_ladspa_channel);
5135
5136 ags_connectable_connect(AGS_CONNECTABLE(fx_ladspa_channel));
5137
5138 /* AgsFxLadspaChannelProcessor */
5139 fx_ladspa_channel_processor = (AgsFxLadspaChannelProcessor *) g_object_new(AGS_TYPE_FX_LADSPA_CHANNEL_PROCESSOR,
5140 "output-soundcard", output_soundcard,
5141 "source", channel,
5142 "recall-audio", fx_ladspa_audio,
5143 "recall-audio-run", fx_ladspa_audio_processor,
5144 "recall-channel", fx_ladspa_channel,
5145 "recall-container", play_container,
5146 "filename", filename,
5147 "effect", effect,
5148 NULL);
5149 ags_recall_set_flags((AgsRecall *) fx_ladspa_channel_processor,
5150 (AGS_RECALL_TEMPLATE));
5151 ags_recall_set_ability_flags((AgsRecall *) fx_ladspa_channel_processor,
5152 (AGS_SOUND_ABILITY_PLAYBACK |
5153 AGS_SOUND_ABILITY_SEQUENCER |
5154 AGS_SOUND_ABILITY_NOTATION |
5155 AGS_SOUND_ABILITY_WAVE |
5156 AGS_SOUND_ABILITY_MIDI));
5157 ags_recall_set_behaviour_flags((AgsRecall *) fx_ladspa_channel_processor,
5158 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5159
5160 ags_channel_insert_recall(channel, (GObject *) fx_ladspa_channel_processor,
5161 TRUE,
5162 channel_position);
5163 ags_recall_container_add(play_container,
5164 fx_ladspa_channel_processor);
5165
5166 start_recall = g_list_prepend(start_recall,
5167 fx_ladspa_channel_processor);
5168
5169 ags_connectable_connect(AGS_CONNECTABLE(fx_ladspa_channel_processor));
5170
5171 /* load */
5172 ags_fx_ladspa_channel_load_plugin(fx_ladspa_channel);
5173 ags_fx_ladspa_channel_load_port(fx_ladspa_channel);
5174
5175 /* iterate */
5176 next_channel = ags_channel_next(channel);
5177
5178 g_object_unref(channel);
5179
5180 channel = next_channel;
5181 }
5182
5183 if(channel != NULL){
5184 g_object_unref(channel);
5185 }
5186 }
5187
5188 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
5189 if(fx_ladspa_audio != NULL){
5190 g_object_unref(fx_ladspa_audio);
5191 }
5192
5193 if(fx_ladspa_audio_processor != NULL){
5194 g_object_unref(fx_ladspa_audio_processor);
5195 }
5196 }
5197
5198 /* audio - recall context */
5199 fx_ladspa_audio = NULL;
5200 fx_ladspa_audio_processor = NULL;
5201
5202 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
5203 /* AgsFxLadspaAudio */
5204 fx_ladspa_audio = (AgsFxLadspaAudio *) g_object_new(AGS_TYPE_FX_LADSPA_AUDIO,
5205 "output-soundcard", output_soundcard,
5206 "audio", audio,
5207 "recall-container", recall_container,
5208 "filename", filename,
5209 "effect", effect,
5210 NULL);
5211 ags_recall_set_flags((AgsRecall *) fx_ladspa_audio,
5212 (AGS_RECALL_TEMPLATE));
5213 ags_recall_set_ability_flags((AgsRecall *) fx_ladspa_audio,
5214 (AGS_SOUND_ABILITY_PLAYBACK |
5215 AGS_SOUND_ABILITY_SEQUENCER |
5216 AGS_SOUND_ABILITY_NOTATION |
5217 AGS_SOUND_ABILITY_WAVE |
5218 AGS_SOUND_ABILITY_MIDI));
5219 ags_recall_set_behaviour_flags((AgsRecall *) fx_ladspa_audio,
5220 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5221
5222 ags_audio_insert_recall(audio, (GObject *) fx_ladspa_audio,
5223 FALSE,
5224 position);
5225 ags_recall_container_add(recall_container,
5226 fx_ladspa_audio);
5227
5228 start_recall = g_list_prepend(start_recall,
5229 fx_ladspa_audio);
5230
5231 ags_connectable_connect(AGS_CONNECTABLE(fx_ladspa_audio));
5232
5233 /* AgsFxLadspaAudioProcessor */
5234 fx_ladspa_audio_processor = (AgsFxLadspaAudioProcessor *) g_object_new(AGS_TYPE_FX_LADSPA_AUDIO_PROCESSOR,
5235 "output-soundcard", output_soundcard,
5236 "audio", audio,
5237 "recall-audio", fx_ladspa_audio,
5238 "recall-container", recall_container,
5239 "filename", filename,
5240 "effect", effect,
5241 NULL);
5242 ags_recall_set_flags((AgsRecall *) fx_ladspa_audio_processor,
5243 (AGS_RECALL_TEMPLATE));
5244 ags_recall_set_ability_flags((AgsRecall *) fx_ladspa_audio_processor,
5245 (AGS_SOUND_ABILITY_PLAYBACK |
5246 AGS_SOUND_ABILITY_SEQUENCER |
5247 AGS_SOUND_ABILITY_NOTATION |
5248 AGS_SOUND_ABILITY_WAVE |
5249 AGS_SOUND_ABILITY_MIDI));
5250 ags_recall_set_behaviour_flags((AgsRecall *) fx_ladspa_audio_processor,
5251 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5252
5253 ags_audio_insert_recall(audio, (GObject *) fx_ladspa_audio_processor,
5254 FALSE,
5255 position);
5256 ags_recall_container_add(recall_container,
5257 fx_ladspa_audio_processor);
5258
5259 start_recall = g_list_prepend(start_recall,
5260 fx_ladspa_audio_processor);
5261
5262 ags_connectable_connect(AGS_CONNECTABLE(fx_ladspa_audio_processor));
5263 }else{
5264 GList *start_recall_audio_run, *recall_audio_run;
5265
5266 fx_ladspa_audio = ags_recall_container_get_recall_audio(recall_container);
5267
5268 if(fx_ladspa_audio != NULL){
5269 g_object_ref(fx_ladspa_audio);
5270 }
5271
5272 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
5273
5274 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
5275 fx_ladspa_audio_processor = recall_audio_run->data;
5276 g_object_ref(fx_ladspa_audio_processor);
5277 }
5278 }
5279
5280 /* channel - recall context */
5281
5282 for(i = 0; i < stop_pad - start_pad; i++){
5283 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
5284 channel = ags_channel_pad_nth(start_output,
5285 start_pad + i);
5286 }else{
5287 channel = ags_channel_pad_nth(start_input,
5288 start_pad + i);
5289 }
5290
5291 next_channel = ags_channel_nth(channel,
5292 start_audio_channel);
5293
5294 if(channel != NULL){
5295 g_object_unref(channel);
5296 }
5297
5298 channel = next_channel;
5299
5300 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
5301 /* AgsFxLadspaChannel */
5302 fx_ladspa_channel = (AgsFxLadspaChannel *) g_object_new(AGS_TYPE_FX_LADSPA_CHANNEL,
5303 "output-soundcard", output_soundcard,
5304 "source", channel,
5305 "recall-audio", fx_ladspa_audio,
5306 "recall-container", recall_container,
5307 "filename", filename,
5308 "effect", effect,
5309 NULL);
5310 ags_recall_set_flags((AgsRecall *) fx_ladspa_channel,
5311 (AGS_RECALL_TEMPLATE));
5312 ags_recall_set_ability_flags((AgsRecall *) fx_ladspa_channel,
5313 (AGS_SOUND_ABILITY_PLAYBACK |
5314 AGS_SOUND_ABILITY_SEQUENCER |
5315 AGS_SOUND_ABILITY_NOTATION |
5316 AGS_SOUND_ABILITY_WAVE |
5317 AGS_SOUND_ABILITY_MIDI));
5318 ags_recall_set_behaviour_flags((AgsRecall *) fx_ladspa_channel,
5319 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5320
5321 ags_channel_insert_recall(channel, (GObject *) fx_ladspa_channel,
5322 FALSE,
5323 channel_position);
5324 ags_recall_container_add(recall_container,
5325 fx_ladspa_channel);
5326
5327 start_recall = g_list_prepend(start_recall,
5328 fx_ladspa_channel);
5329
5330 ags_connectable_connect(AGS_CONNECTABLE(fx_ladspa_channel));
5331
5332 /* AgsFxLadspaChannelProcessor */
5333 fx_ladspa_channel_processor = (AgsFxLadspaChannelProcessor *) g_object_new(AGS_TYPE_FX_LADSPA_CHANNEL_PROCESSOR,
5334 "output-soundcard", output_soundcard,
5335 "source", channel,
5336 "recall-audio", fx_ladspa_audio,
5337 "recall-audio-run", fx_ladspa_audio_processor,
5338 "recall-channel", fx_ladspa_channel,
5339 "recall-container", recall_container,
5340 "filename", filename,
5341 "effect", effect,
5342 NULL);
5343 ags_recall_set_flags((AgsRecall *) fx_ladspa_channel_processor,
5344 (AGS_RECALL_TEMPLATE));
5345 ags_recall_set_ability_flags((AgsRecall *) fx_ladspa_channel_processor,
5346 (AGS_SOUND_ABILITY_PLAYBACK |
5347 AGS_SOUND_ABILITY_SEQUENCER |
5348 AGS_SOUND_ABILITY_NOTATION |
5349 AGS_SOUND_ABILITY_WAVE |
5350 AGS_SOUND_ABILITY_MIDI));
5351 ags_recall_set_behaviour_flags((AgsRecall *) fx_ladspa_channel_processor,
5352 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5353
5354 ags_channel_insert_recall(channel, (GObject *) fx_ladspa_channel_processor,
5355 FALSE,
5356 channel_position);
5357 ags_recall_container_add(recall_container,
5358 fx_ladspa_channel_processor);
5359
5360 start_recall = g_list_prepend(start_recall,
5361 fx_ladspa_channel_processor);
5362
5363 ags_connectable_connect(AGS_CONNECTABLE(fx_ladspa_channel_processor));
5364
5365 /* load */
5366 ags_fx_ladspa_channel_load_plugin(fx_ladspa_channel);
5367 ags_fx_ladspa_channel_load_port(fx_ladspa_channel);
5368
5369 /* iterate */
5370 next_channel = ags_channel_next(channel);
5371
5372 g_object_unref(channel);
5373
5374 channel = next_channel;
5375 }
5376
5377 if(channel != NULL){
5378 g_object_unref(channel);
5379 }
5380 }
5381
5382 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
5383 if(fx_ladspa_audio != NULL){
5384 g_object_unref(fx_ladspa_audio);
5385 }
5386
5387 if(fx_ladspa_audio_processor != NULL){
5388 g_object_unref(fx_ladspa_audio_processor);
5389 }
5390 }
5391
5392 if(output_soundcard != NULL){
5393 g_object_unref(output_soundcard);
5394 }
5395
5396 if(input_sequencer != NULL){
5397 g_object_unref(input_sequencer);
5398 }
5399
5400 if(start_output != NULL){
5401 g_object_unref(start_output);
5402 }
5403
5404 if(start_input != NULL){
5405 g_object_unref(start_input);
5406 }
5407
5408 return(start_recall);
5409 }
5410
5411 GList*
ags_fx_factory_create_dssi(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)5412 ags_fx_factory_create_dssi(AgsAudio *audio,
5413 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
5414 gchar *plugin_name,
5415 gchar *filename,
5416 gchar *effect,
5417 guint start_audio_channel, guint stop_audio_channel,
5418 guint start_pad, guint stop_pad,
5419 gint position,
5420 guint create_flags, guint recall_flags)
5421 {
5422 AgsChannel *start_input, *start_output;
5423 AgsChannel *channel, *next_channel;
5424
5425 AgsFxDssiAudio *fx_dssi_audio;
5426 AgsFxDssiAudioProcessor *fx_dssi_audio_processor;
5427 AgsFxDssiChannel *fx_dssi_channel;
5428 AgsFxDssiChannelProcessor *fx_dssi_channel_processor;
5429
5430 GObject *output_soundcard;
5431 GObject *input_sequencer;
5432
5433 GList *start_recall;
5434
5435 gint channel_position;
5436 guint audio_channels;
5437 guint i, j;
5438
5439 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
5440 !AGS_IS_RECALL_CONTAINER(recall_container)){
5441 g_warning("ags-fx-dssi recall container not provided");
5442
5443 return(NULL);
5444 }
5445
5446 start_recall = NULL;
5447
5448 start_output = NULL;
5449
5450 start_input = NULL;
5451
5452 g_object_get(audio,
5453 "output-soundcard", &output_soundcard,
5454 "input-sequencer", &input_sequencer,
5455 "output", &start_output,
5456 "input", &start_input,
5457 "audio-channels", &audio_channels,
5458 NULL);
5459
5460 channel_position = 0;
5461
5462 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
5463 channel_position = ags_fx_factory_get_output_position(audio,
5464 position);
5465 }else{
5466 channel_position = ags_fx_factory_get_input_position(audio,
5467 position);
5468 }
5469
5470 /* audio - play context */
5471 fx_dssi_audio = NULL;
5472 fx_dssi_audio_processor = NULL;
5473
5474 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
5475 /* AgsFxDssiAudio */
5476 fx_dssi_audio = (AgsFxDssiAudio *) g_object_new(AGS_TYPE_FX_DSSI_AUDIO,
5477 "output-soundcard", output_soundcard,
5478 "audio", audio,
5479 "recall-container", play_container,
5480 "filename", filename,
5481 "effect", effect,
5482 NULL);
5483 ags_recall_set_flags((AgsRecall *) fx_dssi_audio,
5484 (AGS_RECALL_TEMPLATE));
5485 ags_recall_set_ability_flags((AgsRecall *) fx_dssi_audio,
5486 (AGS_SOUND_ABILITY_PLAYBACK |
5487 AGS_SOUND_ABILITY_NOTATION |
5488 AGS_SOUND_ABILITY_MIDI));
5489 ags_recall_set_behaviour_flags((AgsRecall *) fx_dssi_audio,
5490 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5491
5492 ags_audio_insert_recall(audio, (GObject *) fx_dssi_audio,
5493 TRUE,
5494 position);
5495 ags_recall_container_add(play_container,
5496 fx_dssi_audio);
5497
5498 start_recall = g_list_prepend(start_recall,
5499 fx_dssi_audio);
5500
5501 ags_connectable_connect(AGS_CONNECTABLE(fx_dssi_audio));
5502
5503 /* AgsFxDssiAudioProcessor */
5504 fx_dssi_audio_processor = (AgsFxDssiAudioProcessor *) g_object_new(AGS_TYPE_FX_DSSI_AUDIO_PROCESSOR,
5505 "output-soundcard", output_soundcard,
5506 "audio", audio,
5507 "recall-audio", fx_dssi_audio,
5508 "recall-container", play_container,
5509 "filename", filename,
5510 "effect", effect,
5511 NULL);
5512 ags_recall_set_flags((AgsRecall *) fx_dssi_audio_processor,
5513 (AGS_RECALL_TEMPLATE));
5514 ags_recall_set_ability_flags((AgsRecall *) fx_dssi_audio_processor,
5515 (AGS_SOUND_ABILITY_PLAYBACK |
5516 AGS_SOUND_ABILITY_NOTATION |
5517 AGS_SOUND_ABILITY_MIDI));
5518 ags_recall_set_behaviour_flags((AgsRecall *) fx_dssi_audio_processor,
5519 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5520
5521 ags_audio_insert_recall(audio, (GObject *) fx_dssi_audio_processor,
5522 TRUE,
5523 position);
5524 ags_recall_container_add(play_container,
5525 fx_dssi_audio_processor);
5526
5527 start_recall = g_list_prepend(start_recall,
5528 fx_dssi_audio_processor);
5529
5530 ags_connectable_connect(AGS_CONNECTABLE(fx_dssi_audio_processor));
5531
5532 /* load */
5533 if((AGS_FX_FACTORY_LIVE & (create_flags)) == 0){
5534 ags_fx_dssi_audio_unset_flags(fx_dssi_audio,
5535 AGS_FX_DSSI_AUDIO_LIVE_INSTRUMENT);
5536 }
5537
5538 ags_fx_dssi_audio_load_plugin(fx_dssi_audio);
5539 ags_fx_dssi_audio_load_port(fx_dssi_audio);
5540 }else{
5541 GList *start_recall_audio_run, *recall_audio_run;
5542
5543 fx_dssi_audio = ags_recall_container_get_recall_audio(play_container);
5544
5545 if(fx_dssi_audio != NULL){
5546 g_object_ref(fx_dssi_audio);
5547 }
5548
5549 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
5550
5551 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
5552 fx_dssi_audio_processor = recall_audio_run->data;
5553 g_object_ref(fx_dssi_audio_processor);
5554 }
5555 }
5556
5557 /* channel - play context */
5558 for(i = 0; i < stop_pad - start_pad; i++){
5559 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
5560 channel = ags_channel_pad_nth(start_output,
5561 start_pad + i);
5562 }else{
5563 channel = ags_channel_pad_nth(start_input,
5564 start_pad + i);
5565 }
5566
5567 next_channel = ags_channel_nth(channel,
5568 start_audio_channel);
5569
5570 if(channel != NULL){
5571 g_object_unref(channel);
5572 }
5573
5574 channel = next_channel;
5575
5576 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
5577 /* add recall container */
5578 ags_channel_add_recall_container(channel,
5579 (GObject *) recall_container);
5580
5581 /* AgsFxDssiChannel */
5582 fx_dssi_channel = (AgsFxDssiChannel *) g_object_new(AGS_TYPE_FX_DSSI_CHANNEL,
5583 "output-soundcard", output_soundcard,
5584 "source", channel,
5585 "recall-audio", fx_dssi_audio,
5586 "recall-container", play_container,
5587 "filename", filename,
5588 "effect", effect,
5589 NULL);
5590 ags_recall_set_flags((AgsRecall *) fx_dssi_channel,
5591 (AGS_RECALL_TEMPLATE));
5592 ags_recall_set_ability_flags((AgsRecall *) fx_dssi_channel,
5593 (AGS_SOUND_ABILITY_PLAYBACK |
5594 AGS_SOUND_ABILITY_NOTATION |
5595 AGS_SOUND_ABILITY_MIDI));
5596 ags_recall_set_behaviour_flags((AgsRecall *) fx_dssi_channel,
5597 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5598
5599 ags_channel_insert_recall(channel, (GObject *) fx_dssi_channel,
5600 TRUE,
5601 channel_position);
5602 ags_recall_container_add(play_container,
5603 fx_dssi_channel);
5604
5605 start_recall = g_list_prepend(start_recall,
5606 fx_dssi_channel);
5607
5608 ags_connectable_connect(AGS_CONNECTABLE(fx_dssi_channel));
5609
5610 /* AgsFxDssiChannelProcessor */
5611 fx_dssi_channel_processor = (AgsFxDssiChannelProcessor *) g_object_new(AGS_TYPE_FX_DSSI_CHANNEL_PROCESSOR,
5612 "output-soundcard", output_soundcard,
5613 "source", channel,
5614 "recall-audio", fx_dssi_audio,
5615 "recall-audio-run", fx_dssi_audio_processor,
5616 "recall-channel", fx_dssi_channel,
5617 "recall-container", play_container,
5618 "filename", filename,
5619 "effect", effect,
5620 NULL);
5621 ags_recall_set_flags((AgsRecall *) fx_dssi_channel_processor,
5622 (AGS_RECALL_TEMPLATE));
5623 ags_recall_set_ability_flags((AgsRecall *) fx_dssi_channel_processor,
5624 (AGS_SOUND_ABILITY_PLAYBACK |
5625 AGS_SOUND_ABILITY_NOTATION |
5626 AGS_SOUND_ABILITY_MIDI));
5627 ags_recall_set_behaviour_flags((AgsRecall *) fx_dssi_channel_processor,
5628 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5629
5630 ags_channel_insert_recall(channel, (GObject *) fx_dssi_channel_processor,
5631 TRUE,
5632 channel_position);
5633 ags_recall_container_add(play_container,
5634 fx_dssi_channel_processor);
5635
5636 start_recall = g_list_prepend(start_recall,
5637 fx_dssi_channel_processor);
5638
5639 ags_connectable_connect(AGS_CONNECTABLE(fx_dssi_channel_processor));
5640
5641 /* load */
5642 ags_fx_dssi_channel_load_port(fx_dssi_channel);
5643
5644 /* iterate */
5645 next_channel = ags_channel_next(channel);
5646
5647 g_object_unref(channel);
5648
5649 channel = next_channel;
5650 }
5651
5652 if(channel != NULL){
5653 g_object_unref(channel);
5654 }
5655 }
5656
5657 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
5658 if(fx_dssi_audio != NULL){
5659 g_object_unref(fx_dssi_audio);
5660 }
5661
5662 if(fx_dssi_audio_processor != NULL){
5663 g_object_unref(fx_dssi_audio_processor);
5664 }
5665 }
5666
5667 /* audio - recall context */
5668 fx_dssi_audio = NULL;
5669 fx_dssi_audio_processor = NULL;
5670
5671 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
5672 /* AgsFxDssiAudio */
5673 fx_dssi_audio = (AgsFxDssiAudio *) g_object_new(AGS_TYPE_FX_DSSI_AUDIO,
5674 "output-soundcard", output_soundcard,
5675 "audio", audio,
5676 "recall-container", recall_container,
5677 "filename", filename,
5678 "effect", effect,
5679 NULL);
5680 ags_recall_set_flags((AgsRecall *) fx_dssi_audio,
5681 (AGS_RECALL_TEMPLATE));
5682 ags_recall_set_ability_flags((AgsRecall *) fx_dssi_audio,
5683 (AGS_SOUND_ABILITY_PLAYBACK |
5684 AGS_SOUND_ABILITY_NOTATION |
5685 AGS_SOUND_ABILITY_MIDI));
5686 ags_recall_set_behaviour_flags((AgsRecall *) fx_dssi_audio,
5687 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5688
5689 ags_audio_insert_recall(audio, (GObject *) fx_dssi_audio,
5690 FALSE,
5691 position);
5692 ags_recall_container_add(recall_container,
5693 fx_dssi_audio);
5694
5695 start_recall = g_list_prepend(start_recall,
5696 fx_dssi_audio);
5697
5698 ags_connectable_connect(AGS_CONNECTABLE(fx_dssi_audio));
5699
5700 /* AgsFxDssiAudioProcessor */
5701 fx_dssi_audio_processor = (AgsFxDssiAudioProcessor *) g_object_new(AGS_TYPE_FX_DSSI_AUDIO_PROCESSOR,
5702 "output-soundcard", output_soundcard,
5703 "audio", audio,
5704 "recall-audio", fx_dssi_audio,
5705 "recall-container", recall_container,
5706 "filename", filename,
5707 "effect", effect,
5708 NULL);
5709 ags_recall_set_flags((AgsRecall *) fx_dssi_audio_processor,
5710 (AGS_RECALL_TEMPLATE));
5711 ags_recall_set_ability_flags((AgsRecall *) fx_dssi_audio_processor,
5712 (AGS_SOUND_ABILITY_PLAYBACK |
5713 AGS_SOUND_ABILITY_NOTATION |
5714 AGS_SOUND_ABILITY_MIDI));
5715 ags_recall_set_behaviour_flags((AgsRecall *) fx_dssi_audio_processor,
5716 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5717
5718 ags_audio_insert_recall(audio, (GObject *) fx_dssi_audio_processor,
5719 FALSE,
5720 position);
5721 ags_recall_container_add(recall_container,
5722 fx_dssi_audio_processor);
5723
5724 start_recall = g_list_prepend(start_recall,
5725 fx_dssi_audio_processor);
5726
5727 ags_connectable_connect(AGS_CONNECTABLE(fx_dssi_audio_processor));
5728
5729 /* load */
5730 if((AGS_FX_FACTORY_LIVE & (create_flags)) == 0){
5731 ags_fx_dssi_audio_unset_flags(fx_dssi_audio,
5732 AGS_FX_DSSI_AUDIO_LIVE_INSTRUMENT);
5733 }
5734
5735 ags_fx_dssi_audio_load_plugin(fx_dssi_audio);
5736 ags_fx_dssi_audio_load_port(fx_dssi_audio);
5737 }else{
5738 GList *start_recall_audio_run, *recall_audio_run;
5739
5740 fx_dssi_audio = ags_recall_container_get_recall_audio(recall_container);
5741
5742 if(fx_dssi_audio != NULL){
5743 g_object_ref(fx_dssi_audio);
5744 }
5745
5746 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
5747
5748 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
5749 fx_dssi_audio_processor = recall_audio_run->data;
5750 g_object_ref(fx_dssi_audio_processor);
5751 }
5752 }
5753
5754 /* channel - recall context */
5755 for(i = 0; i < stop_pad - start_pad; i++){
5756 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
5757 channel = ags_channel_pad_nth(start_output,
5758 start_pad + i);
5759 }else{
5760 channel = ags_channel_pad_nth(start_input,
5761 start_pad + i);
5762 }
5763
5764 next_channel = ags_channel_nth(channel,
5765 start_audio_channel);
5766
5767 if(channel != NULL){
5768 g_object_unref(channel);
5769 }
5770
5771 channel = next_channel;
5772
5773 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
5774 /* AgsFxDssiChannel */
5775 fx_dssi_channel = (AgsFxDssiChannel *) g_object_new(AGS_TYPE_FX_DSSI_CHANNEL,
5776 "output-soundcard", output_soundcard,
5777 "source", channel,
5778 "recall-audio", fx_dssi_audio,
5779 "recall-container", recall_container,
5780 "filename", filename,
5781 "effect", effect,
5782 NULL);
5783 ags_recall_set_flags((AgsRecall *) fx_dssi_channel,
5784 (AGS_RECALL_TEMPLATE));
5785 ags_recall_set_ability_flags((AgsRecall *) fx_dssi_channel,
5786 (AGS_SOUND_ABILITY_PLAYBACK |
5787 AGS_SOUND_ABILITY_NOTATION |
5788 AGS_SOUND_ABILITY_MIDI));
5789 ags_recall_set_behaviour_flags((AgsRecall *) fx_dssi_channel,
5790 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5791
5792 ags_channel_insert_recall(channel, (GObject *) fx_dssi_channel,
5793 FALSE,
5794 channel_position);
5795 ags_recall_container_add(recall_container,
5796 fx_dssi_channel);
5797
5798 start_recall = g_list_prepend(start_recall,
5799 fx_dssi_channel);
5800
5801 ags_connectable_connect(AGS_CONNECTABLE(fx_dssi_channel));
5802
5803 /* AgsFxDssiChannelProcessor */
5804 fx_dssi_channel_processor = (AgsFxDssiChannelProcessor *) g_object_new(AGS_TYPE_FX_DSSI_CHANNEL_PROCESSOR,
5805 "output-soundcard", output_soundcard,
5806 "source", channel,
5807 "recall-audio", fx_dssi_audio,
5808 "recall-audio-run", fx_dssi_audio_processor,
5809 "recall-channel", fx_dssi_channel,
5810 "recall-container", recall_container,
5811 "filename", filename,
5812 "effect", effect,
5813 NULL);
5814 ags_recall_set_flags((AgsRecall *) fx_dssi_channel_processor,
5815 (AGS_RECALL_TEMPLATE));
5816 ags_recall_set_ability_flags((AgsRecall *) fx_dssi_channel_processor,
5817 (AGS_SOUND_ABILITY_PLAYBACK |
5818 AGS_SOUND_ABILITY_NOTATION |
5819 AGS_SOUND_ABILITY_MIDI));
5820 ags_recall_set_behaviour_flags((AgsRecall *) fx_dssi_channel_processor,
5821 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5822
5823 ags_channel_insert_recall(channel, (GObject *) fx_dssi_channel_processor,
5824 FALSE,
5825 channel_position);
5826 ags_recall_container_add(recall_container,
5827 fx_dssi_channel_processor);
5828
5829 start_recall = g_list_prepend(start_recall,
5830 fx_dssi_channel_processor);
5831
5832 ags_connectable_connect(AGS_CONNECTABLE(fx_dssi_channel_processor));
5833
5834 /* load */
5835 ags_fx_dssi_channel_load_port(fx_dssi_channel);
5836
5837 /* iterate */
5838 next_channel = ags_channel_next(channel);
5839
5840 g_object_unref(channel);
5841
5842 channel = next_channel;
5843 }
5844
5845 if(channel != NULL){
5846 g_object_unref(channel);
5847 }
5848 }
5849
5850 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
5851 if(fx_dssi_audio != NULL){
5852 g_object_unref(fx_dssi_audio);
5853 }
5854
5855 if(fx_dssi_audio_processor != NULL){
5856 g_object_unref(fx_dssi_audio_processor);
5857 }
5858 }
5859
5860 if(output_soundcard != NULL){
5861 g_object_unref(output_soundcard);
5862 }
5863
5864 if(input_sequencer != NULL){
5865 g_object_unref(input_sequencer);
5866 }
5867
5868 if(start_output != NULL){
5869 g_object_unref(start_output);
5870 }
5871
5872 if(start_input != NULL){
5873 g_object_unref(start_input);
5874 }
5875
5876 return(start_recall);
5877 }
5878
5879 GList*
ags_fx_factory_create_lv2(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)5880 ags_fx_factory_create_lv2(AgsAudio *audio,
5881 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
5882 gchar *plugin_name,
5883 gchar *filename,
5884 gchar *effect,
5885 guint start_audio_channel, guint stop_audio_channel,
5886 guint start_pad, guint stop_pad,
5887 gint position,
5888 guint create_flags, guint recall_flags)
5889 {
5890 AgsChannel *start_input, *start_output;
5891 AgsChannel *channel, *next_channel;
5892
5893 AgsFxLv2Audio *fx_lv2_audio;
5894 AgsFxLv2AudioProcessor *fx_lv2_audio_processor;
5895 AgsFxLv2Channel *fx_lv2_channel;
5896 AgsFxLv2ChannelProcessor *fx_lv2_channel_processor;
5897
5898 AgsLv2Manager *lv2_manager;
5899 AgsLv2Plugin *lv2_plugin;
5900
5901 GObject *output_soundcard;
5902 GObject *input_sequencer;
5903
5904 GList *start_recall;
5905
5906 gint channel_position;
5907 guint audio_channels;
5908 guint i, j;
5909 gboolean is_instrument;
5910
5911 if(!AGS_IS_RECALL_CONTAINER(play_container) ||
5912 !AGS_IS_RECALL_CONTAINER(recall_container)){
5913 g_warning("ags-fx-lv2 recall container not provided");
5914
5915 return(NULL);
5916 }
5917
5918 lv2_manager = ags_lv2_manager_get_instance();
5919
5920 lv2_plugin = ags_lv2_manager_find_lv2_plugin(lv2_manager,
5921 filename, effect);
5922
5923 is_instrument = ags_base_plugin_test_flags((AgsBasePlugin *) lv2_plugin, AGS_BASE_PLUGIN_IS_INSTRUMENT);
5924
5925 start_recall = NULL;
5926
5927 start_output = NULL;
5928
5929 start_input = NULL;
5930
5931 g_object_get(audio,
5932 "output-soundcard", &output_soundcard,
5933 "input-sequencer", &input_sequencer,
5934 "output", &start_output,
5935 "input", &start_input,
5936 "audio-channels", &audio_channels,
5937 NULL);
5938
5939 channel_position = 0;
5940
5941 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
5942 channel_position = ags_fx_factory_get_output_position(audio,
5943 position);
5944 }else{
5945 channel_position = ags_fx_factory_get_input_position(audio,
5946 position);
5947 }
5948
5949 /* audio - play context */
5950 fx_lv2_audio = NULL;
5951 fx_lv2_audio_processor = NULL;
5952
5953 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
5954 /* AgsFxLv2Audio */
5955 fx_lv2_audio = (AgsFxLv2Audio *) g_object_new(AGS_TYPE_FX_LV2_AUDIO,
5956 "output-soundcard", output_soundcard,
5957 "audio", audio,
5958 "recall-container", play_container,
5959 "filename", filename,
5960 "effect", effect,
5961 NULL);
5962 ags_recall_set_flags((AgsRecall *) fx_lv2_audio,
5963 (AGS_RECALL_TEMPLATE));
5964
5965 if(is_instrument){
5966 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_audio,
5967 (AGS_SOUND_ABILITY_PLAYBACK |
5968 AGS_SOUND_ABILITY_NOTATION |
5969 AGS_SOUND_ABILITY_MIDI));
5970 }else{
5971 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_audio,
5972 (AGS_SOUND_ABILITY_PLAYBACK |
5973 AGS_SOUND_ABILITY_SEQUENCER |
5974 AGS_SOUND_ABILITY_NOTATION |
5975 AGS_SOUND_ABILITY_WAVE |
5976 AGS_SOUND_ABILITY_MIDI));
5977 }
5978
5979 ags_recall_set_behaviour_flags((AgsRecall *) fx_lv2_audio,
5980 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5981
5982 ags_audio_insert_recall(audio, (GObject *) fx_lv2_audio,
5983 TRUE,
5984 position);
5985 ags_recall_container_add(play_container,
5986 fx_lv2_audio);
5987
5988 start_recall = g_list_prepend(start_recall,
5989 fx_lv2_audio);
5990
5991 ags_connectable_connect(AGS_CONNECTABLE(fx_lv2_audio));
5992
5993 /* AgsFxLv2AudioProcessor */
5994 fx_lv2_audio_processor = (AgsFxLv2AudioProcessor *) g_object_new(AGS_TYPE_FX_LV2_AUDIO_PROCESSOR,
5995 "output-soundcard", output_soundcard,
5996 "audio", audio,
5997 "recall-audio", fx_lv2_audio,
5998 "recall-container", play_container,
5999 "filename", filename,
6000 "effect", effect,
6001 NULL);
6002 ags_recall_set_flags((AgsRecall *) fx_lv2_audio_processor,
6003 (AGS_RECALL_TEMPLATE));
6004
6005 if(is_instrument){
6006 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_audio_processor,
6007 (AGS_SOUND_ABILITY_PLAYBACK |
6008 AGS_SOUND_ABILITY_NOTATION |
6009 AGS_SOUND_ABILITY_MIDI));
6010 }else{
6011 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_audio_processor,
6012 (AGS_SOUND_ABILITY_PLAYBACK |
6013 AGS_SOUND_ABILITY_SEQUENCER |
6014 AGS_SOUND_ABILITY_NOTATION |
6015 AGS_SOUND_ABILITY_WAVE |
6016 AGS_SOUND_ABILITY_MIDI));
6017 }
6018
6019 ags_recall_set_behaviour_flags((AgsRecall *) fx_lv2_audio_processor,
6020 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6021
6022 ags_audio_insert_recall(audio, (GObject *) fx_lv2_audio_processor,
6023 TRUE,
6024 position);
6025 ags_recall_container_add(play_container,
6026 fx_lv2_audio_processor);
6027
6028 start_recall = g_list_prepend(start_recall,
6029 fx_lv2_audio_processor);
6030
6031 ags_connectable_connect(AGS_CONNECTABLE(fx_lv2_audio_processor));
6032
6033 /* load */
6034 if((AGS_FX_FACTORY_LIVE & (create_flags)) == 0){
6035 ags_fx_lv2_audio_unset_flags(fx_lv2_audio,
6036 AGS_FX_LV2_AUDIO_LIVE_INSTRUMENT);
6037 }
6038
6039 ags_fx_lv2_audio_load_plugin(fx_lv2_audio);
6040 ags_fx_lv2_audio_load_port(fx_lv2_audio);
6041 }else{
6042 GList *start_recall_audio_run, *recall_audio_run;
6043
6044 fx_lv2_audio = ags_recall_container_get_recall_audio(play_container);
6045
6046 if(fx_lv2_audio != NULL){
6047 g_object_ref(fx_lv2_audio);
6048 }
6049
6050 start_recall_audio_run = ags_recall_container_get_recall_audio_run(play_container);
6051
6052 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
6053 fx_lv2_audio_processor = recall_audio_run->data;
6054 g_object_ref(fx_lv2_audio_processor);
6055 }
6056
6057 ags_fx_lv2_audio_load_plugin(fx_lv2_audio);
6058 ags_fx_lv2_audio_load_port(fx_lv2_audio);
6059 }
6060
6061 /* channel - play context */
6062 for(i = 0; i < stop_pad - start_pad; i++){
6063 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
6064 channel = ags_channel_pad_nth(start_output,
6065 start_pad + i);
6066 }else{
6067 channel = ags_channel_pad_nth(start_input,
6068 start_pad + i);
6069 }
6070
6071 next_channel = ags_channel_nth(channel,
6072 start_audio_channel);
6073
6074 if(channel != NULL){
6075 g_object_unref(channel);
6076 }
6077
6078 channel = next_channel;
6079
6080 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
6081 /* add recall container */
6082 ags_channel_add_recall_container(channel,
6083 (GObject *) recall_container);
6084
6085 /* AgsFxLv2Channel */
6086 fx_lv2_channel = (AgsFxLv2Channel *) g_object_new(AGS_TYPE_FX_LV2_CHANNEL,
6087 "output-soundcard", output_soundcard,
6088 "source", channel,
6089 "recall-audio", fx_lv2_audio,
6090 "recall-container", play_container,
6091 "filename", filename,
6092 "effect", effect,
6093 NULL);
6094 ags_recall_set_flags((AgsRecall *) fx_lv2_channel,
6095 (AGS_RECALL_TEMPLATE));
6096
6097 if(is_instrument){
6098 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_channel,
6099 (AGS_SOUND_ABILITY_PLAYBACK |
6100 AGS_SOUND_ABILITY_NOTATION |
6101 AGS_SOUND_ABILITY_MIDI));
6102 }else{
6103 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_channel,
6104 (AGS_SOUND_ABILITY_PLAYBACK |
6105 AGS_SOUND_ABILITY_SEQUENCER |
6106 AGS_SOUND_ABILITY_NOTATION |
6107 AGS_SOUND_ABILITY_WAVE |
6108 AGS_SOUND_ABILITY_MIDI));
6109 }
6110
6111 ags_recall_set_behaviour_flags((AgsRecall *) fx_lv2_channel,
6112 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6113
6114 ags_channel_insert_recall(channel, (GObject *) fx_lv2_channel,
6115 TRUE,
6116 channel_position);
6117 ags_recall_container_add(play_container,
6118 fx_lv2_channel);
6119
6120 start_recall = g_list_prepend(start_recall,
6121 fx_lv2_channel);
6122
6123 ags_connectable_connect(AGS_CONNECTABLE(fx_lv2_channel));
6124
6125 /* AgsFxLv2ChannelProcessor */
6126 fx_lv2_channel_processor = (AgsFxLv2ChannelProcessor *) g_object_new(AGS_TYPE_FX_LV2_CHANNEL_PROCESSOR,
6127 "output-soundcard", output_soundcard,
6128 "source", channel,
6129 "recall-audio", fx_lv2_audio,
6130 "recall-audio-run", fx_lv2_audio_processor,
6131 "recall-channel", fx_lv2_channel,
6132 "recall-container", play_container,
6133 "filename", filename,
6134 "effect", effect,
6135 NULL);
6136 ags_recall_set_flags((AgsRecall *) fx_lv2_channel_processor,
6137 (AGS_RECALL_TEMPLATE));
6138
6139 if(is_instrument){
6140 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_channel_processor,
6141 (AGS_SOUND_ABILITY_PLAYBACK |
6142 AGS_SOUND_ABILITY_NOTATION |
6143 AGS_SOUND_ABILITY_MIDI));
6144 }else{
6145 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_channel_processor,
6146 (AGS_SOUND_ABILITY_PLAYBACK |
6147 AGS_SOUND_ABILITY_SEQUENCER |
6148 AGS_SOUND_ABILITY_NOTATION |
6149 AGS_SOUND_ABILITY_WAVE |
6150 AGS_SOUND_ABILITY_MIDI));
6151 }
6152
6153 ags_recall_set_behaviour_flags((AgsRecall *) fx_lv2_channel_processor,
6154 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6155
6156 ags_channel_insert_recall(channel, (GObject *) fx_lv2_channel_processor,
6157 TRUE,
6158 channel_position);
6159 ags_recall_container_add(play_container,
6160 fx_lv2_channel_processor);
6161
6162 start_recall = g_list_prepend(start_recall,
6163 fx_lv2_channel_processor);
6164
6165 ags_connectable_connect(AGS_CONNECTABLE(fx_lv2_channel_processor));
6166
6167 /* load */
6168 ags_fx_lv2_channel_load_plugin(fx_lv2_channel);
6169 ags_fx_lv2_channel_load_port(fx_lv2_channel);
6170
6171 /* iterate */
6172 next_channel = ags_channel_next(channel);
6173
6174 g_object_unref(channel);
6175
6176 channel = next_channel;
6177 }
6178
6179 if(channel != NULL){
6180 g_object_unref(channel);
6181 }
6182 }
6183
6184 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
6185 if(fx_lv2_audio != NULL){
6186 g_object_unref(fx_lv2_audio);
6187 }
6188
6189 if(fx_lv2_audio_processor != NULL){
6190 g_object_unref(fx_lv2_audio_processor);
6191 }
6192 }
6193
6194 /* audio - recall context */
6195 fx_lv2_audio = NULL;
6196 fx_lv2_audio_processor = NULL;
6197
6198 if((AGS_FX_FACTORY_REMAP & (create_flags)) == 0){
6199 /* AgsFxLv2Audio */
6200 fx_lv2_audio = (AgsFxLv2Audio *) g_object_new(AGS_TYPE_FX_LV2_AUDIO,
6201 "output-soundcard", output_soundcard,
6202 "audio", audio,
6203 "recall-container", recall_container,
6204 "filename", filename,
6205 "effect", effect,
6206 NULL);
6207 ags_recall_set_flags((AgsRecall *) fx_lv2_audio,
6208 (AGS_RECALL_TEMPLATE));
6209
6210 if(is_instrument){
6211 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_audio,
6212 (AGS_SOUND_ABILITY_PLAYBACK |
6213 AGS_SOUND_ABILITY_NOTATION |
6214 AGS_SOUND_ABILITY_MIDI));
6215 }else{
6216 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_audio,
6217 (AGS_SOUND_ABILITY_PLAYBACK |
6218 AGS_SOUND_ABILITY_SEQUENCER |
6219 AGS_SOUND_ABILITY_NOTATION |
6220 AGS_SOUND_ABILITY_WAVE |
6221 AGS_SOUND_ABILITY_MIDI));
6222 }
6223
6224 ags_recall_set_behaviour_flags((AgsRecall *) fx_lv2_audio,
6225 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6226
6227 ags_audio_insert_recall(audio, (GObject *) fx_lv2_audio,
6228 FALSE,
6229 position);
6230 ags_recall_container_add(recall_container,
6231 fx_lv2_audio);
6232
6233 start_recall = g_list_prepend(start_recall,
6234 fx_lv2_audio);
6235
6236 ags_connectable_connect(AGS_CONNECTABLE(fx_lv2_audio));
6237
6238 /* AgsFxLv2AudioProcessor */
6239 fx_lv2_audio_processor = (AgsFxLv2AudioProcessor *) g_object_new(AGS_TYPE_FX_LV2_AUDIO_PROCESSOR,
6240 "output-soundcard", output_soundcard,
6241 "audio", audio,
6242 "recall-audio", fx_lv2_audio,
6243 "recall-container", recall_container,
6244 "filename", filename,
6245 "effect", effect,
6246 NULL);
6247 ags_recall_set_flags((AgsRecall *) fx_lv2_audio_processor,
6248 (AGS_RECALL_TEMPLATE));
6249
6250 if(is_instrument){
6251 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_audio_processor,
6252 (AGS_SOUND_ABILITY_PLAYBACK |
6253 AGS_SOUND_ABILITY_NOTATION |
6254 AGS_SOUND_ABILITY_MIDI));
6255 }else{
6256 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_audio_processor,
6257 (AGS_SOUND_ABILITY_PLAYBACK |
6258 AGS_SOUND_ABILITY_SEQUENCER |
6259 AGS_SOUND_ABILITY_NOTATION |
6260 AGS_SOUND_ABILITY_WAVE |
6261 AGS_SOUND_ABILITY_MIDI));
6262 }
6263
6264 ags_recall_set_behaviour_flags((AgsRecall *) fx_lv2_audio_processor,
6265 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6266
6267 ags_audio_insert_recall(audio, (GObject *) fx_lv2_audio_processor,
6268 FALSE,
6269 position);
6270 ags_recall_container_add(recall_container,
6271 fx_lv2_audio_processor);
6272
6273 start_recall = g_list_prepend(start_recall,
6274 fx_lv2_audio_processor);
6275
6276 ags_connectable_connect(AGS_CONNECTABLE(fx_lv2_audio_processor));
6277
6278 /* load */
6279 if((AGS_FX_FACTORY_LIVE & (create_flags)) == 0){
6280 ags_fx_lv2_audio_unset_flags(fx_lv2_audio,
6281 AGS_FX_LV2_AUDIO_LIVE_INSTRUMENT);
6282 }
6283
6284 ags_fx_lv2_audio_load_plugin(fx_lv2_audio);
6285 ags_fx_lv2_audio_load_port(fx_lv2_audio);
6286 }else{
6287 GList *start_recall_audio_run, *recall_audio_run;
6288
6289 fx_lv2_audio = ags_recall_container_get_recall_audio(recall_container);
6290
6291 if(fx_lv2_audio != NULL){
6292 g_object_ref(fx_lv2_audio);
6293 }
6294
6295 start_recall_audio_run = ags_recall_container_get_recall_audio_run(recall_container);
6296
6297 if((recall_audio_run = ags_recall_find_template(start_recall_audio_run)) != NULL){
6298 fx_lv2_audio_processor = recall_audio_run->data;
6299 g_object_ref(fx_lv2_audio_processor);
6300 }
6301 }
6302
6303 /* channel - recall context */
6304 for(i = 0; i < stop_pad - start_pad; i++){
6305 if((AGS_FX_FACTORY_OUTPUT & create_flags) != 0){
6306 channel = ags_channel_pad_nth(start_output,
6307 start_pad + i);
6308 }else{
6309 channel = ags_channel_pad_nth(start_input,
6310 start_pad + i);
6311 }
6312
6313 next_channel = ags_channel_nth(channel,
6314 start_audio_channel);
6315
6316 if(channel != NULL){
6317 g_object_unref(channel);
6318 }
6319
6320 channel = next_channel;
6321
6322 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
6323 /* AgsFxLv2Channel */
6324 fx_lv2_channel = (AgsFxLv2Channel *) g_object_new(AGS_TYPE_FX_LV2_CHANNEL,
6325 "output-soundcard", output_soundcard,
6326 "source", channel,
6327 "recall-audio", fx_lv2_audio,
6328 "recall-container", recall_container,
6329 "filename", filename,
6330 "effect", effect,
6331 NULL);
6332 ags_recall_set_flags((AgsRecall *) fx_lv2_channel,
6333 (AGS_RECALL_TEMPLATE));
6334
6335 if(is_instrument){
6336 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_channel,
6337 (AGS_SOUND_ABILITY_PLAYBACK |
6338 AGS_SOUND_ABILITY_NOTATION |
6339 AGS_SOUND_ABILITY_MIDI));
6340 }else{
6341 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_channel,
6342 (AGS_SOUND_ABILITY_PLAYBACK |
6343 AGS_SOUND_ABILITY_SEQUENCER |
6344 AGS_SOUND_ABILITY_NOTATION |
6345 AGS_SOUND_ABILITY_WAVE |
6346 AGS_SOUND_ABILITY_MIDI));
6347 }
6348
6349 ags_recall_set_behaviour_flags((AgsRecall *) fx_lv2_channel,
6350 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6351
6352 ags_channel_insert_recall(channel, (GObject *) fx_lv2_channel,
6353 FALSE,
6354 channel_position);
6355 ags_recall_container_add(recall_container,
6356 fx_lv2_channel);
6357
6358 start_recall = g_list_prepend(start_recall,
6359 fx_lv2_channel);
6360
6361 ags_connectable_connect(AGS_CONNECTABLE(fx_lv2_channel));
6362
6363 /* AgsFxLv2ChannelProcessor */
6364 fx_lv2_channel_processor = (AgsFxLv2ChannelProcessor *) g_object_new(AGS_TYPE_FX_LV2_CHANNEL_PROCESSOR,
6365 "output-soundcard", output_soundcard,
6366 "source", channel,
6367 "recall-audio", fx_lv2_audio,
6368 "recall-audio-run", fx_lv2_audio_processor,
6369 "recall-channel", fx_lv2_channel,
6370 "recall-container", recall_container,
6371 "filename", filename,
6372 "effect", effect,
6373 NULL);
6374 ags_recall_set_flags((AgsRecall *) fx_lv2_channel_processor,
6375 (AGS_RECALL_TEMPLATE));
6376
6377 if(is_instrument){
6378 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_channel_processor,
6379 (AGS_SOUND_ABILITY_PLAYBACK |
6380 AGS_SOUND_ABILITY_NOTATION |
6381 AGS_SOUND_ABILITY_MIDI));
6382 }else{
6383 ags_recall_set_ability_flags((AgsRecall *) fx_lv2_channel_processor,
6384 (AGS_SOUND_ABILITY_PLAYBACK |
6385 AGS_SOUND_ABILITY_SEQUENCER |
6386 AGS_SOUND_ABILITY_NOTATION |
6387 AGS_SOUND_ABILITY_WAVE |
6388 AGS_SOUND_ABILITY_MIDI));
6389 }
6390
6391 ags_recall_set_behaviour_flags((AgsRecall *) fx_lv2_channel_processor,
6392 (((AGS_FX_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6393
6394 ags_channel_insert_recall(channel, (GObject *) fx_lv2_channel_processor,
6395 FALSE,
6396 channel_position);
6397 ags_recall_container_add(recall_container,
6398 fx_lv2_channel_processor);
6399
6400 start_recall = g_list_prepend(start_recall,
6401 fx_lv2_channel_processor);
6402
6403 ags_connectable_connect(AGS_CONNECTABLE(fx_lv2_channel_processor));
6404
6405 /* load */
6406 ags_fx_lv2_channel_load_plugin(fx_lv2_channel);
6407 ags_fx_lv2_channel_load_port(fx_lv2_channel);
6408
6409 /* iterate */
6410 next_channel = ags_channel_next(channel);
6411
6412 g_object_unref(channel);
6413
6414 channel = next_channel;
6415 }
6416
6417 if(channel != NULL){
6418 g_object_unref(channel);
6419 }
6420 }
6421
6422 if((AGS_FX_FACTORY_REMAP & (create_flags)) != 0){
6423 if(fx_lv2_audio != NULL){
6424 g_object_unref(fx_lv2_audio);
6425 }
6426
6427 if(fx_lv2_audio_processor != NULL){
6428 g_object_unref(fx_lv2_audio_processor);
6429 }
6430 }
6431
6432 if(output_soundcard != NULL){
6433 g_object_unref(output_soundcard);
6434 }
6435
6436 if(input_sequencer != NULL){
6437 g_object_unref(input_sequencer);
6438 }
6439
6440 if(start_output != NULL){
6441 g_object_unref(start_output);
6442 }
6443
6444 if(start_input != NULL){
6445 g_object_unref(start_input);
6446 }
6447
6448 return(start_recall);
6449 }
6450
6451 /**
6452 * ags_fx_factory_create:
6453 * @audio: an #AgsAudio that should keep the recalls
6454 * @play_container: an #AgsRecallContainer to indetify what recall to use
6455 * @recall_container: an #AgsRecallContainer to indetify what recall to use
6456 * @plugin_name: the plugin identifier to instantiate
6457 * @filename: the plugin filename
6458 * @effect: the plugin effect
6459 * @start_audio_channel: the first audio channel to apply
6460 * @stop_audio_channel: the last audio channel to apply
6461 * @start_pad: the first pad to apply
6462 * @stop_pad: the last pad to apply
6463 * @position: the position to insert the recall
6464 * @create_flags: modify the behaviour of this function
6465 * @recall_flags: flags to be set for #AgsRecall
6466 *
6467 * Instantiate #AgsRecall by this factory.
6468 *
6469 * Returns: (element-type AgsAudio.Recall) (transfer full): The #GList-struct containing #AgsRecall
6470 *
6471 * Since: 3.3.0
6472 */
6473 GList*
ags_fx_factory_create(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,gchar * filename,gchar * effect,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,gint position,guint create_flags,guint recall_flags)6474 ags_fx_factory_create(AgsAudio *audio,
6475 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
6476 gchar *plugin_name,
6477 gchar *filename,
6478 gchar *effect,
6479 guint start_audio_channel, guint stop_audio_channel,
6480 guint start_pad, guint stop_pad,
6481 gint position,
6482 guint create_flags, guint recall_flags)
6483 {
6484 GList *start_recall;
6485
6486 if(!AGS_IS_AUDIO(audio) ||
6487 plugin_name == NULL){
6488 return(NULL);
6489 }
6490
6491 start_recall = NULL;
6492
6493 if(!g_ascii_strncasecmp(plugin_name,
6494 "ags-fx-buffer",
6495 14)){
6496 start_recall = ags_fx_factory_create_buffer(audio,
6497 play_container, recall_container,
6498 plugin_name,
6499 filename,
6500 effect,
6501 start_audio_channel, stop_audio_channel,
6502 start_pad, stop_pad,
6503 position,
6504 create_flags, recall_flags);
6505 }else if(!g_ascii_strncasecmp(plugin_name,
6506 "ags-fx-playback",
6507 16)){
6508 start_recall = ags_fx_factory_create_playback(audio,
6509 play_container, recall_container,
6510 plugin_name,
6511 filename,
6512 effect,
6513 start_audio_channel, stop_audio_channel,
6514 start_pad, stop_pad,
6515 position,
6516 create_flags, recall_flags);
6517 }else if(!g_ascii_strncasecmp(plugin_name,
6518 "ags-fx-volume",
6519 14)){
6520 start_recall = ags_fx_factory_create_volume(audio,
6521 play_container, recall_container,
6522 plugin_name,
6523 filename,
6524 effect,
6525 start_audio_channel, stop_audio_channel,
6526 start_pad, stop_pad,
6527 position,
6528 create_flags, recall_flags);
6529 }else if(!g_ascii_strncasecmp(plugin_name,
6530 "ags-fx-peak",
6531 12)){
6532 start_recall = ags_fx_factory_create_peak(audio,
6533 play_container, recall_container,
6534 plugin_name,
6535 filename,
6536 effect,
6537 start_audio_channel, stop_audio_channel,
6538 start_pad, stop_pad,
6539 position,
6540 create_flags, recall_flags);
6541 }else if(!g_ascii_strncasecmp(plugin_name,
6542 "ags-fx-eq10",
6543 12)){
6544 start_recall = ags_fx_factory_create_eq10(audio,
6545 play_container, recall_container,
6546 plugin_name,
6547 filename,
6548 effect,
6549 start_audio_channel, stop_audio_channel,
6550 start_pad, stop_pad,
6551 position,
6552 create_flags, recall_flags);
6553 }else if(!g_ascii_strncasecmp(plugin_name,
6554 "ags-fx-analyse",
6555 15)){
6556 start_recall = ags_fx_factory_create_analyse(audio,
6557 play_container, recall_container,
6558 plugin_name,
6559 filename,
6560 effect,
6561 start_audio_channel, stop_audio_channel,
6562 start_pad, stop_pad,
6563 position,
6564 create_flags, recall_flags);
6565 }else if(!g_ascii_strncasecmp(plugin_name,
6566 "ags-fx-two-pass-aliase",
6567 22)){
6568 start_recall = ags_fx_factory_create_two_pass_aliase(audio,
6569 play_container, recall_container,
6570 plugin_name,
6571 filename,
6572 effect,
6573 start_audio_channel, stop_audio_channel,
6574 start_pad, stop_pad,
6575 position,
6576 create_flags, recall_flags);
6577 }else if(!g_ascii_strncasecmp(plugin_name,
6578 "ags-fx-lfo",
6579 11)){
6580 start_recall = ags_fx_factory_create_lfo(audio,
6581 play_container, recall_container,
6582 plugin_name,
6583 filename,
6584 effect,
6585 start_audio_channel, stop_audio_channel,
6586 start_pad, stop_pad,
6587 position,
6588 create_flags, recall_flags);
6589 }else if(!g_ascii_strncasecmp(plugin_name,
6590 "ags-fx-envelope",
6591 16)){
6592 start_recall = ags_fx_factory_create_envelope(audio,
6593 play_container, recall_container,
6594 plugin_name,
6595 filename,
6596 effect,
6597 start_audio_channel, stop_audio_channel,
6598 start_pad, stop_pad,
6599 position,
6600 create_flags, recall_flags);
6601 }else if(!g_ascii_strncasecmp(plugin_name,
6602 "ags-fx-pattern",
6603 15)){
6604 start_recall = ags_fx_factory_create_pattern(audio,
6605 play_container, recall_container,
6606 plugin_name,
6607 filename,
6608 effect,
6609 start_audio_channel, stop_audio_channel,
6610 start_pad, stop_pad,
6611 position,
6612 create_flags, recall_flags);
6613 }else if(!g_ascii_strncasecmp(plugin_name,
6614 "ags-fx-notation",
6615 16)){
6616 start_recall = ags_fx_factory_create_notation(audio,
6617 play_container, recall_container,
6618 plugin_name,
6619 filename,
6620 effect,
6621 start_audio_channel, stop_audio_channel,
6622 start_pad, stop_pad,
6623 position,
6624 create_flags, recall_flags);
6625 }else if(!g_ascii_strncasecmp(plugin_name,
6626 "ags-fx-ladspa",
6627 14)){
6628 start_recall = ags_fx_factory_create_ladspa(audio,
6629 play_container, recall_container,
6630 plugin_name,
6631 filename,
6632 effect,
6633 start_audio_channel, stop_audio_channel,
6634 start_pad, stop_pad,
6635 position,
6636 create_flags, recall_flags);
6637 }else if(!g_ascii_strncasecmp(plugin_name,
6638 "ags-fx-dssi",
6639 12)){
6640 start_recall = ags_fx_factory_create_dssi(audio,
6641 play_container, recall_container,
6642 plugin_name,
6643 filename,
6644 effect,
6645 start_audio_channel, stop_audio_channel,
6646 start_pad, stop_pad,
6647 position,
6648 create_flags, recall_flags);
6649 }else if(!g_ascii_strncasecmp(plugin_name,
6650 "ags-fx-lv2",
6651 11)){
6652 start_recall = ags_fx_factory_create_lv2(audio,
6653 play_container, recall_container,
6654 plugin_name,
6655 filename,
6656 effect,
6657 start_audio_channel, stop_audio_channel,
6658 start_pad, stop_pad,
6659 position,
6660 create_flags, recall_flags);
6661 }else{
6662 g_warning("no such plugin - %s", plugin_name);
6663 }
6664
6665 return(start_recall);
6666 }
6667