1 /* GSequencer - Advanced GTK Sequencer
2 * Copyright (C) 2005-2019 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_recall_factory.h>
21
22 #include <ags/audio/ags_audio.h>
23 #include <ags/audio/ags_channel.h>
24 #include <ags/audio/ags_recall.h>
25 #include <ags/audio/ags_recall_container.h>
26 #include <ags/audio/ags_generic_recall_channel_run.h>
27 #include <ags/audio/ags_generic_recall_recycling.h>
28 #include <ags/audio/ags_recall_dssi.h>
29 #include <ags/audio/ags_recall_dssi_run.h>
30 #include <ags/audio/ags_recall_ladspa.h>
31 #include <ags/audio/ags_recall_ladspa_run.h>
32 #include <ags/audio/ags_recall_lv2.h>
33 #include <ags/audio/ags_recall_lv2_run.h>
34 #include <ags/audio/ags_port.h>
35
36 #include <ags/audio/recall/ags_play_audio.h>
37 #include <ags/audio/recall/ags_play_channel.h>
38 #include <ags/audio/recall/ags_play_channel_run_master.h>
39 #include <ags/audio/recall/ags_play_channel_run.h>
40 #include <ags/audio/recall/ags_delay_audio.h>
41 #include <ags/audio/recall/ags_delay_audio_run.h>
42 #include <ags/audio/recall/ags_capture_wave_audio.h>
43 #include <ags/audio/recall/ags_capture_wave_audio_run.h>
44 #include <ags/audio/recall/ags_capture_wave_channel.h>
45 #include <ags/audio/recall/ags_capture_wave_channel_run.h>
46 #include <ags/audio/recall/ags_count_beats_audio.h>
47 #include <ags/audio/recall/ags_count_beats_audio_run.h>
48 #include <ags/audio/recall/ags_loop_channel.h>
49 #include <ags/audio/recall/ags_loop_channel_run.h>
50 #include <ags/audio/recall/ags_play_channel.h>
51 #include <ags/audio/recall/ags_play_channel_run.h>
52 #include <ags/audio/recall/ags_prepare_channel.h>
53 #include <ags/audio/recall/ags_prepare_channel_run.h>
54 #include <ags/audio/recall/ags_copy_channel.h>
55 #include <ags/audio/recall/ags_copy_channel_run.h>
56 #include <ags/audio/recall/ags_feed_channel.h>
57 #include <ags/audio/recall/ags_feed_channel_run.h>
58 #include <ags/audio/recall/ags_stream_channel.h>
59 #include <ags/audio/recall/ags_stream_channel_run.h>
60 #include <ags/audio/recall/ags_rt_stream_channel.h>
61 #include <ags/audio/recall/ags_rt_stream_channel_run.h>
62 #include <ags/audio/recall/ags_buffer_channel.h>
63 #include <ags/audio/recall/ags_buffer_channel_run.h>
64 #include <ags/audio/recall/ags_copy_pattern_audio.h>
65 #include <ags/audio/recall/ags_copy_pattern_audio_run.h>
66 #include <ags/audio/recall/ags_copy_pattern_channel.h>
67 #include <ags/audio/recall/ags_copy_pattern_channel_run.h>
68 #include <ags/audio/recall/ags_play_dssi_audio.h>
69 #include <ags/audio/recall/ags_play_dssi_audio_run.h>
70 #include <ags/audio/recall/ags_play_lv2_audio.h>
71 #include <ags/audio/recall/ags_play_lv2_audio_run.h>
72 #include <ags/audio/recall/ags_play_notation_audio.h>
73 #include <ags/audio/recall/ags_play_notation_audio_run.h>
74 #include <ags/audio/recall/ags_play_wave_audio.h>
75 #include <ags/audio/recall/ags_play_wave_audio_run.h>
76 #include <ags/audio/recall/ags_play_wave_channel.h>
77 #include <ags/audio/recall/ags_play_wave_channel_run.h>
78 #include <ags/audio/recall/ags_peak_channel.h>
79 #include <ags/audio/recall/ags_peak_channel_run.h>
80 #include <ags/audio/recall/ags_analyse_channel.h>
81 #include <ags/audio/recall/ags_analyse_channel_run.h>
82 #include <ags/audio/recall/ags_mute_audio.h>
83 #include <ags/audio/recall/ags_mute_audio_run.h>
84 #include <ags/audio/recall/ags_mute_channel.h>
85 #include <ags/audio/recall/ags_mute_channel_run.h>
86 #include <ags/audio/recall/ags_volume_channel.h>
87 #include <ags/audio/recall/ags_volume_channel_run.h>
88 #include <ags/audio/recall/ags_eq10_channel.h>
89 #include <ags/audio/recall/ags_eq10_channel_run.h>
90 #include <ags/audio/recall/ags_envelope_channel.h>
91 #include <ags/audio/recall/ags_envelope_channel_run.h>
92 #include <ags/audio/recall/ags_lfo_channel.h>
93 #include <ags/audio/recall/ags_lfo_channel_run.h>
94 #include <ags/audio/recall/ags_record_midi_audio.h>
95 #include <ags/audio/recall/ags_record_midi_audio_run.h>
96 #include <ags/audio/recall/ags_route_dssi_audio.h>
97 #include <ags/audio/recall/ags_route_dssi_audio_run.h>
98 #include <ags/audio/recall/ags_route_lv2_audio.h>
99 #include <ags/audio/recall/ags_route_lv2_audio_run.h>
100
101 #include <string.h>
102
103 void ags_recall_factory_class_init(AgsRecallFactoryClass *recall_factory_class);
104 void ags_recall_factory_connectable_interface_init(AgsConnectableInterface *connectable);
105 void ags_recall_factory_init(AgsRecallFactory *recall_factory);
106
107 GList* ags_recall_factory_create_play(AgsAudio *audio,
108 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
109 gchar *plugin_name,
110 guint start_audio_channel, guint stop_audio_channel,
111 guint start_pad, guint stop_pad,
112 guint create_flags, guint recall_flags);
113 GList* ags_recall_factory_create_play_master(AgsAudio *audio,
114 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
115 gchar *plugin_name,
116 guint start_audio_channel, guint stop_audio_channel,
117 guint start_pad, guint stop_pad,
118 guint create_flags, guint recall_flags);
119 GList* ags_recall_factory_create_prepare(AgsAudio *audio,
120 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
121 gchar *plugin_name,
122 guint start_audio_channel, guint stop_audio_channel,
123 guint start_pad, guint stop_pad,
124 guint create_flags, guint recall_flags);
125 GList* ags_recall_factory_create_copy(AgsAudio *audio,
126 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
127 gchar *plugin_name,
128 guint start_audio_channel, guint stop_audio_channel,
129 guint start_pad, guint stop_pad,
130 guint create_flags, guint recall_flags);
131 GList* ags_recall_factory_create_feed(AgsAudio *audio,
132 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
133 gchar *plugin_name,
134 guint start_audio_channel, guint stop_audio_channel,
135 guint start_pad, guint stop_pad,
136 guint create_flags, guint recall_flags);
137 GList* ags_recall_factory_create_stream(AgsAudio *audio,
138 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
139 gchar *plugin_name,
140 guint start_audio_channel, guint stop_audio_channel,
141 guint start_pad, guint stop_pad,
142 guint create_flags, guint recall_flags);
143 GList* ags_recall_factory_create_rt_stream(AgsAudio *audio,
144 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
145 gchar *plugin_name,
146 guint start_audio_channel, guint stop_audio_channel,
147 guint start_pad, guint stop_pad,
148 guint create_flags, guint recall_flags);
149 GList* ags_recall_factory_create_buffer(AgsAudio *audio,
150 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
151 gchar *plugin_name,
152 guint start_audio_channel, guint stop_audio_channel,
153 guint start_pad, guint stop_pad,
154 guint create_flags, guint recall_flags);
155 GList* ags_recall_factory_create_delay(AgsAudio *audio,
156 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
157 gchar *plugin_name,
158 guint start_audio_channel, guint stop_audio_channel,
159 guint start_pad, guint stop_pad,
160 guint create_flags, guint recall_flags);
161 GList* ags_recall_factory_create_count_beats(AgsAudio *audio,
162 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
163 gchar *plugin_name,
164 guint start_audio_channel, guint stop_audio_channel,
165 guint start_pad, guint stop_pad,
166 guint create_flags, guint recall_flags);
167 GList* ags_recall_factory_create_loop(AgsAudio *audio,
168 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
169 gchar *plugin_name,
170 guint start_audio_channel, guint stop_audio_channel,
171 guint start_pad, guint stop_pad,
172 guint create_flags, guint recall_flags);
173 GList* ags_recall_factory_create_copy_pattern(AgsAudio *audio,
174 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
175 gchar *plugin_name,
176 guint start_audio_channel, guint stop_audio_channel,
177 guint start_pad, guint stop_pad,
178 guint create_flags, guint recall_flags);
179 GList* ags_recall_factory_create_play_wave(AgsAudio *audio,
180 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
181 gchar *plugin_name,
182 guint start_audio_channel, guint stop_audio_channel,
183 guint start_pad, guint stop_pad,
184 guint create_flags, guint recall_flags);
185 GList* ags_recall_factory_create_capture_wave(AgsAudio *audio,
186 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
187 gchar *plugin_name,
188 guint start_audio_channel, guint stop_audio_channel,
189 guint start_pad, guint stop_pad,
190 guint create_flags, guint recall_flags);
191 GList* ags_recall_factory_create_play_dssi(AgsAudio *audio,
192 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
193 gchar *plugin_name,
194 guint start_audio_channel, guint stop_audio_channel,
195 guint start_pad, guint stop_pad,
196 guint create_flags, guint recall_flags);
197 GList* ags_recall_factory_create_play_lv2(AgsAudio *audio,
198 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
199 gchar *plugin_name,
200 guint start_audio_channel, guint stop_audio_channel,
201 guint start_pad, guint stop_pad,
202 guint create_flags, guint recall_flags);
203 GList* ags_recall_factory_create_play_notation(AgsAudio *audio,
204 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
205 gchar *plugin_name,
206 guint start_audio_channel, guint stop_audio_channel,
207 guint start_pad, guint stop_pad,
208 guint create_flags, guint recall_flags);
209 GList* ags_recall_factory_create_peak(AgsAudio *audio,
210 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
211 gchar *plugin_name,
212 guint start_audio_channel, guint stop_audio_channel,
213 guint start_pad, guint stop_pad,
214 guint create_flags, guint recall_flags);
215 GList* ags_recall_factory_create_analyse(AgsAudio *audio,
216 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
217 gchar *plugin_name,
218 guint start_audio_channel, guint stop_audio_channel,
219 guint start_pad, guint stop_pad,
220 guint create_flags, guint recall_flags);
221 GList* ags_recall_factory_create_mute(AgsAudio *audio,
222 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
223 gchar *plugin_name,
224 guint start_audio_channel, guint stop_audio_channel,
225 guint start_pad, guint stop_pad,
226 guint create_flags, guint recall_flags);
227 GList* ags_recall_factory_create_volume(AgsAudio *audio,
228 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
229 gchar *plugin_name,
230 guint start_audio_channel, guint stop_audio_channel,
231 guint start_pad, guint stop_pad,
232 guint create_flags, guint recall_flags);
233 GList* ags_recall_factory_create_eq10(AgsAudio *audio,
234 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
235 gchar *plugin_name,
236 guint start_audio_channel, guint stop_audio_channel,
237 guint start_pad, guint stop_pad,
238 guint create_flags, guint recall_flags);
239 GList* ags_recall_factory_create_envelope(AgsAudio *audio,
240 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
241 gchar *plugin_name,
242 guint start_audio_channel, guint stop_audio_channel,
243 guint start_pad, guint stop_pad,
244 guint create_flags, guint recall_flags);
245 GList* ags_recall_factory_create_lfo(AgsAudio *audio,
246 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
247 gchar *plugin_name,
248 guint start_audio_channel, guint stop_audio_channel,
249 guint start_pad, guint stop_pad,
250 guint create_flags, guint recall_flags);
251 GList* ags_recall_factory_create_ladspa(AgsAudio *audio,
252 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
253 gchar *plugin_name,
254 guint start_audio_channel, guint stop_audio_channel,
255 guint start_pad, guint stop_pad,
256 guint create_flags, guint recall_flags);
257 GList* ags_recall_factory_create_lv2(AgsAudio *audio,
258 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
259 gchar *plugin_name,
260 guint start_audio_channel, guint stop_audio_channel,
261 guint start_pad, guint stop_pad,
262 guint create_flags, guint recall_flags);
263 GList* ags_recall_factory_create_dssi(AgsAudio *audio,
264 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
265 gchar *plugin_name,
266 guint start_audio_channel, guint stop_audio_channel,
267 guint start_pad, guint stop_pad,
268 guint create_flags, guint recall_flags);
269 GList* ags_recall_factory_create_record_midi(AgsAudio *audio,
270 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
271 gchar *plugin_name,
272 guint start_audio_channel, guint stop_audio_channel,
273 guint start_pad, guint stop_pad,
274 guint create_flags, guint recall_flags);
275 GList* ags_recall_factory_create_route_dssi(AgsAudio *audio,
276 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
277 gchar *plugin_name,
278 guint start_audio_channel, guint stop_audio_channel,
279 guint start_pad, guint stop_pad,
280 guint create_flags, guint recall_flags);
281 GList* ags_recall_factory_create_route_lv2(AgsAudio *audio,
282 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
283 gchar *plugin_name,
284 guint start_audio_channel, guint stop_audio_channel,
285 guint start_pad, guint stop_pad,
286 guint create_flags, guint recall_flags);
287
288 /**
289 * SECTION:ags_recall_factory
290 * @short_description: Factory pattern
291 * @title: AgsRecallFactory
292 * @section_id:
293 * @include: ags/audio/ags_recall_factory.h
294 *
295 * #AgsRecallFactory instantiates and sets up recalls.
296 */
297
298 static gpointer ags_recall_factory_parent_class = NULL;
299
300 GType
ags_recall_factory_get_type(void)301 ags_recall_factory_get_type (void)
302 {
303 static volatile gsize g_define_type_id__volatile = 0;
304
305 if(g_once_init_enter (&g_define_type_id__volatile)){
306 GType ags_type_recall_factory = 0;
307
308 static const GTypeInfo ags_recall_factory_info = {
309 sizeof (AgsRecallFactoryClass),
310 NULL, /* base_init */
311 NULL, /* base_finalize */
312 (GClassInitFunc) ags_recall_factory_class_init,
313 NULL, /* class_finalize */
314 NULL, /* class_data */
315 sizeof (AgsRecallFactory),
316 0, /* n_preallocs */
317 (GInstanceInitFunc) ags_recall_factory_init,
318 };
319
320 static const GInterfaceInfo ags_connectable_interface_info = {
321 (GInterfaceInitFunc) ags_recall_factory_connectable_interface_init,
322 NULL, /* interface_finalize */
323 NULL, /* interface_data */
324 };
325
326 ags_type_recall_factory = g_type_register_static(G_TYPE_OBJECT,
327 "AgsRecallFactory",
328 &ags_recall_factory_info,
329 0);
330
331 g_type_add_interface_static(ags_type_recall_factory,
332 AGS_TYPE_CONNECTABLE,
333 &ags_connectable_interface_info);
334
335 g_once_init_leave(&g_define_type_id__volatile, ags_type_recall_factory);
336 }
337
338 return g_define_type_id__volatile;
339 }
340
341 void
ags_recall_factory_class_init(AgsRecallFactoryClass * recall_factory)342 ags_recall_factory_class_init(AgsRecallFactoryClass *recall_factory)
343 {
344 ags_recall_factory_parent_class = g_type_class_peek_parent(recall_factory);
345 }
346
347 void
ags_recall_factory_connectable_interface_init(AgsConnectableInterface * connectable)348 ags_recall_factory_connectable_interface_init(AgsConnectableInterface *connectable)
349 {
350 connectable->add_to_registry = NULL;
351 connectable->remove_from_registry = NULL;
352 connectable->connect = NULL;
353 connectable->disconnect = NULL;
354 }
355
356 void
ags_recall_factory_init(AgsRecallFactory * recall_factory)357 ags_recall_factory_init(AgsRecallFactory *recall_factory)
358 {
359 }
360
361 GList*
ags_recall_factory_create_play(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)362 ags_recall_factory_create_play(AgsAudio *audio,
363 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
364 gchar *plugin_name,
365 guint start_audio_channel, guint stop_audio_channel,
366 guint start_pad, guint stop_pad,
367 guint create_flags, guint recall_flags)
368 {
369 AgsPlayChannel *play_channel;
370 AgsPlayChannelRun *play_channel_run;
371 AgsChannel *start_output, *start_input;
372 AgsChannel *start, *channel, *next_channel, *nth_channel;
373 AgsPort *port;
374
375 GObject *output_soundcard;
376
377 GList *list_start, list;
378 GList *recall;
379
380 guint audio_channels;
381 guint i, j;
382
383 GRecMutex *audio_mutex;
384
385 if(!AGS_IS_AUDIO(audio)){
386 return(NULL);
387 }
388
389 /* get audio mutex */
390 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
391
392 /* get some fields */
393 g_rec_mutex_lock(audio_mutex);
394
395 output_soundcard = audio->output_soundcard;
396
397 audio_channels = audio->audio_channels;
398
399 start_output = audio->output;
400
401 if(start_output != NULL){
402 g_object_ref(start_output);
403 }
404
405 start_input = audio->input;
406
407 if(start_input != NULL){
408 g_object_ref(start_input);
409 }
410
411 g_rec_mutex_unlock(audio_mutex);
412
413 /* get channel */
414 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
415 start = ags_channel_nth(start_output,
416 start_pad * audio_channels);
417 }else{
418 start = ags_channel_nth(start_input,
419 start_pad * audio_channels);
420 }
421
422 recall = NULL;
423
424 /* play */
425 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
426 channel = start;
427
428 if(channel != NULL){
429 g_object_ref(channel);
430 }
431
432 if(play_container == NULL){
433 play_container = ags_recall_container_new();
434 }
435
436 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
437 ags_audio_add_recall_container(audio, (GObject *) play_container);
438
439 nth_channel = NULL;
440
441 for(i = 0; i < stop_pad - start_pad; i++){
442 nth_channel = ags_channel_nth(channel,
443 start_audio_channel);
444
445 g_object_unref(channel);
446
447 channel = nth_channel;
448
449 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
450 /* add recall container */
451 ags_channel_add_recall_container(channel,
452 (GObject *) play_container);
453
454 /* AgsPlayChannel */
455 play_channel = (AgsPlayChannel *) g_object_new(AGS_TYPE_PLAY_CHANNEL,
456 "output-soundcard", output_soundcard,
457 "source", channel,
458 "recall-container", play_container,
459 NULL);
460 ags_recall_set_flags((AgsRecall *) play_channel,
461 (AGS_RECALL_TEMPLATE));
462 ags_recall_set_ability_flags((AgsRecall *) play_channel,
463 (AGS_SOUND_ABILITY_PLAYBACK));
464 ags_recall_set_behaviour_flags((AgsRecall *) play_channel,
465 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
466
467 play_channel->audio_channel->port_value.ags_port_uint = start_audio_channel + j;
468 ags_channel_add_recall(channel, (GObject *) play_channel, TRUE);
469 recall = g_list_prepend(recall,
470 play_channel);
471
472 g_object_set(play_container,
473 "recall-channel", play_channel,
474 NULL);
475 ags_connectable_connect(AGS_CONNECTABLE(play_channel));
476
477 /* AgsPlayChannelRun */
478 play_channel_run = (AgsPlayChannelRun *) g_object_new(AGS_TYPE_PLAY_CHANNEL_RUN,
479 "output-soundcard", output_soundcard,
480 "source", channel,
481 "recall-channel", play_channel,
482 "recall-container", play_container,
483 NULL);
484 ags_recall_set_flags((AgsRecall *) play_channel_run,
485 (AGS_RECALL_TEMPLATE));
486 ags_recall_set_ability_flags((AgsRecall *) play_channel_run,
487 (AGS_SOUND_ABILITY_PLAYBACK));
488 ags_recall_set_behaviour_flags((AgsRecall *) play_channel_run,
489 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
490
491 ags_channel_add_recall(channel, (GObject *) play_channel_run, TRUE);
492 recall = g_list_prepend(recall,
493 play_channel_run);
494
495 g_object_set(play_container,
496 "recall-channel-run", play_channel_run,
497 NULL);
498 ags_connectable_connect(AGS_CONNECTABLE(play_channel_run));
499
500 /* iterate */
501 next_channel = ags_channel_next(channel);
502
503 g_object_unref(channel);
504
505 channel = next_channel;
506 }
507
508 nth_channel = ags_channel_nth(channel,
509 audio_channels - stop_audio_channel);
510
511 if(channel != NULL){
512 g_object_unref(channel);
513 }
514
515 channel = nth_channel;
516 }
517
518 if(nth_channel != NULL){
519 g_object_unref(nth_channel);
520 }
521 }
522
523 /* recall */
524 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
525 channel = start;
526
527 if(channel != NULL){
528 g_object_ref(channel);
529 }
530
531 if(recall_container == NULL){
532 recall_container = ags_recall_container_new();
533 }
534
535 ags_audio_add_recall_container(audio, (GObject *) recall_container);
536
537 nth_channel = NULL;
538
539 for(i = 0; i < stop_pad - start_pad; i++){
540 nth_channel = ags_channel_nth(channel,
541 start_audio_channel);
542
543 g_object_unref(channel);
544
545 channel = nth_channel;
546
547 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
548 /* add recall container */
549 ags_channel_add_recall_container(channel,
550 (GObject *) recall_container);
551
552 /* AgsPlayChannel */
553 play_channel = (AgsPlayChannel *) g_object_new(AGS_TYPE_PLAY_CHANNEL,
554 "output-soundcard", output_soundcard,
555 "source", channel,
556 "recall-container", recall_container,
557 NULL);
558 ags_recall_set_flags((AgsRecall *) play_channel,
559 (AGS_RECALL_TEMPLATE));
560 ags_recall_set_ability_flags((AgsRecall *) play_channel,
561 (AGS_SOUND_ABILITY_PLAYBACK));
562 ags_recall_set_behaviour_flags((AgsRecall *) play_channel,
563 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
564
565 play_channel->audio_channel->port_value.ags_port_uint = start_audio_channel + j;
566 ags_channel_add_recall(channel, (GObject *) play_channel, FALSE);
567 recall = g_list_prepend(recall,
568 play_channel);
569
570 g_object_set(recall_container,
571 "recall-channel", play_channel,
572 NULL);
573 ags_connectable_connect(AGS_CONNECTABLE(play_channel));
574
575 /* AgsPlayChannelRun */
576 play_channel_run = (AgsPlayChannelRun *) g_object_new(AGS_TYPE_PLAY_CHANNEL_RUN,
577 "output-soundcard", output_soundcard,
578 "source", channel,
579 "recall-channel", play_channel,
580 "recall-container", recall_container,
581 NULL);
582 ags_recall_set_flags((AgsRecall *) play_channel_run,
583 (AGS_RECALL_TEMPLATE));
584 ags_recall_set_ability_flags((AgsRecall *) play_channel_run,
585 (AGS_SOUND_ABILITY_PLAYBACK));
586 ags_recall_set_behaviour_flags((AgsRecall *) play_channel_run,
587 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
588
589 ags_channel_add_recall(channel, (GObject *) play_channel_run, FALSE);
590 recall = g_list_prepend(recall,
591 play_channel_run);
592
593 g_object_set(recall_container,
594 "recall-channel-run", play_channel_run,
595 NULL);
596 ags_connectable_connect(AGS_CONNECTABLE(play_channel_run));
597
598 /* iterate */
599 next_channel = ags_channel_next(channel);
600
601 g_object_unref(channel);
602
603 channel = next_channel;
604 }
605
606 nth_channel = ags_channel_nth(channel,
607 audio_channels - stop_audio_channel);
608
609 if(channel != NULL){
610 g_object_unref(channel);
611 }
612
613 channel = nth_channel;
614 }
615
616 if(nth_channel != NULL){
617 g_object_unref(nth_channel);
618 }
619 }
620
621 /* unref */
622 if(start_output != NULL){
623 g_object_unref(start_output);
624 }
625
626 if(start_input != NULL){
627 g_object_unref(start_input);
628 }
629
630 if(start != NULL){
631 g_object_unref(start);
632 }
633
634 /* return instantiated recall */
635 recall = g_list_reverse(recall);
636 g_list_foreach(recall,
637 (GFunc) g_object_ref,
638 NULL);
639
640 return(recall);
641 }
642
643 GList*
ags_recall_factory_create_play_master(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)644 ags_recall_factory_create_play_master(AgsAudio *audio,
645 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
646 gchar *plugin_name,
647 guint start_audio_channel, guint stop_audio_channel,
648 guint start_pad, guint stop_pad,
649 guint create_flags, guint recall_flags)
650 {
651 AgsPlayAudio *play_audio;
652 AgsPlayChannel *play_channel;
653 AgsPlayChannelRunMaster *play_channel_run_master;
654 AgsChannel *start_output, *start_input;
655 AgsChannel *start, *channel, *next_channel, *nth_channel;
656 AgsPort *port;
657
658 GObject *output_soundcard;
659
660 GList *list_start, *list;
661 GList *recall;
662
663 guint audio_channels;
664 guint i, j;
665
666 GRecMutex *audio_mutex;
667
668 if(!AGS_IS_AUDIO(audio)){
669 return(NULL);
670 }
671
672 /* get audio mutex */
673 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
674
675 /* get some fields */
676 g_rec_mutex_lock(audio_mutex);
677
678 output_soundcard = audio->output_soundcard;
679
680 audio_channels = audio->audio_channels;
681
682 start_output = audio->output;
683
684 if(start_output != NULL){
685 g_object_ref(start_output);
686 }
687
688 start_input = audio->input;
689
690 if(start_input != NULL){
691 g_object_ref(start_input);
692 }
693
694 g_rec_mutex_unlock(audio_mutex);
695
696 /* get channel */
697 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
698 start = ags_channel_nth(start_output,
699 start_pad * audio_channels);
700 }else{
701 start = ags_channel_nth(start_input,
702 start_pad * audio_channels);
703 }
704
705 recall = NULL;
706
707 /* play */
708 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
709 channel = start;
710
711 if(channel != NULL){
712 g_object_ref(channel);
713 }
714
715 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0){
716 if(play_container == NULL){
717 play_container = ags_recall_container_new();
718 }
719
720 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
721 ags_audio_add_recall_container(audio, (GObject *) play_container);
722
723 /* */
724 play_audio = (AgsPlayAudio *) g_object_new(AGS_TYPE_PLAY_AUDIO,
725 "output-soundcard", output_soundcard,
726 "audio", audio,
727 "recall-container", play_container,
728 NULL);
729 ags_recall_set_flags((AgsRecall *) play_audio,
730 (AGS_RECALL_TEMPLATE));
731 ags_recall_set_ability_flags((AgsRecall *) play_audio,
732 (AGS_SOUND_ABILITY_PLAYBACK |
733 AGS_SOUND_ABILITY_NOTATION |
734 AGS_SOUND_ABILITY_SEQUENCER |
735 AGS_SOUND_ABILITY_MIDI |
736 AGS_SOUND_ABILITY_WAVE));
737 ags_recall_set_behaviour_flags((AgsRecall *) play_audio,
738 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
739
740
741 ags_audio_add_recall(audio, (GObject *) play_audio, TRUE);
742 recall = g_list_prepend(recall,
743 play_audio);
744 }else{
745 if(play_container == NULL){
746 g_object_get(audio,
747 "play", &list_start,
748 NULL);
749
750 list = ags_recall_find_type(list_start,
751 AGS_TYPE_PLAY_AUDIO);
752 play_audio = AGS_PLAY_AUDIO(list->data);
753 g_list_free_full(list_start,
754 g_object_unref);
755
756 recall = g_list_prepend(recall,
757 play_audio);
758
759 g_object_get(play_audio,
760 "recall-container", &play_container,
761 NULL);
762 g_object_unref(play_container);
763 }else{
764 g_object_get(play_container,
765 "recall-audio", &play_audio,
766 NULL);
767 g_object_unref(play_audio);
768
769 recall = g_list_prepend(recall,
770 play_audio);
771 }
772 }
773
774 nth_channel = NULL;
775
776 for(i = 0; i < stop_pad - start_pad; i++){
777 nth_channel = ags_channel_nth(channel,
778 start_audio_channel);
779
780 g_object_unref(channel);
781
782 channel = nth_channel;
783
784 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
785 /* add recall container */
786 ags_channel_add_recall_container(channel,
787 (GObject *) play_container);
788
789 /* AgsPlayChannel */
790 play_channel = (AgsPlayChannel *) g_object_new(AGS_TYPE_PLAY_CHANNEL,
791 "output-soundcard", output_soundcard,
792 "source", channel,
793 "recall-container", play_container,
794 NULL);
795 ags_recall_set_flags((AgsRecall *) play_channel,
796 (AGS_RECALL_TEMPLATE));
797 ags_recall_set_ability_flags((AgsRecall *) play_channel,
798 (AGS_SOUND_ABILITY_PLAYBACK |
799 AGS_SOUND_ABILITY_NOTATION |
800 AGS_SOUND_ABILITY_SEQUENCER |
801 AGS_SOUND_ABILITY_MIDI |
802 AGS_SOUND_ABILITY_WAVE));
803 ags_recall_set_behaviour_flags((AgsRecall *) play_channel,
804 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
805
806 play_channel->audio_channel->port_value.ags_port_uint = start_audio_channel + j;
807 ags_channel_add_recall(channel, (GObject *) play_channel, TRUE);
808 recall = g_list_prepend(recall,
809 play_channel);
810
811 g_object_set(play_container,
812 "recall-channel", play_channel,
813 NULL);
814 ags_connectable_connect(AGS_CONNECTABLE(play_channel));
815
816 /* AgsPlayChannelRun */
817 play_channel_run_master = (AgsPlayChannelRunMaster *) g_object_new(AGS_TYPE_PLAY_CHANNEL_RUN_MASTER,
818 "output-soundcard", output_soundcard,
819 "source", channel,
820 "recall-channel", play_channel,
821 "recall-container", play_container,
822 NULL);
823 ags_recall_set_flags((AgsRecall *) play_channel_run_master,
824 (AGS_RECALL_TEMPLATE));
825 ags_recall_set_ability_flags((AgsRecall *) play_channel_run_master,
826 (AGS_SOUND_ABILITY_PLAYBACK |
827 AGS_SOUND_ABILITY_NOTATION |
828 AGS_SOUND_ABILITY_SEQUENCER |
829 AGS_SOUND_ABILITY_MIDI |
830 AGS_SOUND_ABILITY_WAVE));
831 ags_recall_set_behaviour_flags((AgsRecall *) play_channel_run_master,
832 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
833
834 ags_channel_add_recall(channel, (GObject *) play_channel_run_master, TRUE);
835 recall = g_list_prepend(recall,
836 play_channel_run_master);
837
838 g_object_set(play_container,
839 "recall-channel-run", play_channel_run_master,
840 NULL);
841 ags_connectable_connect(AGS_CONNECTABLE(play_channel_run_master));
842
843 /* iterate */
844 next_channel = ags_channel_next(channel);
845
846 g_object_unref(channel);
847
848 channel = next_channel;
849 }
850
851 nth_channel = ags_channel_nth(channel,
852 audio_channels - stop_audio_channel);
853
854 if(channel != NULL){
855 g_object_unref(channel);
856 }
857
858 channel = nth_channel;
859 }
860
861 if(nth_channel != NULL){
862 g_object_unref(nth_channel);
863 }
864 }
865
866 /* recall */
867 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
868 channel = start;
869
870 if(channel != NULL){
871 g_object_ref(channel);
872 }
873
874 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0){
875 if(recall_container == NULL){
876 recall_container = ags_recall_container_new();
877 }
878
879 ags_audio_add_recall_container(audio, (GObject *) recall_container);
880
881 /* */
882 play_audio = (AgsPlayAudio *) g_object_new(AGS_TYPE_PLAY_AUDIO,
883 "output-soundcard", output_soundcard,
884 "audio", audio,
885 "recall-container", recall_container,
886 NULL);
887 ags_recall_set_flags((AgsRecall *) play_audio,
888 (AGS_RECALL_TEMPLATE));
889 ags_recall_set_ability_flags((AgsRecall *) play_audio,
890 (AGS_SOUND_ABILITY_PLAYBACK |
891 AGS_SOUND_ABILITY_NOTATION |
892 AGS_SOUND_ABILITY_SEQUENCER |
893 AGS_SOUND_ABILITY_MIDI |
894 AGS_SOUND_ABILITY_WAVE));
895 ags_recall_set_behaviour_flags((AgsRecall *) play_audio,
896 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
897
898 ags_audio_add_recall(audio, (GObject *) play_audio, FALSE);
899 recall = g_list_prepend(recall,
900 play_audio);
901 }else{
902 if(recall_container == NULL){
903 g_object_get(audio,
904 "recall", &list_start,
905 NULL);
906
907 list = ags_recall_find_type(list_start,
908 AGS_TYPE_PLAY_AUDIO);
909 play_audio = AGS_PLAY_AUDIO(list->data);
910 g_list_free_full(list_start,
911 g_object_unref);
912
913 recall = g_list_prepend(recall,
914 play_audio);
915
916 g_object_get(play_audio,
917 "recall-container", &recall_container,
918 NULL);
919 g_object_unref(recall_container);
920 }else{
921 g_object_get(recall_container,
922 "recall-audio", &play_audio,
923 NULL);
924 g_object_unref(play_audio);
925 recall = g_list_prepend(recall,
926 play_audio);
927 }
928 }
929
930 nth_channel = NULL;
931
932 for(i = 0; i < stop_pad - start_pad; i++){
933 nth_channel = ags_channel_nth(channel,
934 start_audio_channel);
935
936 g_object_unref(channel);
937
938 channel = nth_channel;
939
940 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
941 /* add recall container */
942 ags_channel_add_recall_container(channel,
943 (GObject *) recall_container);
944
945 /* AgsPlayChannel */
946 play_channel = (AgsPlayChannel *) g_object_new(AGS_TYPE_PLAY_CHANNEL,
947 "output-soundcard", output_soundcard,
948 "source", channel,
949 "recall-container", recall_container,
950 NULL);
951 ags_recall_set_flags((AgsRecall *) play_channel,
952 (AGS_RECALL_TEMPLATE));
953 ags_recall_set_ability_flags((AgsRecall *) play_channel,
954 (AGS_SOUND_ABILITY_PLAYBACK |
955 AGS_SOUND_ABILITY_NOTATION |
956 AGS_SOUND_ABILITY_SEQUENCER |
957 AGS_SOUND_ABILITY_MIDI |
958 AGS_SOUND_ABILITY_WAVE));
959 ags_recall_set_behaviour_flags((AgsRecall *) play_channel,
960 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
961
962 play_channel->audio_channel->port_value.ags_port_uint = start_audio_channel + j;
963 ags_channel_add_recall(channel, (GObject *) play_channel, FALSE);
964 recall = g_list_prepend(recall,
965 play_channel);
966
967 g_object_set(recall_container,
968 "recall-channel", play_channel,
969 NULL);
970 ags_connectable_connect(AGS_CONNECTABLE(play_channel));
971
972 /* AgsPlayChannelRun */
973 play_channel_run_master = (AgsPlayChannelRunMaster *) g_object_new(AGS_TYPE_PLAY_CHANNEL_RUN_MASTER,
974 "output-soundcard", output_soundcard,
975 "source", channel,
976 "recall-channel", play_channel,
977 "recall-container", recall_container,
978 NULL);
979 ags_recall_set_flags((AgsRecall *) play_channel_run_master,
980 (AGS_RECALL_TEMPLATE));
981 ags_recall_set_ability_flags((AgsRecall *) play_channel_run_master,
982 (AGS_SOUND_ABILITY_PLAYBACK |
983 AGS_SOUND_ABILITY_NOTATION |
984 AGS_SOUND_ABILITY_SEQUENCER |
985 AGS_SOUND_ABILITY_MIDI |
986 AGS_SOUND_ABILITY_WAVE));
987 ags_recall_set_behaviour_flags((AgsRecall *) play_channel_run_master,
988 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
989
990 ags_channel_add_recall(channel, (GObject *) play_channel_run_master, FALSE);
991 recall = g_list_prepend(recall,
992 play_channel_run_master);
993
994 g_object_set(recall_container,
995 "recall-channel-run", play_channel_run_master,
996 NULL);
997 ags_connectable_connect(AGS_CONNECTABLE(play_channel_run_master));
998
999 /* iterate */
1000 next_channel = ags_channel_next(channel);
1001
1002 g_object_unref(channel);
1003
1004 channel = next_channel;
1005 }
1006
1007 nth_channel = ags_channel_nth(channel,
1008 audio_channels - stop_audio_channel);
1009
1010 if(channel != NULL){
1011 g_object_unref(channel);
1012 }
1013
1014 channel = nth_channel;
1015 }
1016
1017 if(nth_channel != NULL){
1018 g_object_unref(nth_channel);
1019 }
1020 }
1021
1022 /* unref */
1023 if(start_output != NULL){
1024 g_object_unref(start_output);
1025 }
1026
1027 if(start_input != NULL){
1028 g_object_unref(start_input);
1029 }
1030
1031 if(start != NULL){
1032 g_object_unref(start);
1033 }
1034
1035 /* return instantiated recall */
1036 recall = g_list_reverse(recall);
1037 g_list_foreach(recall,
1038 (GFunc) g_object_ref,
1039 NULL);
1040
1041 return(recall);
1042 }
1043
1044 GList*
ags_recall_factory_create_prepare(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)1045 ags_recall_factory_create_prepare(AgsAudio *audio,
1046 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
1047 gchar *plugin_name,
1048 guint start_audio_channel, guint stop_audio_channel,
1049 guint start_pad, guint stop_pad,
1050 guint create_flags, guint recall_flags)
1051 {
1052 AgsPrepareChannel *prepare_channel;
1053 AgsPrepareChannelRun *prepare_channel_run;
1054 AgsChannel *start_output, *start_input;
1055 AgsChannel *start, *channel, *next_pad, *next_channel, *nth_channel, *current;
1056 AgsPort *port;
1057
1058 GObject *output_soundcard;
1059
1060 GList *list_start, *list;
1061 GList *recall;
1062
1063 guint audio_channels;
1064 guint i, j;
1065
1066 GRecMutex *audio_mutex;
1067 GRecMutex *current_mutex;
1068
1069 if(!AGS_IS_AUDIO(audio)){
1070 return(NULL);
1071 }
1072
1073 /* get audio mutex */
1074 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
1075
1076 /* get some fields */
1077 g_rec_mutex_lock(audio_mutex);
1078
1079 output_soundcard = audio->output_soundcard;
1080
1081 audio_channels = audio->audio_channels;
1082
1083 start_output = audio->output;
1084
1085 if(start_output != NULL){
1086 g_object_ref(start_output);
1087 }
1088
1089 start_input = audio->input;
1090
1091 if(start_input != NULL){
1092 g_object_ref(start_input);
1093 }
1094
1095 g_rec_mutex_unlock(audio_mutex);
1096
1097 /* get channel */
1098 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
1099 start = ags_channel_nth(start_output,
1100 start_pad * audio_channels);
1101 }else{
1102 start = ags_channel_nth(start_input,
1103 start_pad * audio_channels);
1104 }
1105
1106 recall = NULL;
1107
1108 /* play */
1109 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
1110 gboolean found_prepare;
1111
1112 channel = start;
1113
1114 if(channel != NULL){
1115 g_object_ref(channel);
1116 }
1117
1118 nth_channel = NULL;
1119
1120 for(i = 0; i < stop_pad - start_pad; i++){
1121 nth_channel = ags_channel_nth(channel,
1122 start_audio_channel);
1123
1124 g_object_unref(channel);
1125
1126 channel = nth_channel;
1127
1128 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
1129 current = ags_channel_nth(start_output,
1130 start_audio_channel + j);
1131
1132 /* check output */
1133 while(current != NULL){
1134 /* get channel mutex */
1135 current_mutex = AGS_CHANNEL_GET_OBJ_MUTEX(current);
1136
1137 /* check output present */
1138 g_object_get(channel,
1139 "play", &list_start,
1140 NULL);
1141
1142 list = list_start;
1143 found_prepare = FALSE;
1144
1145 while((list = ags_recall_template_find_type(list,
1146 AGS_TYPE_PREPARE_CHANNEL)) != NULL){
1147 AgsChannel *current_destination;
1148
1149 g_object_get(list->data,
1150 "destination", ¤t_destination,
1151 NULL);
1152
1153 if(current_destination == current){
1154 found_prepare = TRUE;
1155 break;
1156 }
1157
1158 list = list->next;
1159 }
1160
1161 g_list_free_full(list_start,
1162 g_object_unref);
1163
1164 if(found_prepare){
1165 /* iterate - current */
1166 g_rec_mutex_lock(current_mutex);
1167
1168 current = current->next_pad;
1169
1170 g_rec_mutex_unlock(current_mutex);
1171
1172 continue;
1173 }
1174
1175 if(play_container == NULL){
1176 play_container = ags_recall_container_new();
1177 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
1178 ags_audio_add_recall_container(audio, (GObject *) play_container);
1179 }
1180
1181 ags_channel_add_recall_container(channel, (GObject *) play_container);
1182
1183 /* AgsPrepareChannel */
1184 prepare_channel = (AgsPrepareChannel *) g_object_new(AGS_TYPE_PREPARE_CHANNEL,
1185 "output-soundcard", output_soundcard,
1186 "source", channel,
1187 "destination", current,
1188 "recall-container", play_container,
1189 NULL);
1190 ags_recall_set_flags((AgsRecall *) prepare_channel,
1191 (AGS_RECALL_TEMPLATE));
1192 ags_recall_set_ability_flags((AgsRecall *) prepare_channel,
1193 (AGS_SOUND_ABILITY_PLAYBACK |
1194 AGS_SOUND_ABILITY_NOTATION |
1195 AGS_SOUND_ABILITY_SEQUENCER |
1196 AGS_SOUND_ABILITY_MIDI |
1197 AGS_SOUND_ABILITY_WAVE));
1198 ags_recall_set_behaviour_flags((AgsRecall *) prepare_channel,
1199 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1200
1201 ags_channel_add_recall(channel,
1202 (GObject *) prepare_channel, TRUE);
1203
1204 recall = g_list_prepend(recall,
1205 prepare_channel);
1206
1207 g_object_set(play_container,
1208 "recall-channel", prepare_channel,
1209 NULL);
1210 ags_connectable_connect(AGS_CONNECTABLE(prepare_channel));
1211
1212 /* AgsPrepareChannelRun */
1213 prepare_channel_run = (AgsPrepareChannelRun *) g_object_new(AGS_TYPE_PREPARE_CHANNEL_RUN,
1214 "output-soundcard", output_soundcard,
1215 "recall-channel", prepare_channel,
1216 "source", channel,
1217 "destination", current,
1218 "recall-container", play_container,
1219 NULL);
1220 ags_recall_set_flags((AgsRecall *) prepare_channel_run,
1221 (AGS_RECALL_TEMPLATE));
1222 ags_recall_set_ability_flags((AgsRecall *) prepare_channel_run,
1223 (AGS_SOUND_ABILITY_PLAYBACK |
1224 AGS_SOUND_ABILITY_NOTATION |
1225 AGS_SOUND_ABILITY_SEQUENCER |
1226 AGS_SOUND_ABILITY_MIDI |
1227 AGS_SOUND_ABILITY_WAVE));
1228 ags_recall_set_behaviour_flags((AgsRecall *) prepare_channel_run,
1229 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1230
1231 ags_channel_add_recall(channel,
1232 (GObject *) prepare_channel_run, TRUE);
1233
1234 recall = g_list_prepend(recall,
1235 prepare_channel_run);
1236
1237 g_object_set(play_container,
1238 "recall-channel-run", prepare_channel_run,
1239 NULL);
1240 ags_connectable_connect(AGS_CONNECTABLE(prepare_channel_run));
1241
1242 /* iterate */
1243 next_pad = ags_channel_next_pad(current);
1244
1245 g_object_unref(current);
1246
1247 current = next_pad;
1248 }
1249
1250 /* iterate */
1251 next_channel = ags_channel_next(channel);
1252
1253 g_object_unref(channel);
1254
1255 channel = next_channel;
1256 }
1257
1258 nth_channel = ags_channel_nth(channel,
1259 audio_channels - stop_audio_channel);
1260
1261 if(channel != NULL){
1262 g_object_unref(channel);
1263 }
1264
1265 channel = nth_channel;
1266 }
1267
1268 if(nth_channel != NULL){
1269 g_object_unref(nth_channel);
1270 }
1271 }
1272
1273 /* recall */
1274 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
1275 gboolean found_prepare;
1276
1277 channel = start;
1278
1279 if(channel != NULL){
1280 g_object_ref(channel);
1281 }
1282
1283 nth_channel = NULL;
1284
1285 for(i = 0; i < stop_pad - start_pad; i++){
1286 nth_channel = ags_channel_nth(channel,
1287 start_audio_channel);
1288
1289 g_object_unref(channel);
1290
1291 channel = nth_channel;
1292
1293 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
1294 current = ags_channel_nth(start_output,
1295 start_audio_channel + j);
1296
1297 /* check output */
1298 while(current != NULL){
1299 /* get channel mutex */
1300 current_mutex = AGS_CHANNEL_GET_OBJ_MUTEX(current);
1301
1302 /* check output present */
1303 g_object_get(channel,
1304 "recall", &list_start,
1305 NULL);
1306
1307 list = list_start;
1308 found_prepare = FALSE;
1309
1310 while((list = ags_recall_template_find_type(list,
1311 AGS_TYPE_PREPARE_CHANNEL)) != NULL){
1312 AgsChannel *current_destination;
1313
1314 g_object_get(list->data,
1315 "destination", ¤t_destination,
1316 NULL);
1317
1318 if(current_destination == current){
1319 found_prepare = TRUE;
1320 break;
1321 }
1322
1323 list = list->next;
1324 }
1325
1326 g_list_free_full(list_start,
1327 g_object_unref);
1328
1329 if(found_prepare){
1330 /* iterate */
1331 g_rec_mutex_lock(current_mutex);
1332
1333 current = current->next_pad;
1334
1335 g_rec_mutex_unlock(current_mutex);
1336
1337 continue;
1338 }
1339
1340 if(recall_container == NULL){
1341 recall_container = ags_recall_container_new();
1342 ags_audio_add_recall_container(audio, (GObject *) recall_container);
1343 }
1344
1345 ags_channel_add_recall_container(channel, (GObject *) recall_container);
1346
1347 /* AgsPrepareChannel */
1348 prepare_channel = (AgsPrepareChannel *) g_object_new(AGS_TYPE_PREPARE_CHANNEL,
1349 "output-soundcard", output_soundcard,
1350 "source", channel,
1351 "destination", current,
1352 "recall-container", recall_container,
1353 NULL);
1354 ags_recall_set_flags((AgsRecall *) prepare_channel,
1355 (AGS_RECALL_TEMPLATE));
1356 ags_recall_set_ability_flags((AgsRecall *) prepare_channel,
1357 (AGS_SOUND_ABILITY_PLAYBACK |
1358 AGS_SOUND_ABILITY_NOTATION |
1359 AGS_SOUND_ABILITY_SEQUENCER |
1360 AGS_SOUND_ABILITY_MIDI |
1361 AGS_SOUND_ABILITY_WAVE));
1362 ags_recall_set_behaviour_flags((AgsRecall *) prepare_channel,
1363 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1364
1365 ags_channel_add_recall(channel,
1366 (GObject *) prepare_channel, FALSE);
1367
1368 recall = g_list_prepend(recall,
1369 prepare_channel);
1370
1371 g_object_set(recall_container,
1372 "recall-channel", prepare_channel,
1373 NULL);
1374 ags_connectable_connect(AGS_CONNECTABLE(prepare_channel));
1375
1376 /* AgsPrepareChannelRun */
1377 prepare_channel_run = (AgsPrepareChannelRun *) g_object_new(AGS_TYPE_PREPARE_CHANNEL_RUN,
1378 "output-soundcard", output_soundcard,
1379 "recall-channel", prepare_channel,
1380 "source", channel,
1381 "destination", current,
1382 "recall-container", recall_container,
1383 NULL);
1384 ags_recall_set_flags((AgsRecall *) prepare_channel_run,
1385 (AGS_RECALL_TEMPLATE));
1386 ags_recall_set_ability_flags((AgsRecall *) prepare_channel_run,
1387 (AGS_SOUND_ABILITY_PLAYBACK |
1388 AGS_SOUND_ABILITY_NOTATION |
1389 AGS_SOUND_ABILITY_SEQUENCER |
1390 AGS_SOUND_ABILITY_MIDI |
1391 AGS_SOUND_ABILITY_WAVE));
1392 ags_recall_set_behaviour_flags((AgsRecall *) prepare_channel_run,
1393 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1394
1395 ags_channel_add_recall(channel,
1396 (GObject *) prepare_channel_run, FALSE);
1397
1398 recall = g_list_prepend(recall,
1399 prepare_channel_run);
1400
1401 g_object_set(recall_container,
1402 "recall-channel-run", prepare_channel_run,
1403 NULL);
1404 ags_connectable_connect(AGS_CONNECTABLE(prepare_channel_run));
1405
1406 /* iterate */
1407 next_pad = ags_channel_next_pad(current);
1408
1409 g_object_unref(current);
1410
1411 current = next_pad;
1412 }
1413
1414 /* iterate */
1415 next_channel = ags_channel_next(channel);
1416
1417 g_object_unref(channel);
1418
1419 channel = next_channel;
1420 }
1421
1422 nth_channel = ags_channel_nth(channel,
1423 audio_channels - stop_audio_channel);
1424
1425 if(channel != NULL){
1426 g_object_unref(channel);
1427 }
1428
1429 channel = nth_channel;
1430 }
1431
1432 if(nth_channel != NULL){
1433 g_object_unref(nth_channel);
1434 }
1435 }
1436
1437 /* unref */
1438 if(start_output != NULL){
1439 g_object_unref(start_output);
1440 }
1441
1442 if(start_input != NULL){
1443 g_object_unref(start_input);
1444 }
1445
1446 if(start != NULL){
1447 g_object_unref(start);
1448 }
1449
1450 /* return instantiated recall */
1451 recall = g_list_reverse(recall);
1452 g_list_foreach(recall,
1453 (GFunc) g_object_ref,
1454 NULL);
1455
1456 return(recall);
1457 }
1458
1459 GList*
ags_recall_factory_create_copy(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)1460 ags_recall_factory_create_copy(AgsAudio *audio,
1461 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
1462 gchar *plugin_name,
1463 guint start_audio_channel, guint stop_audio_channel,
1464 guint start_pad, guint stop_pad,
1465 guint create_flags, guint recall_flags)
1466 {
1467 AgsCopyChannel *copy_channel;
1468 AgsCopyChannelRun *copy_channel_run;
1469 AgsChannel *start_output, *start_input;
1470 AgsChannel *start, *channel, *next_pad, *next_channel, *nth_channel, *current;
1471 AgsPort *port;
1472
1473 GObject *output_soundcard;
1474
1475 GList *list_start, *list;
1476 GList *recall;
1477
1478 guint audio_channels;
1479 guint i, j;
1480
1481 GRecMutex *audio_mutex;
1482 GRecMutex *current_mutex;
1483
1484 if(!AGS_IS_AUDIO(audio)){
1485 return(NULL);
1486 }
1487
1488 /* get audio mutex */
1489 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
1490
1491 /* get some fields */
1492 g_rec_mutex_lock(audio_mutex);
1493
1494 output_soundcard = audio->output_soundcard;
1495
1496 audio_channels = audio->audio_channels;
1497
1498 start_output = audio->output;
1499
1500 if(start_output != NULL){
1501 g_object_ref(start_output);
1502 }
1503
1504 start_input = audio->input;
1505
1506 if(start_input != NULL){
1507 g_object_ref(start_input);
1508 }
1509
1510 g_rec_mutex_unlock(audio_mutex);
1511
1512 /* get channel */
1513 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
1514 start = ags_channel_nth(start_output,
1515 start_pad * audio_channels);
1516 }else{
1517 start = ags_channel_nth(start_input,
1518 start_pad * audio_channels);
1519 }
1520
1521 recall = NULL;
1522
1523 /* play */
1524 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
1525 gboolean found_copy;
1526
1527 channel = start;
1528
1529 if(channel != NULL){
1530 g_object_ref(channel);
1531 }
1532
1533 nth_channel = NULL;
1534
1535 for(i = 0; i < stop_pad - start_pad; i++){
1536 nth_channel = ags_channel_nth(channel,
1537 start_audio_channel);
1538
1539 g_object_unref(channel);
1540
1541 channel = nth_channel;
1542
1543 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
1544 current = ags_channel_nth(start_output,
1545 start_audio_channel + j);
1546
1547 /* check output */
1548 while(current != NULL){
1549 current_mutex = AGS_CHANNEL_GET_OBJ_MUTEX(current);
1550
1551 /* check output present */
1552 g_object_get(channel,
1553 "play", &list_start,
1554 NULL);
1555
1556 list = list_start;
1557 found_copy = FALSE;
1558
1559 while((list = ags_recall_template_find_type(list,
1560 AGS_TYPE_COPY_CHANNEL)) != NULL){
1561 AgsChannel *current_destination;
1562
1563 g_object_get(list->data,
1564 "destination", ¤t_destination,
1565 NULL);
1566
1567 if(current_destination == current){
1568 found_copy = TRUE;
1569 break;
1570 }
1571
1572 list = list->next;
1573 }
1574
1575 g_list_free_full(list_start,
1576 g_object_unref);
1577
1578 if(found_copy){
1579 /* iterate - current */
1580 g_rec_mutex_lock(current_mutex);
1581
1582 current = current->next_pad;
1583
1584 g_rec_mutex_unlock(current_mutex);
1585
1586 continue;
1587 }
1588
1589 if(play_container == NULL){
1590 play_container = ags_recall_container_new();
1591 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
1592 ags_audio_add_recall_container(audio, (GObject *) play_container);
1593 }
1594
1595 ags_channel_add_recall_container(channel, (GObject *) play_container);
1596
1597 /* AgsCopyChannel */
1598 copy_channel = (AgsCopyChannel *) g_object_new(AGS_TYPE_COPY_CHANNEL,
1599 "output-soundcard", output_soundcard,
1600 "source", channel,
1601 "destination", current,
1602 "recall-container", play_container,
1603 NULL);
1604 ags_recall_set_flags((AgsRecall *) copy_channel,
1605 (AGS_RECALL_TEMPLATE));
1606 ags_recall_set_ability_flags((AgsRecall *) copy_channel,
1607 (AGS_SOUND_ABILITY_PLAYBACK |
1608 AGS_SOUND_ABILITY_NOTATION |
1609 AGS_SOUND_ABILITY_SEQUENCER |
1610 AGS_SOUND_ABILITY_MIDI |
1611 AGS_SOUND_ABILITY_WAVE));
1612 ags_recall_set_behaviour_flags((AgsRecall *) copy_channel,
1613 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1614
1615 ags_channel_add_recall(channel,
1616 (GObject *) copy_channel, TRUE);
1617
1618 recall = g_list_prepend(recall,
1619 copy_channel);
1620
1621 g_object_set(play_container,
1622 "recall-channel", copy_channel,
1623 NULL);
1624 ags_connectable_connect(AGS_CONNECTABLE(copy_channel));
1625
1626 /* AgsCopyChannelRun */
1627 copy_channel_run = (AgsCopyChannelRun *) g_object_new(AGS_TYPE_COPY_CHANNEL_RUN,
1628 "output-soundcard", output_soundcard,
1629 "recall-channel", copy_channel,
1630 "source", channel,
1631 "destination", current,
1632 "recall-container", play_container,
1633 NULL);
1634 ags_recall_set_flags((AgsRecall *) copy_channel_run,
1635 (AGS_RECALL_TEMPLATE));
1636 ags_recall_set_ability_flags((AgsRecall *) copy_channel_run,
1637 (AGS_SOUND_ABILITY_PLAYBACK |
1638 AGS_SOUND_ABILITY_NOTATION |
1639 AGS_SOUND_ABILITY_SEQUENCER |
1640 AGS_SOUND_ABILITY_MIDI |
1641 AGS_SOUND_ABILITY_WAVE));
1642 ags_recall_set_behaviour_flags((AgsRecall *) copy_channel_run,
1643 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1644
1645 ags_channel_add_recall(channel,
1646 (GObject *) copy_channel_run, TRUE);
1647
1648 recall = g_list_prepend(recall,
1649 copy_channel_run);
1650
1651 g_object_set(play_container,
1652 "recall-channel-run", copy_channel_run,
1653 NULL);
1654 ags_connectable_connect(AGS_CONNECTABLE(copy_channel_run));
1655
1656 /* iterate */
1657 next_pad = ags_channel_next_pad(current);
1658
1659 g_object_unref(current);
1660
1661 current = next_pad;
1662 }
1663
1664 /* iterate */
1665 next_channel = ags_channel_next(channel);
1666
1667 g_object_unref(channel);
1668
1669 channel = next_channel;
1670 }
1671
1672 nth_channel = ags_channel_nth(channel,
1673 audio_channels - stop_audio_channel);
1674
1675 if(channel != NULL){
1676 g_object_unref(channel);
1677 }
1678
1679 channel = nth_channel;
1680 }
1681
1682 if(nth_channel != NULL){
1683 g_object_unref(nth_channel);
1684 }
1685 }
1686
1687 /* recall */
1688 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
1689 gboolean found_copy;
1690
1691 channel = start;
1692
1693 if(channel != NULL){
1694 g_object_ref(channel);
1695 }
1696
1697 nth_channel = NULL;
1698
1699 for(i = 0; i < stop_pad - start_pad; i++){
1700 nth_channel = ags_channel_nth(channel,
1701 start_audio_channel);
1702
1703 g_object_unref(channel);
1704
1705 channel = nth_channel;
1706
1707 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
1708 current = ags_channel_nth(start_output,
1709 start_audio_channel + j);
1710
1711 /* check output */
1712 while(current != NULL){
1713 current_mutex = AGS_CHANNEL_GET_OBJ_MUTEX(current);
1714
1715 /* check output present */
1716 g_object_get(channel,
1717 "recall", &list_start,
1718 NULL);
1719
1720 list = list_start;
1721 found_copy = FALSE;
1722
1723 while((list = ags_recall_template_find_type(list,
1724 AGS_TYPE_COPY_CHANNEL)) != NULL){
1725 AgsChannel *current_destination;
1726
1727 g_object_get(list->data,
1728 "destination", ¤t_destination,
1729 NULL);
1730
1731 if(current_destination == current){
1732 found_copy = TRUE;
1733 break;
1734 }
1735
1736 list = list->next;
1737 }
1738
1739 g_list_free_full(list_start,
1740 g_object_unref);
1741
1742 if(found_copy){
1743 /* iterate */
1744 g_rec_mutex_lock(current_mutex);
1745
1746 current = current->next_pad;
1747
1748 g_rec_mutex_unlock(current_mutex);
1749
1750 continue;
1751 }
1752
1753 if(recall_container == NULL){
1754 recall_container = ags_recall_container_new();
1755 ags_audio_add_recall_container(audio, (GObject *) recall_container);
1756 }
1757
1758 ags_channel_add_recall_container(channel, (GObject *) recall_container);
1759
1760 /* AgsCopyChannel */
1761 copy_channel = (AgsCopyChannel *) g_object_new(AGS_TYPE_COPY_CHANNEL,
1762 "output-soundcard", output_soundcard,
1763 "source", channel,
1764 "destination", current,
1765 "recall-container", recall_container,
1766 NULL);
1767 ags_recall_set_flags((AgsRecall *) copy_channel,
1768 (AGS_RECALL_TEMPLATE));
1769 ags_recall_set_ability_flags((AgsRecall *) copy_channel,
1770 (AGS_SOUND_ABILITY_PLAYBACK |
1771 AGS_SOUND_ABILITY_NOTATION |
1772 AGS_SOUND_ABILITY_SEQUENCER |
1773 AGS_SOUND_ABILITY_MIDI |
1774 AGS_SOUND_ABILITY_WAVE));
1775 ags_recall_set_behaviour_flags((AgsRecall *) copy_channel,
1776 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1777
1778 ags_channel_add_recall(channel,
1779 (GObject *) copy_channel, FALSE);
1780
1781 recall = g_list_prepend(recall,
1782 copy_channel);
1783
1784 g_object_set(recall_container,
1785 "recall-channel", copy_channel,
1786 NULL);
1787 ags_connectable_connect(AGS_CONNECTABLE(copy_channel));
1788
1789 /* AgsCopyChannelRun */
1790 copy_channel_run = (AgsCopyChannelRun *) g_object_new(AGS_TYPE_COPY_CHANNEL_RUN,
1791 "output-soundcard", output_soundcard,
1792 "recall-channel", copy_channel,
1793 "source", channel,
1794 "destination", current,
1795 "recall-container", recall_container,
1796 NULL);
1797 ags_recall_set_flags((AgsRecall *) copy_channel_run,
1798 (AGS_RECALL_TEMPLATE));
1799 ags_recall_set_ability_flags((AgsRecall *) copy_channel_run,
1800 (AGS_SOUND_ABILITY_PLAYBACK |
1801 AGS_SOUND_ABILITY_NOTATION |
1802 AGS_SOUND_ABILITY_SEQUENCER |
1803 AGS_SOUND_ABILITY_MIDI |
1804 AGS_SOUND_ABILITY_WAVE));
1805 ags_recall_set_behaviour_flags((AgsRecall *) copy_channel_run,
1806 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1807
1808 ags_channel_add_recall(channel,
1809 (GObject *) copy_channel_run, FALSE);
1810
1811 recall = g_list_prepend(recall,
1812 copy_channel_run);
1813
1814 g_object_set(recall_container,
1815 "recall-channel-run", copy_channel_run,
1816 NULL);
1817 ags_connectable_connect(AGS_CONNECTABLE(copy_channel_run));
1818
1819 /* iterate */
1820 next_pad = ags_channel_next_pad(current);
1821
1822 g_object_unref(current);
1823
1824 current = next_pad;
1825 }
1826
1827 /* iterate */
1828 next_channel = ags_channel_next(channel);
1829
1830 g_object_unref(channel);
1831
1832 channel = next_channel;
1833 }
1834
1835 nth_channel = ags_channel_nth(channel,
1836 audio_channels - stop_audio_channel);
1837
1838 if(channel != NULL){
1839 g_object_unref(channel);
1840 }
1841
1842 channel = nth_channel;
1843 }
1844
1845 if(nth_channel != NULL){
1846 g_object_unref(nth_channel);
1847 }
1848 }
1849
1850 /* unref */
1851 if(start_output != NULL){
1852 g_object_unref(start_output);
1853 }
1854
1855 if(start_input != NULL){
1856 g_object_unref(start_input);
1857 }
1858
1859 if(start != NULL){
1860 g_object_unref(start);
1861 }
1862
1863 /* return instantiated recall */
1864 recall = g_list_reverse(recall);
1865 g_list_foreach(recall,
1866 (GFunc) g_object_ref,
1867 NULL);
1868
1869 return(recall);
1870 }
1871
1872 GList*
ags_recall_factory_create_feed(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)1873 ags_recall_factory_create_feed(AgsAudio *audio,
1874 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
1875 gchar *plugin_name,
1876 guint start_audio_channel, guint stop_audio_channel,
1877 guint start_pad, guint stop_pad,
1878 guint create_flags, guint recall_flags)
1879 {
1880 AgsFeedChannel *feed_channel;
1881 AgsFeedChannelRun *feed_channel_run;
1882 AgsChannel *start_output, *start_input;
1883 AgsChannel *start, *channel, *next_channel, *nth_channel;
1884 AgsPort *port;
1885
1886 GObject *output_soundcard;
1887
1888 GList *list_start, *list;
1889 GList *recall;
1890
1891 guint audio_channels;
1892 guint i, j;
1893
1894 GRecMutex *audio_mutex;
1895
1896 if(!AGS_IS_AUDIO(audio)){
1897 return(NULL);
1898 }
1899
1900 /* get audio mutex */
1901 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
1902
1903 /* get some fields */
1904 g_rec_mutex_lock(audio_mutex);
1905
1906 output_soundcard = audio->output_soundcard;
1907
1908 audio_channels = audio->audio_channels;
1909
1910 start_output = audio->output;
1911
1912 if(start_output != NULL){
1913 g_object_ref(start_output);
1914 }
1915
1916 start_input = audio->input;
1917
1918 if(start_input != NULL){
1919 g_object_ref(start_input);
1920 }
1921
1922 g_rec_mutex_unlock(audio_mutex);
1923
1924 /* get channel */
1925 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
1926 start = ags_channel_nth(start_output,
1927 start_pad * audio_channels);
1928 }else{
1929 start = ags_channel_nth(start_input,
1930 start_pad * audio_channels);
1931 }
1932
1933 recall = NULL;
1934
1935 /* play */
1936 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
1937 channel = start;
1938
1939 if(channel != NULL){
1940 g_object_ref(channel);
1941 }
1942
1943 if(play_container == NULL){
1944 play_container = ags_recall_container_new();
1945 }
1946
1947 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
1948 ags_audio_add_recall_container(audio, (GObject *) play_container);
1949
1950 nth_channel = NULL;
1951
1952 for(i = 0; i < stop_pad - start_pad; i++){
1953 nth_channel = ags_channel_nth(channel,
1954 start_audio_channel);
1955
1956 g_object_unref(channel);
1957
1958 channel = nth_channel;
1959
1960 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
1961 /* add recall container */
1962 ags_channel_add_recall_container(channel,
1963 (GObject *) play_container);
1964
1965 /* AgsFeedChannel */
1966 feed_channel = (AgsFeedChannel *) g_object_new(AGS_TYPE_FEED_CHANNEL,
1967 "output-soundcard", output_soundcard,
1968 "source", channel,
1969 "recall-container", play_container,
1970 NULL);
1971 ags_recall_set_flags((AgsRecall *) feed_channel,
1972 (AGS_RECALL_TEMPLATE));
1973 ags_recall_set_ability_flags((AgsRecall *) feed_channel,
1974 (AGS_SOUND_ABILITY_PLAYBACK |
1975 AGS_SOUND_ABILITY_NOTATION |
1976 AGS_SOUND_ABILITY_SEQUENCER |
1977 AGS_SOUND_ABILITY_MIDI |
1978 AGS_SOUND_ABILITY_WAVE));
1979 ags_recall_set_behaviour_flags((AgsRecall *) feed_channel,
1980 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
1981
1982 ags_channel_add_recall(channel, (GObject *) feed_channel, TRUE);
1983 recall = g_list_prepend(recall,
1984 feed_channel);
1985
1986 g_object_set(play_container,
1987 "recall-channel", feed_channel,
1988 NULL);
1989 ags_connectable_connect(AGS_CONNECTABLE(feed_channel));
1990
1991 /* AgsFeedChannelRun */
1992 feed_channel_run = (AgsFeedChannelRun *) g_object_new(AGS_TYPE_FEED_CHANNEL_RUN,
1993 "output-soundcard", output_soundcard,
1994 "recall-channel", feed_channel,
1995 "source", channel,
1996 "recall-container", play_container,
1997 NULL);
1998 ags_recall_set_flags((AgsRecall *) feed_channel_run,
1999 (AGS_RECALL_TEMPLATE));
2000 ags_recall_set_ability_flags((AgsRecall *) feed_channel_run,
2001 (AGS_SOUND_ABILITY_PLAYBACK |
2002 AGS_SOUND_ABILITY_NOTATION |
2003 AGS_SOUND_ABILITY_SEQUENCER |
2004 AGS_SOUND_ABILITY_MIDI |
2005 AGS_SOUND_ABILITY_WAVE));
2006 ags_recall_set_behaviour_flags((AgsRecall *) feed_channel_run,
2007 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2008
2009 ags_channel_add_recall(channel, (GObject *) feed_channel_run, TRUE);
2010 recall = g_list_prepend(recall,
2011 feed_channel_run);
2012
2013 g_object_set(play_container,
2014 "recall-channel-run", feed_channel_run,
2015 NULL);
2016 ags_connectable_connect(AGS_CONNECTABLE(feed_channel_run));
2017
2018 /* iterate */
2019 next_channel = ags_channel_next(channel);
2020
2021 g_object_unref(channel);
2022
2023 channel = next_channel;
2024 }
2025
2026 nth_channel = ags_channel_nth(channel,
2027 audio_channels - stop_audio_channel);
2028
2029 if(channel != NULL){
2030 g_object_unref(channel);
2031 }
2032
2033 channel = nth_channel;
2034 }
2035
2036 if(nth_channel != NULL){
2037 g_object_unref(nth_channel);
2038 }
2039 }
2040
2041 /* recall */
2042 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
2043 channel = start;
2044
2045 if(channel != NULL){
2046 g_object_ref(channel);
2047 }
2048
2049 if(recall_container == NULL){
2050 recall_container = ags_recall_container_new();
2051 }
2052
2053 ags_audio_add_recall_container(audio, (GObject *) recall_container);
2054
2055 nth_channel = NULL;
2056
2057 for(i = 0; i < stop_pad - start_pad; i++){
2058 nth_channel = ags_channel_nth(channel,
2059 start_audio_channel);
2060
2061 g_object_unref(channel);
2062
2063 channel = nth_channel;
2064
2065 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2066 /* add recall container */
2067 ags_channel_add_recall_container(channel,
2068 (GObject *) recall_container);
2069
2070 /* AgsFeedChannel */
2071 feed_channel = (AgsFeedChannel *) g_object_new(AGS_TYPE_FEED_CHANNEL,
2072 "output-soundcard", output_soundcard,
2073 "source", channel,
2074 "recall-container", recall_container,
2075 NULL);
2076 ags_recall_set_flags((AgsRecall *) feed_channel,
2077 (AGS_RECALL_TEMPLATE));
2078 ags_recall_set_ability_flags((AgsRecall *) feed_channel,
2079 (AGS_SOUND_ABILITY_PLAYBACK |
2080 AGS_SOUND_ABILITY_NOTATION |
2081 AGS_SOUND_ABILITY_SEQUENCER |
2082 AGS_SOUND_ABILITY_MIDI |
2083 AGS_SOUND_ABILITY_WAVE));
2084 ags_recall_set_behaviour_flags((AgsRecall *) feed_channel,
2085 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2086
2087 ags_channel_add_recall(channel, (GObject *) feed_channel, FALSE);
2088 recall = g_list_prepend(recall,
2089 feed_channel);
2090
2091 g_object_set(recall_container,
2092 "recall-channel", feed_channel,
2093 NULL);
2094 ags_connectable_connect(AGS_CONNECTABLE(feed_channel));
2095
2096 /* AgsFeedChannelRun */
2097 feed_channel_run = (AgsFeedChannelRun *) g_object_new(AGS_TYPE_FEED_CHANNEL_RUN,
2098 "output-soundcard", output_soundcard,
2099 "recall-channel", feed_channel,
2100 "source", channel,
2101 "recall-container", recall_container,
2102 NULL);
2103 ags_recall_set_flags((AgsRecall *) feed_channel_run,
2104 (AGS_RECALL_TEMPLATE));
2105 ags_recall_set_ability_flags((AgsRecall *) feed_channel_run,
2106 (AGS_SOUND_ABILITY_PLAYBACK |
2107 AGS_SOUND_ABILITY_NOTATION |
2108 AGS_SOUND_ABILITY_SEQUENCER |
2109 AGS_SOUND_ABILITY_MIDI |
2110 AGS_SOUND_ABILITY_WAVE));
2111 ags_recall_set_behaviour_flags((AgsRecall *) feed_channel_run,
2112 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2113
2114 ags_channel_add_recall(channel, (GObject *) feed_channel_run, FALSE);
2115 recall = g_list_prepend(recall,
2116 feed_channel_run);
2117
2118 g_object_set(recall_container,
2119 "recall-channel-run", feed_channel_run,
2120 NULL);
2121 ags_connectable_connect(AGS_CONNECTABLE(feed_channel_run));
2122
2123 /* iterate */
2124 next_channel = ags_channel_next(channel);
2125
2126 g_object_unref(channel);
2127
2128 channel = next_channel;
2129 }
2130
2131 nth_channel = ags_channel_nth(channel,
2132 audio_channels - stop_audio_channel);
2133
2134 if(channel != NULL){
2135 g_object_unref(channel);
2136 }
2137
2138 channel = nth_channel;
2139 }
2140
2141 if(nth_channel != NULL){
2142 g_object_unref(nth_channel);
2143 }
2144 }
2145
2146 /* return instantiated recall */
2147 recall = g_list_reverse(recall);
2148 g_list_foreach(recall,
2149 (GFunc) g_object_ref,
2150 NULL);
2151
2152 return(recall);
2153 }
2154
2155 GList*
ags_recall_factory_create_stream(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)2156 ags_recall_factory_create_stream(AgsAudio *audio,
2157 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
2158 gchar *plugin_name,
2159 guint start_audio_channel, guint stop_audio_channel,
2160 guint start_pad, guint stop_pad,
2161 guint create_flags, guint recall_flags)
2162 {
2163 AgsStreamChannel *stream_channel;
2164 AgsStreamChannelRun *stream_channel_run;
2165 AgsChannel *start_output, *start_input;
2166 AgsChannel *start, *channel, *next_channel, *nth_channel;
2167 AgsPort *port;
2168
2169 GObject *output_soundcard;
2170
2171 GList *list_start, *list;
2172 GList *recall;
2173
2174 guint audio_channels;
2175 guint i, j;
2176
2177 GRecMutex *audio_mutex;
2178
2179 if(!AGS_IS_AUDIO(audio)){
2180 return(NULL);
2181 }
2182
2183 /* get audio mutex */
2184 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
2185
2186 /* get some fields */
2187 g_rec_mutex_lock(audio_mutex);
2188
2189 output_soundcard = audio->output_soundcard;
2190
2191 audio_channels = audio->audio_channels;
2192
2193 start_output = audio->output;
2194
2195 if(start_output != NULL){
2196 g_object_ref(start_output);
2197 }
2198
2199 start_input = audio->input;
2200
2201 if(start_input != NULL){
2202 g_object_ref(start_input);
2203 }
2204
2205 g_rec_mutex_unlock(audio_mutex);
2206
2207 /* get channel */
2208 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
2209 start = ags_channel_nth(start_output,
2210 start_pad * audio_channels);
2211 }else{
2212 start = ags_channel_nth(start_input,
2213 start_pad * audio_channels);
2214 }
2215
2216 recall = NULL;
2217
2218 /* play */
2219 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
2220 channel = start;
2221
2222 if(channel != NULL){
2223 g_object_ref(channel);
2224 }
2225
2226 if(play_container == NULL){
2227 play_container = ags_recall_container_new();
2228 }
2229
2230 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
2231 ags_audio_add_recall_container(audio, (GObject *) play_container);
2232
2233 nth_channel = NULL;
2234
2235 for(i = 0; i < stop_pad - start_pad; i++){
2236 nth_channel = ags_channel_nth(channel,
2237 start_audio_channel);
2238
2239 g_object_unref(channel);
2240
2241 channel = nth_channel;
2242
2243 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2244 /* add recall container */
2245 ags_channel_add_recall_container(channel,
2246 (GObject *) play_container);
2247
2248 /* AgsStreamChannel */
2249 stream_channel = (AgsStreamChannel *) g_object_new(AGS_TYPE_STREAM_CHANNEL,
2250 "output-soundcard", output_soundcard,
2251 "source", channel,
2252 "recall-container", play_container,
2253 NULL);
2254 ags_recall_set_flags((AgsRecall *) stream_channel,
2255 (AGS_RECALL_TEMPLATE));
2256 ags_recall_set_ability_flags((AgsRecall *) stream_channel,
2257 (AGS_SOUND_ABILITY_PLAYBACK |
2258 AGS_SOUND_ABILITY_NOTATION |
2259 AGS_SOUND_ABILITY_SEQUENCER |
2260 AGS_SOUND_ABILITY_MIDI |
2261 AGS_SOUND_ABILITY_WAVE));
2262 ags_recall_set_behaviour_flags((AgsRecall *) stream_channel,
2263 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2264
2265 ags_channel_add_recall(channel, (GObject *) stream_channel, TRUE);
2266 recall = g_list_prepend(recall,
2267 stream_channel);
2268
2269 g_object_set(play_container,
2270 "recall-channel", stream_channel,
2271 NULL);
2272 ags_connectable_connect(AGS_CONNECTABLE(stream_channel));
2273
2274 /* AgsStreamChannelRun */
2275 stream_channel_run = (AgsStreamChannelRun *) g_object_new(AGS_TYPE_STREAM_CHANNEL_RUN,
2276 "output-soundcard", output_soundcard,
2277 "recall-channel", stream_channel,
2278 "source", channel,
2279 "recall-container", play_container,
2280 NULL);
2281 ags_recall_set_flags((AgsRecall *) stream_channel_run,
2282 (AGS_RECALL_TEMPLATE));
2283 ags_recall_set_ability_flags((AgsRecall *) stream_channel_run,
2284 (AGS_SOUND_ABILITY_PLAYBACK |
2285 AGS_SOUND_ABILITY_NOTATION |
2286 AGS_SOUND_ABILITY_SEQUENCER |
2287 AGS_SOUND_ABILITY_MIDI |
2288 AGS_SOUND_ABILITY_WAVE));
2289 ags_recall_set_behaviour_flags((AgsRecall *) stream_channel_run,
2290 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2291
2292 ags_channel_add_recall(channel, (GObject *) stream_channel_run, TRUE);
2293 recall = g_list_prepend(recall,
2294 stream_channel_run);
2295
2296 g_object_set(play_container,
2297 "recall-channel-run", stream_channel_run,
2298 NULL);
2299 ags_connectable_connect(AGS_CONNECTABLE(stream_channel_run));
2300
2301 /* iterate */
2302 next_channel = ags_channel_next(channel);
2303
2304 g_object_unref(channel);
2305
2306 channel = next_channel;
2307 }
2308
2309 nth_channel = ags_channel_nth(channel,
2310 audio_channels - stop_audio_channel);
2311
2312 if(channel != NULL){
2313 g_object_unref(channel);
2314 }
2315
2316 channel = nth_channel;
2317 }
2318
2319 if(nth_channel != NULL){
2320 g_object_unref(nth_channel);
2321 }
2322 }
2323
2324 /* recall */
2325 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
2326 channel = start;
2327
2328 if(channel != NULL){
2329 g_object_ref(channel);
2330 }
2331
2332 if(recall_container == NULL){
2333 recall_container = ags_recall_container_new();
2334 }
2335
2336 ags_audio_add_recall_container(audio, (GObject *) recall_container);
2337
2338 nth_channel = NULL;
2339
2340 for(i = 0; i < stop_pad - start_pad; i++){
2341 nth_channel = ags_channel_nth(channel,
2342 start_audio_channel);
2343
2344 g_object_unref(channel);
2345
2346 channel = nth_channel;
2347
2348 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2349 /* add recall container */
2350 ags_channel_add_recall_container(channel,
2351 (GObject *) recall_container);
2352
2353 /* AgsStreamChannel */
2354 stream_channel = (AgsStreamChannel *) g_object_new(AGS_TYPE_STREAM_CHANNEL,
2355 "output-soundcard", output_soundcard,
2356 "source", channel,
2357 "recall-container", recall_container,
2358 NULL);
2359 ags_recall_set_flags((AgsRecall *) stream_channel,
2360 (AGS_RECALL_TEMPLATE));
2361 ags_recall_set_ability_flags((AgsRecall *) stream_channel,
2362 (AGS_SOUND_ABILITY_PLAYBACK |
2363 AGS_SOUND_ABILITY_NOTATION |
2364 AGS_SOUND_ABILITY_SEQUENCER |
2365 AGS_SOUND_ABILITY_MIDI |
2366 AGS_SOUND_ABILITY_WAVE));
2367 ags_recall_set_behaviour_flags((AgsRecall *) stream_channel,
2368 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2369
2370 ags_channel_add_recall(channel, (GObject *) stream_channel, FALSE);
2371 recall = g_list_prepend(recall,
2372 stream_channel);
2373
2374 g_object_set(recall_container,
2375 "recall-channel", stream_channel,
2376 NULL);
2377 ags_connectable_connect(AGS_CONNECTABLE(stream_channel));
2378
2379 /* AgsStreamChannelRun */
2380 stream_channel_run = (AgsStreamChannelRun *) g_object_new(AGS_TYPE_STREAM_CHANNEL_RUN,
2381 "output-soundcard", output_soundcard,
2382 "recall-channel", stream_channel,
2383 "source", channel,
2384 "recall-container", recall_container,
2385 NULL);
2386 ags_recall_set_flags((AgsRecall *) stream_channel_run,
2387 (AGS_RECALL_TEMPLATE));
2388 ags_recall_set_ability_flags((AgsRecall *) stream_channel_run,
2389 (AGS_SOUND_ABILITY_PLAYBACK |
2390 AGS_SOUND_ABILITY_NOTATION |
2391 AGS_SOUND_ABILITY_SEQUENCER |
2392 AGS_SOUND_ABILITY_MIDI |
2393 AGS_SOUND_ABILITY_WAVE));
2394 ags_recall_set_behaviour_flags((AgsRecall *) stream_channel_run,
2395 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2396
2397 ags_channel_add_recall(channel, (GObject *) stream_channel_run, FALSE);
2398 recall = g_list_prepend(recall,
2399 stream_channel_run);
2400
2401 g_object_set(recall_container,
2402 "recall-channel-run", stream_channel_run,
2403 NULL);
2404 ags_connectable_connect(AGS_CONNECTABLE(stream_channel_run));
2405
2406 /* iterate */
2407 next_channel = ags_channel_next(channel);
2408
2409 g_object_unref(channel);
2410
2411 channel = next_channel;
2412 }
2413
2414 nth_channel = ags_channel_nth(channel,
2415 audio_channels - stop_audio_channel);
2416
2417 if(channel != NULL){
2418 g_object_unref(channel);
2419 }
2420
2421 channel = nth_channel;
2422 }
2423
2424 if(nth_channel != NULL){
2425 g_object_unref(nth_channel);
2426 }
2427 }
2428
2429 /* unref */
2430 if(start_output != NULL){
2431 g_object_unref(start_output);
2432 }
2433
2434 if(start_input != NULL){
2435 g_object_unref(start_input);
2436 }
2437
2438 if(start != NULL){
2439 g_object_unref(start);
2440 }
2441
2442 /* return instantiated recall */
2443 recall = g_list_reverse(recall);
2444 g_list_foreach(recall,
2445 (GFunc) g_object_ref,
2446 NULL);
2447
2448 return(recall);
2449 }
2450
2451 GList*
ags_recall_factory_create_rt_stream(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)2452 ags_recall_factory_create_rt_stream(AgsAudio *audio,
2453 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
2454 gchar *plugin_name,
2455 guint start_audio_channel, guint stop_audio_channel,
2456 guint start_pad, guint stop_pad,
2457 guint create_flags, guint recall_flags)
2458 {
2459 AgsRtStreamChannel *rt_stream_channel;
2460 AgsRtStreamChannelRun *rt_stream_channel_run;
2461 AgsChannel *start_output, *start_input;
2462 AgsChannel *start, *channel, *next_channel, *nth_channel;
2463 AgsPort *port;
2464
2465 GObject *output_soundcard;
2466
2467 GList *list_start, *list;
2468 GList *recall;
2469
2470 guint audio_channels;
2471 guint i, j;
2472
2473 GRecMutex *audio_mutex;
2474
2475 if(!AGS_IS_AUDIO(audio)){
2476 return(NULL);
2477 }
2478
2479 /* get audio mutex */
2480 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
2481
2482 /* get some fields */
2483 g_rec_mutex_lock(audio_mutex);
2484
2485 output_soundcard = audio->output_soundcard;
2486
2487 audio_channels = audio->audio_channels;
2488
2489 start_output = audio->output;
2490
2491 if(start_output != NULL){
2492 g_object_ref(start_output);
2493 }
2494
2495 start_input = audio->input;
2496
2497 if(start_input != NULL){
2498 g_object_ref(start_input);
2499 }
2500
2501 g_rec_mutex_unlock(audio_mutex);
2502
2503 /* get channel */
2504 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
2505 start = ags_channel_nth(start_output,
2506 start_pad * audio_channels);
2507 }else{
2508 start = ags_channel_nth(start_input,
2509 start_pad * audio_channels);
2510 }
2511
2512 recall = NULL;
2513
2514 /* play */
2515 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
2516 channel = start;
2517
2518 if(channel != NULL){
2519 g_object_ref(channel);
2520 }
2521
2522 if(play_container == NULL){
2523 play_container = ags_recall_container_new();
2524 }
2525
2526 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
2527 ags_audio_add_recall_container(audio, (GObject *) play_container);
2528
2529 nth_channel = NULL;
2530
2531 for(i = 0; i < stop_pad - start_pad; i++){
2532 nth_channel = ags_channel_nth(channel,
2533 start_audio_channel);
2534
2535 g_object_unref(channel);
2536
2537 channel = nth_channel;
2538
2539 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2540 /* add recall container */
2541 ags_channel_add_recall_container(channel,
2542 (GObject *) play_container);
2543
2544 /* AgsRtStreamChannel */
2545 rt_stream_channel = (AgsRtStreamChannel *) g_object_new(AGS_TYPE_RT_STREAM_CHANNEL,
2546 "output-soundcard", output_soundcard,
2547 "source", channel,
2548 "recall-container", play_container,
2549 NULL);
2550 ags_recall_set_flags((AgsRecall *) rt_stream_channel,
2551 (AGS_RECALL_TEMPLATE));
2552 ags_recall_set_ability_flags((AgsRecall *) rt_stream_channel,
2553 (AGS_SOUND_ABILITY_PLAYBACK |
2554 AGS_SOUND_ABILITY_NOTATION |
2555 AGS_SOUND_ABILITY_SEQUENCER |
2556 AGS_SOUND_ABILITY_MIDI |
2557 AGS_SOUND_ABILITY_WAVE));
2558 ags_recall_set_behaviour_flags((AgsRecall *) rt_stream_channel,
2559 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2560
2561 ags_channel_add_recall(channel, (GObject *) rt_stream_channel, TRUE);
2562 recall = g_list_prepend(recall,
2563 rt_stream_channel);
2564
2565 g_object_set(play_container,
2566 "recall-channel", rt_stream_channel,
2567 NULL);
2568 ags_connectable_connect(AGS_CONNECTABLE(rt_stream_channel));
2569
2570 /* AgsRtStreamChannelRun */
2571 rt_stream_channel_run = (AgsRtStreamChannelRun *) g_object_new(AGS_TYPE_RT_STREAM_CHANNEL_RUN,
2572 "output-soundcard", output_soundcard,
2573 "recall-channel", rt_stream_channel,
2574 "source", channel,
2575 "recall-container", play_container,
2576 NULL);
2577 ags_recall_set_flags((AgsRecall *) rt_stream_channel_run,
2578 (AGS_RECALL_TEMPLATE));
2579 ags_recall_set_ability_flags((AgsRecall *) rt_stream_channel_run,
2580 (AGS_SOUND_ABILITY_PLAYBACK |
2581 AGS_SOUND_ABILITY_NOTATION |
2582 AGS_SOUND_ABILITY_SEQUENCER |
2583 AGS_SOUND_ABILITY_MIDI |
2584 AGS_SOUND_ABILITY_WAVE));
2585 ags_recall_set_behaviour_flags((AgsRecall *) rt_stream_channel_run,
2586 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2587
2588 ags_channel_add_recall(channel, (GObject *) rt_stream_channel_run, TRUE);
2589 recall = g_list_prepend(recall,
2590 rt_stream_channel_run);
2591
2592 g_object_set(play_container,
2593 "recall-channel-run", rt_stream_channel_run,
2594 NULL);
2595 ags_connectable_connect(AGS_CONNECTABLE(rt_stream_channel_run));
2596
2597 /* iterate */
2598 next_channel = ags_channel_next(channel);
2599
2600 g_object_unref(channel);
2601
2602 channel = next_channel;
2603 }
2604
2605 nth_channel = ags_channel_nth(channel,
2606 audio_channels - stop_audio_channel);
2607
2608 if(channel != NULL){
2609 g_object_unref(channel);
2610 }
2611
2612 channel = nth_channel;
2613 }
2614
2615 if(nth_channel != NULL){
2616 g_object_unref(nth_channel);
2617 }
2618 }
2619
2620 /* recall */
2621 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
2622 channel = start;
2623
2624 if(channel != NULL){
2625 g_object_ref(channel);
2626 }
2627
2628 if(recall_container == NULL){
2629 recall_container = ags_recall_container_new();
2630 }
2631
2632 ags_audio_add_recall_container(audio, (GObject *) recall_container);
2633
2634 nth_channel = NULL;
2635
2636 for(i = 0; i < stop_pad - start_pad; i++){
2637 nth_channel = ags_channel_nth(channel,
2638 start_audio_channel);
2639
2640 g_object_unref(channel);
2641
2642 channel = nth_channel;
2643
2644 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2645 /* add recall container */
2646 ags_channel_add_recall_container(channel,
2647 (GObject *) recall_container);
2648
2649 /* AgsRtStreamChannel */
2650 rt_stream_channel = (AgsRtStreamChannel *) g_object_new(AGS_TYPE_RT_STREAM_CHANNEL,
2651 "output-soundcard", output_soundcard,
2652 "source", channel,
2653 "recall-container", recall_container,
2654 NULL);
2655 ags_recall_set_flags((AgsRecall *) rt_stream_channel,
2656 (AGS_RECALL_TEMPLATE));
2657 ags_recall_set_ability_flags((AgsRecall *) rt_stream_channel,
2658 (AGS_SOUND_ABILITY_PLAYBACK |
2659 AGS_SOUND_ABILITY_NOTATION |
2660 AGS_SOUND_ABILITY_SEQUENCER |
2661 AGS_SOUND_ABILITY_MIDI |
2662 AGS_SOUND_ABILITY_WAVE));
2663 ags_recall_set_behaviour_flags((AgsRecall *) rt_stream_channel,
2664 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2665
2666 ags_channel_add_recall(channel, (GObject *) rt_stream_channel, FALSE);
2667 recall = g_list_prepend(recall,
2668 rt_stream_channel);
2669
2670 g_object_set(recall_container,
2671 "recall-channel", rt_stream_channel,
2672 NULL);
2673 ags_connectable_connect(AGS_CONNECTABLE(rt_stream_channel));
2674
2675 /* AgsRtStreamChannelRun */
2676 rt_stream_channel_run = (AgsRtStreamChannelRun *) g_object_new(AGS_TYPE_RT_STREAM_CHANNEL_RUN,
2677 "output-soundcard", output_soundcard,
2678 "recall-channel", rt_stream_channel,
2679 "source", channel,
2680 "recall-container", recall_container,
2681 NULL);
2682 ags_recall_set_flags((AgsRecall *) rt_stream_channel_run,
2683 (AGS_RECALL_TEMPLATE));
2684 ags_recall_set_ability_flags((AgsRecall *) rt_stream_channel_run,
2685 (AGS_SOUND_ABILITY_PLAYBACK |
2686 AGS_SOUND_ABILITY_NOTATION |
2687 AGS_SOUND_ABILITY_SEQUENCER |
2688 AGS_SOUND_ABILITY_MIDI |
2689 AGS_SOUND_ABILITY_WAVE));
2690 ags_recall_set_behaviour_flags((AgsRecall *) rt_stream_channel_run,
2691 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2692
2693 ags_channel_add_recall(channel, (GObject *) rt_stream_channel_run, FALSE);
2694 recall = g_list_prepend(recall,
2695 rt_stream_channel_run);
2696
2697 g_object_set(recall_container,
2698 "recall-channel-run", rt_stream_channel_run,
2699 NULL);
2700 ags_connectable_connect(AGS_CONNECTABLE(rt_stream_channel_run));
2701
2702 /* iterate */
2703 next_channel = ags_channel_next(channel);
2704
2705 g_object_unref(channel);
2706
2707 channel = next_channel;
2708 }
2709
2710 nth_channel = ags_channel_nth(channel,
2711 audio_channels - stop_audio_channel);
2712
2713 if(channel != NULL){
2714 g_object_unref(channel);
2715 }
2716
2717 channel = nth_channel;
2718 }
2719
2720 if(nth_channel != NULL){
2721 g_object_unref(nth_channel);
2722 }
2723 }
2724
2725 /* unref */
2726 if(start_output != NULL){
2727 g_object_unref(start_output);
2728 }
2729
2730 if(start_input != NULL){
2731 g_object_unref(start_input);
2732 }
2733
2734 if(start != NULL){
2735 g_object_unref(start);
2736 }
2737
2738 /* return instantiated recall */
2739 recall = g_list_reverse(recall);
2740 g_list_foreach(recall,
2741 (GFunc) g_object_ref,
2742 NULL);
2743
2744 return(recall);
2745 }
2746
2747 GList*
ags_recall_factory_create_buffer(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)2748 ags_recall_factory_create_buffer(AgsAudio *audio,
2749 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
2750 gchar *plugin_name,
2751 guint start_audio_channel, guint stop_audio_channel,
2752 guint start_pad, guint stop_pad,
2753 guint create_flags, guint recall_flags)
2754 {
2755 AgsBufferChannel *buffer_channel;
2756 AgsBufferChannelRun *buffer_channel_run;
2757 AgsChannel *start_output, *start_input;
2758 AgsChannel *start, *channel, *next_pad, *nth_channel, *current;
2759 AgsPort *port;
2760
2761 GObject *output_soundcard;
2762
2763 GList *list_start, *list;
2764 GList *recall;
2765
2766 guint audio_channels;
2767 guint output_pads, input_pads;
2768 guint i, j;
2769
2770 GRecMutex *audio_mutex;
2771
2772 if(!AGS_IS_AUDIO(audio)){
2773 return(NULL);
2774 }
2775
2776 /* get audio mutex */
2777 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
2778
2779 /* get some fields */
2780 g_rec_mutex_lock(audio_mutex);
2781
2782 output_soundcard = audio->output_soundcard;
2783
2784 audio_channels = audio->audio_channels;
2785
2786 output_pads = audio->output_pads;
2787 input_pads = audio->input_pads;
2788
2789 start_output = audio->output;
2790
2791 if(start_output != NULL){
2792 g_object_ref(start_output);
2793 }
2794
2795 start_input = audio->input;
2796
2797 if(start_input != NULL){
2798 g_object_ref(start_input);
2799 }
2800
2801 g_rec_mutex_unlock(audio_mutex);
2802
2803 /* get channel */
2804 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
2805 start = start_output;
2806
2807 if(start != NULL){
2808 g_object_ref(start);
2809 }
2810 }else{
2811 start = start_input;
2812
2813 if(start != NULL){
2814 g_object_ref(start);
2815 }
2816 }
2817
2818 recall = NULL;
2819
2820 /* play */
2821 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
2822 gboolean found_buffer;
2823
2824 for(i = start_pad; i < stop_pad && i < input_pads; i++){
2825 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2826 channel = ags_channel_nth(start,
2827 i * audio_channels + start_audio_channel + j);
2828
2829 if(channel == NULL){
2830 break;
2831 }
2832
2833 current = ags_channel_nth(start_output,
2834 start_audio_channel + j);
2835
2836 /* check output */
2837 next_pad = NULL;
2838
2839 while(current != NULL){
2840 /* check output present */
2841 g_object_get(channel,
2842 "play", &list_start,
2843 NULL);
2844
2845 list = list_start;
2846 found_buffer = FALSE;
2847
2848 while((list = ags_recall_template_find_type(list,
2849 AGS_TYPE_BUFFER_CHANNEL)) != NULL){
2850 AgsChannel *current_destination;
2851
2852 g_object_get(list->data,
2853 "destination", ¤t_destination,
2854 NULL);
2855
2856 if(current_destination == current){
2857 found_buffer = TRUE;
2858
2859 break;
2860 }
2861
2862 list = list->next;
2863 }
2864
2865 g_list_free_full(list_start,
2866 g_object_unref);
2867
2868 if(found_buffer){
2869 /* iterate - current */
2870 next_pad = ags_channel_next_pad(current);
2871
2872 g_object_unref(current);
2873
2874 current = next_pad;
2875
2876 continue;
2877 }
2878
2879 if(play_container == NULL){
2880 play_container = ags_recall_container_new();
2881 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
2882 ags_audio_add_recall_container(audio, (GObject *) play_container);
2883 }
2884
2885 ags_channel_add_recall_container(channel, (GObject *) play_container);
2886
2887 /* AgsBufferChannel */
2888 buffer_channel = (AgsBufferChannel *) g_object_new(AGS_TYPE_BUFFER_CHANNEL,
2889 "output-soundcard", output_soundcard,
2890 "source", channel,
2891 "destination", current,
2892 "recall-container", play_container,
2893 NULL);
2894 ags_recall_set_flags((AgsRecall *) buffer_channel,
2895 (AGS_RECALL_TEMPLATE));
2896 ags_recall_set_ability_flags((AgsRecall *) buffer_channel,
2897 (AGS_SOUND_ABILITY_PLAYBACK |
2898 AGS_SOUND_ABILITY_NOTATION |
2899 AGS_SOUND_ABILITY_SEQUENCER |
2900 AGS_SOUND_ABILITY_MIDI |
2901 AGS_SOUND_ABILITY_WAVE));
2902 ags_recall_set_behaviour_flags((AgsRecall *) buffer_channel,
2903 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2904
2905 ags_channel_add_recall(channel,
2906 (GObject *) buffer_channel, TRUE);
2907
2908 recall = g_list_prepend(recall,
2909 buffer_channel);
2910
2911 g_object_set(play_container,
2912 "recall-channel", buffer_channel,
2913 NULL);
2914 ags_connectable_connect(AGS_CONNECTABLE(buffer_channel));
2915
2916 /* AgsBufferChannelRun */
2917 buffer_channel_run = (AgsBufferChannelRun *) g_object_new(AGS_TYPE_BUFFER_CHANNEL_RUN,
2918 "output-soundcard", output_soundcard,
2919 "recall-channel", buffer_channel,
2920 "source", channel,
2921 "destination", current,
2922 "recall-container", play_container,
2923 NULL);
2924 ags_recall_set_flags((AgsRecall *) buffer_channel_run,
2925 (AGS_RECALL_TEMPLATE));
2926 ags_recall_set_ability_flags((AgsRecall *) buffer_channel_run,
2927 (AGS_SOUND_ABILITY_PLAYBACK |
2928 AGS_SOUND_ABILITY_NOTATION |
2929 AGS_SOUND_ABILITY_SEQUENCER |
2930 AGS_SOUND_ABILITY_MIDI |
2931 AGS_SOUND_ABILITY_WAVE));
2932 ags_recall_set_behaviour_flags((AgsRecall *) buffer_channel_run,
2933 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
2934
2935 ags_channel_add_recall(channel,
2936 (GObject *) buffer_channel_run, TRUE);
2937
2938 recall = g_list_prepend(recall,
2939 buffer_channel_run);
2940
2941 g_object_set(play_container,
2942 "recall-channel-run", buffer_channel_run,
2943 NULL);
2944 ags_connectable_connect(AGS_CONNECTABLE(buffer_channel_run));
2945
2946 /* iterate - current */
2947 next_pad = ags_channel_next_pad(current);
2948
2949 g_object_unref(current);
2950
2951 current = next_pad;
2952 }
2953
2954 if(next_pad != NULL){
2955 g_object_unref(next_pad);
2956 }
2957
2958 g_object_unref(channel);
2959 }
2960 }
2961 }
2962
2963 /* recall */
2964 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
2965 gboolean found_buffer;
2966
2967 for(i = start_pad; i < stop_pad && i < input_pads; i++){
2968 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
2969 channel = ags_channel_nth(start,
2970 i * audio_channels + start_audio_channel + j);
2971
2972 if(channel == NULL){
2973 break;
2974 }
2975
2976 current = ags_channel_nth(start_output,
2977 start_audio_channel + j);
2978
2979 /* check output */
2980 next_pad = NULL;
2981
2982 while(current != NULL){
2983 /* check output present */
2984 g_object_get(channel,
2985 "recall", &list_start,
2986 NULL);
2987
2988 list = list_start;
2989 found_buffer = FALSE;
2990
2991 while((list = ags_recall_template_find_type(list,
2992 AGS_TYPE_BUFFER_CHANNEL)) != NULL){
2993 AgsChannel *current_destination;
2994
2995 g_object_get(list->data,
2996 "destination", ¤t_destination,
2997 NULL);
2998
2999 if(current_destination == current){
3000 found_buffer = TRUE;
3001
3002 break;
3003 }
3004
3005 list = list->next;
3006 }
3007
3008 g_list_free_full(list_start,
3009 g_object_unref);
3010
3011 if(found_buffer){
3012 /* iterate - current */
3013 next_pad = ags_channel_next_pad(current);
3014
3015 g_object_unref(current);
3016
3017 current = next_pad;
3018
3019 continue;
3020 }
3021
3022 if(recall_container == NULL){
3023 recall_container = ags_recall_container_new();
3024 ags_audio_add_recall_container(audio, (GObject *) recall_container);
3025 }
3026
3027 ags_channel_add_recall_container(channel, (GObject *) recall_container);
3028
3029 /* AgsBufferChannel */
3030 buffer_channel = (AgsBufferChannel *) g_object_new(AGS_TYPE_BUFFER_CHANNEL,
3031 "output-soundcard", output_soundcard,
3032 "source", channel,
3033 "destination", current,
3034 "recall-container", recall_container,
3035 NULL);
3036 ags_recall_set_flags((AgsRecall *) buffer_channel,
3037 (AGS_RECALL_TEMPLATE));
3038 ags_recall_set_ability_flags((AgsRecall *) buffer_channel,
3039 (AGS_SOUND_ABILITY_PLAYBACK |
3040 AGS_SOUND_ABILITY_NOTATION |
3041 AGS_SOUND_ABILITY_SEQUENCER |
3042 AGS_SOUND_ABILITY_MIDI |
3043 AGS_SOUND_ABILITY_WAVE));
3044 ags_recall_set_behaviour_flags((AgsRecall *) buffer_channel,
3045 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3046
3047 ags_channel_add_recall(channel,
3048 (GObject *) buffer_channel, FALSE);
3049
3050 recall = g_list_prepend(recall,
3051 buffer_channel);
3052
3053 g_object_set(recall_container,
3054 "recall-channel", buffer_channel,
3055 NULL);
3056 ags_connectable_connect(AGS_CONNECTABLE(buffer_channel));
3057
3058 /* AgsBufferChannelRun */
3059 buffer_channel_run = (AgsBufferChannelRun *) g_object_new(AGS_TYPE_BUFFER_CHANNEL_RUN,
3060 "output-soundcard", output_soundcard,
3061 "recall-channel", buffer_channel,
3062 "source", channel,
3063 "destination", current,
3064 "recall-container", recall_container,
3065 NULL);
3066 ags_recall_set_flags((AgsRecall *) buffer_channel_run,
3067 (AGS_RECALL_TEMPLATE));
3068 ags_recall_set_ability_flags((AgsRecall *) buffer_channel_run,
3069 (AGS_SOUND_ABILITY_PLAYBACK |
3070 AGS_SOUND_ABILITY_NOTATION |
3071 AGS_SOUND_ABILITY_SEQUENCER |
3072 AGS_SOUND_ABILITY_MIDI |
3073 AGS_SOUND_ABILITY_WAVE));
3074 ags_recall_set_behaviour_flags((AgsRecall *) buffer_channel_run,
3075 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3076
3077 ags_channel_add_recall(channel,
3078 (GObject *) buffer_channel_run, FALSE);
3079
3080 recall = g_list_prepend(recall,
3081 buffer_channel_run);
3082
3083 g_object_set(recall_container,
3084 "recall-channel-run", buffer_channel_run,
3085 NULL);
3086 ags_connectable_connect(AGS_CONNECTABLE(buffer_channel_run));
3087
3088 /* iterate - current */
3089 next_pad = ags_channel_next_pad(current);
3090
3091 g_object_unref(current);
3092
3093 current = next_pad;
3094 }
3095
3096 if(next_pad != NULL){
3097 g_object_unref(next_pad);
3098 }
3099
3100 g_object_unref(channel);
3101 }
3102 }
3103 }
3104
3105 /* unref */
3106 if(start_output != NULL){
3107 g_object_unref(start_output);
3108 }
3109
3110 if(start_input != NULL){
3111 g_object_unref(start_input);
3112 }
3113
3114 if(start != NULL){
3115 g_object_unref(start);
3116 }
3117
3118 /* return instantiated recall */
3119 recall = g_list_reverse(recall);
3120 g_list_foreach(recall,
3121 (GFunc) g_object_ref,
3122 NULL);
3123
3124 return(recall);
3125 }
3126
3127 GList*
ags_recall_factory_create_delay(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)3128 ags_recall_factory_create_delay(AgsAudio *audio,
3129 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
3130 gchar *plugin_name,
3131 guint start_audio_channel, guint stop_audio_channel,
3132 guint start_pad, guint stop_pad,
3133 guint create_flags, guint recall_flags)
3134 {
3135 AgsDelayAudio *delay_audio;
3136 AgsDelayAudioRun *delay_audio_run;
3137 AgsPort *port;
3138
3139 GObject *output_soundcard;
3140
3141 GList *list_start, *list;
3142 GList *recall;
3143
3144 guint i, j;
3145
3146 GRecMutex *audio_mutex;
3147
3148 if(!AGS_IS_AUDIO(audio)){
3149 return(NULL);
3150 }
3151
3152 /* get audio mutex */
3153 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
3154
3155 /* get some fields */
3156 g_rec_mutex_lock(audio_mutex);
3157
3158 output_soundcard = audio->output_soundcard;
3159
3160 g_rec_mutex_unlock(audio_mutex);
3161
3162 /* list */
3163 recall = NULL;
3164
3165 /* play */
3166 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
3167 if(play_container == NULL){
3168 play_container = ags_recall_container_new();
3169 }
3170
3171 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
3172 ags_audio_add_recall_container(audio, (GObject *) play_container);
3173
3174 delay_audio = (AgsDelayAudio *) g_object_new(AGS_TYPE_DELAY_AUDIO,
3175 "output-soundcard", output_soundcard,
3176 "audio", audio,
3177 "recall-container", play_container,
3178 NULL);
3179 ags_recall_set_flags((AgsRecall *) delay_audio,
3180 (AGS_RECALL_TEMPLATE));
3181 ags_recall_set_ability_flags((AgsRecall *) delay_audio,
3182 (AGS_SOUND_ABILITY_PLAYBACK |
3183 AGS_SOUND_ABILITY_NOTATION |
3184 AGS_SOUND_ABILITY_SEQUENCER |
3185 AGS_SOUND_ABILITY_MIDI |
3186 AGS_SOUND_ABILITY_WAVE));
3187 ags_recall_set_behaviour_flags((AgsRecall *) delay_audio,
3188 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3189
3190 ags_audio_add_recall(audio, (GObject *) delay_audio, TRUE);
3191 recall = g_list_prepend(recall,
3192 delay_audio);
3193
3194 g_object_set(play_container,
3195 "recall-audio", delay_audio,
3196 NULL);
3197 ags_connectable_connect(AGS_CONNECTABLE(delay_audio));
3198
3199 delay_audio_run = (AgsDelayAudioRun *) g_object_new(AGS_TYPE_DELAY_AUDIO_RUN,
3200 "output-soundcard", output_soundcard,
3201 "recall-audio", delay_audio,
3202 "recall-container", play_container,
3203 NULL);
3204 ags_recall_set_flags((AgsRecall *) delay_audio_run,
3205 (AGS_RECALL_TEMPLATE));
3206 ags_recall_set_ability_flags((AgsRecall *) delay_audio_run,
3207 (AGS_SOUND_ABILITY_PLAYBACK |
3208 AGS_SOUND_ABILITY_NOTATION |
3209 AGS_SOUND_ABILITY_SEQUENCER |
3210 AGS_SOUND_ABILITY_MIDI |
3211 AGS_SOUND_ABILITY_WAVE));
3212 ags_recall_set_behaviour_flags((AgsRecall *) delay_audio_run,
3213 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3214
3215 ags_audio_add_recall(audio, (GObject *) delay_audio_run, TRUE);
3216 recall = g_list_prepend(recall,
3217 delay_audio_run);
3218
3219 g_object_set(play_container,
3220 "recall-audio-run", delay_audio_run,
3221 NULL);
3222 ags_connectable_connect(AGS_CONNECTABLE(delay_audio_run));
3223 }
3224
3225 /* recall */
3226 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
3227 if(recall_container == NULL){
3228 recall_container = ags_recall_container_new();
3229 }
3230
3231 ags_audio_add_recall_container(audio, (GObject *) recall_container);
3232
3233 delay_audio = (AgsDelayAudio *) g_object_new(AGS_TYPE_DELAY_AUDIO,
3234 "output-soundcard", output_soundcard,
3235 "audio", audio,
3236 "recall-container", recall_container,
3237 NULL);
3238 ags_recall_set_flags((AgsRecall *) delay_audio,
3239 (AGS_RECALL_TEMPLATE));
3240 ags_recall_set_ability_flags((AgsRecall *) delay_audio,
3241 (AGS_SOUND_ABILITY_PLAYBACK |
3242 AGS_SOUND_ABILITY_NOTATION |
3243 AGS_SOUND_ABILITY_SEQUENCER |
3244 AGS_SOUND_ABILITY_MIDI |
3245 AGS_SOUND_ABILITY_WAVE));
3246 ags_recall_set_behaviour_flags((AgsRecall *) delay_audio,
3247 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3248
3249 ags_audio_add_recall(audio, (GObject *) delay_audio, FALSE);
3250 recall = g_list_prepend(recall,
3251 delay_audio);
3252
3253 g_object_set(recall_container,
3254 "recall-audio", delay_audio,
3255 NULL);
3256 ags_connectable_connect(AGS_CONNECTABLE(delay_audio));
3257
3258 delay_audio_run = (AgsDelayAudioRun *) g_object_new(AGS_TYPE_DELAY_AUDIO_RUN,
3259 "output-soundcard", output_soundcard,
3260 "recall-audio", delay_audio,
3261 "recall-container", recall_container,
3262 //TODO:JK: add missing dependency "delay-audio"
3263 NULL);
3264 ags_recall_set_flags((AgsRecall *) delay_audio_run,
3265 (AGS_RECALL_TEMPLATE));
3266 ags_recall_set_ability_flags((AgsRecall *) delay_audio_run,
3267 (AGS_SOUND_ABILITY_PLAYBACK |
3268 AGS_SOUND_ABILITY_NOTATION |
3269 AGS_SOUND_ABILITY_SEQUENCER |
3270 AGS_SOUND_ABILITY_MIDI |
3271 AGS_SOUND_ABILITY_WAVE));
3272 ags_recall_set_behaviour_flags((AgsRecall *) delay_audio_run,
3273 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3274
3275 ags_audio_add_recall(audio, (GObject *) delay_audio_run, FALSE);
3276 recall = g_list_prepend(recall,
3277 delay_audio_run);
3278
3279 g_object_set(recall_container,
3280 "recall-audio-run", delay_audio_run,
3281 NULL);
3282 ags_connectable_connect(AGS_CONNECTABLE(delay_audio_run));
3283 }
3284
3285 /* return instantiated recall */
3286 recall = g_list_reverse(recall);
3287 g_list_foreach(recall,
3288 (GFunc) g_object_ref,
3289 NULL);
3290
3291 return(recall);
3292 }
3293
3294 GList*
ags_recall_factory_create_count_beats(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)3295 ags_recall_factory_create_count_beats(AgsAudio *audio,
3296 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
3297 gchar *plugin_name,
3298 guint start_audio_channel, guint stop_audio_channel,
3299 guint start_pad, guint stop_pad,
3300 guint create_flags, guint recall_flags)
3301 {
3302 AgsCountBeatsAudio *count_beats_audio;
3303 AgsCountBeatsAudioRun *count_beats_audio_run;
3304 AgsPort *port;
3305
3306 GObject *output_soundcard;
3307
3308 GList *list_start, *list;
3309 GList *recall;
3310
3311 guint i, j;
3312
3313 GRecMutex *audio_mutex;
3314
3315 if(!AGS_IS_AUDIO(audio)){
3316 return(NULL);
3317 }
3318
3319 /* get audio mutex */
3320 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
3321
3322 /* get some fields */
3323 g_rec_mutex_lock(audio_mutex);
3324
3325 output_soundcard = audio->output_soundcard;
3326
3327 g_rec_mutex_unlock(audio_mutex);
3328
3329 /* list */
3330 recall = NULL;
3331
3332 /* play */
3333 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
3334 if(play_container == NULL){
3335 play_container = ags_recall_container_new();
3336 }
3337
3338 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
3339 ags_audio_add_recall_container(audio, (GObject *) play_container);
3340
3341 count_beats_audio = (AgsCountBeatsAudio *) g_object_new(AGS_TYPE_COUNT_BEATS_AUDIO,
3342 "output-soundcard", output_soundcard,
3343 "audio", audio,
3344 "recall-container", play_container,
3345 NULL);
3346 ags_recall_set_flags((AgsRecall *) count_beats_audio,
3347 (AGS_RECALL_TEMPLATE));
3348 ags_recall_set_ability_flags((AgsRecall *) count_beats_audio,
3349 (AGS_SOUND_ABILITY_PLAYBACK |
3350 AGS_SOUND_ABILITY_NOTATION |
3351 AGS_SOUND_ABILITY_SEQUENCER |
3352 AGS_SOUND_ABILITY_MIDI |
3353 AGS_SOUND_ABILITY_WAVE));
3354 ags_recall_set_behaviour_flags((AgsRecall *) count_beats_audio,
3355 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3356
3357 ags_audio_add_recall(audio, (GObject *) count_beats_audio, TRUE);
3358 recall = g_list_prepend(recall,
3359 count_beats_audio);
3360
3361 g_object_set(play_container,
3362 "recall-audio", count_beats_audio,
3363 NULL);
3364 ags_connectable_connect(AGS_CONNECTABLE(count_beats_audio));
3365
3366 count_beats_audio_run = (AgsCountBeatsAudioRun *) g_object_new(AGS_TYPE_COUNT_BEATS_AUDIO_RUN,
3367 "output-soundcard", output_soundcard,
3368 "recall-audio", count_beats_audio,
3369 "recall-container", play_container,
3370 NULL);
3371 ags_recall_set_flags((AgsRecall *) count_beats_audio_run,
3372 (AGS_RECALL_TEMPLATE));
3373 ags_recall_set_ability_flags((AgsRecall *) count_beats_audio_run,
3374 (AGS_SOUND_ABILITY_PLAYBACK |
3375 AGS_SOUND_ABILITY_NOTATION |
3376 AGS_SOUND_ABILITY_SEQUENCER |
3377 AGS_SOUND_ABILITY_MIDI |
3378 AGS_SOUND_ABILITY_WAVE));
3379 ags_recall_set_behaviour_flags((AgsRecall *) count_beats_audio_run,
3380 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3381
3382 ags_audio_add_recall(audio, (GObject *) count_beats_audio_run, TRUE);
3383 recall = g_list_prepend(recall,
3384 count_beats_audio_run);
3385
3386 g_object_set(play_container,
3387 "recall-audio-run", count_beats_audio_run,
3388 NULL);
3389 ags_connectable_connect(AGS_CONNECTABLE(count_beats_audio_run));
3390 }
3391
3392 /* recall */
3393 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
3394 if(recall_container == NULL){
3395 recall_container = ags_recall_container_new();
3396 }
3397
3398 ags_audio_add_recall_container(audio, (GObject *) recall_container);
3399
3400 count_beats_audio = (AgsCountBeatsAudio *) g_object_new(AGS_TYPE_COUNT_BEATS_AUDIO,
3401 "output-soundcard", output_soundcard,
3402 "audio", audio,
3403 "recall-container", recall_container,
3404 NULL);
3405 ags_recall_set_flags((AgsRecall *) count_beats_audio,
3406 (AGS_RECALL_TEMPLATE));
3407 ags_recall_set_ability_flags((AgsRecall *) count_beats_audio,
3408 (AGS_SOUND_ABILITY_PLAYBACK |
3409 AGS_SOUND_ABILITY_NOTATION |
3410 AGS_SOUND_ABILITY_SEQUENCER |
3411 AGS_SOUND_ABILITY_MIDI |
3412 AGS_SOUND_ABILITY_WAVE));
3413 ags_recall_set_behaviour_flags((AgsRecall *) count_beats_audio,
3414 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3415
3416 ags_audio_add_recall(audio, (GObject *) count_beats_audio, FALSE);
3417 recall = g_list_prepend(recall,
3418 count_beats_audio);
3419
3420 g_object_set(recall_container,
3421 "recall-audio", count_beats_audio,
3422 NULL);
3423 ags_connectable_connect(AGS_CONNECTABLE(count_beats_audio));
3424
3425 count_beats_audio_run = (AgsCountBeatsAudioRun *) g_object_new(AGS_TYPE_COUNT_BEATS_AUDIO_RUN,
3426 "output-soundcard", output_soundcard,
3427 "recall-audio", count_beats_audio,
3428 "recall-container", recall_container,
3429 //TODO:JK: add missing dependency "delay-audio"
3430 NULL);
3431 ags_recall_set_flags((AgsRecall *) count_beats_audio_run,
3432 (AGS_RECALL_TEMPLATE));
3433 ags_recall_set_ability_flags((AgsRecall *) count_beats_audio_run,
3434 (AGS_SOUND_ABILITY_PLAYBACK |
3435 AGS_SOUND_ABILITY_NOTATION |
3436 AGS_SOUND_ABILITY_SEQUENCER |
3437 AGS_SOUND_ABILITY_MIDI |
3438 AGS_SOUND_ABILITY_WAVE));
3439 ags_recall_set_behaviour_flags((AgsRecall *) count_beats_audio_run,
3440 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3441
3442 ags_audio_add_recall(audio, (GObject *) count_beats_audio_run, FALSE);
3443 recall = g_list_prepend(recall,
3444 count_beats_audio_run);
3445
3446 g_object_set(recall_container,
3447 "recall-audio-run", count_beats_audio_run,
3448 NULL);
3449 ags_connectable_connect(AGS_CONNECTABLE(count_beats_audio_run));
3450 }
3451
3452 /* return instantiated recall */
3453 recall = g_list_reverse(recall);
3454 g_list_foreach(recall,
3455 (GFunc) g_object_ref,
3456 NULL);
3457
3458 return(recall);
3459 }
3460
3461 GList*
ags_recall_factory_create_loop(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)3462 ags_recall_factory_create_loop(AgsAudio *audio,
3463 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
3464 gchar *plugin_name,
3465 guint start_audio_channel, guint stop_audio_channel,
3466 guint start_pad, guint stop_pad,
3467 guint create_flags, guint recall_flags)
3468 {
3469 AgsLoopChannel *loop_channel;
3470 AgsLoopChannelRun *loop_channel_run;
3471 AgsChannel *start_output, *start_input;
3472 AgsChannel *start, *channel, *next_channel, *nth_channel;
3473 AgsPort *port;
3474
3475 GObject *output_soundcard;
3476
3477 GList *list_start, *list;
3478 GList *recall;
3479
3480 guint audio_channels;
3481 guint i, j;
3482
3483 GRecMutex *audio_mutex;
3484
3485 if(!AGS_IS_AUDIO(audio)){
3486 return(NULL);
3487 }
3488
3489 /* get audio mutex */
3490 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
3491
3492 /* get some fields */
3493 g_rec_mutex_lock(audio_mutex);
3494
3495 output_soundcard = audio->output_soundcard;
3496
3497 audio_channels = audio->audio_channels;
3498
3499 start_output = audio->output;
3500
3501 if(start_output != NULL){
3502 g_object_ref(start_output);
3503 }
3504
3505 start_input = audio->input;
3506
3507 if(start_input != NULL){
3508 g_object_ref(start_input);
3509 }
3510
3511 g_rec_mutex_unlock(audio_mutex);
3512
3513 /* get channel */
3514 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
3515 start = ags_channel_nth(start_output,
3516 start_pad * audio_channels);
3517 }else{
3518 start = ags_channel_nth(start_input,
3519 start_pad * audio_channels);
3520 }
3521
3522 recall = NULL;
3523
3524 /* play */
3525 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
3526 channel = start;
3527
3528 if(channel != NULL){
3529 g_object_ref(channel);
3530 }
3531
3532 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0){
3533 if(play_container == NULL){
3534 play_container = ags_recall_container_new();
3535 }
3536
3537 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
3538 ags_audio_add_recall_container(audio, (GObject *) play_container);
3539 }else{
3540 //TODO:JK: implement me
3541 }
3542
3543 nth_channel = NULL;
3544
3545 for(i = 0; i < stop_pad - start_pad; i++){
3546 nth_channel = ags_channel_nth(channel,
3547 start_audio_channel);
3548
3549 g_object_unref(channel);
3550
3551 channel = nth_channel;
3552
3553 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
3554 /* add recall container */
3555 ags_channel_add_recall_container(channel,
3556 (GObject *) play_container);
3557
3558 /* AgsLoopChannel */
3559 loop_channel = (AgsLoopChannel *) g_object_new(AGS_TYPE_LOOP_CHANNEL,
3560 "output-soundcard", output_soundcard,
3561 "source", channel,
3562 "recall-container", play_container,
3563 //TODO:JK: add missing dependency "delay_audio"
3564 NULL);
3565 ags_recall_set_flags((AgsRecall *) loop_channel,
3566 (AGS_RECALL_TEMPLATE));
3567 ags_recall_set_ability_flags((AgsRecall *) loop_channel,
3568 (AGS_SOUND_ABILITY_PLAYBACK |
3569 AGS_SOUND_ABILITY_NOTATION |
3570 AGS_SOUND_ABILITY_SEQUENCER |
3571 AGS_SOUND_ABILITY_MIDI |
3572 AGS_SOUND_ABILITY_WAVE));
3573 ags_recall_set_behaviour_flags((AgsRecall *) loop_channel,
3574 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3575
3576 ags_channel_add_recall(channel, (GObject *) loop_channel, TRUE);
3577 recall = g_list_prepend(recall,
3578 loop_channel);
3579
3580 g_object_set(play_container,
3581 "recall-channel", loop_channel,
3582 NULL);
3583 ags_connectable_connect(AGS_CONNECTABLE(loop_channel));
3584
3585 /* AgsLoopChannelRun */
3586 loop_channel_run = (AgsLoopChannelRun *) g_object_new(AGS_TYPE_LOOP_CHANNEL_RUN,
3587 "output-soundcard", output_soundcard,
3588 "source", channel,
3589 "recall-channel", loop_channel,
3590 "recall-container", play_container,
3591 //TODO:JK: add missing dependency "count_beats_audio_run"
3592 NULL);
3593 ags_recall_set_flags((AgsRecall *) loop_channel_run,
3594 (AGS_RECALL_TEMPLATE));
3595 ags_recall_set_ability_flags((AgsRecall *) loop_channel_run,
3596 (AGS_SOUND_ABILITY_PLAYBACK |
3597 AGS_SOUND_ABILITY_NOTATION |
3598 AGS_SOUND_ABILITY_SEQUENCER |
3599 AGS_SOUND_ABILITY_MIDI |
3600 AGS_SOUND_ABILITY_WAVE));
3601 ags_recall_set_behaviour_flags((AgsRecall *) loop_channel_run,
3602 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3603
3604 ags_channel_add_recall(channel, (GObject *) loop_channel_run, TRUE);
3605 recall = g_list_prepend(recall,
3606 loop_channel_run);
3607
3608 g_object_set(play_container,
3609 "recall-channel-run", loop_channel_run,
3610 NULL);
3611 ags_connectable_connect(AGS_CONNECTABLE(loop_channel_run));
3612
3613 /* iterate */
3614 next_channel = ags_channel_next(channel);
3615
3616 g_object_unref(channel);
3617
3618 channel = next_channel;
3619 }
3620
3621 nth_channel = ags_channel_nth(channel,
3622 audio_channels - stop_audio_channel);
3623
3624 if(channel != NULL){
3625 g_object_unref(channel);
3626 }
3627
3628 channel = nth_channel;
3629 }
3630
3631 if(nth_channel != NULL){
3632 g_object_unref(nth_channel);
3633 }
3634 }
3635
3636 /* recall */
3637 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
3638 channel = start;
3639
3640 if(channel != NULL){
3641 g_object_ref(channel);
3642 }
3643
3644 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0){
3645 if(recall_container == NULL){
3646 recall_container = ags_recall_container_new();
3647 }
3648
3649 ags_audio_add_recall_container(audio, (GObject *) recall_container);
3650 }else{
3651 //TODO:JK: implement me
3652 }
3653
3654 nth_channel = NULL;
3655
3656 for(i = 0; i < stop_pad - start_pad; i++){
3657 nth_channel = ags_channel_nth(channel,
3658 start_audio_channel);
3659
3660 g_object_unref(channel);
3661
3662 channel = nth_channel;
3663
3664 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
3665 /* add recall container */
3666 ags_channel_add_recall_container(channel,
3667 (GObject *) recall_container);
3668
3669 /* AgsLoopChannel */
3670 loop_channel = (AgsLoopChannel *) g_object_new(AGS_TYPE_LOOP_CHANNEL,
3671 "output-soundcard", output_soundcard,
3672 "source", channel,
3673 "recall-container", recall_container,
3674 //TODO:JK: add missing dependency "delay_audio"
3675 NULL);
3676 ags_recall_set_flags((AgsRecall *) loop_channel,
3677 (AGS_RECALL_TEMPLATE));
3678 ags_recall_set_ability_flags((AgsRecall *) loop_channel,
3679 (AGS_SOUND_ABILITY_PLAYBACK |
3680 AGS_SOUND_ABILITY_NOTATION |
3681 AGS_SOUND_ABILITY_SEQUENCER |
3682 AGS_SOUND_ABILITY_MIDI |
3683 AGS_SOUND_ABILITY_WAVE));
3684 ags_recall_set_behaviour_flags((AgsRecall *) loop_channel,
3685 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3686
3687 ags_channel_add_recall(channel, (GObject *) loop_channel, FALSE);
3688 recall = g_list_prepend(recall,
3689 loop_channel);
3690
3691 g_object_set(recall_container,
3692 "recall-channel", loop_channel,
3693 NULL);
3694 ags_connectable_connect(AGS_CONNECTABLE(loop_channel));
3695
3696 /* AgsLoopChannelRun */
3697 loop_channel_run = (AgsLoopChannelRun *) g_object_new(AGS_TYPE_LOOP_CHANNEL_RUN,
3698 "output-soundcard", output_soundcard,
3699 "source", channel,
3700 "recall-channel", loop_channel,
3701 "recall-container", recall_container,
3702 //TODO:JK: add missing dependency "count_beats_audio_run"
3703 NULL);
3704 ags_recall_set_flags((AgsRecall *) loop_channel_run,
3705 (AGS_RECALL_TEMPLATE));
3706 ags_recall_set_ability_flags((AgsRecall *) loop_channel_run,
3707 (AGS_SOUND_ABILITY_PLAYBACK |
3708 AGS_SOUND_ABILITY_NOTATION |
3709 AGS_SOUND_ABILITY_SEQUENCER |
3710 AGS_SOUND_ABILITY_MIDI |
3711 AGS_SOUND_ABILITY_WAVE));
3712 ags_recall_set_behaviour_flags((AgsRecall *) loop_channel_run,
3713 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3714
3715 ags_channel_add_recall(channel, (GObject *) loop_channel_run, FALSE);
3716 recall = g_list_prepend(recall,
3717 loop_channel_run);
3718
3719 g_object_set(recall_container,
3720 "recall-channel-run", loop_channel_run,
3721 NULL);
3722 ags_connectable_connect(AGS_CONNECTABLE(loop_channel_run));
3723
3724 /* iterate */
3725 next_channel = ags_channel_next(channel);
3726
3727 g_object_unref(channel);
3728
3729 channel = next_channel;
3730 }
3731
3732 nth_channel = ags_channel_nth(channel,
3733 audio_channels - stop_audio_channel);
3734
3735 if(channel != NULL){
3736 g_object_unref(channel);
3737 }
3738
3739 channel = nth_channel;
3740 }
3741
3742 if(nth_channel != NULL){
3743 g_object_unref(nth_channel);
3744 }
3745 }
3746
3747 /* unref */
3748 if(start_output != NULL){
3749 g_object_unref(start_output);
3750 }
3751
3752 if(start_input != NULL){
3753 g_object_unref(start_input);
3754 }
3755
3756 if(start != NULL){
3757 g_object_unref(start);
3758 }
3759
3760 /* return instantiated recall */
3761 recall = g_list_reverse(recall);
3762 g_list_foreach(recall,
3763 (GFunc) g_object_ref,
3764 NULL);
3765
3766 return(recall);
3767 }
3768
3769
3770 GList*
ags_recall_factory_create_copy_pattern(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)3771 ags_recall_factory_create_copy_pattern(AgsAudio *audio,
3772 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
3773 gchar *plugin_name,
3774 guint start_audio_channel, guint stop_audio_channel,
3775 guint start_pad, guint stop_pad,
3776 guint create_flags, guint recall_flags)
3777 {
3778 AgsCopyPatternAudio *copy_pattern_audio;
3779 AgsCopyPatternAudioRun *copy_pattern_audio_run;
3780 AgsCopyPatternChannel *copy_pattern_channel;
3781 AgsCopyPatternChannelRun *copy_pattern_channel_run;
3782 AgsChannel *start_output, *start_input;
3783 AgsChannel *start, *channel, *next_channel, *nth_channel;
3784 AgsPort *port;
3785
3786 GObject *output_soundcard;
3787
3788 GList *list_start, *list;
3789 GList *recall;
3790
3791 guint audio_channels;
3792 guint i, j;
3793
3794 GRecMutex *audio_mutex;
3795
3796 if(!AGS_IS_AUDIO(audio)){
3797 return(NULL);
3798 }
3799
3800 /* get audio mutex */
3801 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
3802
3803 /* get some fields */
3804 g_rec_mutex_lock(audio_mutex);
3805
3806 output_soundcard = audio->output_soundcard;
3807
3808 audio_channels = audio->audio_channels;
3809
3810 start_output = audio->output;
3811
3812 if(start_output != NULL){
3813 g_object_ref(start_output);
3814 }
3815
3816 start_input = audio->input;
3817
3818 if(start_input != NULL){
3819 g_object_ref(start_input);
3820 }
3821
3822 g_rec_mutex_unlock(audio_mutex);
3823
3824 /* get channel */
3825 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
3826 start = ags_channel_nth(start_output,
3827 start_pad * audio_channels);
3828 }else{
3829 start = ags_channel_nth(start_input,
3830 start_pad * audio_channels);
3831 }
3832
3833 recall = NULL;
3834
3835 /* play */
3836 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
3837 channel = start;
3838
3839 if(channel != NULL){
3840 g_object_ref(channel);
3841 }
3842
3843 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0 ||
3844 ags_recall_find_type(audio->play, AGS_TYPE_COPY_PATTERN_AUDIO) == NULL){
3845 if(play_container == NULL){
3846 play_container = ags_recall_container_new();
3847 }
3848
3849 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
3850 ags_audio_add_recall_container(audio, (GObject *) play_container);
3851
3852 /* AgsCopyPatternAudio */
3853 copy_pattern_audio = (AgsCopyPatternAudio *) g_object_new(AGS_TYPE_COPY_PATTERN_AUDIO,
3854 "output-soundcard", output_soundcard,
3855 "audio", audio,
3856 "recall-container", play_container,
3857 NULL);
3858 ags_recall_set_flags((AgsRecall *) copy_pattern_audio,
3859 (AGS_RECALL_TEMPLATE));
3860 ags_recall_set_ability_flags((AgsRecall *) copy_pattern_audio,
3861 (AGS_SOUND_ABILITY_SEQUENCER));
3862 ags_recall_set_behaviour_flags((AgsRecall *) copy_pattern_audio,
3863 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3864
3865 ags_audio_add_recall(audio, (GObject *) copy_pattern_audio, TRUE);
3866 recall = g_list_prepend(recall,
3867 copy_pattern_audio);
3868
3869 g_object_set(play_container,
3870 "recall-audio", copy_pattern_audio,
3871 NULL);
3872
3873 /* AgsCopyPatternAudioRun */
3874 copy_pattern_audio_run = (AgsCopyPatternAudioRun *) g_object_new(AGS_TYPE_COPY_PATTERN_AUDIO_RUN,
3875 "output-soundcard", output_soundcard,
3876 "audio", audio,
3877 "recall-container", play_container,
3878 "recall-audio", copy_pattern_audio,
3879 //TODO:JK: add missing dependency "count_beats_audio_run"
3880 NULL);
3881 ags_recall_set_flags((AgsRecall *) copy_pattern_audio_run,
3882 (AGS_RECALL_TEMPLATE));
3883 ags_recall_set_ability_flags((AgsRecall *) copy_pattern_audio_run,
3884 (AGS_SOUND_ABILITY_SEQUENCER));
3885 ags_recall_set_behaviour_flags((AgsRecall *) copy_pattern_audio_run,
3886 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3887
3888 ags_audio_add_recall(audio, (GObject *) copy_pattern_audio_run, TRUE);
3889 recall = g_list_prepend(recall,
3890 copy_pattern_audio_run);
3891
3892 g_object_set(play_container,
3893 "recall-audio-run", copy_pattern_audio_run,
3894 NULL);
3895 }else{
3896 if(play_container == NULL){
3897 g_object_get(audio,
3898 "play", &list_start,
3899 NULL);
3900
3901 list = ags_recall_find_type(list_start,
3902 AGS_TYPE_COPY_PATTERN_AUDIO);
3903 copy_pattern_audio = AGS_COPY_PATTERN_AUDIO(list->data);
3904 g_list_free(list_start);
3905
3906 recall = g_list_prepend(recall,
3907 copy_pattern_audio);
3908
3909 g_object_get(copy_pattern_audio,
3910 "recall-container", &play_container,
3911 NULL);
3912
3913 g_object_get(play_container,
3914 "recall-audio-run", &list_start,
3915 NULL);
3916
3917 g_object_unref(play_container);
3918
3919 list = ags_recall_find_template(list_start);
3920 copy_pattern_audio_run = AGS_COPY_PATTERN_AUDIO_RUN(list->data);
3921 g_list_free_full(list_start,
3922 g_object_unref);
3923
3924 recall = g_list_prepend(recall,
3925 copy_pattern_audio_run);
3926 }else{
3927 g_object_get(play_container,
3928 "recall-audio", ©_pattern_audio,
3929 NULL);
3930 g_object_unref(copy_pattern_audio);
3931
3932 recall = g_list_prepend(recall,
3933 copy_pattern_audio);
3934
3935 g_object_get(play_container,
3936 "recall-audio-run", &list_start,
3937 NULL);
3938
3939 list = ags_recall_find_template(list_start);
3940 copy_pattern_audio_run = AGS_COPY_PATTERN_AUDIO_RUN(list->data);
3941 g_list_free_full(list_start,
3942 g_object_unref);
3943
3944 recall = g_list_prepend(recall,
3945 copy_pattern_audio_run);
3946 }
3947 }
3948
3949 nth_channel = NULL;
3950
3951 for(i = 0; i < stop_pad - start_pad; i++){
3952 nth_channel = ags_channel_nth(channel,
3953 start_audio_channel);
3954
3955 g_object_unref(channel);
3956
3957 channel = nth_channel;
3958
3959 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
3960 /* add recall container */
3961 ags_channel_add_recall_container(channel,
3962 (GObject *) play_container);
3963
3964 /* AgsCopyPatternChannel in channel->recall */
3965 copy_pattern_channel = (AgsCopyPatternChannel *) g_object_new(AGS_TYPE_COPY_PATTERN_CHANNEL,
3966 "output-soundcard", output_soundcard,
3967 "source", channel,
3968 // "destination", destination,
3969 "recall-container", play_container,
3970 "recall-audio", copy_pattern_audio,
3971 // "pattern", channel->pattern->data,
3972 NULL);
3973 ags_recall_set_flags((AgsRecall *) copy_pattern_channel,
3974 (AGS_RECALL_TEMPLATE));
3975 ags_recall_set_ability_flags((AgsRecall *) copy_pattern_channel,
3976 (AGS_SOUND_ABILITY_SEQUENCER));
3977 ags_recall_set_behaviour_flags((AgsRecall *) copy_pattern_channel,
3978 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
3979
3980 ags_channel_add_recall(channel, (GObject *) copy_pattern_channel, TRUE);
3981 recall = g_list_prepend(recall,
3982 copy_pattern_channel);
3983
3984 g_object_set(play_container,
3985 "recall-channel", copy_pattern_channel,
3986 NULL);
3987 ags_connectable_connect(AGS_CONNECTABLE(copy_pattern_channel));
3988
3989 /* AgsCopyPatternChannelRun */
3990 copy_pattern_channel_run = (AgsCopyPatternChannelRun *) g_object_new(AGS_TYPE_COPY_PATTERN_CHANNEL_RUN,
3991 "output-soundcard", output_soundcard,
3992 "source", channel,
3993 // "destination", destination,
3994 // "recall_audio_run", copy_pattern_audio_run,
3995 "recall-container", play_container,
3996 "recall-audio", copy_pattern_audio,
3997 "recall-audio-run", copy_pattern_audio_run,
3998 "recall-channel", copy_pattern_channel,
3999 NULL);
4000 ags_recall_set_flags((AgsRecall *) copy_pattern_channel_run,
4001 (AGS_RECALL_TEMPLATE));
4002 ags_recall_set_ability_flags((AgsRecall *) copy_pattern_channel_run,
4003 (AGS_SOUND_ABILITY_SEQUENCER));
4004 ags_recall_set_behaviour_flags((AgsRecall *) copy_pattern_channel_run,
4005 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4006
4007 ags_channel_add_recall(channel, (GObject *) copy_pattern_channel_run, TRUE);
4008 recall = g_list_prepend(recall,
4009 copy_pattern_channel_run);
4010
4011 g_object_set(play_container,
4012 "recall-channel-run", copy_pattern_channel_run,
4013 NULL);
4014 ags_connectable_connect(AGS_CONNECTABLE(copy_pattern_channel_run));
4015
4016 /* iterate */
4017 next_channel = ags_channel_next(channel);
4018
4019 g_object_unref(channel);
4020
4021 channel = next_channel;
4022 }
4023
4024 nth_channel = ags_channel_nth(channel,
4025 audio_channels - stop_audio_channel);
4026
4027 if(channel != NULL){
4028 g_object_unref(channel);
4029 }
4030
4031 channel = nth_channel;
4032 }
4033
4034 if(nth_channel != NULL){
4035 g_object_unref(nth_channel);
4036 }
4037 }
4038
4039 /* recall */
4040 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
4041 channel = start;
4042
4043 if(channel != NULL){
4044 g_object_ref(channel);
4045 }
4046
4047 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0 ||
4048 ags_recall_find_type(audio->recall, AGS_TYPE_COPY_PATTERN_AUDIO) == NULL){
4049 if(recall_container == NULL){
4050 recall_container = ags_recall_container_new();
4051 }
4052
4053 ags_audio_add_recall_container(audio, (GObject *) recall_container);
4054
4055 /* AgsCopyPatternAudio */
4056 copy_pattern_audio = (AgsCopyPatternAudio *) g_object_new(AGS_TYPE_COPY_PATTERN_AUDIO,
4057 "output-soundcard", output_soundcard,
4058 "audio", audio,
4059 "recall-container", recall_container,
4060 NULL);
4061 ags_recall_set_flags((AgsRecall *) copy_pattern_audio,
4062 (AGS_RECALL_TEMPLATE));
4063 ags_recall_set_ability_flags((AgsRecall *) copy_pattern_audio,
4064 (AGS_SOUND_ABILITY_SEQUENCER));
4065 ags_recall_set_behaviour_flags((AgsRecall *) copy_pattern_audio,
4066 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4067
4068 ags_audio_add_recall(audio, (GObject *) copy_pattern_audio, FALSE);
4069 recall = g_list_prepend(recall,
4070 copy_pattern_audio);
4071
4072 g_object_set(recall_container,
4073 "recall-audio", copy_pattern_audio,
4074 NULL);
4075
4076 /* AgsCopyPatternAudioRun */
4077 copy_pattern_audio_run = (AgsCopyPatternAudioRun *) g_object_new(AGS_TYPE_COPY_PATTERN_AUDIO_RUN,
4078 "output-soundcard", output_soundcard,
4079 "recall-container", recall_container,
4080 "recall-audio", copy_pattern_audio,
4081 //TODO:JK: add missing dependency "count_beats_audio_run"
4082 NULL);
4083 ags_recall_set_flags((AgsRecall *) copy_pattern_audio_run,
4084 (AGS_RECALL_TEMPLATE));
4085 ags_recall_set_ability_flags((AgsRecall *) copy_pattern_audio_run,
4086 (AGS_SOUND_ABILITY_SEQUENCER));
4087 ags_recall_set_behaviour_flags((AgsRecall *) copy_pattern_audio_run,
4088 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4089
4090 ags_audio_add_recall(audio, (GObject *) copy_pattern_audio_run, FALSE);
4091 recall = g_list_prepend(recall,
4092 copy_pattern_audio_run);
4093
4094 g_object_set(recall_container,
4095 "recall-audio-run", copy_pattern_audio_run,
4096 NULL);
4097 }else{
4098 if(recall_container == NULL){
4099 g_object_get(audio,
4100 "recall", &list_start,
4101 NULL);
4102
4103 list = ags_recall_find_type(list_start,
4104 AGS_TYPE_COPY_PATTERN_AUDIO);
4105 copy_pattern_audio = AGS_COPY_PATTERN_AUDIO(list->data);
4106 g_list_free_full(list_start,
4107 g_object_unref);
4108
4109 recall = g_list_prepend(recall,
4110 copy_pattern_audio);
4111
4112 g_object_get(copy_pattern_audio,
4113 "recall-container", &recall_container,
4114 NULL);
4115
4116 g_object_get(recall_container,
4117 "recall-audio-run", &list_start,
4118 NULL);
4119
4120 g_object_unref(recall_container);
4121
4122 list = ags_recall_find_template(list_start);
4123 copy_pattern_audio_run = AGS_COPY_PATTERN_AUDIO_RUN(list->data);
4124 g_list_free_full(list_start,
4125 g_object_unref);
4126
4127 recall = g_list_prepend(recall,
4128 copy_pattern_audio_run);
4129 }else{
4130 g_object_get(recall_container,
4131 "recall-audio", ©_pattern_audio,
4132 NULL);
4133 recall = g_list_prepend(recall,
4134 copy_pattern_audio);
4135
4136 g_object_get(recall_container,
4137 "recall-audio-run", &list_start,
4138 NULL);
4139
4140 g_object_unref(copy_pattern_audio);
4141
4142 list = ags_recall_template_find_type(list_start,
4143 AGS_TYPE_COPY_PATTERN_AUDIO_RUN);
4144 copy_pattern_audio_run = list->data;
4145 recall = g_list_prepend(recall,
4146 copy_pattern_audio_run);
4147
4148 g_list_free_full(list_start,
4149 g_object_unref);
4150 }
4151 }
4152
4153 nth_channel = NULL;
4154
4155 for(i = 0; i < stop_pad - start_pad; i++){
4156 nth_channel = ags_channel_nth(channel,
4157 start_audio_channel);
4158
4159 g_object_unref(channel);
4160
4161 channel = nth_channel;
4162
4163 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
4164 /* add recall container */
4165 ags_channel_add_recall_container(channel,
4166 (GObject *) recall_container);
4167
4168 /* AgsCopyPatternChannel in channel->recall */
4169 copy_pattern_channel = (AgsCopyPatternChannel *) g_object_new(AGS_TYPE_COPY_PATTERN_CHANNEL,
4170 "output-soundcard", output_soundcard,
4171 "source", channel,
4172 // "destination", destination,
4173 "recall-container", recall_container,
4174 "recall-audio", copy_pattern_audio,
4175 //"pattern", channel->pattern->data,
4176 NULL);
4177 ags_recall_set_flags((AgsRecall *) copy_pattern_channel,
4178 (AGS_RECALL_TEMPLATE));
4179 ags_recall_set_ability_flags((AgsRecall *) copy_pattern_channel,
4180 (AGS_SOUND_ABILITY_SEQUENCER));
4181 ags_recall_set_behaviour_flags((AgsRecall *) copy_pattern_channel,
4182 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4183
4184 ags_channel_add_recall(channel, (GObject *) copy_pattern_channel, FALSE);
4185 recall = g_list_prepend(recall,
4186 copy_pattern_channel);
4187
4188 g_object_set(recall_container,
4189 "recall-channel", copy_pattern_channel,
4190 NULL);
4191 ags_connectable_connect(AGS_CONNECTABLE(copy_pattern_channel));
4192
4193 /* AgsCopyPatternChannelRun */
4194 copy_pattern_channel_run = (AgsCopyPatternChannelRun *) g_object_new(AGS_TYPE_COPY_PATTERN_CHANNEL_RUN,
4195 "output-soundcard", output_soundcard,
4196 "source", channel,
4197 // "destination", destination,
4198 // "recall_audio_run", copy_pattern_audio_run,
4199 "recall-container", recall_container,
4200 "recall-audio", copy_pattern_audio,
4201 "recall-audio-run", copy_pattern_audio_run,
4202 "recall-channel", copy_pattern_channel,
4203 NULL);
4204 ags_recall_set_flags((AgsRecall *) copy_pattern_channel_run,
4205 (AGS_RECALL_TEMPLATE));
4206 ags_recall_set_ability_flags((AgsRecall *) copy_pattern_channel_run,
4207 (AGS_SOUND_ABILITY_SEQUENCER));
4208 ags_recall_set_behaviour_flags((AgsRecall *) copy_pattern_channel_run,
4209 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4210
4211 ags_channel_add_recall(channel, (GObject *) copy_pattern_channel_run, FALSE);
4212 recall = g_list_prepend(recall,
4213 copy_pattern_channel_run);
4214
4215 g_object_set(recall_container,
4216 "recall-channel-run", copy_pattern_channel_run,
4217 NULL);
4218 ags_connectable_connect(AGS_CONNECTABLE(copy_pattern_channel_run));
4219
4220 /* iterate */
4221 next_channel = ags_channel_next(channel);
4222
4223 g_object_unref(channel);
4224
4225 channel = next_channel;
4226 }
4227
4228 nth_channel = ags_channel_nth(channel,
4229 audio_channels - stop_audio_channel);
4230
4231 if(channel != NULL){
4232 g_object_unref(channel);
4233 }
4234
4235 channel = nth_channel;
4236 }
4237
4238 if(nth_channel != NULL){
4239 g_object_unref(nth_channel);
4240 }
4241 }
4242
4243 /* unref */
4244 if(start_output != NULL){
4245 g_object_unref(start_output);
4246 }
4247
4248 if(start_input != NULL){
4249 g_object_unref(start_input);
4250 }
4251
4252 if(start != NULL){
4253 g_object_unref(start);
4254 }
4255
4256 /* return instantiated recall */
4257 recall = g_list_reverse(recall);
4258 g_list_foreach(recall,
4259 (GFunc) g_object_ref,
4260 NULL);
4261
4262 return(recall);
4263 }
4264
4265 GList*
ags_recall_factory_create_play_wave(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)4266 ags_recall_factory_create_play_wave(AgsAudio *audio,
4267 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
4268 gchar *plugin_name,
4269 guint start_audio_channel, guint stop_audio_channel,
4270 guint start_pad, guint stop_pad,
4271 guint create_flags, guint recall_flags)
4272 {
4273 AgsPlayWaveAudio *play_wave_audio;
4274 AgsPlayWaveAudioRun *play_wave_audio_run;
4275 AgsPlayWaveChannel *play_wave_channel;
4276 AgsPlayWaveChannelRun *play_wave_channel_run;
4277 AgsChannel *start_output, *start_input;
4278 AgsChannel *start, *channel, *next_channel, *nth_channel;
4279 AgsPort *port;
4280
4281 GObject *output_soundcard;
4282
4283 GList *list_start, *list;
4284 GList *recall;
4285
4286 guint audio_channels;
4287 guint i, j;
4288
4289 GRecMutex *audio_mutex;
4290
4291 if(!AGS_IS_AUDIO(audio)){
4292 return(NULL);
4293 }
4294
4295 /* get audio mutex */
4296 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
4297
4298 /* get some fields */
4299 g_rec_mutex_lock(audio_mutex);
4300
4301 output_soundcard = audio->output_soundcard;
4302
4303 audio_channels = audio->audio_channels;
4304
4305 start_output = audio->output;
4306
4307 if(start_output != NULL){
4308 g_object_ref(start_output);
4309 }
4310
4311 start_input = audio->input;
4312
4313 if(start_input != NULL){
4314 g_object_ref(start_input);
4315 }
4316
4317 g_rec_mutex_unlock(audio_mutex);
4318
4319 /* get channel */
4320 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
4321 start = ags_channel_nth(start_output,
4322 start_pad * audio_channels);
4323 }else{
4324 start = ags_channel_nth(start_input,
4325 start_pad * audio_channels);
4326 }
4327
4328 recall = NULL;
4329
4330 /* play */
4331 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
4332 channel = start;
4333
4334 if(channel != NULL){
4335 g_object_ref(channel);
4336 }
4337
4338 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0 ||
4339 ags_recall_find_type(audio->play, AGS_TYPE_PLAY_WAVE_AUDIO) == NULL){
4340 if(play_container == NULL){
4341 play_container = ags_recall_container_new();
4342 }
4343
4344 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
4345 ags_audio_add_recall_container(audio, (GObject *) play_container);
4346
4347 /* AgsPlayWaveAudio */
4348 play_wave_audio = (AgsPlayWaveAudio *) g_object_new(AGS_TYPE_PLAY_WAVE_AUDIO,
4349 "output-soundcard", output_soundcard,
4350 "audio", audio,
4351 "recall-container", play_container,
4352 NULL);
4353 ags_recall_set_flags((AgsRecall *) play_wave_audio,
4354 (AGS_RECALL_TEMPLATE));
4355 ags_recall_set_ability_flags((AgsRecall *) play_wave_audio,
4356 (AGS_SOUND_ABILITY_WAVE));
4357 ags_recall_set_behaviour_flags((AgsRecall *) play_wave_audio,
4358 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4359
4360 ags_audio_add_recall(audio, (GObject *) play_wave_audio, TRUE);
4361 recall = g_list_prepend(recall,
4362 play_wave_audio);
4363
4364 g_object_set(play_container,
4365 "recall-audio", play_wave_audio,
4366 NULL);
4367
4368 /* AgsPlayWaveAudioRun */
4369 play_wave_audio_run = (AgsPlayWaveAudioRun *) g_object_new(AGS_TYPE_PLAY_WAVE_AUDIO_RUN,
4370 "output-soundcard", output_soundcard,
4371 "audio", audio,
4372 "recall-container", play_container,
4373 "recall-audio", play_wave_audio,
4374 //TODO:JK: add missing dependency "count_beats_audio_run"
4375 NULL);
4376 ags_recall_set_flags((AgsRecall *) play_wave_audio_run,
4377 (AGS_RECALL_TEMPLATE));
4378 ags_recall_set_ability_flags((AgsRecall *) play_wave_audio_run,
4379 (AGS_SOUND_ABILITY_WAVE));
4380 ags_recall_set_behaviour_flags((AgsRecall *) play_wave_audio_run,
4381 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4382
4383 ags_audio_add_recall(audio, (GObject *) play_wave_audio_run, TRUE);
4384 recall = g_list_prepend(recall,
4385 play_wave_audio_run);
4386
4387 g_object_set(play_container,
4388 "recall-audio-run", play_wave_audio_run,
4389 NULL);
4390 }else{
4391 if(play_container == NULL){
4392 g_object_get(audio,
4393 "play", &list_start,
4394 NULL);
4395
4396 list = ags_recall_find_type(list_start,
4397 AGS_TYPE_PLAY_WAVE_AUDIO);
4398 play_wave_audio = AGS_PLAY_WAVE_AUDIO(list->data);
4399 g_list_free_full(list_start,
4400 g_object_unref);
4401
4402 recall = g_list_prepend(recall,
4403 play_wave_audio);
4404
4405 g_object_get(play_wave_audio,
4406 "recall-container", &play_container,
4407 NULL);
4408
4409 g_object_get(play_container,
4410 "recall-audio-run", &list_start,
4411 NULL);
4412
4413 g_object_unref(play_container);
4414
4415 list = ags_recall_find_template(list_start);
4416 play_wave_audio_run = AGS_PLAY_WAVE_AUDIO_RUN(list->data);
4417 g_list_free_full(list_start,
4418 g_object_unref);
4419
4420 recall = g_list_prepend(recall,
4421 play_wave_audio_run);
4422 }else{
4423 g_object_get(play_container,
4424 "recall-audio", &play_wave_audio,
4425 NULL);
4426 g_object_unref(play_wave_audio);
4427
4428 recall = g_list_prepend(recall,
4429 play_wave_audio);
4430
4431 g_object_get(play_container,
4432 "recall-audio-run", &list_start,
4433 NULL);
4434
4435 list = ags_recall_find_template(list_start);
4436 play_wave_audio_run = AGS_PLAY_WAVE_AUDIO_RUN(list->data);
4437 g_list_free_full(list_start,
4438 g_object_unref);
4439
4440 recall = g_list_prepend(recall,
4441 play_wave_audio_run);
4442 }
4443 }
4444
4445 nth_channel = NULL;
4446
4447 for(i = 0; i < stop_pad - start_pad; i++){
4448 nth_channel = ags_channel_nth(channel,
4449 start_audio_channel);
4450
4451 g_object_unref(channel);
4452
4453 channel = nth_channel;
4454
4455 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
4456 /* add recall container */
4457 ags_channel_add_recall_container(channel,
4458 (GObject *) play_container);
4459
4460 /* AgsPlayWaveChannel in channel->recall */
4461 play_wave_channel = (AgsPlayWaveChannel *) g_object_new(AGS_TYPE_PLAY_WAVE_CHANNEL,
4462 "output-soundcard", output_soundcard,
4463 "source", channel,
4464 // "destination", destination,
4465 "recall-container", play_container,
4466 "recall-audio", play_wave_audio,
4467 // "pattern", channel->pattern->data,
4468 NULL);
4469 ags_recall_set_flags((AgsRecall *) play_wave_channel,
4470 (AGS_RECALL_TEMPLATE));
4471 ags_recall_set_ability_flags((AgsRecall *) play_wave_channel,
4472 (AGS_SOUND_ABILITY_WAVE));
4473 ags_recall_set_behaviour_flags((AgsRecall *) play_wave_channel,
4474 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4475
4476 ags_channel_add_recall(channel, (GObject *) play_wave_channel, TRUE);
4477 recall = g_list_prepend(recall,
4478 play_wave_channel);
4479
4480 g_object_set(play_container,
4481 "recall-channel", play_wave_channel,
4482 NULL);
4483 ags_connectable_connect(AGS_CONNECTABLE(play_wave_channel));
4484
4485 /* AgsPlayWaveChannelRun */
4486 play_wave_channel_run = (AgsPlayWaveChannelRun *) g_object_new(AGS_TYPE_PLAY_WAVE_CHANNEL_RUN,
4487 "output-soundcard", output_soundcard,
4488 "source", channel,
4489 // "destination", destination,
4490 // "recall_audio_run", play_wave_audio_run,
4491 "recall-container", play_container,
4492 "recall-audio", play_wave_audio,
4493 "recall-audio-run", play_wave_audio_run,
4494 "recall-channel", play_wave_channel,
4495 NULL);
4496 ags_recall_set_flags((AgsRecall *) play_wave_channel_run,
4497 (AGS_RECALL_TEMPLATE));
4498 ags_recall_set_ability_flags((AgsRecall *) play_wave_channel_run,
4499 (AGS_SOUND_ABILITY_WAVE));
4500 ags_recall_set_behaviour_flags((AgsRecall *) play_wave_channel_run,
4501 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4502
4503 ags_channel_add_recall(channel, (GObject *) play_wave_channel_run, TRUE);
4504 recall = g_list_prepend(recall,
4505 play_wave_channel_run);
4506
4507 g_object_set(play_container,
4508 "recall-channel-run", play_wave_channel_run,
4509 NULL);
4510 ags_connectable_connect(AGS_CONNECTABLE(play_wave_channel_run));
4511
4512 /* iterate */
4513 next_channel = ags_channel_next(channel);
4514
4515 g_object_unref(channel);
4516
4517 channel = next_channel;
4518 }
4519
4520 nth_channel = ags_channel_nth(channel,
4521 audio_channels - stop_audio_channel);
4522
4523 if(channel != NULL){
4524 g_object_unref(channel);
4525 }
4526
4527 channel = nth_channel;
4528 }
4529
4530 if(nth_channel != NULL){
4531 g_object_unref(nth_channel);
4532 }
4533 }
4534
4535 /* recall */
4536 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
4537 channel = start;
4538
4539 if(channel != NULL){
4540 g_object_ref(channel);
4541 }
4542
4543 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0 ||
4544 ags_recall_find_type(audio->recall, AGS_TYPE_PLAY_WAVE_AUDIO) == NULL){
4545 if(recall_container == NULL){
4546 recall_container = ags_recall_container_new();
4547 }
4548
4549 ags_audio_add_recall_container(audio, (GObject *) recall_container);
4550
4551 /* AgsPlayWaveAudio */
4552 play_wave_audio = (AgsPlayWaveAudio *) g_object_new(AGS_TYPE_PLAY_WAVE_AUDIO,
4553 "output-soundcard", output_soundcard,
4554 "audio", audio,
4555 "recall-container", recall_container,
4556 NULL);
4557 ags_recall_set_flags((AgsRecall *) play_wave_audio,
4558 (AGS_RECALL_TEMPLATE));
4559 ags_recall_set_ability_flags((AgsRecall *) play_wave_audio,
4560 (AGS_SOUND_ABILITY_WAVE));
4561 ags_recall_set_behaviour_flags((AgsRecall *) play_wave_audio,
4562 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4563
4564 ags_audio_add_recall(audio, (GObject *) play_wave_audio, FALSE);
4565 recall = g_list_prepend(recall,
4566 play_wave_audio);
4567
4568 g_object_set(recall_container,
4569 "recall-audio", play_wave_audio,
4570 NULL);
4571
4572 /* AgsPlayWaveAudioRun */
4573 play_wave_audio_run = (AgsPlayWaveAudioRun *) g_object_new(AGS_TYPE_PLAY_WAVE_AUDIO_RUN,
4574 "output-soundcard", output_soundcard,
4575 "recall-container", recall_container,
4576 "recall-audio", play_wave_audio,
4577 //TODO:JK: add missing dependency "count_beats_audio_run"
4578 NULL);
4579 ags_recall_set_flags((AgsRecall *) play_wave_audio_run,
4580 (AGS_RECALL_TEMPLATE));
4581 ags_recall_set_ability_flags((AgsRecall *) play_wave_audio_run,
4582 (AGS_SOUND_ABILITY_WAVE));
4583 ags_recall_set_behaviour_flags((AgsRecall *) play_wave_audio_run,
4584 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4585
4586 ags_audio_add_recall(audio, (GObject *) play_wave_audio_run, FALSE);
4587 recall = g_list_prepend(recall,
4588 play_wave_audio_run);
4589
4590 g_object_set(recall_container,
4591 "recall-audio-run", play_wave_audio_run,
4592 NULL);
4593 }else{
4594 if(recall_container == NULL){
4595 g_object_get(audio,
4596 "recall", &list_start,
4597 NULL);
4598
4599 list = ags_recall_find_type(list_start,
4600 AGS_TYPE_PLAY_WAVE_AUDIO);
4601 play_wave_audio = AGS_PLAY_WAVE_AUDIO(list->data);
4602 g_list_free_full(list_start,
4603 g_object_unref);
4604
4605 recall = g_list_prepend(recall,
4606 play_wave_audio);
4607
4608 g_object_get(play_wave_audio,
4609 "recall-container", &recall_container,
4610 NULL);
4611
4612 g_object_get(recall_container,
4613 "recall-audio-run", &list_start,
4614 NULL);
4615
4616 g_object_unref(recall_container);
4617
4618 list = ags_recall_find_template(list_start);
4619 play_wave_audio_run = AGS_PLAY_WAVE_AUDIO_RUN(list->data);
4620 g_list_free_full(list_start,
4621 g_object_unref);
4622
4623 recall = g_list_prepend(recall,
4624 play_wave_audio_run);
4625 }else{
4626 g_object_get(recall_container,
4627 "recall-audio", &play_wave_audio,
4628 NULL);
4629 g_object_unref(play_wave_audio);
4630
4631 recall = g_list_prepend(recall,
4632 play_wave_audio);
4633
4634 g_object_get(recall_container,
4635 "recall-audio-run", &list_start,
4636 NULL);
4637
4638 list = ags_recall_template_find_type(list_start,
4639 AGS_TYPE_PLAY_WAVE_AUDIO_RUN);
4640 play_wave_audio_run = list->data;
4641 recall = g_list_prepend(recall,
4642 play_wave_audio_run);
4643
4644 g_list_free_full(list_start,
4645 g_object_unref);
4646 }
4647 }
4648
4649 nth_channel = NULL;
4650
4651 for(i = 0; i < stop_pad - start_pad; i++){
4652 nth_channel = ags_channel_nth(channel,
4653 start_audio_channel);
4654
4655 g_object_unref(channel);
4656
4657 channel = nth_channel;
4658
4659 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
4660 /* add recall container */
4661 ags_channel_add_recall_container(channel,
4662 (GObject *) recall_container);
4663
4664 /* AgsPlayWaveChannel in channel->recall */
4665 play_wave_channel = (AgsPlayWaveChannel *) g_object_new(AGS_TYPE_PLAY_WAVE_CHANNEL,
4666 "output-soundcard", output_soundcard,
4667 "source", channel,
4668 // "destination", destination,
4669 "recall-container", recall_container,
4670 "recall-audio", play_wave_audio,
4671 //"pattern", channel->pattern->data,
4672 NULL);
4673 ags_recall_set_flags((AgsRecall *) play_wave_channel,
4674 (AGS_RECALL_TEMPLATE));
4675 ags_recall_set_ability_flags((AgsRecall *) play_wave_channel,
4676 (AGS_SOUND_ABILITY_WAVE));
4677 ags_recall_set_behaviour_flags((AgsRecall *) play_wave_channel,
4678 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4679
4680 ags_channel_add_recall(channel, (GObject *) play_wave_channel, FALSE);
4681 recall = g_list_prepend(recall,
4682 play_wave_channel);
4683
4684 g_object_set(recall_container,
4685 "recall-channel", play_wave_channel,
4686 NULL);
4687 ags_connectable_connect(AGS_CONNECTABLE(play_wave_channel));
4688
4689 /* AgsPlayWaveChannelRun */
4690 play_wave_channel_run = (AgsPlayWaveChannelRun *) g_object_new(AGS_TYPE_PLAY_WAVE_CHANNEL_RUN,
4691 "output-soundcard", output_soundcard,
4692 "source", channel,
4693 // "destination", destination,
4694 // "recall_audio_run", play_wave_audio_run,
4695 "recall-container", recall_container,
4696 "recall-audio", play_wave_audio,
4697 "recall-audio-run", play_wave_audio_run,
4698 "recall-channel", play_wave_channel,
4699 NULL);
4700 ags_recall_set_flags((AgsRecall *) play_wave_channel_run,
4701 (AGS_RECALL_TEMPLATE));
4702 ags_recall_set_ability_flags((AgsRecall *) play_wave_channel_run,
4703 (AGS_SOUND_ABILITY_WAVE));
4704 ags_recall_set_behaviour_flags((AgsRecall *) play_wave_channel_run,
4705 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4706
4707 ags_channel_add_recall(channel, (GObject *) play_wave_channel_run, FALSE);
4708 recall = g_list_prepend(recall,
4709 play_wave_channel_run);
4710
4711 g_object_set(recall_container,
4712 "recall-channel-run", play_wave_channel_run,
4713 NULL);
4714 ags_connectable_connect(AGS_CONNECTABLE(play_wave_channel_run));
4715
4716 /* iterate */
4717 next_channel = ags_channel_next(channel);
4718
4719 g_object_unref(channel);
4720
4721 channel = next_channel;
4722 }
4723
4724 nth_channel = ags_channel_nth(channel,
4725 audio_channels - stop_audio_channel);
4726
4727 if(channel != NULL){
4728 g_object_unref(channel);
4729 }
4730
4731 channel = nth_channel;
4732 }
4733
4734 if(nth_channel != NULL){
4735 g_object_unref(nth_channel);
4736 }
4737 }
4738
4739 /* unref */
4740 if(start_output != NULL){
4741 g_object_unref(start_output);
4742 }
4743
4744 if(start_input != NULL){
4745 g_object_unref(start_input);
4746 }
4747
4748 if(start != NULL){
4749 g_object_unref(start);
4750 }
4751
4752 /* return instantiated recall */
4753 recall = g_list_reverse(recall);
4754 g_list_foreach(recall,
4755 (GFunc) g_object_ref,
4756 NULL);
4757
4758 return(recall);
4759 }
4760
4761 GList*
ags_recall_factory_create_capture_wave(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)4762 ags_recall_factory_create_capture_wave(AgsAudio *audio,
4763 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
4764 gchar *plugin_name,
4765 guint start_audio_channel, guint stop_audio_channel,
4766 guint start_pad, guint stop_pad,
4767 guint create_flags, guint recall_flags)
4768 {
4769 AgsCaptureWaveAudio *capture_wave_audio;
4770 AgsCaptureWaveAudioRun *capture_wave_audio_run;
4771 AgsCaptureWaveChannel *capture_wave_channel;
4772 AgsCaptureWaveChannelRun *capture_wave_channel_run;
4773 AgsChannel *start_output, *start_input;
4774 AgsChannel *start, *channel, *next_channel, *nth_channel;
4775 AgsPort *port;
4776
4777 GObject *output_soundcard;
4778
4779 GList *list_start, *list;
4780 GList *recall;
4781
4782 guint audio_channels;
4783 guint i, j;
4784
4785 GRecMutex *audio_mutex;
4786
4787 if(!AGS_IS_AUDIO(audio)){
4788 return(NULL);
4789 }
4790
4791 /* get audio mutex */
4792 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
4793
4794 /* get some fields */
4795 g_rec_mutex_lock(audio_mutex);
4796
4797 output_soundcard = audio->output_soundcard;
4798
4799 audio_channels = audio->audio_channels;
4800
4801 start_output = audio->output;
4802
4803 if(start_output != NULL){
4804 g_object_ref(start_output);
4805 }
4806
4807 start_input = audio->input;
4808
4809 if(start_input != NULL){
4810 g_object_ref(start_input);
4811 }
4812
4813 g_rec_mutex_unlock(audio_mutex);
4814
4815 /* get channel */
4816 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
4817 start = ags_channel_nth(start_output,
4818 start_pad * audio_channels);
4819 }else{
4820 start = ags_channel_nth(start_input,
4821 start_pad * audio_channels);
4822 }
4823
4824 recall = NULL;
4825
4826 /* play */
4827 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
4828 channel = start;
4829
4830 if(channel != NULL){
4831 g_object_ref(channel);
4832 }
4833
4834 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0 ||
4835 ags_recall_find_type(audio->play, AGS_TYPE_CAPTURE_WAVE_AUDIO) == NULL){
4836 if(play_container == NULL){
4837 play_container = ags_recall_container_new();
4838 }
4839
4840 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
4841 ags_audio_add_recall_container(audio, (GObject *) play_container);
4842
4843 /* AgsCaptureWaveAudio */
4844 capture_wave_audio = (AgsCaptureWaveAudio *) g_object_new(AGS_TYPE_CAPTURE_WAVE_AUDIO,
4845 "output-soundcard", output_soundcard,
4846 "audio", audio,
4847 "recall-container", play_container,
4848 NULL);
4849 ags_recall_set_flags((AgsRecall *) capture_wave_audio,
4850 (AGS_RECALL_TEMPLATE));
4851 ags_recall_set_ability_flags((AgsRecall *) capture_wave_audio,
4852 (AGS_SOUND_ABILITY_WAVE));
4853 ags_recall_set_behaviour_flags((AgsRecall *) capture_wave_audio,
4854 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4855
4856 ags_audio_add_recall(audio, (GObject *) capture_wave_audio, TRUE);
4857 recall = g_list_prepend(recall,
4858 capture_wave_audio);
4859
4860 g_object_set(play_container,
4861 "recall-audio", capture_wave_audio,
4862 NULL);
4863
4864 /* AgsCaptureWaveAudioRun */
4865 capture_wave_audio_run = (AgsCaptureWaveAudioRun *) g_object_new(AGS_TYPE_CAPTURE_WAVE_AUDIO_RUN,
4866 "output-soundcard", output_soundcard,
4867 "audio", audio,
4868 "recall-container", play_container,
4869 "recall-audio", capture_wave_audio,
4870 //TODO:JK: add missing dependency "count_beats_audio_run"
4871 NULL);
4872 ags_recall_set_flags((AgsRecall *) capture_wave_audio_run,
4873 (AGS_RECALL_TEMPLATE));
4874 ags_recall_set_ability_flags((AgsRecall *) capture_wave_audio_run,
4875 (AGS_SOUND_ABILITY_WAVE));
4876 ags_recall_set_behaviour_flags((AgsRecall *) capture_wave_audio_run,
4877 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4878
4879 ags_audio_add_recall(audio, (GObject *) capture_wave_audio_run, TRUE);
4880 recall = g_list_prepend(recall,
4881 capture_wave_audio_run);
4882
4883 g_object_set(play_container,
4884 "recall-audio-run", capture_wave_audio_run,
4885 NULL);
4886 }else{
4887 if(play_container == NULL){
4888 g_object_get(audio,
4889 "play", &list_start,
4890 NULL);
4891
4892 list = ags_recall_find_type(list_start,
4893 AGS_TYPE_CAPTURE_WAVE_AUDIO);
4894 capture_wave_audio = AGS_CAPTURE_WAVE_AUDIO(list->data);
4895 g_list_free_full(list_start,
4896 g_object_unref);
4897
4898 recall = g_list_prepend(recall,
4899 capture_wave_audio);
4900
4901 g_object_get(capture_wave_audio,
4902 "recall-container", &play_container,
4903 NULL);
4904
4905 g_object_get(play_container,
4906 "recall-audio-run", &list_start,
4907 NULL);
4908
4909 g_object_unref(play_container);
4910
4911 list = ags_recall_find_template(list_start);
4912 capture_wave_audio_run = AGS_CAPTURE_WAVE_AUDIO_RUN(list->data);
4913 g_list_free_full(list_start,
4914 g_object_unref);
4915
4916 recall = g_list_prepend(recall,
4917 capture_wave_audio_run);
4918 }else{
4919 g_object_get(play_container,
4920 "recall-audio", &capture_wave_audio,
4921 NULL);
4922 g_object_unref(capture_wave_audio);
4923
4924 recall = g_list_prepend(recall,
4925 capture_wave_audio);
4926
4927 g_object_get(play_container,
4928 "recall-audio-run", &list_start,
4929 NULL);
4930
4931 list = ags_recall_find_template(list_start);
4932 capture_wave_audio_run = AGS_CAPTURE_WAVE_AUDIO_RUN(list->data);
4933 g_list_free_full(list_start,
4934 g_object_unref);
4935
4936 recall = g_list_prepend(recall,
4937 capture_wave_audio_run);
4938 }
4939 }
4940
4941 nth_channel = NULL;
4942
4943 for(i = 0; i < stop_pad - start_pad; i++){
4944 nth_channel = ags_channel_nth(channel,
4945 start_audio_channel);
4946
4947 g_object_unref(channel);
4948
4949 channel = nth_channel;
4950
4951 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
4952 /* add recall container */
4953 ags_channel_add_recall_container(channel,
4954 (GObject *) play_container);
4955
4956 /* AgsCaptureWaveChannel in channel->recall */
4957 capture_wave_channel = (AgsCaptureWaveChannel *) g_object_new(AGS_TYPE_CAPTURE_WAVE_CHANNEL,
4958 "output-soundcard", output_soundcard,
4959 "source", channel,
4960 // "destination", destination,
4961 "recall-container", play_container,
4962 "recall-audio", capture_wave_audio,
4963 // "pattern", channel->pattern->data,
4964 NULL);
4965 ags_recall_set_flags((AgsRecall *) capture_wave_channel,
4966 (AGS_RECALL_TEMPLATE));
4967 ags_recall_set_ability_flags((AgsRecall *) capture_wave_channel,
4968 (AGS_SOUND_ABILITY_WAVE));
4969 ags_recall_set_behaviour_flags((AgsRecall *) capture_wave_channel,
4970 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4971
4972 ags_channel_add_recall(channel, (GObject *) capture_wave_channel, TRUE);
4973 recall = g_list_prepend(recall,
4974 capture_wave_channel);
4975
4976 g_object_set(play_container,
4977 "recall-channel", capture_wave_channel,
4978 NULL);
4979 ags_connectable_connect(AGS_CONNECTABLE(capture_wave_channel));
4980
4981 /* AgsCaptureWaveChannelRun */
4982 capture_wave_channel_run = (AgsCaptureWaveChannelRun *) g_object_new(AGS_TYPE_CAPTURE_WAVE_CHANNEL_RUN,
4983 "output-soundcard", output_soundcard,
4984 "source", channel,
4985 // "destination", destination,
4986 // "recall_audio_run", capture_wave_audio_run,
4987 "recall-container", play_container,
4988 "recall-audio", capture_wave_audio,
4989 "recall-audio-run", capture_wave_audio_run,
4990 "recall-channel", capture_wave_channel,
4991 NULL);
4992 ags_recall_set_flags((AgsRecall *) capture_wave_channel_run,
4993 (AGS_RECALL_TEMPLATE));
4994 ags_recall_set_ability_flags((AgsRecall *) capture_wave_channel_run,
4995 (AGS_SOUND_ABILITY_WAVE));
4996 ags_recall_set_behaviour_flags((AgsRecall *) capture_wave_channel_run,
4997 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
4998
4999 ags_channel_add_recall(channel, (GObject *) capture_wave_channel_run, TRUE);
5000 recall = g_list_prepend(recall,
5001 capture_wave_channel_run);
5002
5003 g_object_set(play_container,
5004 "recall-channel-run", capture_wave_channel_run,
5005 NULL);
5006 ags_connectable_connect(AGS_CONNECTABLE(capture_wave_channel_run));
5007
5008 /* iterate */
5009 next_channel = ags_channel_next(channel);
5010
5011 g_object_unref(channel);
5012
5013 channel = next_channel;
5014 }
5015
5016 nth_channel = ags_channel_nth(channel,
5017 audio_channels - stop_audio_channel);
5018
5019 if(channel != NULL){
5020 g_object_unref(channel);
5021 }
5022
5023 channel = nth_channel;
5024 }
5025
5026 if(nth_channel != NULL){
5027 g_object_unref(nth_channel);
5028 }
5029 }
5030
5031 /* recall */
5032 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
5033 channel = start;
5034
5035 if(channel != NULL){
5036 g_object_ref(channel);
5037 }
5038
5039 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0 ||
5040 ags_recall_find_type(audio->recall, AGS_TYPE_CAPTURE_WAVE_AUDIO) == NULL){
5041 if(recall_container == NULL){
5042 recall_container = ags_recall_container_new();
5043 }
5044
5045 ags_audio_add_recall_container(audio, (GObject *) recall_container);
5046
5047 /* AgsCaptureWaveAudio */
5048 capture_wave_audio = (AgsCaptureWaveAudio *) g_object_new(AGS_TYPE_CAPTURE_WAVE_AUDIO,
5049 "output-soundcard", output_soundcard,
5050 "audio", audio,
5051 "recall-container", recall_container,
5052 NULL);
5053 ags_recall_set_flags((AgsRecall *) capture_wave_audio,
5054 (AGS_RECALL_TEMPLATE));
5055 ags_recall_set_ability_flags((AgsRecall *) capture_wave_audio,
5056 (AGS_SOUND_ABILITY_WAVE));
5057 ags_recall_set_behaviour_flags((AgsRecall *) capture_wave_audio,
5058 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5059
5060 ags_audio_add_recall(audio, (GObject *) capture_wave_audio, FALSE);
5061 recall = g_list_prepend(recall,
5062 capture_wave_audio);
5063
5064 g_object_set(recall_container,
5065 "recall-audio", capture_wave_audio,
5066 NULL);
5067
5068 /* AgsCaptureWaveAudioRun */
5069 capture_wave_audio_run = (AgsCaptureWaveAudioRun *) g_object_new(AGS_TYPE_CAPTURE_WAVE_AUDIO_RUN,
5070 "output-soundcard", output_soundcard,
5071 "recall-container", recall_container,
5072 "recall-audio", capture_wave_audio,
5073 //TODO:JK: add missing dependency "count_beats_audio_run"
5074 NULL);
5075 ags_recall_set_flags((AgsRecall *) capture_wave_audio_run,
5076 (AGS_RECALL_TEMPLATE));
5077 ags_recall_set_ability_flags((AgsRecall *) capture_wave_audio_run,
5078 (AGS_SOUND_ABILITY_WAVE));
5079 ags_recall_set_behaviour_flags((AgsRecall *) capture_wave_audio_run,
5080 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5081
5082 ags_audio_add_recall(audio, (GObject *) capture_wave_audio_run, FALSE);
5083 recall = g_list_prepend(recall,
5084 capture_wave_audio_run);
5085
5086 g_object_set(recall_container,
5087 "recall-audio-run", capture_wave_audio_run,
5088 NULL);
5089 }else{
5090 if(recall_container == NULL){
5091 g_object_get(audio,
5092 "recall", &list_start,
5093 NULL);
5094
5095 list = ags_recall_find_type(list_start,
5096 AGS_TYPE_CAPTURE_WAVE_AUDIO);
5097 capture_wave_audio = AGS_CAPTURE_WAVE_AUDIO(list->data);
5098 g_list_free_full(list_start,
5099 g_object_unref);
5100
5101 recall = g_list_prepend(recall,
5102 capture_wave_audio);
5103
5104 g_object_get(capture_wave_audio,
5105 "recall-container", &recall_container,
5106 NULL);
5107
5108 g_object_get(recall_container,
5109 "recall-audio-run", &list_start,
5110 NULL);
5111
5112 g_object_unref(recall_container);
5113
5114 list = ags_recall_find_template(list_start);
5115 capture_wave_audio_run = AGS_CAPTURE_WAVE_AUDIO_RUN(list->data);
5116 g_list_free_full(list_start,
5117 g_object_unref);
5118
5119 recall = g_list_prepend(recall,
5120 capture_wave_audio_run);
5121 }else{
5122 g_object_get(recall_container,
5123 "recall-audio", &capture_wave_audio,
5124 NULL);
5125 g_object_unref(capture_wave_audio);
5126
5127 recall = g_list_prepend(recall,
5128 capture_wave_audio);
5129
5130 g_object_get(recall_container,
5131 "recall-audio-run", &list_start,
5132 NULL);
5133
5134 list = ags_recall_template_find_type(list_start,
5135 AGS_TYPE_CAPTURE_WAVE_AUDIO_RUN);
5136 capture_wave_audio_run = list->data;
5137 recall = g_list_prepend(recall,
5138 capture_wave_audio_run);
5139
5140 g_list_free_full(list_start,
5141 g_object_unref);
5142 }
5143 }
5144
5145 nth_channel = NULL;
5146
5147 for(i = 0; i < stop_pad - start_pad; i++){
5148 nth_channel = ags_channel_nth(channel,
5149 start_audio_channel);
5150
5151 g_object_unref(channel);
5152
5153 channel = nth_channel;
5154
5155 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
5156 /* add recall container */
5157 ags_channel_add_recall_container(channel,
5158 (GObject *) recall_container);
5159
5160 /* AgsCaptureWaveChannel in channel->recall */
5161 capture_wave_channel = (AgsCaptureWaveChannel *) g_object_new(AGS_TYPE_CAPTURE_WAVE_CHANNEL,
5162 "output-soundcard", output_soundcard,
5163 "source", channel,
5164 // "destination", destination,
5165 "recall-container", recall_container,
5166 "recall-audio", capture_wave_audio,
5167 //"pattern", channel->pattern->data,
5168 NULL);
5169 ags_recall_set_flags((AgsRecall *) capture_wave_channel,
5170 (AGS_RECALL_TEMPLATE));
5171 ags_recall_set_ability_flags((AgsRecall *) capture_wave_channel,
5172 (AGS_SOUND_ABILITY_WAVE));
5173 ags_recall_set_behaviour_flags((AgsRecall *) capture_wave_channel,
5174 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5175
5176 ags_channel_add_recall(channel, (GObject *) capture_wave_channel, FALSE);
5177 recall = g_list_prepend(recall,
5178 capture_wave_channel);
5179
5180 g_object_set(recall_container,
5181 "recall-channel", capture_wave_channel,
5182 NULL);
5183 ags_connectable_connect(AGS_CONNECTABLE(capture_wave_channel));
5184
5185 /* AgsCaptureWaveChannelRun */
5186 capture_wave_channel_run = (AgsCaptureWaveChannelRun *) g_object_new(AGS_TYPE_CAPTURE_WAVE_CHANNEL_RUN,
5187 "output-soundcard", output_soundcard,
5188 "source", channel,
5189 // "destination", destination,
5190 // "recall_audio_run", capture_wave_audio_run,
5191 "recall-container", recall_container,
5192 "recall-audio", capture_wave_audio,
5193 "recall-audio-run", capture_wave_audio_run,
5194 "recall-channel", capture_wave_channel,
5195 NULL);
5196 ags_recall_set_flags((AgsRecall *) capture_wave_channel_run,
5197 (AGS_RECALL_TEMPLATE));
5198 ags_recall_set_ability_flags((AgsRecall *) capture_wave_channel_run,
5199 (AGS_SOUND_ABILITY_WAVE));
5200 ags_recall_set_behaviour_flags((AgsRecall *) capture_wave_channel_run,
5201 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5202
5203 ags_channel_add_recall(channel, (GObject *) capture_wave_channel_run, FALSE);
5204 recall = g_list_prepend(recall,
5205 capture_wave_channel_run);
5206
5207 g_object_set(recall_container,
5208 "recall-channel-run", capture_wave_channel_run,
5209 NULL);
5210 ags_connectable_connect(AGS_CONNECTABLE(capture_wave_channel_run));
5211
5212 /* iterate */
5213 next_channel = ags_channel_next(channel);
5214
5215 g_object_unref(channel);
5216
5217 channel = next_channel;
5218 }
5219
5220 nth_channel = ags_channel_nth(channel,
5221 audio_channels - stop_audio_channel);
5222
5223 if(channel != NULL){
5224 g_object_unref(channel);
5225 }
5226
5227 channel = nth_channel;
5228 }
5229
5230 if(nth_channel != NULL){
5231 g_object_unref(nth_channel);
5232 }
5233 }
5234
5235 /* unref */
5236 if(start_output != NULL){
5237 g_object_unref(start_output);
5238 }
5239
5240 if(start_input != NULL){
5241 g_object_unref(start_input);
5242 }
5243
5244 if(start != NULL){
5245 g_object_unref(start);
5246 }
5247
5248 /* return instantiated recall */
5249 recall = g_list_reverse(recall);
5250 g_list_foreach(recall,
5251 (GFunc) g_object_ref,
5252 NULL);
5253
5254 return(recall);
5255 }
5256
5257 GList*
ags_recall_factory_create_play_dssi(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)5258 ags_recall_factory_create_play_dssi(AgsAudio *audio,
5259 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
5260 gchar *plugin_name,
5261 guint start_audio_channel, guint stop_audio_channel,
5262 guint start_pad, guint stop_pad,
5263 guint create_flags, guint recall_flags)
5264 {
5265 AgsPlayDssiAudio *play_dssi_audio;
5266 AgsPlayDssiAudioRun *play_dssi_audio_run;
5267 AgsPort *port;
5268
5269 GObject *output_soundcard;
5270
5271 GList *list_start, *list;
5272 GList *recall;
5273
5274 guint i, j;
5275
5276 GRecMutex *audio_mutex;
5277
5278 if(!AGS_IS_AUDIO(audio)){
5279 return(NULL);
5280 }
5281
5282 /* get audio mutex */
5283 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
5284
5285 /* get some fields */
5286 g_rec_mutex_lock(audio_mutex);
5287
5288 output_soundcard = audio->output_soundcard;
5289
5290 g_rec_mutex_unlock(audio_mutex);
5291
5292 /* list */
5293 recall = NULL;
5294
5295 /* play */
5296 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
5297 if(play_container == NULL){
5298 play_container = ags_recall_container_new();
5299 }
5300
5301 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
5302 ags_audio_add_recall_container(audio, (GObject *) play_container);
5303
5304 play_dssi_audio = (AgsPlayDssiAudio *) g_object_new(AGS_TYPE_PLAY_DSSI_AUDIO,
5305 "output-soundcard", output_soundcard,
5306 "audio", audio,
5307 "recall-container", play_container,
5308 NULL);
5309 ags_recall_set_flags((AgsRecall *) play_dssi_audio,
5310 (AGS_RECALL_TEMPLATE));
5311 ags_recall_set_ability_flags((AgsRecall *) play_dssi_audio,
5312 (AGS_SOUND_ABILITY_NOTATION |
5313 AGS_SOUND_ABILITY_MIDI));
5314 ags_recall_set_behaviour_flags((AgsRecall *) play_dssi_audio,
5315 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5316
5317 if((AGS_RECALL_FACTORY_BULK & create_flags) != 0){
5318 ags_recall_set_behaviour_flags((AgsRecall *) play_dssi_audio,
5319 (AGS_SOUND_BEHAVIOUR_BULK_MODE));
5320 }
5321
5322 ags_audio_add_recall(audio, (GObject *) play_dssi_audio, TRUE);
5323 recall = g_list_prepend(recall,
5324 play_dssi_audio);
5325
5326 g_object_set(play_container,
5327 "recall-audio", play_dssi_audio,
5328 NULL);
5329 ags_connectable_connect(AGS_CONNECTABLE(play_dssi_audio));
5330
5331 play_dssi_audio_run = (AgsPlayDssiAudioRun *) g_object_new(AGS_TYPE_PLAY_DSSI_AUDIO_RUN,
5332 "output-soundcard", output_soundcard,
5333 "recall-audio", play_dssi_audio,
5334 "recall-container", play_container,
5335 NULL);
5336 ags_recall_set_flags((AgsRecall *) play_dssi_audio_run,
5337 (AGS_RECALL_TEMPLATE));
5338 ags_recall_set_ability_flags((AgsRecall *) play_dssi_audio_run,
5339 (AGS_SOUND_ABILITY_NOTATION |
5340 AGS_SOUND_ABILITY_MIDI));
5341 ags_recall_set_behaviour_flags((AgsRecall *) play_dssi_audio_run,
5342 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5343
5344 ags_audio_add_recall(audio, (GObject *) play_dssi_audio_run, TRUE);
5345 recall = g_list_prepend(recall,
5346 play_dssi_audio_run);
5347
5348 g_object_set(play_container,
5349 "recall-audio-run", play_dssi_audio_run,
5350 NULL);
5351 ags_connectable_connect(AGS_CONNECTABLE(play_dssi_audio_run));
5352 }
5353
5354 /* recall */
5355 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
5356 if(recall_container == NULL){
5357 recall_container = ags_recall_container_new();
5358 }
5359
5360 ags_audio_add_recall_container(audio, (GObject *) recall_container);
5361
5362 play_dssi_audio = (AgsPlayDssiAudio *) g_object_new(AGS_TYPE_PLAY_DSSI_AUDIO,
5363 "output-soundcard", output_soundcard,
5364 "audio", audio,
5365 "recall-container", recall_container,
5366 NULL);
5367 ags_recall_set_flags((AgsRecall *) play_dssi_audio,
5368 (AGS_RECALL_TEMPLATE));
5369 ags_recall_set_ability_flags((AgsRecall *) play_dssi_audio,
5370 (AGS_SOUND_ABILITY_NOTATION |
5371 AGS_SOUND_ABILITY_MIDI));
5372 ags_recall_set_behaviour_flags((AgsRecall *) play_dssi_audio,
5373 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5374
5375 if((AGS_RECALL_FACTORY_BULK & create_flags) != 0){
5376 ags_recall_set_behaviour_flags((AgsRecall *) play_dssi_audio,
5377 (AGS_SOUND_BEHAVIOUR_BULK_MODE));
5378 }
5379
5380 ags_audio_add_recall(audio, (GObject *) play_dssi_audio, FALSE);
5381 recall = g_list_prepend(recall,
5382 play_dssi_audio);
5383
5384 g_object_set(recall_container,
5385 "recall-audio", play_dssi_audio,
5386 NULL);
5387 ags_connectable_connect(AGS_CONNECTABLE(play_dssi_audio));
5388
5389 play_dssi_audio_run = (AgsPlayDssiAudioRun *) g_object_new(AGS_TYPE_PLAY_DSSI_AUDIO_RUN,
5390 "output-soundcard", output_soundcard,
5391 "recall-audio", play_dssi_audio,
5392 "recall-container", recall_container,
5393 //TODO:JK: add missing dependency "delay-audio"
5394 NULL);
5395 ags_recall_set_flags((AgsRecall *) play_dssi_audio_run,
5396 (AGS_RECALL_TEMPLATE));
5397 ags_recall_set_ability_flags((AgsRecall *) play_dssi_audio_run,
5398 (AGS_SOUND_ABILITY_NOTATION |
5399 AGS_SOUND_ABILITY_MIDI));
5400 ags_recall_set_behaviour_flags((AgsRecall *) play_dssi_audio_run,
5401 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5402
5403 ags_audio_add_recall(audio, (GObject *) play_dssi_audio_run, FALSE);
5404 recall = g_list_prepend(recall,
5405 play_dssi_audio_run);
5406
5407 g_object_set(recall_container,
5408 "recall-audio-run", play_dssi_audio_run,
5409 NULL);
5410 ags_connectable_connect(AGS_CONNECTABLE(play_dssi_audio_run));
5411 }
5412
5413 /* return instantiated recall */
5414 recall = g_list_reverse(recall);
5415 g_list_foreach(recall,
5416 (GFunc) g_object_ref,
5417 NULL);
5418
5419 return(recall);
5420 }
5421
5422 GList*
ags_recall_factory_create_play_lv2(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)5423 ags_recall_factory_create_play_lv2(AgsAudio *audio,
5424 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
5425 gchar *plugin_name,
5426 guint start_audio_channel, guint stop_audio_channel,
5427 guint start_pad, guint stop_pad,
5428 guint create_flags, guint recall_flags)
5429 {
5430 AgsPlayLv2Audio *play_lv2_audio;
5431 AgsPlayLv2AudioRun *play_lv2_audio_run;
5432 AgsPort *port;
5433
5434 GObject *output_soundcard;
5435
5436 GList *list_start, *list;
5437 GList *recall;
5438
5439 guint i, j;
5440
5441 GRecMutex *audio_mutex;
5442
5443 if(!AGS_IS_AUDIO(audio)){
5444 return(NULL);
5445 }
5446
5447 /* get audio mutex */
5448 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
5449
5450 /* get some fields */
5451 g_rec_mutex_lock(audio_mutex);
5452
5453 output_soundcard = audio->output_soundcard;
5454
5455 g_rec_mutex_unlock(audio_mutex);
5456
5457 /* list */
5458 recall = NULL;
5459
5460 /* play */
5461 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
5462 if(play_container == NULL){
5463 play_container = ags_recall_container_new();
5464 }
5465
5466 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
5467 ags_audio_add_recall_container(audio, (GObject *) play_container);
5468
5469 play_lv2_audio = (AgsPlayLv2Audio *) g_object_new(AGS_TYPE_PLAY_LV2_AUDIO,
5470 "output-soundcard", output_soundcard,
5471 "audio", audio,
5472 "recall-container", play_container,
5473 NULL);
5474 ags_recall_set_flags((AgsRecall *) play_lv2_audio,
5475 (AGS_RECALL_TEMPLATE));
5476 ags_recall_set_ability_flags((AgsRecall *) play_lv2_audio,
5477 (AGS_SOUND_ABILITY_NOTATION |
5478 AGS_SOUND_ABILITY_MIDI));
5479 ags_recall_set_behaviour_flags((AgsRecall *) play_lv2_audio,
5480 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5481
5482 ags_audio_add_recall(audio, (GObject *) play_lv2_audio, TRUE);
5483 recall = g_list_prepend(recall,
5484 play_lv2_audio);
5485
5486 g_object_set(play_container,
5487 "recall-audio", play_lv2_audio,
5488 NULL);
5489 ags_connectable_connect(AGS_CONNECTABLE(play_lv2_audio));
5490
5491 play_lv2_audio_run = (AgsPlayLv2AudioRun *) g_object_new(AGS_TYPE_PLAY_LV2_AUDIO_RUN,
5492 "output-soundcard", output_soundcard,
5493 "recall-audio", play_lv2_audio,
5494 "recall-container", play_container,
5495 NULL);
5496 ags_recall_set_flags((AgsRecall *) play_lv2_audio_run,
5497 (AGS_RECALL_TEMPLATE));
5498 ags_recall_set_ability_flags((AgsRecall *) play_lv2_audio_run,
5499 (AGS_SOUND_ABILITY_NOTATION |
5500 AGS_SOUND_ABILITY_MIDI));
5501 ags_recall_set_behaviour_flags((AgsRecall *) play_lv2_audio_run,
5502 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5503
5504 if((AGS_RECALL_FACTORY_BULK & create_flags) != 0){
5505 ags_recall_set_behaviour_flags((AgsRecall *) play_lv2_audio,
5506 (AGS_SOUND_BEHAVIOUR_BULK_MODE));
5507 }
5508
5509 ags_audio_add_recall(audio, (GObject *) play_lv2_audio_run, TRUE);
5510 recall = g_list_prepend(recall,
5511 play_lv2_audio_run);
5512
5513 g_object_set(play_container,
5514 "recall-audio-run", play_lv2_audio_run,
5515 NULL);
5516 ags_connectable_connect(AGS_CONNECTABLE(play_lv2_audio_run));
5517 }
5518
5519 /* recall */
5520 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
5521 if(recall_container == NULL){
5522 recall_container = ags_recall_container_new();
5523 }
5524
5525 ags_audio_add_recall_container(audio, (GObject *) recall_container);
5526
5527 play_lv2_audio = (AgsPlayLv2Audio *) g_object_new(AGS_TYPE_PLAY_LV2_AUDIO,
5528 "output-soundcard", output_soundcard,
5529 "audio", audio,
5530 "recall-container", recall_container,
5531 NULL);
5532 ags_recall_set_flags((AgsRecall *) play_lv2_audio,
5533 (AGS_RECALL_TEMPLATE));
5534 ags_recall_set_ability_flags((AgsRecall *) play_lv2_audio,
5535 (AGS_SOUND_ABILITY_NOTATION |
5536 AGS_SOUND_ABILITY_MIDI));
5537 ags_recall_set_behaviour_flags((AgsRecall *) play_lv2_audio,
5538 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5539
5540 if((AGS_RECALL_FACTORY_BULK & create_flags) != 0){
5541 ags_recall_set_behaviour_flags((AgsRecall *) play_lv2_audio,
5542 (AGS_SOUND_BEHAVIOUR_BULK_MODE));
5543 }
5544
5545 ags_audio_add_recall(audio, (GObject *) play_lv2_audio, FALSE);
5546 recall = g_list_prepend(recall,
5547 play_lv2_audio);
5548
5549 g_object_set(recall_container,
5550 "recall-audio", play_lv2_audio,
5551 NULL);
5552 ags_connectable_connect(AGS_CONNECTABLE(play_lv2_audio));
5553
5554 play_lv2_audio_run = (AgsPlayLv2AudioRun *) g_object_new(AGS_TYPE_PLAY_LV2_AUDIO_RUN,
5555 "output-soundcard", output_soundcard,
5556 "recall-audio", play_lv2_audio,
5557 "recall-container", recall_container,
5558 //TODO:JK: add missing dependency "delay-audio"
5559 NULL);
5560 ags_recall_set_flags((AgsRecall *) play_lv2_audio_run,
5561 (AGS_RECALL_TEMPLATE));
5562 ags_recall_set_ability_flags((AgsRecall *) play_lv2_audio_run,
5563 (AGS_SOUND_ABILITY_NOTATION |
5564 AGS_SOUND_ABILITY_MIDI));
5565 ags_recall_set_behaviour_flags((AgsRecall *) play_lv2_audio_run,
5566 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5567
5568 ags_audio_add_recall(audio, (GObject *) play_lv2_audio_run, FALSE);
5569 recall = g_list_prepend(recall,
5570 play_lv2_audio_run);
5571
5572 g_object_set(recall_container,
5573 "recall-audio-run", play_lv2_audio_run,
5574 NULL);
5575 ags_connectable_connect(AGS_CONNECTABLE(play_lv2_audio_run));
5576 }
5577
5578 /* return instantiated recall */
5579 recall = g_list_reverse(recall);
5580 g_list_foreach(recall,
5581 (GFunc) g_object_ref,
5582 NULL);
5583
5584 return(recall);
5585 }
5586
5587 GList*
ags_recall_factory_create_play_notation(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)5588 ags_recall_factory_create_play_notation(AgsAudio *audio,
5589 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
5590 gchar *plugin_name,
5591 guint start_audio_channel, guint stop_audio_channel,
5592 guint start_pad, guint stop_pad,
5593 guint create_flags, guint recall_flags)
5594 {
5595 AgsPlayNotationAudio *play_notation_audio;
5596 AgsPlayNotationAudioRun *play_notation_audio_run;
5597 AgsPort *port;
5598
5599 GObject *output_soundcard;
5600
5601 GList *list_start, *list;
5602 GList *recall;
5603
5604 guint i, j;
5605
5606 GRecMutex *audio_mutex;
5607
5608 if(!AGS_IS_AUDIO(audio)){
5609 return(NULL);
5610 }
5611
5612 /* get audio mutex */
5613 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
5614
5615 /* get some fields */
5616 g_rec_mutex_lock(audio_mutex);
5617
5618 output_soundcard = audio->output_soundcard;
5619
5620 g_rec_mutex_unlock(audio_mutex);
5621
5622 /* list */
5623 recall = NULL;
5624
5625 /* play */
5626 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
5627 if(play_container == NULL){
5628 play_container = ags_recall_container_new();
5629 }
5630
5631 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
5632 ags_audio_add_recall_container(audio, (GObject *) play_container);
5633
5634 play_notation_audio = (AgsPlayNotationAudio *) g_object_new(AGS_TYPE_PLAY_NOTATION_AUDIO,
5635 "output-soundcard", output_soundcard,
5636 "audio", audio,
5637 "recall-container", play_container,
5638 NULL);
5639 ags_recall_set_flags((AgsRecall *) play_notation_audio,
5640 (AGS_RECALL_TEMPLATE));
5641 ags_recall_set_ability_flags((AgsRecall *) play_notation_audio,
5642 (AGS_SOUND_ABILITY_NOTATION |
5643 AGS_SOUND_ABILITY_MIDI));
5644 ags_recall_set_behaviour_flags((AgsRecall *) play_notation_audio,
5645 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5646
5647 ags_audio_add_recall(audio, (GObject *) play_notation_audio, TRUE);
5648 recall = g_list_prepend(recall,
5649 play_notation_audio);
5650
5651 g_object_set(play_container,
5652 "recall-audio", play_notation_audio,
5653 NULL);
5654 ags_connectable_connect(AGS_CONNECTABLE(play_notation_audio));
5655
5656 play_notation_audio_run = (AgsPlayNotationAudioRun *) g_object_new(AGS_TYPE_PLAY_NOTATION_AUDIO_RUN,
5657 "output-soundcard", output_soundcard,
5658 "recall-audio", play_notation_audio,
5659 "recall-container", play_container,
5660 NULL);
5661 ags_recall_set_flags((AgsRecall *) play_notation_audio_run,
5662 (AGS_RECALL_TEMPLATE));
5663 ags_recall_set_ability_flags((AgsRecall *) play_notation_audio_run,
5664 (AGS_SOUND_ABILITY_NOTATION |
5665 AGS_SOUND_ABILITY_MIDI));
5666 ags_recall_set_behaviour_flags((AgsRecall *) play_notation_audio_run,
5667 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5668
5669 ags_audio_add_recall(audio, (GObject *) play_notation_audio_run, TRUE);
5670 recall = g_list_prepend(recall,
5671 play_notation_audio_run);
5672
5673 g_object_set(play_container,
5674 "recall-audio-run", play_notation_audio_run,
5675 NULL);
5676 ags_connectable_connect(AGS_CONNECTABLE(play_notation_audio_run));
5677 }
5678
5679 /* recall */
5680 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
5681 if(recall_container == NULL){
5682 recall_container = ags_recall_container_new();
5683 }
5684
5685 ags_audio_add_recall_container(audio, (GObject *) recall_container);
5686
5687 play_notation_audio = (AgsPlayNotationAudio *) g_object_new(AGS_TYPE_PLAY_NOTATION_AUDIO,
5688 "output-soundcard", output_soundcard,
5689 "audio", audio,
5690 "recall-container", recall_container,
5691 NULL);
5692 ags_recall_set_flags((AgsRecall *) play_notation_audio,
5693 (AGS_RECALL_TEMPLATE));
5694 ags_recall_set_ability_flags((AgsRecall *) play_notation_audio,
5695 (AGS_SOUND_ABILITY_NOTATION |
5696 AGS_SOUND_ABILITY_MIDI));
5697 ags_recall_set_behaviour_flags((AgsRecall *) play_notation_audio,
5698 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5699
5700 ags_audio_add_recall(audio, (GObject *) play_notation_audio, FALSE);
5701 recall = g_list_prepend(recall,
5702 play_notation_audio);
5703
5704 g_object_set(recall_container,
5705 "recall-audio", play_notation_audio,
5706 NULL);
5707 ags_connectable_connect(AGS_CONNECTABLE(play_notation_audio));
5708
5709 play_notation_audio_run = (AgsPlayNotationAudioRun *) g_object_new(AGS_TYPE_PLAY_NOTATION_AUDIO_RUN,
5710 "output-soundcard", output_soundcard,
5711 "recall-audio", play_notation_audio,
5712 "recall-container", recall_container,
5713 //TODO:JK: add missing dependency "delay-audio"
5714 NULL);
5715 ags_recall_set_flags((AgsRecall *) play_notation_audio_run,
5716 (AGS_RECALL_TEMPLATE));
5717 ags_recall_set_ability_flags((AgsRecall *) play_notation_audio_run,
5718 (AGS_SOUND_ABILITY_NOTATION |
5719 AGS_SOUND_ABILITY_MIDI));
5720 ags_recall_set_behaviour_flags((AgsRecall *) play_notation_audio_run,
5721 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5722
5723 ags_audio_add_recall(audio, (GObject *) play_notation_audio_run, FALSE);
5724 recall = g_list_prepend(recall,
5725 play_notation_audio_run);
5726
5727 g_object_set(recall_container,
5728 "recall-audio-run", play_notation_audio_run,
5729 NULL);
5730 ags_connectable_connect(AGS_CONNECTABLE(play_notation_audio_run));
5731 }
5732
5733 /* return instantiated recall */
5734 recall = g_list_reverse(recall);
5735 g_list_foreach(recall,
5736 (GFunc) g_object_ref,
5737 NULL);
5738
5739 return(recall);
5740 }
5741
5742 GList*
ags_recall_factory_create_peak(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)5743 ags_recall_factory_create_peak(AgsAudio *audio,
5744 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
5745 gchar *plugin_name,
5746 guint start_audio_channel, guint stop_audio_channel,
5747 guint start_pad, guint stop_pad,
5748 guint create_flags, guint recall_flags)
5749 {
5750 AgsPeakChannel *peak_channel;
5751 AgsPeakChannelRun *peak_channel_run;
5752 AgsChannel *start_output, *start_input;
5753 AgsChannel *start, *channel, *next_channel, *nth_channel;
5754 AgsPort *port;
5755
5756 GObject *output_soundcard;
5757
5758 GList *list_start, *list;
5759 GList *recall;
5760
5761 guint audio_channels;
5762 guint i, j;
5763
5764 GRecMutex *audio_mutex;
5765
5766 if(!AGS_IS_AUDIO(audio)){
5767 return(NULL);
5768 }
5769
5770 /* get audio mutex */
5771 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
5772
5773 /* get some fields */
5774 g_rec_mutex_lock(audio_mutex);
5775
5776 output_soundcard = audio->output_soundcard;
5777
5778 audio_channels = audio->audio_channels;
5779
5780 start_output = audio->output;
5781
5782 if(start_output != NULL){
5783 g_object_ref(start_output);
5784 }
5785
5786 start_input = audio->input;
5787
5788 if(start_input != NULL){
5789 g_object_ref(start_input);
5790 }
5791
5792 g_rec_mutex_unlock(audio_mutex);
5793
5794 /* get channel */
5795 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
5796 start = ags_channel_nth(start_output,
5797 start_pad * audio_channels);
5798 }else{
5799 start = ags_channel_nth(start_input,
5800 start_pad * audio_channels);
5801 }
5802
5803 recall = NULL;
5804
5805 /* play */
5806 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
5807 channel = start;
5808
5809 if(channel != NULL){
5810 g_object_ref(channel);
5811 }
5812
5813 if(play_container == NULL){
5814 play_container = ags_recall_container_new();
5815 }
5816
5817 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
5818 ags_audio_add_recall_container(audio, (GObject *) play_container);
5819
5820 nth_channel = NULL;
5821
5822 for(i = 0; i < stop_pad - start_pad; i++){
5823 nth_channel = ags_channel_nth(channel,
5824 start_audio_channel);
5825
5826 g_object_unref(channel);
5827
5828 channel = nth_channel;
5829
5830 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
5831 /* add recall container */
5832 ags_channel_add_recall_container(channel,
5833 (GObject *) play_container);
5834
5835 /* AgsPeakChannel */
5836 peak_channel = (AgsPeakChannel *) g_object_new(AGS_TYPE_PEAK_CHANNEL,
5837 "output-soundcard", output_soundcard,
5838 "source", channel,
5839 "recall-container", play_container,
5840 NULL);
5841 ags_recall_set_flags((AgsRecall *) peak_channel,
5842 (AGS_RECALL_TEMPLATE));
5843 ags_recall_set_ability_flags((AgsRecall *) peak_channel,
5844 (AGS_SOUND_ABILITY_PLAYBACK |
5845 AGS_SOUND_ABILITY_NOTATION |
5846 AGS_SOUND_ABILITY_SEQUENCER |
5847 AGS_SOUND_ABILITY_MIDI |
5848 AGS_SOUND_ABILITY_WAVE));
5849 ags_recall_set_behaviour_flags((AgsRecall *) peak_channel,
5850 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5851
5852 ags_channel_add_recall(channel, (GObject *) peak_channel, TRUE);
5853 recall = g_list_prepend(recall,
5854 peak_channel);
5855
5856 g_object_set(play_container,
5857 "recall-channel", peak_channel,
5858 NULL);
5859 ags_connectable_connect(AGS_CONNECTABLE(peak_channel));
5860
5861 /* AgsPeakChannelRun */
5862 peak_channel_run = (AgsPeakChannelRun *) g_object_new(AGS_TYPE_PEAK_CHANNEL_RUN,
5863 "output-soundcard", output_soundcard,
5864 "recall-channel", peak_channel,
5865 "source", channel,
5866 "recall-container", play_container,
5867 NULL);
5868 ags_recall_set_flags((AgsRecall *) peak_channel_run,
5869 (AGS_RECALL_TEMPLATE));
5870 ags_recall_set_ability_flags((AgsRecall *) peak_channel_run,
5871 (AGS_SOUND_ABILITY_PLAYBACK |
5872 AGS_SOUND_ABILITY_NOTATION |
5873 AGS_SOUND_ABILITY_SEQUENCER |
5874 AGS_SOUND_ABILITY_MIDI |
5875 AGS_SOUND_ABILITY_WAVE));
5876 ags_recall_set_behaviour_flags((AgsRecall *) peak_channel_run,
5877 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5878
5879 ags_channel_add_recall(channel, (GObject *) peak_channel_run, TRUE);
5880 recall = g_list_prepend(recall,
5881 peak_channel_run);
5882
5883 g_object_set(play_container,
5884 "recall-channel-run", peak_channel_run,
5885 NULL);
5886 ags_connectable_connect(AGS_CONNECTABLE(peak_channel_run));
5887
5888 /* iterate */
5889 next_channel = ags_channel_next(channel);
5890
5891 g_object_unref(channel);
5892
5893 channel = next_channel;
5894 }
5895
5896 nth_channel = ags_channel_nth(channel,
5897 audio_channels - stop_audio_channel);
5898
5899 if(channel != NULL){
5900 g_object_unref(channel);
5901 }
5902
5903 channel = nth_channel;
5904 }
5905
5906 if(nth_channel != NULL){
5907 g_object_unref(nth_channel);
5908 }
5909 }
5910
5911 /* recall */
5912 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
5913 channel = start;
5914
5915 if(channel != NULL){
5916 g_object_ref(channel);
5917 }
5918
5919 if(recall_container == NULL){
5920 recall_container = ags_recall_container_new();
5921 }
5922
5923 ags_audio_add_recall_container(audio, (GObject *) recall_container);
5924
5925 nth_channel = NULL;
5926
5927 for(i = 0; i < stop_pad - start_pad; i++){
5928 nth_channel = ags_channel_nth(channel,
5929 start_audio_channel);
5930
5931 g_object_unref(channel);
5932
5933 channel = nth_channel;
5934
5935 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
5936 /* add recall container */
5937 ags_channel_add_recall_container(channel,
5938 (GObject *) recall_container);
5939
5940 /* AgsPeakChannel */
5941 peak_channel = (AgsPeakChannel *) g_object_new(AGS_TYPE_PEAK_CHANNEL,
5942 "output-soundcard", output_soundcard,
5943 "source", channel,
5944 "recall-container", recall_container,
5945 NULL);
5946 ags_recall_set_flags((AgsRecall *) peak_channel,
5947 (AGS_RECALL_TEMPLATE));
5948 ags_recall_set_ability_flags((AgsRecall *) peak_channel,
5949 (AGS_SOUND_ABILITY_PLAYBACK |
5950 AGS_SOUND_ABILITY_NOTATION |
5951 AGS_SOUND_ABILITY_SEQUENCER |
5952 AGS_SOUND_ABILITY_MIDI |
5953 AGS_SOUND_ABILITY_WAVE));
5954 ags_recall_set_behaviour_flags((AgsRecall *) peak_channel,
5955 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5956
5957 ags_channel_add_recall(channel, (GObject *) peak_channel, FALSE);
5958 recall = g_list_prepend(recall,
5959 peak_channel);
5960
5961 g_object_set(recall_container,
5962 "recall-channel", peak_channel,
5963 NULL);
5964 ags_connectable_connect(AGS_CONNECTABLE(peak_channel));
5965
5966 /* AgsPeakChannelRun */
5967 peak_channel_run = (AgsPeakChannelRun *) g_object_new(AGS_TYPE_PEAK_CHANNEL_RUN,
5968 "output-soundcard", output_soundcard,
5969 "recall-channel", peak_channel,
5970 "source", channel,
5971 "recall-container", recall_container,
5972 NULL);
5973 ags_recall_set_flags((AgsRecall *) peak_channel_run,
5974 (AGS_RECALL_TEMPLATE));
5975 ags_recall_set_ability_flags((AgsRecall *) peak_channel_run,
5976 (AGS_SOUND_ABILITY_PLAYBACK |
5977 AGS_SOUND_ABILITY_NOTATION |
5978 AGS_SOUND_ABILITY_SEQUENCER |
5979 AGS_SOUND_ABILITY_MIDI |
5980 AGS_SOUND_ABILITY_WAVE));
5981 ags_recall_set_behaviour_flags((AgsRecall *) peak_channel_run,
5982 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
5983
5984 ags_channel_add_recall(channel, (GObject *) peak_channel_run, FALSE);
5985 recall = g_list_prepend(recall,
5986 peak_channel_run);
5987
5988 g_object_set(recall_container,
5989 "recall-channel-run", peak_channel_run,
5990 NULL);
5991 ags_connectable_connect(AGS_CONNECTABLE(peak_channel_run));
5992
5993 /* iterate */
5994 next_channel = ags_channel_next(channel);
5995
5996 g_object_unref(channel);
5997
5998 channel = next_channel;
5999 }
6000
6001 nth_channel = ags_channel_nth(channel,
6002 audio_channels - stop_audio_channel);
6003
6004 if(channel != NULL){
6005 g_object_unref(channel);
6006 }
6007
6008 channel = nth_channel;
6009 }
6010
6011 if(nth_channel != NULL){
6012 g_object_unref(nth_channel);
6013 }
6014 }
6015
6016 /* unref */
6017 if(start_output != NULL){
6018 g_object_unref(start_output);
6019 }
6020
6021 if(start_input != NULL){
6022 g_object_unref(start_input);
6023 }
6024
6025 if(start != NULL){
6026 g_object_unref(start);
6027 }
6028
6029 /* return instantiated recall */
6030 recall = g_list_reverse(recall);
6031 g_list_foreach(recall,
6032 (GFunc) g_object_ref,
6033 NULL);
6034
6035 return(recall);
6036 }
6037
6038 GList*
ags_recall_factory_create_analyse(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)6039 ags_recall_factory_create_analyse(AgsAudio *audio,
6040 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
6041 gchar *plugin_name,
6042 guint start_audio_channel, guint stop_audio_channel,
6043 guint start_pad, guint stop_pad,
6044 guint create_flags, guint recall_flags)
6045 {
6046 AgsAnalyseChannel *analyse_channel;
6047 AgsAnalyseChannelRun *analyse_channel_run;
6048 AgsChannel *start_output, *start_input;
6049 AgsChannel *start, *channel, *next_channel, *nth_channel;
6050 AgsPort *port;
6051
6052 GObject *output_soundcard;
6053
6054 GList *list_start, *list;
6055 GList *recall;
6056
6057 guint audio_channels;
6058 guint i, j;
6059
6060 GRecMutex *audio_mutex;
6061
6062 if(!AGS_IS_AUDIO(audio)){
6063 return(NULL);
6064 }
6065
6066 /* get audio mutex */
6067 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
6068
6069 /* get some fields */
6070 g_rec_mutex_lock(audio_mutex);
6071
6072 output_soundcard = audio->output_soundcard;
6073
6074 audio_channels = audio->audio_channels;
6075
6076 start_output = audio->output;
6077
6078 if(start_output != NULL){
6079 g_object_ref(start_output);
6080 }
6081
6082 start_input = audio->input;
6083
6084 if(start_input != NULL){
6085 g_object_ref(start_input);
6086 }
6087
6088 g_rec_mutex_unlock(audio_mutex);
6089
6090 /* get channel */
6091 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
6092 start = ags_channel_nth(start_output,
6093 start_pad * audio_channels);
6094 }else{
6095 start = ags_channel_nth(start_input,
6096 start_pad * audio_channels);
6097 }
6098
6099 recall = NULL;
6100
6101 /* play */
6102 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
6103 channel = start;
6104
6105 if(channel != NULL){
6106 g_object_ref(channel);
6107 }
6108
6109 if(play_container == NULL){
6110 play_container = ags_recall_container_new();
6111 }
6112
6113 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
6114 ags_audio_add_recall_container(audio, (GObject *) play_container);
6115
6116 nth_channel = NULL;
6117
6118 for(i = 0; i < stop_pad - start_pad && channel != NULL; i++){
6119 nth_channel = ags_channel_nth(channel,
6120 start_audio_channel);
6121
6122 g_object_unref(channel);
6123
6124 channel = nth_channel;
6125
6126 for(j = 0; j < stop_audio_channel - start_audio_channel && channel != NULL; j++){
6127 /* add recall container */
6128 ags_channel_add_recall_container(channel,
6129 (GObject *) play_container);
6130
6131 /* AgsAnalyseChannel */
6132 analyse_channel = (AgsAnalyseChannel *) g_object_new(AGS_TYPE_ANALYSE_CHANNEL,
6133 "output-soundcard", output_soundcard,
6134 "source", channel,
6135 "recall-container", play_container,
6136 NULL);
6137 ags_recall_set_flags((AgsRecall *) analyse_channel,
6138 (AGS_RECALL_TEMPLATE));
6139 ags_recall_set_ability_flags((AgsRecall *) analyse_channel,
6140 (AGS_SOUND_ABILITY_PLAYBACK |
6141 AGS_SOUND_ABILITY_NOTATION |
6142 AGS_SOUND_ABILITY_SEQUENCER |
6143 AGS_SOUND_ABILITY_MIDI |
6144 AGS_SOUND_ABILITY_WAVE));
6145 ags_recall_set_behaviour_flags((AgsRecall *) analyse_channel,
6146 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6147
6148 ags_channel_add_recall(channel, (GObject *) analyse_channel, TRUE);
6149 recall = g_list_prepend(recall,
6150 analyse_channel);
6151
6152 g_object_set(play_container,
6153 "recall-channel", analyse_channel,
6154 NULL);
6155 ags_connectable_connect(AGS_CONNECTABLE(analyse_channel));
6156
6157 /* AgsAnalyseChannelRun */
6158 analyse_channel_run = (AgsAnalyseChannelRun *) g_object_new(AGS_TYPE_ANALYSE_CHANNEL_RUN,
6159 "output-soundcard", output_soundcard,
6160 "recall-channel", analyse_channel,
6161 "source", channel,
6162 "recall-container", play_container,
6163 NULL);
6164 ags_recall_set_flags((AgsRecall *) analyse_channel_run,
6165 (AGS_RECALL_TEMPLATE));
6166 ags_recall_set_ability_flags((AgsRecall *) analyse_channel_run,
6167 (AGS_SOUND_ABILITY_PLAYBACK |
6168 AGS_SOUND_ABILITY_NOTATION |
6169 AGS_SOUND_ABILITY_SEQUENCER |
6170 AGS_SOUND_ABILITY_MIDI |
6171 AGS_SOUND_ABILITY_WAVE));
6172 ags_recall_set_behaviour_flags((AgsRecall *) analyse_channel_run,
6173 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6174
6175 ags_channel_add_recall(channel, (GObject *) analyse_channel_run, TRUE);
6176 recall = g_list_prepend(recall,
6177 analyse_channel_run);
6178
6179 g_object_set(play_container,
6180 "recall-channel-run", analyse_channel_run,
6181 NULL);
6182 ags_connectable_connect(AGS_CONNECTABLE(analyse_channel_run));
6183
6184 /* iterate */
6185 next_channel = ags_channel_next(channel);
6186
6187 g_object_unref(channel);
6188
6189 channel = next_channel;
6190 }
6191
6192 nth_channel = ags_channel_nth(channel,
6193 audio_channels - stop_audio_channel);
6194
6195 if(channel != NULL){
6196 g_object_unref(channel);
6197 }
6198
6199 channel = nth_channel;
6200 }
6201
6202 if(nth_channel != NULL){
6203 g_object_unref(nth_channel);
6204 }
6205 }
6206
6207 /* recall */
6208 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
6209 channel = start;
6210
6211 if(channel != NULL){
6212 g_object_ref(channel);
6213 }
6214
6215 if(recall_container == NULL){
6216 recall_container = ags_recall_container_new();
6217 }
6218
6219 ags_audio_add_recall_container(audio, (GObject *) recall_container);
6220
6221 nth_channel = NULL;
6222
6223 for(i = 0; i < stop_pad - start_pad && channel != NULL; i++){
6224 nth_channel = ags_channel_nth(channel,
6225 start_audio_channel);
6226
6227 g_object_unref(channel);
6228
6229 channel = nth_channel;
6230
6231 for(j = 0; j < stop_audio_channel - start_audio_channel && channel != NULL; j++){
6232 /* add recall container */
6233 ags_channel_add_recall_container(channel,
6234 (GObject *) recall_container);
6235
6236 /* AgsAnalyseChannel */
6237 analyse_channel = (AgsAnalyseChannel *) g_object_new(AGS_TYPE_ANALYSE_CHANNEL,
6238 "output-soundcard", output_soundcard,
6239 "source", channel,
6240 "recall-container", recall_container,
6241 NULL);
6242 ags_recall_set_flags((AgsRecall *) analyse_channel,
6243 (AGS_RECALL_TEMPLATE));
6244 ags_recall_set_ability_flags((AgsRecall *) analyse_channel,
6245 (AGS_SOUND_ABILITY_PLAYBACK |
6246 AGS_SOUND_ABILITY_NOTATION |
6247 AGS_SOUND_ABILITY_SEQUENCER |
6248 AGS_SOUND_ABILITY_MIDI |
6249 AGS_SOUND_ABILITY_WAVE));
6250 ags_recall_set_behaviour_flags((AgsRecall *) analyse_channel,
6251 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6252
6253 ags_channel_add_recall(channel, (GObject *) analyse_channel, FALSE);
6254 recall = g_list_prepend(recall,
6255 analyse_channel);
6256
6257 g_object_set(recall_container,
6258 "recall-channel", analyse_channel,
6259 NULL);
6260 ags_connectable_connect(AGS_CONNECTABLE(analyse_channel));
6261
6262 /* AgsAnalyseChannelRun */
6263 analyse_channel_run = (AgsAnalyseChannelRun *) g_object_new(AGS_TYPE_ANALYSE_CHANNEL_RUN,
6264 "output-soundcard", output_soundcard,
6265 "recall-channel", analyse_channel,
6266 "source", channel,
6267 "recall-container", recall_container,
6268 NULL);
6269 ags_recall_set_flags((AgsRecall *) analyse_channel_run,
6270 (AGS_RECALL_TEMPLATE));
6271 ags_recall_set_ability_flags((AgsRecall *) analyse_channel_run,
6272 (AGS_SOUND_ABILITY_PLAYBACK |
6273 AGS_SOUND_ABILITY_NOTATION |
6274 AGS_SOUND_ABILITY_SEQUENCER |
6275 AGS_SOUND_ABILITY_MIDI |
6276 AGS_SOUND_ABILITY_WAVE));
6277 ags_recall_set_behaviour_flags((AgsRecall *) analyse_channel_run,
6278 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6279
6280 ags_channel_add_recall(channel, (GObject *) analyse_channel_run, FALSE);
6281 recall = g_list_prepend(recall,
6282 analyse_channel_run);
6283
6284 g_object_set(recall_container,
6285 "recall-channel-run", analyse_channel_run,
6286 NULL);
6287 ags_connectable_connect(AGS_CONNECTABLE(analyse_channel_run));
6288
6289 /* iterate */
6290 next_channel = ags_channel_next(channel);
6291
6292 g_object_unref(channel);
6293
6294 channel = next_channel;
6295 }
6296
6297 nth_channel = ags_channel_nth(channel,
6298 audio_channels - stop_audio_channel);
6299
6300 if(channel != NULL){
6301 g_object_unref(channel);
6302 }
6303
6304 channel = nth_channel;
6305 }
6306
6307 if(nth_channel != NULL){
6308 g_object_unref(nth_channel);
6309 }
6310 }
6311
6312 /* unref */
6313 if(start_output != NULL){
6314 g_object_unref(start_output);
6315 }
6316
6317 if(start_input != NULL){
6318 g_object_unref(start_input);
6319 }
6320
6321 if(start != NULL){
6322 g_object_unref(start);
6323 }
6324
6325 /* return instantiated recall */
6326 recall = g_list_reverse(recall);
6327 g_list_foreach(recall,
6328 (GFunc) g_object_ref,
6329 NULL);
6330
6331 return(recall);
6332 }
6333
6334 GList*
ags_recall_factory_create_mute(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)6335 ags_recall_factory_create_mute(AgsAudio *audio,
6336 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
6337 gchar *plugin_name,
6338 guint start_audio_channel, guint stop_audio_channel,
6339 guint start_pad, guint stop_pad,
6340 guint create_flags, guint recall_flags)
6341 {
6342 AgsMuteAudio *mute_audio;
6343 AgsMuteAudioRun *mute_audio_run;
6344 AgsMuteChannel *mute_channel;
6345 AgsMuteChannelRun *mute_channel_run;
6346 AgsChannel *start_output, *start_input;
6347 AgsChannel *start, *channel, *next_channel, *nth_channel;
6348 AgsPort *port;
6349
6350 GObject *output_soundcard;
6351
6352 GList *list_start, *list;
6353 GList *recall;
6354
6355 guint audio_channels;
6356 guint i, j;
6357
6358 GRecMutex *audio_mutex;
6359
6360 if(!AGS_IS_AUDIO(audio)){
6361 return(NULL);
6362 }
6363
6364 /* get audio mutex */
6365 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
6366
6367 /* get some fields */
6368 g_rec_mutex_lock(audio_mutex);
6369
6370 output_soundcard = audio->output_soundcard;
6371
6372 audio_channels = audio->audio_channels;
6373
6374 start_output = audio->output;
6375
6376 if(start_output != NULL){
6377 g_object_ref(start_output);
6378 }
6379
6380 start_input = audio->input;
6381
6382 if(start_input != NULL){
6383 g_object_ref(start_input);
6384 }
6385
6386 g_rec_mutex_unlock(audio_mutex);
6387
6388 /* get channel */
6389 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
6390 start = ags_channel_nth(start_output,
6391 start_pad * audio_channels);
6392 }else{
6393 start = ags_channel_nth(start_input,
6394 start_pad * audio_channels);
6395 }
6396
6397 recall = NULL;
6398
6399 /* play */
6400 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
6401 channel = start;
6402
6403 if(channel != NULL){
6404 g_object_ref(channel);
6405 }
6406
6407 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0){
6408 if(play_container == NULL){
6409 play_container = ags_recall_container_new();
6410 }
6411
6412 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
6413 ags_audio_add_recall_container(audio, (GObject *) play_container);
6414
6415 /* AgsMuteAudio */
6416 mute_audio = (AgsMuteAudio *) g_object_new(AGS_TYPE_MUTE_AUDIO,
6417 "output-soundcard", output_soundcard,
6418 "audio", audio,
6419 "recall-container", play_container,
6420 NULL);
6421 ags_recall_set_flags((AgsRecall *) mute_audio,
6422 (AGS_RECALL_TEMPLATE));
6423 ags_recall_set_ability_flags((AgsRecall *) mute_audio,
6424 (AGS_SOUND_ABILITY_PLAYBACK |
6425 AGS_SOUND_ABILITY_NOTATION |
6426 AGS_SOUND_ABILITY_SEQUENCER |
6427 AGS_SOUND_ABILITY_MIDI |
6428 AGS_SOUND_ABILITY_WAVE));
6429 ags_recall_set_behaviour_flags((AgsRecall *) mute_audio,
6430 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6431
6432 ags_audio_add_recall(audio, (GObject *) mute_audio, TRUE);
6433 recall = g_list_prepend(recall,
6434 mute_audio);
6435
6436 g_object_set(play_container,
6437 "recall-audio", mute_audio,
6438 NULL);
6439
6440 /* AgsMuteAudioRun */
6441 mute_audio_run = (AgsMuteAudioRun *) g_object_new(AGS_TYPE_MUTE_AUDIO_RUN,
6442 "output-soundcard", output_soundcard,
6443 // "recall-audio", mute_audio,
6444 "recall-container", play_container,
6445 //TODO:JK: add missing dependency "count_beats_audio_run"
6446 NULL);
6447 ags_recall_set_flags((AgsRecall *) mute_audio_run,
6448 (AGS_RECALL_TEMPLATE));
6449 ags_recall_set_ability_flags((AgsRecall *) mute_audio_run,
6450 (AGS_SOUND_ABILITY_PLAYBACK |
6451 AGS_SOUND_ABILITY_NOTATION |
6452 AGS_SOUND_ABILITY_SEQUENCER |
6453 AGS_SOUND_ABILITY_MIDI |
6454 AGS_SOUND_ABILITY_WAVE));
6455 ags_recall_set_behaviour_flags((AgsRecall *) mute_audio_run,
6456 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6457
6458 ags_audio_add_recall(audio, (GObject *) mute_audio_run, TRUE);
6459 recall = g_list_prepend(recall,
6460 mute_audio_run);
6461
6462 g_object_set(play_container,
6463 "recall-audio-run", mute_audio_run,
6464 NULL);
6465 }else{
6466 if(play_container == NULL){
6467 g_object_get(audio,
6468 "play", &list_start,
6469 NULL);
6470
6471 list = ags_recall_find_type(list_start,
6472 AGS_TYPE_MUTE_AUDIO);
6473 mute_audio = AGS_MUTE_AUDIO(list->data);
6474 g_list_free_full(list_start,
6475 g_object_unref);
6476
6477 recall = g_list_prepend(recall,
6478 mute_audio);
6479
6480 g_object_get(mute_audio,
6481 "recall-container", &play_container,
6482 NULL);
6483 g_object_unref(play_container);
6484 }else{
6485 g_object_get(play_container,
6486 "recall-audio", &mute_audio,
6487 NULL);
6488 g_object_unref(mute_audio);
6489
6490 recall = g_list_prepend(recall,
6491 mute_audio);
6492 }
6493 }
6494 }
6495
6496 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
6497 if(play_container == NULL){
6498 play_container = ags_recall_container_new();
6499 }
6500
6501 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
6502 ags_audio_add_recall_container(audio, (GObject *) play_container);
6503
6504 nth_channel = NULL;
6505
6506 for(i = 0; i < stop_pad - start_pad; i++){
6507 nth_channel = ags_channel_nth(channel,
6508 start_audio_channel);
6509
6510 g_object_unref(channel);
6511
6512 channel = nth_channel;
6513
6514 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
6515 /* add recall container */
6516 ags_channel_add_recall_container(channel,
6517 (GObject *) play_container);
6518
6519 /* AgsMuteChannel */
6520 mute_channel = (AgsMuteChannel *) g_object_new(AGS_TYPE_MUTE_CHANNEL,
6521 "output-soundcard", output_soundcard,
6522 "source", channel,
6523 "recall-container", play_container,
6524 NULL);
6525 ags_recall_set_flags((AgsRecall *) mute_channel,
6526 (AGS_RECALL_TEMPLATE));
6527 ags_recall_set_ability_flags((AgsRecall *) mute_channel,
6528 (AGS_SOUND_ABILITY_PLAYBACK |
6529 AGS_SOUND_ABILITY_NOTATION |
6530 AGS_SOUND_ABILITY_SEQUENCER |
6531 AGS_SOUND_ABILITY_MIDI |
6532 AGS_SOUND_ABILITY_WAVE));
6533 ags_recall_set_behaviour_flags((AgsRecall *) mute_channel,
6534 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6535
6536 ags_channel_add_recall(channel, (GObject *) mute_channel, TRUE);
6537 recall = g_list_prepend(recall,
6538 mute_channel);
6539
6540 g_object_set(play_container,
6541 "recall-channel", mute_channel,
6542 NULL);
6543 ags_connectable_connect(AGS_CONNECTABLE(mute_channel));
6544
6545 /* AgsMuteChannelRun */
6546 mute_channel_run = (AgsMuteChannelRun *) g_object_new(AGS_TYPE_MUTE_CHANNEL_RUN,
6547 "output-soundcard", output_soundcard,
6548 "recall-channel", mute_channel,
6549 "source", channel,
6550 "recall-container", play_container,
6551 NULL);
6552 ags_recall_set_flags((AgsRecall *) mute_channel_run,
6553 (AGS_RECALL_TEMPLATE));
6554 ags_recall_set_ability_flags((AgsRecall *) mute_channel_run,
6555 (AGS_SOUND_ABILITY_PLAYBACK |
6556 AGS_SOUND_ABILITY_NOTATION |
6557 AGS_SOUND_ABILITY_SEQUENCER |
6558 AGS_SOUND_ABILITY_MIDI |
6559 AGS_SOUND_ABILITY_WAVE));
6560 ags_recall_set_behaviour_flags((AgsRecall *) mute_channel_run,
6561 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6562
6563 ags_channel_add_recall(channel, (GObject *) mute_channel_run, TRUE);
6564 recall = g_list_prepend(recall,
6565 mute_channel_run);
6566
6567 g_object_set(play_container,
6568 "recall-channel-run", mute_channel_run,
6569 NULL);
6570 ags_connectable_connect(AGS_CONNECTABLE(mute_channel_run));
6571
6572 /* iterate */
6573 next_channel = ags_channel_next(channel);
6574
6575 g_object_unref(channel);
6576
6577 channel = next_channel;
6578 }
6579
6580 nth_channel = ags_channel_nth(channel,
6581 audio_channels - stop_audio_channel);
6582
6583 if(channel != NULL){
6584 g_object_unref(channel);
6585 }
6586
6587 channel = nth_channel;
6588 }
6589
6590 if(nth_channel != NULL){
6591 g_object_unref(nth_channel);
6592 }
6593 }
6594
6595 /* recall */
6596 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
6597 channel = start;
6598
6599 if(channel != NULL){
6600 g_object_ref(channel);
6601 }
6602
6603 if((AGS_RECALL_FACTORY_REMAP & (create_flags)) == 0){
6604 if(recall_container == NULL){
6605 recall_container = ags_recall_container_new();
6606 }
6607
6608 ags_audio_add_recall_container(audio, (GObject *) recall_container);
6609
6610 /* AgsMuteAudio */
6611 mute_audio = (AgsMuteAudio *) g_object_new(AGS_TYPE_MUTE_AUDIO,
6612 "output-soundcard", output_soundcard,
6613 "audio", audio,
6614 "recall-container", recall_container,
6615 NULL);
6616 ags_recall_set_flags((AgsRecall *) mute_audio,
6617 (AGS_RECALL_TEMPLATE));
6618 ags_recall_set_ability_flags((AgsRecall *) mute_audio,
6619 (AGS_SOUND_ABILITY_PLAYBACK |
6620 AGS_SOUND_ABILITY_NOTATION |
6621 AGS_SOUND_ABILITY_SEQUENCER |
6622 AGS_SOUND_ABILITY_MIDI |
6623 AGS_SOUND_ABILITY_WAVE));
6624 ags_recall_set_behaviour_flags((AgsRecall *) mute_audio,
6625 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6626
6627 ags_audio_add_recall(audio, (GObject *) mute_audio, FALSE);
6628 recall = g_list_prepend(recall,
6629 mute_audio);
6630
6631 g_object_set(recall_container,
6632 "recall-audio", mute_audio,
6633 NULL);
6634
6635 /* AgsMuteAudioRun */
6636 mute_audio_run = (AgsMuteAudioRun *) g_object_new(AGS_TYPE_MUTE_AUDIO_RUN,
6637 "output-soundcard", output_soundcard,
6638 // "recall-audio", mute_audio,
6639 "recall-container", recall_container,
6640 //TODO:JK: add missing dependency "count_beats_audio_run"
6641 NULL);
6642 ags_recall_set_flags((AgsRecall *) mute_audio_run,
6643 (AGS_RECALL_TEMPLATE));
6644 ags_recall_set_ability_flags((AgsRecall *) mute_audio_run,
6645 (AGS_SOUND_ABILITY_PLAYBACK |
6646 AGS_SOUND_ABILITY_NOTATION |
6647 AGS_SOUND_ABILITY_SEQUENCER |
6648 AGS_SOUND_ABILITY_MIDI |
6649 AGS_SOUND_ABILITY_WAVE));
6650 ags_recall_set_behaviour_flags((AgsRecall *) mute_audio_run,
6651 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6652
6653 ags_audio_add_recall(audio, (GObject *) mute_audio_run, FALSE);
6654 recall = g_list_prepend(recall,
6655 mute_audio_run);
6656
6657 g_object_set(recall_container,
6658 "recall-audio-run", mute_audio_run,
6659 NULL);
6660 }else{
6661 if(recall_container == NULL){
6662 g_object_get(audio,
6663 "recall", &list_start,
6664 NULL);
6665
6666 list = ags_recall_find_type(list_start,
6667 AGS_TYPE_MUTE_AUDIO);
6668 mute_audio = AGS_MUTE_AUDIO(list->data);
6669 g_list_free_full(list_start,
6670 g_object_unref);
6671
6672 recall = g_list_prepend(recall,
6673 mute_audio);
6674
6675 g_object_get(mute_audio,
6676 "recall-container", &recall_container,
6677 NULL);
6678 g_object_unref(recall_container);
6679 }else{
6680 g_object_get(recall_container,
6681 "recall-audio", &mute_audio,
6682 NULL);
6683 g_object_unref(mute_audio);
6684
6685 recall = g_list_prepend(recall,
6686 mute_audio);
6687 }
6688 }
6689
6690 nth_channel = NULL;
6691
6692 for(i = 0; i < stop_pad - start_pad; i++){
6693 nth_channel = ags_channel_nth(channel,
6694 start_audio_channel);
6695
6696 g_object_unref(channel);
6697
6698 channel = nth_channel;
6699
6700 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
6701 /* add recall container */
6702 ags_channel_add_recall_container(channel,
6703 (GObject *) recall_container);
6704
6705 /* AgsMuteChannel */
6706 mute_channel = (AgsMuteChannel *) g_object_new(AGS_TYPE_MUTE_CHANNEL,
6707 "output-soundcard", output_soundcard,
6708 "source", channel,
6709 "recall-container", recall_container,
6710 NULL);
6711 ags_recall_set_flags((AgsRecall *) mute_channel,
6712 (AGS_RECALL_TEMPLATE));
6713 ags_recall_set_ability_flags((AgsRecall *) mute_channel,
6714 (AGS_SOUND_ABILITY_PLAYBACK |
6715 AGS_SOUND_ABILITY_NOTATION |
6716 AGS_SOUND_ABILITY_SEQUENCER |
6717 AGS_SOUND_ABILITY_MIDI |
6718 AGS_SOUND_ABILITY_WAVE));
6719 ags_recall_set_behaviour_flags((AgsRecall *) mute_channel,
6720 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6721
6722 ags_channel_add_recall(channel, (GObject *) mute_channel, FALSE);
6723 recall = g_list_prepend(recall,
6724 mute_channel);
6725
6726 g_object_set(recall_container,
6727 "recall-channel", mute_channel,
6728 NULL);
6729 ags_connectable_connect(AGS_CONNECTABLE(mute_channel));
6730
6731 /* AgsMuteChannelRun */
6732 mute_channel_run = (AgsMuteChannelRun *) g_object_new(AGS_TYPE_MUTE_CHANNEL_RUN,
6733 "output-soundcard", output_soundcard,
6734 "recall-channel", mute_channel,
6735 "source", channel,
6736 "recall-container", recall_container,
6737 NULL);
6738 ags_recall_set_flags((AgsRecall *) mute_channel_run,
6739 (AGS_RECALL_TEMPLATE));
6740 ags_recall_set_ability_flags((AgsRecall *) mute_channel_run,
6741 (AGS_SOUND_ABILITY_PLAYBACK |
6742 AGS_SOUND_ABILITY_NOTATION |
6743 AGS_SOUND_ABILITY_SEQUENCER |
6744 AGS_SOUND_ABILITY_MIDI |
6745 AGS_SOUND_ABILITY_WAVE));
6746 ags_recall_set_behaviour_flags((AgsRecall *) mute_channel_run,
6747 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6748
6749 ags_channel_add_recall(channel, (GObject *) mute_channel_run, FALSE);
6750 recall = g_list_prepend(recall,
6751 mute_channel_run);
6752
6753 g_object_set(recall_container,
6754 "recall-channel-run", mute_channel_run,
6755 NULL);
6756 ags_connectable_connect(AGS_CONNECTABLE(mute_channel_run));
6757
6758 /* iterate */
6759 next_channel = ags_channel_next(channel);
6760
6761 g_object_unref(channel);
6762
6763 channel = next_channel;
6764 }
6765
6766 nth_channel = ags_channel_nth(channel,
6767 audio_channels - stop_audio_channel);
6768
6769 if(channel != NULL){
6770 g_object_unref(channel);
6771 }
6772
6773 channel = nth_channel;
6774 }
6775
6776 if(nth_channel != NULL){
6777 g_object_unref(nth_channel);
6778 }
6779 }
6780
6781 /* unref */
6782 if(start_output != NULL){
6783 g_object_unref(start_output);
6784 }
6785
6786 if(start_input != NULL){
6787 g_object_unref(start_input);
6788 }
6789
6790 if(start != NULL){
6791 g_object_unref(start);
6792 }
6793
6794 /* return instantiated recall */
6795 recall = g_list_reverse(recall);
6796 g_list_foreach(recall,
6797 (GFunc) g_object_ref,
6798 NULL);
6799
6800 return(recall);
6801 }
6802
6803 GList*
ags_recall_factory_create_volume(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)6804 ags_recall_factory_create_volume(AgsAudio *audio,
6805 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
6806 gchar *plugin_name,
6807 guint start_audio_channel, guint stop_audio_channel,
6808 guint start_pad, guint stop_pad,
6809 guint create_flags, guint recall_flags)
6810 {
6811 AgsVolumeChannel *volume_channel;
6812 AgsVolumeChannelRun *volume_channel_run;
6813 AgsChannel *start_output, *start_input;
6814 AgsChannel *start, *channel, *next_channel, *nth_channel;
6815 AgsPort *port;
6816
6817 GObject *output_soundcard;
6818
6819 GList *list_start, *list;
6820 GList *recall;
6821
6822 guint audio_channels;
6823 guint i, j;
6824
6825 GRecMutex *audio_mutex;
6826
6827 if(!AGS_IS_AUDIO(audio)){
6828 return(NULL);
6829 }
6830
6831 /* get audio mutex */
6832 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
6833
6834 /* get some fields */
6835 g_rec_mutex_lock(audio_mutex);
6836
6837 output_soundcard = audio->output_soundcard;
6838
6839 audio_channels = audio->audio_channels;
6840
6841 start_output = audio->output;
6842
6843 if(start_output != NULL){
6844 g_object_ref(start_output);
6845 }
6846
6847 start_input = audio->input;
6848
6849 if(start_input != NULL){
6850 g_object_ref(start_input);
6851 }
6852
6853 g_rec_mutex_unlock(audio_mutex);
6854
6855 /* get channel */
6856 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
6857 start = ags_channel_nth(start_output,
6858 start_pad * audio_channels);
6859 }else{
6860 start = ags_channel_nth(start_input,
6861 start_pad * audio_channels);
6862 }
6863
6864 recall = NULL;
6865
6866 /* play */
6867 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
6868 channel = start;
6869
6870 if(channel != NULL){
6871 g_object_ref(channel);
6872 }
6873
6874 if(play_container == NULL){
6875 play_container = ags_recall_container_new();
6876 }
6877
6878 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
6879 ags_audio_add_recall_container(audio, (GObject *) play_container);
6880
6881 nth_channel = NULL;
6882
6883 for(i = 0; i < stop_pad - start_pad; i++){
6884 nth_channel = ags_channel_nth(channel,
6885 start_audio_channel);
6886
6887 g_object_unref(channel);
6888
6889 channel = nth_channel;
6890
6891 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
6892 /* add recall container */
6893 ags_channel_add_recall_container(channel,
6894 (GObject *) play_container);
6895
6896 /* AgsVolumeChannel */
6897 volume_channel = (AgsVolumeChannel *) g_object_new(AGS_TYPE_VOLUME_CHANNEL,
6898 "output-soundcard", output_soundcard,
6899 "source", channel,
6900 "recall-container", play_container,
6901 NULL);
6902 ags_recall_set_flags((AgsRecall *) volume_channel,
6903 (AGS_RECALL_TEMPLATE));
6904 ags_recall_set_ability_flags((AgsRecall *) volume_channel,
6905 (AGS_SOUND_ABILITY_PLAYBACK |
6906 AGS_SOUND_ABILITY_NOTATION |
6907 AGS_SOUND_ABILITY_SEQUENCER |
6908 AGS_SOUND_ABILITY_MIDI |
6909 AGS_SOUND_ABILITY_WAVE));
6910 ags_recall_set_behaviour_flags((AgsRecall *) volume_channel,
6911 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6912
6913 ags_channel_add_recall(channel, (GObject *) volume_channel, TRUE);
6914 recall = g_list_prepend(recall,
6915 volume_channel);
6916
6917 g_object_set(play_container,
6918 "recall-channel", volume_channel,
6919 NULL);
6920 ags_connectable_connect(AGS_CONNECTABLE(volume_channel));
6921
6922 /* AgsVolumeChannelRun */
6923 volume_channel_run = (AgsVolumeChannelRun *) g_object_new(AGS_TYPE_VOLUME_CHANNEL_RUN,
6924 "output-soundcard", output_soundcard,
6925 "recall-channel", volume_channel,
6926 "source", channel,
6927 "recall-container", play_container,
6928 NULL);
6929 ags_recall_set_flags((AgsRecall *) volume_channel_run,
6930 (AGS_RECALL_TEMPLATE));
6931 ags_recall_set_ability_flags((AgsRecall *) volume_channel_run,
6932 (AGS_SOUND_ABILITY_PLAYBACK |
6933 AGS_SOUND_ABILITY_NOTATION |
6934 AGS_SOUND_ABILITY_SEQUENCER |
6935 AGS_SOUND_ABILITY_MIDI |
6936 AGS_SOUND_ABILITY_WAVE));
6937 ags_recall_set_behaviour_flags((AgsRecall *) volume_channel_run,
6938 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
6939
6940 ags_channel_add_recall(channel, (GObject *) volume_channel_run, TRUE);
6941 recall = g_list_prepend(recall,
6942 volume_channel_run);
6943
6944 g_object_set(play_container,
6945 "recall-channel-run", volume_channel_run,
6946 NULL);
6947 ags_connectable_connect(AGS_CONNECTABLE(volume_channel_run));
6948
6949 /* iterate */
6950 next_channel = ags_channel_next(channel);
6951
6952 g_object_unref(channel);
6953
6954 channel = next_channel;
6955 }
6956
6957 nth_channel = ags_channel_nth(channel,
6958 audio_channels - stop_audio_channel);
6959
6960 if(channel != NULL){
6961 g_object_unref(channel);
6962 }
6963
6964 channel = nth_channel;
6965 }
6966
6967 if(nth_channel != NULL){
6968 g_object_unref(nth_channel);
6969 }
6970 }
6971
6972 /* recall */
6973 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
6974 channel = start;
6975
6976 if(channel != NULL){
6977 g_object_ref(channel);
6978 }
6979
6980 if(recall_container == NULL){
6981 recall_container = ags_recall_container_new();
6982 }
6983
6984 ags_audio_add_recall_container(audio, (GObject *) recall_container);
6985
6986 nth_channel = NULL;
6987
6988 for(i = 0; i < stop_pad - start_pad; i++){
6989 nth_channel = ags_channel_nth(channel,
6990 start_audio_channel);
6991
6992 g_object_unref(channel);
6993
6994 channel = nth_channel;
6995
6996 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
6997 /* add recall container */
6998 ags_channel_add_recall_container(channel,
6999 (GObject *) recall_container);
7000
7001 /* AgsVolumeChannel */
7002 volume_channel = (AgsVolumeChannel *) g_object_new(AGS_TYPE_VOLUME_CHANNEL,
7003 "output-soundcard", output_soundcard,
7004 "source", channel,
7005 "recall-container", recall_container,
7006 NULL);
7007 ags_recall_set_flags((AgsRecall *) volume_channel,
7008 (AGS_RECALL_TEMPLATE));
7009 ags_recall_set_ability_flags((AgsRecall *) volume_channel,
7010 (AGS_SOUND_ABILITY_PLAYBACK |
7011 AGS_SOUND_ABILITY_NOTATION |
7012 AGS_SOUND_ABILITY_SEQUENCER |
7013 AGS_SOUND_ABILITY_MIDI |
7014 AGS_SOUND_ABILITY_WAVE));
7015 ags_recall_set_behaviour_flags((AgsRecall *) volume_channel,
7016 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7017
7018 ags_channel_add_recall(channel, (GObject *) volume_channel, FALSE);
7019 recall = g_list_prepend(recall,
7020 volume_channel);
7021
7022 g_object_set(recall_container,
7023 "recall-channel", volume_channel,
7024 NULL);
7025 ags_connectable_connect(AGS_CONNECTABLE(volume_channel));
7026
7027 /* AgsVolumeChannelRun */
7028 volume_channel_run = (AgsVolumeChannelRun *) g_object_new(AGS_TYPE_VOLUME_CHANNEL_RUN,
7029 "output-soundcard", output_soundcard,
7030 "recall-channel", volume_channel,
7031 "source", channel,
7032 "recall-container", recall_container,
7033 NULL);
7034 ags_recall_set_flags((AgsRecall *) volume_channel_run,
7035 (AGS_RECALL_TEMPLATE));
7036 ags_recall_set_ability_flags((AgsRecall *) volume_channel_run,
7037 (AGS_SOUND_ABILITY_PLAYBACK |
7038 AGS_SOUND_ABILITY_NOTATION |
7039 AGS_SOUND_ABILITY_SEQUENCER |
7040 AGS_SOUND_ABILITY_MIDI |
7041 AGS_SOUND_ABILITY_WAVE));
7042 ags_recall_set_behaviour_flags((AgsRecall *) volume_channel_run,
7043 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7044
7045 ags_channel_add_recall(channel, (GObject *) volume_channel_run, FALSE);
7046 recall = g_list_prepend(recall,
7047 volume_channel_run);
7048
7049 g_object_set(recall_container,
7050 "recall-channel-run", volume_channel_run,
7051 NULL);
7052 ags_connectable_connect(AGS_CONNECTABLE(volume_channel_run));
7053
7054 /* iterate */
7055 next_channel = ags_channel_next(channel);
7056
7057 g_object_unref(channel);
7058
7059 channel = next_channel;
7060 }
7061
7062 nth_channel = ags_channel_nth(channel,
7063 audio_channels - stop_audio_channel);
7064
7065 if(channel != NULL){
7066 g_object_unref(channel);
7067 }
7068
7069 channel = nth_channel;
7070 }
7071
7072 if(nth_channel != NULL){
7073 g_object_unref(nth_channel);
7074 }
7075 }
7076
7077 /* unref */
7078 if(start_output != NULL){
7079 g_object_unref(start_output);
7080 }
7081
7082 if(start_input != NULL){
7083 g_object_unref(start_input);
7084 }
7085
7086 if(start != NULL){
7087 g_object_unref(start);
7088 }
7089
7090 /* return instantiated recall */
7091 recall = g_list_reverse(recall);
7092 g_list_foreach(recall,
7093 (GFunc) g_object_ref,
7094 NULL);
7095
7096 return(recall);
7097 }
7098
7099 GList*
ags_recall_factory_create_eq10(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)7100 ags_recall_factory_create_eq10(AgsAudio *audio,
7101 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
7102 gchar *plugin_name,
7103 guint start_audio_channel, guint stop_audio_channel,
7104 guint start_pad, guint stop_pad,
7105 guint create_flags, guint recall_flags)
7106 {
7107 AgsEq10Channel *eq10_channel;
7108 AgsEq10ChannelRun *eq10_channel_run;
7109 AgsChannel *start_output, *start_input;
7110 AgsChannel *start, *channel, *next_channel, *nth_channel;
7111 AgsPort *port;
7112
7113 GObject *output_soundcard;
7114
7115 GList *list_start, *list;
7116 GList *recall;
7117
7118 guint audio_channels;
7119 guint i, j;
7120
7121 GRecMutex *audio_mutex;
7122
7123 if(!AGS_IS_AUDIO(audio)){
7124 return(NULL);
7125 }
7126
7127 /* get audio mutex */
7128 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
7129
7130 /* get some fields */
7131 g_rec_mutex_lock(audio_mutex);
7132
7133 output_soundcard = audio->output_soundcard;
7134
7135 audio_channels = audio->audio_channels;
7136
7137 start_output = audio->output;
7138
7139 if(start_output != NULL){
7140 g_object_ref(start_output);
7141 }
7142
7143 start_input = audio->input;
7144
7145 if(start_input != NULL){
7146 g_object_ref(start_input);
7147 }
7148
7149 g_rec_mutex_unlock(audio_mutex);
7150
7151 /* get channel */
7152 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
7153 start = ags_channel_nth(start_output,
7154 start_pad * audio_channels);
7155 }else{
7156 start = ags_channel_nth(start_input,
7157 start_pad * audio_channels);
7158 }
7159
7160 recall = NULL;
7161
7162 /* play */
7163 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
7164 channel = start;
7165
7166 if(channel != NULL){
7167 g_object_ref(channel);
7168 }
7169
7170 if(play_container == NULL){
7171 play_container = ags_recall_container_new();
7172 }
7173
7174 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
7175 ags_audio_add_recall_container(audio, (GObject *) play_container);
7176
7177 nth_channel = NULL;
7178
7179 for(i = 0; i < stop_pad - start_pad && channel != NULL; i++){
7180 nth_channel = ags_channel_nth(channel,
7181 start_audio_channel);
7182
7183 g_object_unref(channel);
7184
7185 channel = nth_channel;
7186
7187 for(j = 0; j < stop_audio_channel - start_audio_channel && channel != NULL; j++){
7188 /* add recall container */
7189 ags_channel_add_recall_container(channel,
7190 (GObject *) play_container);
7191
7192 /* AgsEq10Channel */
7193 eq10_channel = (AgsEq10Channel *) g_object_new(AGS_TYPE_EQ10_CHANNEL,
7194 "output-soundcard", output_soundcard,
7195 "source", channel,
7196 "recall-container", play_container,
7197 NULL);
7198 ags_recall_set_flags((AgsRecall *) eq10_channel,
7199 (AGS_RECALL_TEMPLATE));
7200 ags_recall_set_ability_flags((AgsRecall *) eq10_channel,
7201 (AGS_SOUND_ABILITY_PLAYBACK |
7202 AGS_SOUND_ABILITY_NOTATION |
7203 AGS_SOUND_ABILITY_SEQUENCER |
7204 AGS_SOUND_ABILITY_MIDI |
7205 AGS_SOUND_ABILITY_WAVE));
7206 ags_recall_set_behaviour_flags((AgsRecall *) eq10_channel,
7207 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7208
7209 ags_channel_add_recall(channel, (GObject *) eq10_channel, TRUE);
7210 recall = g_list_prepend(recall,
7211 eq10_channel);
7212
7213 g_object_set(play_container,
7214 "recall-channel", eq10_channel,
7215 NULL);
7216 ags_connectable_connect(AGS_CONNECTABLE(eq10_channel));
7217
7218 /* AgsEq10ChannelRun */
7219 eq10_channel_run = (AgsEq10ChannelRun *) g_object_new(AGS_TYPE_EQ10_CHANNEL_RUN,
7220 "output-soundcard", output_soundcard,
7221 "recall-channel", eq10_channel,
7222 "source", channel,
7223 "recall-container", play_container,
7224 NULL);
7225 ags_recall_set_flags((AgsRecall *) eq10_channel_run,
7226 (AGS_RECALL_TEMPLATE));
7227 ags_recall_set_ability_flags((AgsRecall *) eq10_channel_run,
7228 (AGS_SOUND_ABILITY_PLAYBACK |
7229 AGS_SOUND_ABILITY_NOTATION |
7230 AGS_SOUND_ABILITY_SEQUENCER |
7231 AGS_SOUND_ABILITY_MIDI |
7232 AGS_SOUND_ABILITY_WAVE));
7233 ags_recall_set_behaviour_flags((AgsRecall *) eq10_channel_run,
7234 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7235
7236 ags_channel_add_recall(channel, (GObject *) eq10_channel_run, TRUE);
7237 recall = g_list_prepend(recall,
7238 eq10_channel_run);
7239
7240 g_object_set(play_container,
7241 "recall-channel-run", eq10_channel_run,
7242 NULL);
7243 ags_connectable_connect(AGS_CONNECTABLE(eq10_channel_run));
7244
7245 /* iterate */
7246 next_channel = ags_channel_next(channel);
7247
7248 g_object_unref(channel);
7249
7250 channel = next_channel;
7251 }
7252
7253 nth_channel = ags_channel_nth(channel,
7254 audio_channels - stop_audio_channel);
7255
7256 if(channel != NULL){
7257 g_object_unref(channel);
7258 }
7259
7260 channel = nth_channel;
7261 }
7262
7263 if(nth_channel != NULL){
7264 g_object_unref(nth_channel);
7265 }
7266 }
7267
7268 /* recall */
7269 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
7270 channel = start;
7271
7272 if(channel != NULL){
7273 g_object_ref(channel);
7274 }
7275
7276 if(recall_container == NULL){
7277 recall_container = ags_recall_container_new();
7278 }
7279
7280 ags_audio_add_recall_container(audio, (GObject *) recall_container);
7281
7282 nth_channel = NULL;
7283
7284 for(i = 0; i < stop_pad - start_pad && channel != NULL; i++){
7285 nth_channel = ags_channel_nth(channel,
7286 start_audio_channel);
7287
7288 g_object_unref(channel);
7289
7290 channel = nth_channel;
7291
7292 for(j = 0; j < stop_audio_channel - start_audio_channel && channel != NULL; j++){
7293 /* add recall container */
7294 ags_channel_add_recall_container(channel,
7295 (GObject *) recall_container);
7296
7297 /* AgsEq10Channel */
7298 eq10_channel = (AgsEq10Channel *) g_object_new(AGS_TYPE_EQ10_CHANNEL,
7299 "output-soundcard", output_soundcard,
7300 "source", channel,
7301 "recall-container", recall_container,
7302 NULL);
7303 ags_recall_set_flags((AgsRecall *) eq10_channel,
7304 (AGS_RECALL_TEMPLATE));
7305 ags_recall_set_ability_flags((AgsRecall *) eq10_channel,
7306 (AGS_SOUND_ABILITY_PLAYBACK |
7307 AGS_SOUND_ABILITY_NOTATION |
7308 AGS_SOUND_ABILITY_SEQUENCER |
7309 AGS_SOUND_ABILITY_MIDI |
7310 AGS_SOUND_ABILITY_WAVE));
7311 ags_recall_set_behaviour_flags((AgsRecall *) eq10_channel,
7312 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7313
7314 ags_channel_add_recall(channel, (GObject *) eq10_channel, FALSE);
7315 recall = g_list_prepend(recall,
7316 eq10_channel);
7317
7318 g_object_set(recall_container,
7319 "recall-channel", eq10_channel,
7320 NULL);
7321 ags_connectable_connect(AGS_CONNECTABLE(eq10_channel));
7322
7323 /* AgsEq10ChannelRun */
7324 eq10_channel_run = (AgsEq10ChannelRun *) g_object_new(AGS_TYPE_EQ10_CHANNEL_RUN,
7325 "output-soundcard", output_soundcard,
7326 "recall-channel", eq10_channel,
7327 "source", channel,
7328 "recall-container", recall_container,
7329 NULL);
7330 ags_recall_set_flags((AgsRecall *) eq10_channel_run,
7331 (AGS_RECALL_TEMPLATE));
7332 ags_recall_set_ability_flags((AgsRecall *) eq10_channel_run,
7333 (AGS_SOUND_ABILITY_PLAYBACK |
7334 AGS_SOUND_ABILITY_NOTATION |
7335 AGS_SOUND_ABILITY_SEQUENCER |
7336 AGS_SOUND_ABILITY_MIDI |
7337 AGS_SOUND_ABILITY_WAVE));
7338 ags_recall_set_behaviour_flags((AgsRecall *) eq10_channel_run,
7339 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7340
7341 ags_channel_add_recall(channel, (GObject *) eq10_channel_run, FALSE);
7342 recall = g_list_prepend(recall,
7343 eq10_channel_run);
7344
7345 g_object_set(recall_container,
7346 "recall-channel-run", eq10_channel_run,
7347 NULL);
7348 ags_connectable_connect(AGS_CONNECTABLE(eq10_channel_run));
7349
7350 /* iterate */
7351 next_channel = ags_channel_next(channel);
7352
7353 g_object_unref(channel);
7354
7355 channel = next_channel;
7356 }
7357
7358 nth_channel = ags_channel_nth(channel,
7359 audio_channels - stop_audio_channel);
7360
7361 if(channel != NULL){
7362 g_object_unref(channel);
7363 }
7364
7365 channel = nth_channel;
7366 }
7367
7368 if(nth_channel != NULL){
7369 g_object_unref(nth_channel);
7370 }
7371 }
7372
7373 /* unref */
7374 if(start_output != NULL){
7375 g_object_unref(start_output);
7376 }
7377
7378 if(start_input != NULL){
7379 g_object_unref(start_input);
7380 }
7381
7382 if(start != NULL){
7383 g_object_unref(start);
7384 }
7385
7386 /* return instantiated recall */
7387 recall = g_list_reverse(recall);
7388 g_list_foreach(recall,
7389 (GFunc) g_object_ref,
7390 NULL);
7391
7392 return(recall);
7393 }
7394
7395 GList*
ags_recall_factory_create_envelope(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)7396 ags_recall_factory_create_envelope(AgsAudio *audio,
7397 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
7398 gchar *plugin_name,
7399 guint start_audio_channel, guint stop_audio_channel,
7400 guint start_pad, guint stop_pad,
7401 guint create_flags, guint recall_flags)
7402 {
7403 AgsEnvelopeChannel *envelope_channel;
7404 AgsEnvelopeChannelRun *envelope_channel_run;
7405 AgsChannel *start_output, *start_input;
7406 AgsChannel *start, *channel, *next_channel, *nth_channel;
7407 AgsPort *port;
7408
7409 GObject *output_soundcard;
7410
7411 GList *list_start, *list;
7412 GList *recall;
7413
7414 guint audio_channels;
7415 guint i, j;
7416
7417 GRecMutex *audio_mutex;
7418
7419 if(!AGS_IS_AUDIO(audio)){
7420 return(NULL);
7421 }
7422
7423 /* get audio mutex */
7424 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
7425
7426 /* get some fields */
7427 g_rec_mutex_lock(audio_mutex);
7428
7429 output_soundcard = audio->output_soundcard;
7430
7431 audio_channels = audio->audio_channels;
7432
7433 start_output = audio->output;
7434
7435 if(start_output != NULL){
7436 g_object_ref(start_output);
7437 }
7438
7439 start_input = audio->input;
7440
7441 if(start_input != NULL){
7442 g_object_ref(start_input);
7443 }
7444
7445 g_rec_mutex_unlock(audio_mutex);
7446
7447 /* get channel */
7448 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
7449 start = ags_channel_nth(start_output,
7450 start_pad * audio_channels);
7451 }else{
7452 start = ags_channel_nth(start_input,
7453 start_pad * audio_channels);
7454 }
7455
7456 recall = NULL;
7457
7458 /* play */
7459 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
7460 channel = start;
7461
7462 if(channel != NULL){
7463 g_object_ref(channel);
7464 }
7465
7466 if(play_container == NULL){
7467 play_container = ags_recall_container_new();
7468 }
7469
7470 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
7471 ags_audio_add_recall_container(audio, (GObject *) play_container);
7472
7473 nth_channel = NULL;
7474
7475 for(i = 0; i < stop_pad - start_pad; i++){
7476 nth_channel = ags_channel_nth(channel,
7477 start_audio_channel);
7478
7479 g_object_unref(channel);
7480
7481 channel = nth_channel;
7482
7483 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
7484 /* add recall container */
7485 ags_channel_add_recall_container(channel,
7486 (GObject *) play_container);
7487
7488 /* AgsEnvelopeChannel */
7489 envelope_channel = (AgsEnvelopeChannel *) g_object_new(AGS_TYPE_ENVELOPE_CHANNEL,
7490 "output-soundcard", output_soundcard,
7491 "source", channel,
7492 "recall-container", play_container,
7493 NULL);
7494 ags_recall_set_flags((AgsRecall *) envelope_channel,
7495 (AGS_RECALL_TEMPLATE));
7496 ags_recall_set_ability_flags((AgsRecall *) envelope_channel,
7497 (AGS_SOUND_ABILITY_PLAYBACK |
7498 AGS_SOUND_ABILITY_NOTATION |
7499 AGS_SOUND_ABILITY_SEQUENCER |
7500 AGS_SOUND_ABILITY_MIDI |
7501 AGS_SOUND_ABILITY_WAVE));
7502 ags_recall_set_behaviour_flags((AgsRecall *) envelope_channel,
7503 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7504
7505 ags_channel_add_recall(channel, (GObject *) envelope_channel, TRUE);
7506 recall = g_list_prepend(recall,
7507 envelope_channel);
7508
7509 g_object_set(play_container,
7510 "recall-channel", envelope_channel,
7511 NULL);
7512 ags_connectable_connect(AGS_CONNECTABLE(envelope_channel));
7513
7514 /* AgsEnvelopeChannelRun */
7515 envelope_channel_run = (AgsEnvelopeChannelRun *) g_object_new(AGS_TYPE_ENVELOPE_CHANNEL_RUN,
7516 "output-soundcard", output_soundcard,
7517 "recall-channel", envelope_channel,
7518 "source", channel,
7519 "recall-container", play_container,
7520 NULL);
7521 ags_recall_set_flags((AgsRecall *) envelope_channel_run,
7522 (AGS_RECALL_TEMPLATE));
7523 ags_recall_set_ability_flags((AgsRecall *) envelope_channel_run,
7524 (AGS_SOUND_ABILITY_PLAYBACK |
7525 AGS_SOUND_ABILITY_NOTATION |
7526 AGS_SOUND_ABILITY_SEQUENCER |
7527 AGS_SOUND_ABILITY_MIDI |
7528 AGS_SOUND_ABILITY_WAVE));
7529 ags_recall_set_behaviour_flags((AgsRecall *) envelope_channel_run,
7530 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7531
7532 ags_channel_add_recall(channel, (GObject *) envelope_channel_run, TRUE);
7533 recall = g_list_prepend(recall,
7534 envelope_channel_run);
7535
7536 g_object_set(play_container,
7537 "recall-channel-run", envelope_channel_run,
7538 NULL);
7539 ags_connectable_connect(AGS_CONNECTABLE(envelope_channel_run));
7540
7541 /* iterate */
7542 next_channel = ags_channel_next(channel);
7543
7544 g_object_unref(channel);
7545
7546 channel = next_channel;
7547 }
7548
7549 nth_channel = ags_channel_nth(channel,
7550 audio_channels - stop_audio_channel);
7551
7552 if(channel != NULL){
7553 g_object_unref(channel);
7554 }
7555
7556 channel = nth_channel;
7557 }
7558
7559 if(nth_channel != NULL){
7560 g_object_unref(nth_channel);
7561 }
7562 }
7563
7564 /* recall */
7565 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
7566 channel = start;
7567
7568 if(channel != NULL){
7569 g_object_ref(channel);
7570 }
7571
7572 if(recall_container == NULL){
7573 recall_container = ags_recall_container_new();
7574 }
7575
7576 ags_audio_add_recall_container(audio, (GObject *) recall_container);
7577
7578 nth_channel = NULL;
7579
7580 for(i = 0; i < stop_pad - start_pad; i++){
7581 nth_channel = ags_channel_nth(channel,
7582 start_audio_channel);
7583
7584 g_object_unref(channel);
7585
7586 channel = nth_channel;
7587
7588 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
7589 /* add recall container */
7590 ags_channel_add_recall_container(channel,
7591 (GObject *) recall_container);
7592
7593 /* AgsEnvelopeChannel */
7594 envelope_channel = (AgsEnvelopeChannel *) g_object_new(AGS_TYPE_ENVELOPE_CHANNEL,
7595 "output-soundcard", output_soundcard,
7596 "source", channel,
7597 "recall-container", recall_container,
7598 NULL);
7599 ags_recall_set_flags((AgsRecall *) envelope_channel,
7600 (AGS_RECALL_TEMPLATE));
7601 ags_recall_set_ability_flags((AgsRecall *) envelope_channel,
7602 (AGS_SOUND_ABILITY_PLAYBACK |
7603 AGS_SOUND_ABILITY_NOTATION |
7604 AGS_SOUND_ABILITY_SEQUENCER |
7605 AGS_SOUND_ABILITY_MIDI |
7606 AGS_SOUND_ABILITY_WAVE));
7607 ags_recall_set_behaviour_flags((AgsRecall *) envelope_channel,
7608 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7609
7610 ags_channel_add_recall(channel, (GObject *) envelope_channel, FALSE);
7611 recall = g_list_prepend(recall,
7612 envelope_channel);
7613
7614 g_object_set(recall_container,
7615 "recall-channel", envelope_channel,
7616 NULL);
7617 ags_connectable_connect(AGS_CONNECTABLE(envelope_channel));
7618
7619 /* AgsEnvelopeChannelRun */
7620 envelope_channel_run = (AgsEnvelopeChannelRun *) g_object_new(AGS_TYPE_ENVELOPE_CHANNEL_RUN,
7621 "output-soundcard", output_soundcard,
7622 "recall-channel", envelope_channel,
7623 "source", channel,
7624 "recall-container", recall_container,
7625 NULL);
7626 ags_recall_set_flags((AgsRecall *) envelope_channel_run,
7627 (AGS_RECALL_TEMPLATE));
7628 ags_recall_set_ability_flags((AgsRecall *) envelope_channel_run,
7629 (AGS_SOUND_ABILITY_PLAYBACK |
7630 AGS_SOUND_ABILITY_NOTATION |
7631 AGS_SOUND_ABILITY_SEQUENCER |
7632 AGS_SOUND_ABILITY_MIDI |
7633 AGS_SOUND_ABILITY_WAVE));
7634 ags_recall_set_behaviour_flags((AgsRecall *) envelope_channel_run,
7635 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7636
7637 ags_channel_add_recall(channel, (GObject *) envelope_channel_run, FALSE);
7638 recall = g_list_prepend(recall,
7639 envelope_channel_run);
7640
7641 g_object_set(recall_container,
7642 "recall-channel-run", envelope_channel_run,
7643 NULL);
7644 ags_connectable_connect(AGS_CONNECTABLE(envelope_channel_run));
7645
7646 /* iterate */
7647 next_channel = ags_channel_next(channel);
7648
7649 g_object_unref(channel);
7650
7651 channel = next_channel;
7652 }
7653
7654 nth_channel = ags_channel_nth(channel,
7655 audio_channels - stop_audio_channel);
7656
7657 if(channel != NULL){
7658 g_object_unref(channel);
7659 }
7660
7661 channel = nth_channel;
7662 }
7663
7664 if(nth_channel != NULL){
7665 g_object_unref(nth_channel);
7666 }
7667 }
7668
7669 /* unref */
7670 if(start_output != NULL){
7671 g_object_unref(start_output);
7672 }
7673
7674 if(start_input != NULL){
7675 g_object_unref(start_input);
7676 }
7677
7678 if(start != NULL){
7679 g_object_unref(start);
7680 }
7681
7682 /* return instantiated recall */
7683 recall = g_list_reverse(recall);
7684 g_list_foreach(recall,
7685 (GFunc) g_object_ref,
7686 NULL);
7687
7688 return(recall);
7689 }
7690
7691 GList*
ags_recall_factory_create_lfo(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)7692 ags_recall_factory_create_lfo(AgsAudio *audio,
7693 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
7694 gchar *plugin_name,
7695 guint start_audio_channel, guint stop_audio_channel,
7696 guint start_pad, guint stop_pad,
7697 guint create_flags, guint recall_flags)
7698 {
7699 AgsLfoChannel *lfo_channel;
7700 AgsLfoChannelRun *lfo_channel_run;
7701 AgsChannel *start_output, *start_input;
7702 AgsChannel *start, *channel, *next_channel, *nth_channel;
7703 AgsPort *port;
7704
7705 GObject *output_soundcard;
7706
7707 GList *list_start, *list;
7708 GList *recall;
7709
7710 guint audio_channels;
7711 guint i, j;
7712
7713 GRecMutex *audio_mutex;
7714
7715 if(!AGS_IS_AUDIO(audio)){
7716 return(NULL);
7717 }
7718
7719 /* get audio mutex */
7720 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
7721
7722 /* get some fields */
7723 g_rec_mutex_lock(audio_mutex);
7724
7725 output_soundcard = audio->output_soundcard;
7726
7727 audio_channels = audio->audio_channels;
7728
7729 start_output = audio->output;
7730
7731 if(start_output != NULL){
7732 g_object_ref(start_output);
7733 }
7734
7735 start_input = audio->input;
7736
7737 if(start_input != NULL){
7738 g_object_ref(start_input);
7739 }
7740
7741 g_rec_mutex_unlock(audio_mutex);
7742
7743 /* get channel */
7744 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
7745 start = ags_channel_nth(start_output,
7746 start_pad * audio_channels);
7747 }else{
7748 start = ags_channel_nth(start_input,
7749 start_pad * audio_channels);
7750 }
7751
7752 recall = NULL;
7753
7754 /* play */
7755 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
7756 channel = start;
7757
7758 if(channel != NULL){
7759 g_object_ref(channel);
7760 }
7761
7762 if(play_container == NULL){
7763 play_container = ags_recall_container_new();
7764 }
7765
7766 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
7767 ags_audio_add_recall_container(audio, (GObject *) play_container);
7768
7769 nth_channel = NULL;
7770
7771 for(i = 0; i < stop_pad - start_pad; i++){
7772 nth_channel = ags_channel_nth(channel,
7773 start_audio_channel);
7774
7775 g_object_unref(channel);
7776
7777 channel = nth_channel;
7778
7779 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
7780 /* add recall container */
7781 ags_channel_add_recall_container(channel,
7782 (GObject *) play_container);
7783
7784 /* AgsLfoChannel */
7785 lfo_channel = (AgsLfoChannel *) g_object_new(AGS_TYPE_LFO_CHANNEL,
7786 "output-soundcard", output_soundcard,
7787 "source", channel,
7788 "recall-container", play_container,
7789 NULL);
7790 ags_recall_set_flags((AgsRecall *) lfo_channel,
7791 (AGS_RECALL_TEMPLATE));
7792 ags_recall_set_ability_flags((AgsRecall *) lfo_channel,
7793 (AGS_SOUND_ABILITY_PLAYBACK |
7794 AGS_SOUND_ABILITY_NOTATION |
7795 AGS_SOUND_ABILITY_SEQUENCER |
7796 AGS_SOUND_ABILITY_MIDI |
7797 AGS_SOUND_ABILITY_WAVE));
7798 ags_recall_set_behaviour_flags((AgsRecall *) lfo_channel,
7799 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7800
7801 ags_channel_add_recall(channel, (GObject *) lfo_channel, TRUE);
7802 recall = g_list_prepend(recall,
7803 lfo_channel);
7804
7805 g_object_set(play_container,
7806 "recall-channel", lfo_channel,
7807 NULL);
7808 ags_connectable_connect(AGS_CONNECTABLE(lfo_channel));
7809
7810 /* AgsLfoChannelRun */
7811 lfo_channel_run = (AgsLfoChannelRun *) g_object_new(AGS_TYPE_LFO_CHANNEL_RUN,
7812 "output-soundcard", output_soundcard,
7813 "recall-channel", lfo_channel,
7814 "source", channel,
7815 "recall-container", play_container,
7816 NULL);
7817 ags_recall_set_flags((AgsRecall *) lfo_channel_run,
7818 (AGS_RECALL_TEMPLATE));
7819 ags_recall_set_ability_flags((AgsRecall *) lfo_channel_run,
7820 (AGS_SOUND_ABILITY_PLAYBACK |
7821 AGS_SOUND_ABILITY_NOTATION |
7822 AGS_SOUND_ABILITY_SEQUENCER |
7823 AGS_SOUND_ABILITY_MIDI |
7824 AGS_SOUND_ABILITY_WAVE));
7825 ags_recall_set_behaviour_flags((AgsRecall *) lfo_channel_run,
7826 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7827
7828 ags_channel_add_recall(channel, (GObject *) lfo_channel_run, TRUE);
7829 recall = g_list_prepend(recall,
7830 lfo_channel_run);
7831
7832 g_object_set(play_container,
7833 "recall-channel-run", lfo_channel_run,
7834 NULL);
7835 ags_connectable_connect(AGS_CONNECTABLE(lfo_channel_run));
7836
7837 /* iterate */
7838 next_channel = ags_channel_next(channel);
7839
7840 g_object_unref(channel);
7841
7842 channel = next_channel;
7843 }
7844
7845 nth_channel = ags_channel_nth(channel,
7846 audio_channels - stop_audio_channel);
7847
7848 if(channel != NULL){
7849 g_object_unref(channel);
7850 }
7851
7852 channel = nth_channel;
7853 }
7854
7855 if(nth_channel != NULL){
7856 g_object_unref(nth_channel);
7857 }
7858 }
7859
7860 /* recall */
7861 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
7862 channel = start;
7863
7864 if(channel != NULL){
7865 g_object_ref(channel);
7866 }
7867
7868 if(recall_container == NULL){
7869 recall_container = ags_recall_container_new();
7870 }
7871
7872 ags_audio_add_recall_container(audio, (GObject *) recall_container);
7873
7874 nth_channel = NULL;
7875
7876 for(i = 0; i < stop_pad - start_pad; i++){
7877 nth_channel = ags_channel_nth(channel,
7878 start_audio_channel);
7879
7880 g_object_unref(channel);
7881
7882 channel = nth_channel;
7883
7884 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
7885 /* add recall container */
7886 ags_channel_add_recall_container(channel,
7887 (GObject *) recall_container);
7888
7889 /* AgsLfoChannel */
7890 lfo_channel = (AgsLfoChannel *) g_object_new(AGS_TYPE_LFO_CHANNEL,
7891 "output-soundcard", output_soundcard,
7892 "source", channel,
7893 "recall-container", recall_container,
7894 NULL);
7895 ags_recall_set_flags((AgsRecall *) lfo_channel,
7896 (AGS_RECALL_TEMPLATE));
7897 ags_recall_set_ability_flags((AgsRecall *) lfo_channel,
7898 (AGS_SOUND_ABILITY_PLAYBACK |
7899 AGS_SOUND_ABILITY_NOTATION |
7900 AGS_SOUND_ABILITY_SEQUENCER |
7901 AGS_SOUND_ABILITY_MIDI |
7902 AGS_SOUND_ABILITY_WAVE));
7903 ags_recall_set_behaviour_flags((AgsRecall *) lfo_channel,
7904 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7905
7906 ags_channel_add_recall(channel, (GObject *) lfo_channel, FALSE);
7907 recall = g_list_prepend(recall,
7908 lfo_channel);
7909
7910 g_object_set(recall_container,
7911 "recall-channel", lfo_channel,
7912 NULL);
7913 ags_connectable_connect(AGS_CONNECTABLE(lfo_channel));
7914
7915 /* AgsLfoChannelRun */
7916 lfo_channel_run = (AgsLfoChannelRun *) g_object_new(AGS_TYPE_LFO_CHANNEL_RUN,
7917 "output-soundcard", output_soundcard,
7918 "recall-channel", lfo_channel,
7919 "source", channel,
7920 "recall-container", recall_container,
7921 NULL);
7922 ags_recall_set_flags((AgsRecall *) lfo_channel_run,
7923 (AGS_RECALL_TEMPLATE));
7924 ags_recall_set_ability_flags((AgsRecall *) lfo_channel_run,
7925 (AGS_SOUND_ABILITY_PLAYBACK |
7926 AGS_SOUND_ABILITY_NOTATION |
7927 AGS_SOUND_ABILITY_SEQUENCER |
7928 AGS_SOUND_ABILITY_MIDI |
7929 AGS_SOUND_ABILITY_WAVE));
7930 ags_recall_set_behaviour_flags((AgsRecall *) lfo_channel_run,
7931 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
7932
7933 ags_channel_add_recall(channel, (GObject *) lfo_channel_run, FALSE);
7934 recall = g_list_prepend(recall,
7935 lfo_channel_run);
7936
7937 g_object_set(recall_container,
7938 "recall-channel-run", lfo_channel_run,
7939 NULL);
7940 ags_connectable_connect(AGS_CONNECTABLE(lfo_channel_run));
7941
7942 /* iterate */
7943 next_channel = ags_channel_next(channel);
7944
7945 g_object_unref(channel);
7946
7947 channel = next_channel;
7948 }
7949
7950 nth_channel = ags_channel_nth(channel,
7951 audio_channels - stop_audio_channel);
7952
7953 if(channel != NULL){
7954 g_object_unref(channel);
7955 }
7956
7957 channel = nth_channel;
7958 }
7959
7960 if(nth_channel != NULL){
7961 g_object_unref(nth_channel);
7962 }
7963 }
7964
7965 /* unref */
7966 if(start_output != NULL){
7967 g_object_unref(start_output);
7968 }
7969
7970 if(start_input != NULL){
7971 g_object_unref(start_input);
7972 }
7973
7974 if(start != NULL){
7975 g_object_unref(start);
7976 }
7977
7978 /* return instantiated recall */
7979 recall = g_list_reverse(recall);
7980 g_list_foreach(recall,
7981 (GFunc) g_object_ref,
7982 NULL);
7983
7984 return(recall);
7985 }
7986
7987 GList*
ags_recall_factory_create_ladspa(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)7988 ags_recall_factory_create_ladspa(AgsAudio *audio,
7989 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
7990 gchar *plugin_name,
7991 guint start_audio_channel, guint stop_audio_channel,
7992 guint start_pad, guint stop_pad,
7993 guint create_flags, guint recall_flags)
7994 {
7995 AgsRecallLadspa *recall_ladspa;
7996 AgsGenericRecallChannelRun *generic_recall_channel_run;
7997 AgsChannel *start_output, *start_input;
7998 AgsChannel *start, *channel, *next_channel, *nth_channel;
7999 AgsPort *port;
8000
8001 GObject *output_soundcard;
8002
8003 GList *list_start, *list;
8004 GList *recall;
8005
8006 guint audio_channels;
8007 guint i, j;
8008
8009 GRecMutex *audio_mutex;
8010
8011 if(!AGS_IS_AUDIO(audio)){
8012 return(NULL);
8013 }
8014
8015 /* get audio mutex */
8016 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
8017
8018 /* get some fields */
8019 g_rec_mutex_lock(audio_mutex);
8020
8021 output_soundcard = audio->output_soundcard;
8022
8023 audio_channels = audio->audio_channels;
8024
8025 start_output = audio->output;
8026
8027 if(start_output != NULL){
8028 g_object_ref(start_output);
8029 }
8030
8031 start_input = audio->input;
8032
8033 if(start_input != NULL){
8034 g_object_ref(start_input);
8035 }
8036
8037 g_rec_mutex_unlock(audio_mutex);
8038
8039 /* get channel */
8040 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
8041 start = ags_channel_nth(start_output,
8042 start_pad * audio_channels);
8043 }else{
8044 start = ags_channel_nth(start_input,
8045 start_pad * audio_channels);
8046 }
8047
8048 recall = NULL;
8049
8050 /* play */
8051 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
8052 channel = start;
8053
8054 if(channel != NULL){
8055 g_object_ref(channel);
8056 }
8057
8058 if(play_container == NULL){
8059 play_container = ags_recall_container_new();
8060 }
8061
8062 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
8063 ags_audio_add_recall_container(audio, (GObject *) play_container);
8064
8065 nth_channel = NULL;
8066
8067 for(i = 0; i < stop_pad - start_pad; i++){
8068 nth_channel = ags_channel_nth(channel,
8069 start_audio_channel);
8070
8071 g_object_unref(channel);
8072
8073 channel = nth_channel;
8074
8075 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
8076 /* add recall container */
8077 ags_channel_add_recall_container(channel,
8078 (GObject *) play_container);
8079
8080 /* AgsRecallLadspa */
8081 recall_ladspa = (AgsRecallLadspa *) g_object_new(AGS_TYPE_RECALL_LADSPA,
8082 "output-soundcard", output_soundcard,
8083 "source", channel,
8084 "recall-container", play_container,
8085 NULL);
8086 ags_recall_set_flags((AgsRecall *) recall_ladspa,
8087 (AGS_RECALL_TEMPLATE));
8088 ags_recall_set_ability_flags((AgsRecall *) recall_ladspa,
8089 (AGS_SOUND_ABILITY_PLAYBACK |
8090 AGS_SOUND_ABILITY_NOTATION |
8091 AGS_SOUND_ABILITY_SEQUENCER |
8092 AGS_SOUND_ABILITY_MIDI));
8093 ags_recall_set_behaviour_flags((AgsRecall *) recall_ladspa,
8094 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8095
8096 ags_channel_add_recall(channel, (GObject *) recall_ladspa, TRUE);
8097 recall = g_list_prepend(recall,
8098 recall_ladspa);
8099
8100 g_object_set(play_container,
8101 "recall-channel", recall_ladspa,
8102 NULL);
8103 ags_connectable_connect(AGS_CONNECTABLE(recall_ladspa));
8104
8105 /* AgsGenericRecallChannelRun */
8106 generic_recall_channel_run = ags_generic_recall_channel_run_new(channel,
8107 AGS_TYPE_GENERIC_RECALL_RECYCLING,
8108 AGS_TYPE_RECALL_LADSPA_RUN);
8109
8110 g_object_set(generic_recall_channel_run,
8111 "output-soundcard", output_soundcard,
8112 // "recall-channel", recall_ladspa,
8113 "source", channel,
8114 "recall-container", play_container,
8115 NULL);
8116 ags_recall_set_flags((AgsRecall *) generic_recall_channel_run,
8117 (AGS_RECALL_TEMPLATE));
8118 ags_recall_set_ability_flags((AgsRecall *) generic_recall_channel_run,
8119 (AGS_SOUND_ABILITY_PLAYBACK |
8120 AGS_SOUND_ABILITY_NOTATION |
8121 AGS_SOUND_ABILITY_SEQUENCER |
8122 AGS_SOUND_ABILITY_MIDI));
8123 ags_recall_set_behaviour_flags((AgsRecall *) generic_recall_channel_run,
8124 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8125
8126 ags_channel_add_recall(channel, (GObject *) generic_recall_channel_run, TRUE);
8127 recall = g_list_prepend(recall,
8128 generic_recall_channel_run);
8129
8130 g_object_set(play_container,
8131 "recall-channel-run", generic_recall_channel_run,
8132 NULL);
8133 ags_connectable_connect(AGS_CONNECTABLE(generic_recall_channel_run));
8134
8135 /* iterate */
8136 next_channel = ags_channel_next(channel);
8137
8138 g_object_unref(channel);
8139
8140 channel = next_channel;
8141 }
8142
8143 nth_channel = ags_channel_nth(channel,
8144 audio_channels - stop_audio_channel);
8145
8146 if(channel != NULL){
8147 g_object_unref(channel);
8148 }
8149
8150 channel = nth_channel;
8151 }
8152
8153 if(nth_channel != NULL){
8154 g_object_unref(nth_channel);
8155 }
8156 }
8157
8158 /* recall */
8159 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
8160 channel = start;
8161
8162 if(channel != NULL){
8163 g_object_ref(channel);
8164 }
8165
8166 if(recall_container == NULL){
8167 recall_container = ags_recall_container_new();
8168 }
8169
8170 ags_audio_add_recall_container(audio, (GObject *) recall_container);
8171
8172 nth_channel = NULL;
8173
8174 for(i = 0; i < stop_pad - start_pad; i++){
8175 nth_channel = ags_channel_nth(channel,
8176 start_audio_channel);
8177
8178 g_object_unref(channel);
8179
8180 channel = nth_channel;
8181
8182 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
8183 /* add recall container */
8184 ags_channel_add_recall_container(channel,
8185 (GObject *) recall_container);
8186
8187 /* AgsRecallLadspa */
8188 recall_ladspa = (AgsRecallLadspa *) g_object_new(AGS_TYPE_RECALL_LADSPA,
8189 "output-soundcard", output_soundcard,
8190 "source", channel,
8191 "recall-container", recall_container,
8192 NULL);
8193 ags_recall_set_flags((AgsRecall *) recall_ladspa,
8194 (AGS_RECALL_TEMPLATE));
8195 ags_recall_set_ability_flags((AgsRecall *) recall_ladspa,
8196 (AGS_SOUND_ABILITY_PLAYBACK |
8197 AGS_SOUND_ABILITY_NOTATION |
8198 AGS_SOUND_ABILITY_SEQUENCER |
8199 AGS_SOUND_ABILITY_MIDI));
8200 ags_recall_set_behaviour_flags((AgsRecall *) recall_ladspa,
8201 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8202
8203 ags_channel_add_recall(channel, (GObject *) recall_ladspa, FALSE);
8204 recall = g_list_prepend(recall,
8205 recall_ladspa);
8206
8207 g_object_set(recall_container,
8208 "recall-channel-run", recall_ladspa,
8209 NULL);
8210 ags_connectable_connect(AGS_CONNECTABLE(recall_ladspa));
8211
8212 /* AgsGenericRecallChannelRun */
8213 generic_recall_channel_run = ags_generic_recall_channel_run_new(channel,
8214 AGS_TYPE_GENERIC_RECALL_RECYCLING,
8215 AGS_TYPE_RECALL_LADSPA_RUN);
8216 g_object_set(generic_recall_channel_run,
8217 "output-soundcard", output_soundcard,
8218 // "recall-channel", recall_ladspa,
8219 "source", channel,
8220 "recall-container", recall_container,
8221 NULL);
8222 ags_recall_set_flags((AgsRecall *) generic_recall_channel_run,
8223 (AGS_RECALL_TEMPLATE));
8224 ags_recall_set_ability_flags((AgsRecall *) generic_recall_channel_run,
8225 (AGS_SOUND_ABILITY_PLAYBACK |
8226 AGS_SOUND_ABILITY_NOTATION |
8227 AGS_SOUND_ABILITY_SEQUENCER |
8228 AGS_SOUND_ABILITY_MIDI));
8229 ags_recall_set_behaviour_flags((AgsRecall *) generic_recall_channel_run,
8230 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8231
8232 ags_channel_add_recall(channel, (GObject *) generic_recall_channel_run, FALSE);
8233 recall = g_list_prepend(recall,
8234 generic_recall_channel_run);
8235
8236 g_object_set(recall_container,
8237 "recall-channel-run", generic_recall_channel_run,
8238 NULL);
8239 ags_connectable_connect(AGS_CONNECTABLE(generic_recall_channel_run));
8240
8241 /* iterate */
8242 next_channel = ags_channel_next(channel);
8243
8244 g_object_unref(channel);
8245
8246 channel = next_channel;
8247 }
8248
8249 nth_channel = ags_channel_nth(channel,
8250 audio_channels - stop_audio_channel);
8251
8252 if(channel != NULL){
8253 g_object_unref(channel);
8254 }
8255
8256 channel = nth_channel;
8257 }
8258
8259 if(nth_channel != NULL){
8260 g_object_unref(nth_channel);
8261 }
8262 }
8263
8264 /* unref */
8265 if(start_output != NULL){
8266 g_object_unref(start_output);
8267 }
8268
8269 if(start_input != NULL){
8270 g_object_unref(start_input);
8271 }
8272
8273 if(start != NULL){
8274 g_object_unref(start);
8275 }
8276
8277 /* return instantiated recall */
8278 recall = g_list_reverse(recall);
8279 g_list_foreach(recall,
8280 (GFunc) g_object_ref,
8281 NULL);
8282
8283 return(recall);
8284 }
8285
8286 GList*
ags_recall_factory_create_lv2(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)8287 ags_recall_factory_create_lv2(AgsAudio *audio,
8288 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
8289 gchar *plugin_name,
8290 guint start_audio_channel, guint stop_audio_channel,
8291 guint start_pad, guint stop_pad,
8292 guint create_flags, guint recall_flags)
8293 {
8294 AgsRecallLv2 *recall_lv2;
8295 AgsGenericRecallChannelRun *generic_recall_channel_run;
8296 AgsChannel *start_output, *start_input;
8297 AgsChannel *start, *channel, *next_channel, *nth_channel;
8298 AgsPort *port;
8299
8300 GObject *output_soundcard;
8301
8302 GList *list_start, *list;
8303 GList *recall;
8304
8305 guint audio_channels;
8306 guint i, j;
8307
8308 GRecMutex *audio_mutex;
8309
8310 if(!AGS_IS_AUDIO(audio)){
8311 return(NULL);
8312 }
8313
8314 /* get audio mutex */
8315 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
8316
8317 /* get some fields */
8318 g_rec_mutex_lock(audio_mutex);
8319
8320 output_soundcard = audio->output_soundcard;
8321
8322 audio_channels = audio->audio_channels;
8323
8324 start_output = audio->output;
8325
8326 if(start_output != NULL){
8327 g_object_ref(start_output);
8328 }
8329
8330 start_input = audio->input;
8331
8332 if(start_input != NULL){
8333 g_object_ref(start_input);
8334 }
8335
8336 g_rec_mutex_unlock(audio_mutex);
8337
8338 /* get channel */
8339 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
8340 start = ags_channel_nth(start_output,
8341 start_pad * audio_channels);
8342 }else{
8343 start = ags_channel_nth(start_input,
8344 start_pad * audio_channels);
8345 }
8346
8347 recall = NULL;
8348
8349 /* play */
8350 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
8351 channel = start;
8352
8353 if(channel != NULL){
8354 g_object_ref(channel);
8355 }
8356
8357 if(play_container == NULL){
8358 play_container = ags_recall_container_new();
8359 }
8360
8361 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
8362 ags_audio_add_recall_container(audio, (GObject *) play_container);
8363
8364 nth_channel = NULL;
8365
8366 for(i = 0; i < stop_pad - start_pad; i++){
8367 nth_channel = ags_channel_nth(channel,
8368 start_audio_channel);
8369
8370 g_object_unref(channel);
8371
8372 channel = nth_channel;
8373
8374 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
8375 /* add recall container */
8376 ags_channel_add_recall_container(channel,
8377 (GObject *) play_container);
8378
8379 /* AgsRecallLv2 */
8380 recall_lv2 = (AgsRecallLv2 *) g_object_new(AGS_TYPE_RECALL_LV2,
8381 "output-soundcard", output_soundcard,
8382 "source", channel,
8383 "recall-container", play_container,
8384 NULL);
8385 ags_recall_set_flags((AgsRecall *) recall_lv2,
8386 (AGS_RECALL_TEMPLATE));
8387 ags_recall_set_ability_flags((AgsRecall *) recall_lv2,
8388 (AGS_SOUND_ABILITY_PLAYBACK |
8389 AGS_SOUND_ABILITY_NOTATION |
8390 AGS_SOUND_ABILITY_SEQUENCER |
8391 AGS_SOUND_ABILITY_MIDI));
8392 ags_recall_set_behaviour_flags((AgsRecall *) recall_lv2,
8393 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8394
8395 ags_channel_add_recall(channel, (GObject *) recall_lv2, TRUE);
8396 recall = g_list_prepend(recall,
8397 recall_lv2);
8398
8399 g_object_set(play_container,
8400 "recall-channel", recall_lv2,
8401 NULL);
8402 ags_connectable_connect(AGS_CONNECTABLE(recall_lv2));
8403
8404 /* AgsGenericRecallChannelRun */
8405 generic_recall_channel_run = ags_generic_recall_channel_run_new(channel,
8406 AGS_TYPE_GENERIC_RECALL_RECYCLING,
8407 AGS_TYPE_RECALL_LV2_RUN);
8408
8409 g_object_set(generic_recall_channel_run,
8410 "output-soundcard", output_soundcard,
8411 // "recall-channel", recall_lv2,
8412 "source", channel,
8413 "recall-container", play_container,
8414 NULL);
8415 ags_recall_set_flags((AgsRecall *) generic_recall_channel_run,
8416 (AGS_RECALL_TEMPLATE));
8417 ags_recall_set_ability_flags((AgsRecall *) generic_recall_channel_run,
8418 (AGS_SOUND_ABILITY_PLAYBACK |
8419 AGS_SOUND_ABILITY_NOTATION |
8420 AGS_SOUND_ABILITY_SEQUENCER |
8421 AGS_SOUND_ABILITY_MIDI));
8422 ags_recall_set_behaviour_flags((AgsRecall *) generic_recall_channel_run,
8423 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8424
8425 ags_channel_add_recall(channel, (GObject *) generic_recall_channel_run, TRUE);
8426 recall = g_list_prepend(recall,
8427 generic_recall_channel_run);
8428
8429 g_object_set(play_container,
8430 "recall-channel-run", generic_recall_channel_run,
8431 NULL);
8432 ags_connectable_connect(AGS_CONNECTABLE(generic_recall_channel_run));
8433
8434 /* iterate */
8435 next_channel = ags_channel_next(channel);
8436
8437 g_object_unref(channel);
8438
8439 channel = next_channel;
8440 }
8441
8442 nth_channel = ags_channel_nth(channel,
8443 audio_channels - stop_audio_channel);
8444
8445 if(channel != NULL){
8446 g_object_unref(channel);
8447 }
8448
8449 channel = nth_channel;
8450 }
8451
8452 if(nth_channel != NULL){
8453 g_object_unref(nth_channel);
8454 }
8455 }
8456
8457 /* recall */
8458 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
8459 channel = start;
8460
8461 if(channel != NULL){
8462 g_object_ref(channel);
8463 }
8464
8465 if(recall_container == NULL){
8466 recall_container = ags_recall_container_new();
8467 }
8468
8469 ags_audio_add_recall_container(audio, (GObject *) recall_container);
8470
8471 nth_channel = NULL;
8472
8473 for(i = 0; i < stop_pad - start_pad; i++){
8474 nth_channel = ags_channel_nth(channel,
8475 start_audio_channel);
8476
8477 g_object_unref(channel);
8478
8479 channel = nth_channel;
8480
8481 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
8482 /* add recall container */
8483 ags_channel_add_recall_container(channel,
8484 (GObject *) recall_container);
8485
8486 /* AgsRecallLv2 */
8487 recall_lv2 = (AgsRecallLv2 *) g_object_new(AGS_TYPE_RECALL_LV2,
8488 "output-soundcard", output_soundcard,
8489 "source", channel,
8490 "recall-container", recall_container,
8491 NULL);
8492 ags_recall_set_flags((AgsRecall *) recall_lv2,
8493 (AGS_RECALL_TEMPLATE));
8494 ags_recall_set_ability_flags((AgsRecall *) recall_lv2,
8495 (AGS_SOUND_ABILITY_PLAYBACK |
8496 AGS_SOUND_ABILITY_NOTATION |
8497 AGS_SOUND_ABILITY_SEQUENCER |
8498 AGS_SOUND_ABILITY_MIDI));
8499 ags_recall_set_behaviour_flags((AgsRecall *) recall_lv2,
8500 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8501
8502 ags_channel_add_recall(channel, (GObject *) recall_lv2, FALSE);
8503 recall = g_list_prepend(recall,
8504 recall_lv2);
8505
8506 g_object_set(recall_container,
8507 "recall-channel", recall_lv2,
8508 NULL);
8509 ags_connectable_connect(AGS_CONNECTABLE(recall_lv2));
8510
8511 /* AgsGenericRecallChannelRun */
8512 generic_recall_channel_run = ags_generic_recall_channel_run_new(channel,
8513 AGS_TYPE_GENERIC_RECALL_RECYCLING,
8514 AGS_TYPE_RECALL_LV2_RUN);
8515 g_object_set(generic_recall_channel_run,
8516 "output-soundcard", output_soundcard,
8517 // "recall-channel", recall_lv2,
8518 "source", channel,
8519 "recall-container", recall_container,
8520 NULL);
8521 ags_recall_set_flags((AgsRecall *) generic_recall_channel_run,
8522 (AGS_RECALL_TEMPLATE));
8523 ags_recall_set_ability_flags((AgsRecall *) generic_recall_channel_run,
8524 (AGS_SOUND_ABILITY_PLAYBACK |
8525 AGS_SOUND_ABILITY_NOTATION |
8526 AGS_SOUND_ABILITY_SEQUENCER |
8527 AGS_SOUND_ABILITY_MIDI));
8528 ags_recall_set_behaviour_flags((AgsRecall *) generic_recall_channel_run,
8529 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8530
8531 ags_channel_add_recall(channel, (GObject *) generic_recall_channel_run, FALSE);
8532 recall = g_list_prepend(recall,
8533 generic_recall_channel_run);
8534
8535 g_object_set(recall_container,
8536 "recall-channel-run", generic_recall_channel_run,
8537 NULL);
8538 ags_connectable_connect(AGS_CONNECTABLE(generic_recall_channel_run));
8539
8540 /* iterate */
8541 next_channel = ags_channel_next(channel);
8542
8543 g_object_unref(channel);
8544
8545 channel = next_channel;
8546 }
8547
8548 nth_channel = ags_channel_nth(channel,
8549 audio_channels - stop_audio_channel);
8550
8551 if(channel != NULL){
8552 g_object_unref(channel);
8553 }
8554
8555 channel = nth_channel;
8556 }
8557
8558 if(nth_channel != NULL){
8559 g_object_unref(nth_channel);
8560 }
8561 }
8562
8563 /* unref */
8564 if(start_output != NULL){
8565 g_object_unref(start_output);
8566 }
8567
8568 if(start_input != NULL){
8569 g_object_unref(start_input);
8570 }
8571
8572 if(start != NULL){
8573 g_object_unref(start);
8574 }
8575
8576 /* return instantiated recall */
8577 recall = g_list_reverse(recall);
8578 g_list_foreach(recall,
8579 (GFunc) g_object_ref,
8580 NULL);
8581
8582 return(recall);
8583 }
8584
8585 GList*
ags_recall_factory_create_dssi(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)8586 ags_recall_factory_create_dssi(AgsAudio *audio,
8587 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
8588 gchar *plugin_name,
8589 guint start_audio_channel, guint stop_audio_channel,
8590 guint start_pad, guint stop_pad,
8591 guint create_flags, guint recall_flags)
8592 {
8593 AgsRecallDssi *recall_dssi;
8594 AgsGenericRecallChannelRun *generic_recall_channel_run;
8595 AgsChannel *start_output, *start_input;
8596 AgsChannel *start, *channel, *next_channel, *nth_channel;
8597 AgsPort *port;
8598
8599 GObject *output_soundcard;
8600
8601 GList *list_start, *list;
8602 GList *recall;
8603
8604 guint audio_channels;
8605 guint i, j;
8606
8607 GRecMutex *audio_mutex;
8608
8609 if(!AGS_IS_AUDIO(audio)){
8610 return(NULL);
8611 }
8612
8613 /* get audio mutex */
8614 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
8615
8616 /* get some fields */
8617 g_rec_mutex_lock(audio_mutex);
8618
8619 output_soundcard = audio->output_soundcard;
8620
8621 audio_channels = audio->audio_channels;
8622
8623 start_output = audio->output;
8624
8625 if(start_output != NULL){
8626 g_object_ref(start_output);
8627 }
8628
8629 start_input = audio->input;
8630
8631 if(start_input != NULL){
8632 g_object_ref(start_input);
8633 }
8634
8635 g_rec_mutex_unlock(audio_mutex);
8636
8637 /* get channel */
8638 if((AGS_RECALL_FACTORY_OUTPUT & (create_flags)) != 0){
8639 start = ags_channel_nth(start_output,
8640 start_pad * audio_channels);
8641 }else{
8642 start = ags_channel_nth(start_input,
8643 start_pad * audio_channels);
8644 }
8645
8646 recall = NULL;
8647
8648 /* play */
8649 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
8650 channel = start;
8651
8652 if(channel != NULL){
8653 g_object_ref(channel);
8654 }
8655
8656 if(play_container == NULL){
8657 play_container = ags_recall_container_new();
8658 }
8659
8660 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
8661 ags_audio_add_recall_container(audio, (GObject *) play_container);
8662
8663 nth_channel = NULL;
8664
8665 for(i = 0; i < stop_pad - start_pad; i++){
8666 nth_channel = ags_channel_nth(channel,
8667 start_audio_channel);
8668
8669 g_object_unref(channel);
8670
8671 channel = nth_channel;
8672
8673 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
8674 /* add recall container */
8675 ags_channel_add_recall_container(channel,
8676 (GObject *) play_container);
8677
8678 /* AgsRecallDssi */
8679 recall_dssi = (AgsRecallDssi *) g_object_new(AGS_TYPE_RECALL_DSSI,
8680 "output-soundcard", output_soundcard,
8681 "source", channel,
8682 "recall-container", play_container,
8683 NULL);
8684 ags_recall_set_flags((AgsRecall *) recall_dssi,
8685 (AGS_RECALL_TEMPLATE));
8686 ags_recall_set_ability_flags((AgsRecall *) recall_dssi,
8687 (AGS_SOUND_ABILITY_PLAYBACK |
8688 AGS_SOUND_ABILITY_NOTATION |
8689 AGS_SOUND_ABILITY_SEQUENCER |
8690 AGS_SOUND_ABILITY_MIDI));
8691 ags_recall_set_behaviour_flags((AgsRecall *) recall_dssi,
8692 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8693
8694 ags_channel_add_recall(channel, (GObject *) recall_dssi, TRUE);
8695 recall = g_list_prepend(recall,
8696 recall_dssi);
8697
8698 g_object_set(play_container,
8699 "recall-channel", recall_dssi,
8700 NULL);
8701 ags_connectable_connect(AGS_CONNECTABLE(recall_dssi));
8702
8703 /* AgsGenericRecallChannelRun */
8704 generic_recall_channel_run = ags_generic_recall_channel_run_new(channel,
8705 AGS_TYPE_GENERIC_RECALL_RECYCLING,
8706 AGS_TYPE_RECALL_DSSI_RUN);
8707
8708 g_object_set(generic_recall_channel_run,
8709 "output-soundcard", output_soundcard,
8710 // "recall-channel", recall_dssi,
8711 "source", channel,
8712 "recall-container", play_container,
8713 NULL);
8714 ags_recall_set_flags((AgsRecall *) generic_recall_channel_run,
8715 (AGS_RECALL_TEMPLATE));
8716 ags_recall_set_ability_flags((AgsRecall *) generic_recall_channel_run,
8717 (AGS_SOUND_ABILITY_PLAYBACK |
8718 AGS_SOUND_ABILITY_NOTATION |
8719 AGS_SOUND_ABILITY_SEQUENCER |
8720 AGS_SOUND_ABILITY_MIDI));
8721 ags_recall_set_behaviour_flags((AgsRecall *) generic_recall_channel_run,
8722 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8723
8724 ags_channel_add_recall(channel, (GObject *) generic_recall_channel_run, TRUE);
8725 recall = g_list_prepend(recall,
8726 generic_recall_channel_run);
8727
8728 g_object_set(play_container,
8729 "recall-channel-run", generic_recall_channel_run,
8730 NULL);
8731 ags_connectable_connect(AGS_CONNECTABLE(generic_recall_channel_run));
8732
8733 /* iterate */
8734 next_channel = ags_channel_next(channel);
8735
8736 g_object_unref(channel);
8737
8738 channel = next_channel;
8739 }
8740
8741 nth_channel = ags_channel_nth(channel,
8742 audio_channels - stop_audio_channel);
8743
8744 if(channel != NULL){
8745 g_object_unref(channel);
8746 }
8747
8748 channel = nth_channel;
8749 }
8750
8751 if(nth_channel != NULL){
8752 g_object_unref(nth_channel);
8753 }
8754 }
8755
8756 /* recall */
8757 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
8758 channel = start;
8759
8760 if(channel != NULL){
8761 g_object_ref(channel);
8762 }
8763
8764 if(recall_container == NULL){
8765 recall_container = ags_recall_container_new();
8766 }
8767
8768 ags_audio_add_recall_container(audio, (GObject *) recall_container);
8769
8770 nth_channel = NULL;
8771
8772 for(i = 0; i < stop_pad - start_pad; i++){
8773 nth_channel = ags_channel_nth(channel,
8774 start_audio_channel);
8775
8776 g_object_unref(channel);
8777
8778 channel = nth_channel;
8779
8780 for(j = 0; j < stop_audio_channel - start_audio_channel; j++){
8781 /* add recall container */
8782 ags_channel_add_recall_container(channel,
8783 (GObject *) recall_container);
8784
8785 /* AgsRecallDssi */
8786 recall_dssi = (AgsRecallDssi *) g_object_new(AGS_TYPE_RECALL_DSSI,
8787 "output-soundcard", output_soundcard,
8788 "source", channel,
8789 "recall-container", recall_container,
8790 NULL);
8791 ags_recall_set_flags((AgsRecall *) recall_dssi,
8792 (AGS_RECALL_TEMPLATE));
8793 ags_recall_set_ability_flags((AgsRecall *) recall_dssi,
8794 (AGS_SOUND_ABILITY_PLAYBACK |
8795 AGS_SOUND_ABILITY_NOTATION |
8796 AGS_SOUND_ABILITY_SEQUENCER |
8797 AGS_SOUND_ABILITY_MIDI));
8798 ags_recall_set_behaviour_flags((AgsRecall *) recall_dssi,
8799 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8800
8801 ags_channel_add_recall(channel, (GObject *) recall_dssi, FALSE);
8802 recall = g_list_prepend(recall,
8803 recall_dssi);
8804
8805 g_object_set(recall_container,
8806 "recall-channel", recall_dssi,
8807 NULL);
8808 ags_connectable_connect(AGS_CONNECTABLE(recall_dssi));
8809
8810 /* AgsGenericRecallChannelRun */
8811 generic_recall_channel_run = ags_generic_recall_channel_run_new(channel,
8812 AGS_TYPE_GENERIC_RECALL_RECYCLING,
8813 AGS_TYPE_RECALL_DSSI_RUN);
8814 g_object_set(generic_recall_channel_run,
8815 "output-soundcard", output_soundcard,
8816 // "recall-channel", recall_dssi,
8817 "source", channel,
8818 "recall-container", recall_container,
8819 NULL);
8820 ags_recall_set_flags((AgsRecall *) generic_recall_channel_run,
8821 (AGS_RECALL_TEMPLATE));
8822 ags_recall_set_ability_flags((AgsRecall *) generic_recall_channel_run,
8823 (AGS_SOUND_ABILITY_PLAYBACK |
8824 AGS_SOUND_ABILITY_NOTATION |
8825 AGS_SOUND_ABILITY_SEQUENCER |
8826 AGS_SOUND_ABILITY_MIDI));
8827 ags_recall_set_behaviour_flags((AgsRecall *) generic_recall_channel_run,
8828 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8829
8830 ags_channel_add_recall(channel, (GObject *) generic_recall_channel_run, FALSE);
8831 recall = g_list_prepend(recall,
8832 generic_recall_channel_run);
8833
8834 g_object_set(recall_container,
8835 "recall-channel-run", generic_recall_channel_run,
8836 NULL);
8837 ags_connectable_connect(AGS_CONNECTABLE(generic_recall_channel_run));
8838
8839 /* iterate */
8840 next_channel = ags_channel_next(channel);
8841
8842 g_object_unref(channel);
8843
8844 channel = next_channel;
8845 }
8846
8847 nth_channel = ags_channel_nth(channel,
8848 audio_channels - stop_audio_channel);
8849
8850 if(channel != NULL){
8851 g_object_unref(channel);
8852 }
8853
8854 channel = nth_channel;
8855 }
8856
8857 if(nth_channel != NULL){
8858 g_object_unref(nth_channel);
8859 }
8860 }
8861
8862 /* unref */
8863 if(start_output != NULL){
8864 g_object_unref(start_output);
8865 }
8866
8867 if(start_input != NULL){
8868 g_object_unref(start_input);
8869 }
8870
8871 if(start != NULL){
8872 g_object_unref(start);
8873 }
8874
8875 /* return instantiated recall */
8876 recall = g_list_reverse(recall);
8877 g_list_foreach(recall,
8878 (GFunc) g_object_ref,
8879 NULL);
8880
8881 return(recall);
8882 }
8883
8884 GList*
ags_recall_factory_create_record_midi(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)8885 ags_recall_factory_create_record_midi(AgsAudio *audio,
8886 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
8887 gchar *plugin_name,
8888 guint start_audio_channel, guint stop_audio_channel,
8889 guint start_pad, guint stop_pad,
8890 guint create_flags, guint recall_flags)
8891 {
8892 AgsRecordMidiAudio *record_midi_audio;
8893 AgsRecordMidiAudioRun *record_midi_audio_run;
8894 AgsPort *port;
8895
8896 GObject *output_soundcard;
8897
8898 GList *list_start, *list;
8899 GList *recall;
8900
8901 guint i, j;
8902
8903 GRecMutex *audio_mutex;
8904
8905 if(!AGS_IS_AUDIO(audio)){
8906 return(NULL);
8907 }
8908
8909 /* get audio mutex */
8910 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
8911
8912 /* get some fields */
8913 g_rec_mutex_lock(audio_mutex);
8914
8915 output_soundcard = audio->output_soundcard;
8916
8917 g_rec_mutex_unlock(audio_mutex);
8918
8919 /* list */
8920 recall = NULL;
8921
8922 /* play */
8923 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
8924 if(play_container == NULL){
8925 play_container = ags_recall_container_new();
8926 }
8927
8928 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
8929 ags_audio_add_recall_container(audio, (GObject *) play_container);
8930
8931 record_midi_audio = (AgsRecordMidiAudio *) g_object_new(AGS_TYPE_RECORD_MIDI_AUDIO,
8932 "output-soundcard", output_soundcard,
8933 "audio", audio,
8934 "recall-container", play_container,
8935 NULL);
8936 ags_recall_set_flags((AgsRecall *) record_midi_audio,
8937 (AGS_RECALL_TEMPLATE));
8938 ags_recall_set_ability_flags((AgsRecall *) record_midi_audio,
8939 (AGS_SOUND_ABILITY_MIDI));
8940 ags_recall_set_behaviour_flags((AgsRecall *) record_midi_audio,
8941 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8942
8943 ags_audio_add_recall(audio, (GObject *) record_midi_audio, TRUE);
8944 recall = g_list_prepend(recall,
8945 record_midi_audio);
8946
8947 g_object_set(play_container,
8948 "recall-audio", record_midi_audio,
8949 NULL);
8950 ags_connectable_connect(AGS_CONNECTABLE(record_midi_audio));
8951
8952 record_midi_audio_run = (AgsRecordMidiAudioRun *) g_object_new(AGS_TYPE_RECORD_MIDI_AUDIO_RUN,
8953 "output-soundcard", output_soundcard,
8954 "recall-audio", record_midi_audio,
8955 "recall-container", play_container,
8956 NULL);
8957 ags_recall_set_flags((AgsRecall *) record_midi_audio_run,
8958 (AGS_RECALL_TEMPLATE));
8959 ags_recall_set_ability_flags((AgsRecall *) record_midi_audio_run,
8960 (AGS_SOUND_ABILITY_MIDI));
8961 ags_recall_set_behaviour_flags((AgsRecall *) record_midi_audio_run,
8962 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8963
8964 ags_audio_add_recall(audio, (GObject *) record_midi_audio_run, TRUE);
8965 recall = g_list_prepend(recall,
8966 record_midi_audio_run);
8967
8968 g_object_set(play_container,
8969 "recall-audio-run", record_midi_audio_run,
8970 NULL);
8971 ags_connectable_connect(AGS_CONNECTABLE(record_midi_audio_run));
8972 }
8973
8974 /* recall */
8975 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
8976 if(recall_container == NULL){
8977 recall_container = ags_recall_container_new();
8978 }
8979
8980 ags_audio_add_recall_container(audio, (GObject *) recall_container);
8981
8982 record_midi_audio = (AgsRecordMidiAudio *) g_object_new(AGS_TYPE_RECORD_MIDI_AUDIO,
8983 "output-soundcard", output_soundcard,
8984 "audio", audio,
8985 "recall-container", recall_container,
8986 NULL);
8987 ags_recall_set_flags((AgsRecall *) record_midi_audio,
8988 (AGS_RECALL_TEMPLATE));
8989 ags_recall_set_ability_flags((AgsRecall *) record_midi_audio,
8990 (AGS_SOUND_ABILITY_MIDI));
8991 ags_recall_set_behaviour_flags((AgsRecall *) record_midi_audio,
8992 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
8993
8994 ags_audio_add_recall(audio, (GObject *) record_midi_audio, FALSE);
8995 recall = g_list_prepend(recall,
8996 record_midi_audio);
8997
8998 g_object_set(recall_container,
8999 "recall-audio", record_midi_audio,
9000 NULL);
9001 ags_connectable_connect(AGS_CONNECTABLE(record_midi_audio));
9002
9003 record_midi_audio_run = (AgsRecordMidiAudioRun *) g_object_new(AGS_TYPE_RECORD_MIDI_AUDIO_RUN,
9004 "output-soundcard", output_soundcard,
9005 "recall-audio", record_midi_audio,
9006 "recall-container", recall_container,
9007 //TODO:JK: add missing dependency "delay-audio"
9008 NULL);
9009 ags_recall_set_flags((AgsRecall *) record_midi_audio_run,
9010 (AGS_RECALL_TEMPLATE));
9011 ags_recall_set_ability_flags((AgsRecall *) record_midi_audio_run,
9012 (AGS_SOUND_ABILITY_MIDI));
9013 ags_recall_set_behaviour_flags((AgsRecall *) record_midi_audio_run,
9014 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
9015
9016 ags_audio_add_recall(audio, (GObject *) record_midi_audio_run, FALSE);
9017 recall = g_list_prepend(recall,
9018 record_midi_audio_run);
9019
9020 g_object_set(recall_container,
9021 "recall-audio-run", record_midi_audio_run,
9022 NULL);
9023 ags_connectable_connect(AGS_CONNECTABLE(record_midi_audio_run));
9024 }
9025
9026 /* return instantiated recall */
9027 recall = g_list_reverse(recall);
9028 g_list_foreach(recall,
9029 (GFunc) g_object_ref,
9030 NULL);
9031
9032 return(recall);
9033 }
9034
9035 GList*
ags_recall_factory_create_route_dssi(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)9036 ags_recall_factory_create_route_dssi(AgsAudio *audio,
9037 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
9038 gchar *plugin_name,
9039 guint start_audio_channel, guint stop_audio_channel,
9040 guint start_pad, guint stop_pad,
9041 guint create_flags, guint recall_flags)
9042 {
9043 AgsRouteDssiAudio *route_dssi_audio;
9044 AgsRouteDssiAudioRun *route_dssi_audio_run;
9045 AgsPort *port;
9046
9047 GObject *output_soundcard;
9048
9049 GList *list_start, *list;
9050 GList *recall;
9051
9052 guint i, j;
9053
9054 GRecMutex *audio_mutex;
9055
9056 if(!AGS_IS_AUDIO(audio)){
9057 return(NULL);
9058 }
9059
9060 /* get audio mutex */
9061 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
9062
9063 /* get some fields */
9064 g_rec_mutex_lock(audio_mutex);
9065
9066 output_soundcard = audio->output_soundcard;
9067
9068 g_rec_mutex_unlock(audio_mutex);
9069
9070 /* list */
9071 recall = NULL;
9072
9073 /* play */
9074 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
9075 if(play_container == NULL){
9076 play_container = ags_recall_container_new();
9077 }
9078
9079 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
9080 ags_audio_add_recall_container(audio, (GObject *) play_container);
9081
9082 route_dssi_audio = (AgsRouteDssiAudio *) g_object_new(AGS_TYPE_ROUTE_DSSI_AUDIO,
9083 "output-soundcard", output_soundcard,
9084 "audio", audio,
9085 "recall-container", play_container,
9086 NULL);
9087 ags_recall_set_flags((AgsRecall *) route_dssi_audio,
9088 (AGS_RECALL_TEMPLATE));
9089 ags_recall_set_ability_flags((AgsRecall *) route_dssi_audio,
9090 (AGS_SOUND_ABILITY_MIDI));
9091 ags_recall_set_behaviour_flags((AgsRecall *) route_dssi_audio,
9092 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
9093
9094 ags_audio_add_recall(audio, (GObject *) route_dssi_audio, TRUE);
9095 recall = g_list_prepend(recall,
9096 route_dssi_audio);
9097
9098 g_object_set(play_container,
9099 "recall-audio", route_dssi_audio,
9100 NULL);
9101 ags_connectable_connect(AGS_CONNECTABLE(route_dssi_audio));
9102
9103 route_dssi_audio_run = (AgsRouteDssiAudioRun *) g_object_new(AGS_TYPE_ROUTE_DSSI_AUDIO_RUN,
9104 "output-soundcard", output_soundcard,
9105 "recall-audio", route_dssi_audio,
9106 "recall-container", play_container,
9107 NULL);
9108 ags_recall_set_flags((AgsRecall *) route_dssi_audio_run,
9109 (AGS_RECALL_TEMPLATE));
9110 ags_recall_set_ability_flags((AgsRecall *) route_dssi_audio_run,
9111 (AGS_SOUND_ABILITY_MIDI));
9112 ags_recall_set_behaviour_flags((AgsRecall *) route_dssi_audio_run,
9113 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
9114
9115 ags_audio_add_recall(audio, (GObject *) route_dssi_audio_run, TRUE);
9116 recall = g_list_prepend(recall,
9117 route_dssi_audio_run);
9118
9119 g_object_set(play_container,
9120 "recall-audio-run", route_dssi_audio_run,
9121 NULL);
9122 ags_connectable_connect(AGS_CONNECTABLE(route_dssi_audio_run));
9123 }
9124
9125 /* recall */
9126 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
9127 if(recall_container == NULL){
9128 recall_container = ags_recall_container_new();
9129 }
9130
9131 ags_audio_add_recall_container(audio, (GObject *) recall_container);
9132
9133 route_dssi_audio = (AgsRouteDssiAudio *) g_object_new(AGS_TYPE_ROUTE_DSSI_AUDIO,
9134 "output-soundcard", output_soundcard,
9135 "audio", audio,
9136 "recall-container", recall_container,
9137 NULL);
9138 ags_recall_set_flags((AgsRecall *) route_dssi_audio,
9139 (AGS_RECALL_TEMPLATE));
9140 ags_recall_set_ability_flags((AgsRecall *) route_dssi_audio,
9141 (AGS_SOUND_ABILITY_MIDI));
9142 ags_recall_set_behaviour_flags((AgsRecall *) route_dssi_audio,
9143 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
9144
9145 ags_audio_add_recall(audio, (GObject *) route_dssi_audio, FALSE);
9146 recall = g_list_prepend(recall,
9147 route_dssi_audio);
9148
9149 g_object_set(recall_container,
9150 "recall-audio", route_dssi_audio,
9151 NULL);
9152 ags_connectable_connect(AGS_CONNECTABLE(route_dssi_audio));
9153
9154 route_dssi_audio_run = (AgsRouteDssiAudioRun *) g_object_new(AGS_TYPE_ROUTE_DSSI_AUDIO_RUN,
9155 "output-soundcard", output_soundcard,
9156 "recall-audio", route_dssi_audio,
9157 "recall-container", recall_container,
9158 //TODO:JK: add missing dependency "delay-audio"
9159 NULL);
9160 ags_recall_set_flags((AgsRecall *) route_dssi_audio_run,
9161 (AGS_RECALL_TEMPLATE));
9162 ags_recall_set_ability_flags((AgsRecall *) route_dssi_audio_run,
9163 (AGS_SOUND_ABILITY_MIDI));
9164 ags_recall_set_behaviour_flags((AgsRecall *) route_dssi_audio_run,
9165 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
9166
9167 ags_audio_add_recall(audio, (GObject *) route_dssi_audio_run, FALSE);
9168 recall = g_list_prepend(recall,
9169 route_dssi_audio_run);
9170
9171 g_object_set(recall_container,
9172 "recall-audio-run", route_dssi_audio_run,
9173 NULL);
9174 ags_connectable_connect(AGS_CONNECTABLE(route_dssi_audio_run));
9175 }
9176
9177 /* return instantiated recall */
9178 recall = g_list_reverse(recall);
9179 g_list_foreach(recall,
9180 (GFunc) g_object_ref,
9181 NULL);
9182
9183 return(recall);
9184 }
9185
9186 GList*
ags_recall_factory_create_route_lv2(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)9187 ags_recall_factory_create_route_lv2(AgsAudio *audio,
9188 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
9189 gchar *plugin_name,
9190 guint start_audio_channel, guint stop_audio_channel,
9191 guint start_pad, guint stop_pad,
9192 guint create_flags, guint recall_flags)
9193 {
9194 AgsRouteLv2Audio *route_lv2_audio;
9195 AgsRouteLv2AudioRun *route_lv2_audio_run;
9196 AgsPort *port;
9197
9198 GObject *output_soundcard;
9199
9200 GList *list_start, *list;
9201 GList *recall;
9202
9203 guint i, j;
9204
9205 GRecMutex *audio_mutex;
9206
9207 if(!AGS_IS_AUDIO(audio)){
9208 return(NULL);
9209 }
9210
9211 /* get audio mutex */
9212 audio_mutex = AGS_AUDIO_GET_OBJ_MUTEX(audio);
9213
9214 /* get some fields */
9215 g_rec_mutex_lock(audio_mutex);
9216
9217 output_soundcard = audio->output_soundcard;
9218
9219 g_rec_mutex_unlock(audio_mutex);
9220
9221 /* list */
9222 recall = NULL;
9223
9224 /* play */
9225 if((AGS_RECALL_FACTORY_PLAY & (create_flags)) != 0){
9226 if(play_container == NULL){
9227 play_container = ags_recall_container_new();
9228 }
9229
9230 play_container->flags |= AGS_RECALL_CONTAINER_PLAY;
9231 ags_audio_add_recall_container(audio, (GObject *) play_container);
9232
9233 route_lv2_audio = (AgsRouteLv2Audio *) g_object_new(AGS_TYPE_ROUTE_LV2_AUDIO,
9234 "output-soundcard", output_soundcard,
9235 "audio", audio,
9236 "recall-container", play_container,
9237 NULL);
9238 ags_recall_set_flags((AgsRecall *) route_lv2_audio,
9239 (AGS_RECALL_TEMPLATE));
9240 ags_recall_set_ability_flags((AgsRecall *) route_lv2_audio,
9241 (AGS_SOUND_ABILITY_MIDI));
9242 ags_recall_set_behaviour_flags((AgsRecall *) route_lv2_audio,
9243 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
9244
9245 ags_audio_add_recall(audio, (GObject *) route_lv2_audio, TRUE);
9246 recall = g_list_prepend(recall,
9247 route_lv2_audio);
9248
9249 g_object_set(play_container,
9250 "recall-audio", route_lv2_audio,
9251 NULL);
9252 ags_connectable_connect(AGS_CONNECTABLE(route_lv2_audio));
9253
9254 route_lv2_audio_run = (AgsRouteLv2AudioRun *) g_object_new(AGS_TYPE_ROUTE_LV2_AUDIO_RUN,
9255 "output-soundcard", output_soundcard,
9256 "recall-audio", route_lv2_audio,
9257 "recall-container", play_container,
9258 NULL);
9259 ags_recall_set_flags((AgsRecall *) route_lv2_audio_run,
9260 (AGS_RECALL_TEMPLATE));
9261 ags_recall_set_ability_flags((AgsRecall *) route_lv2_audio_run,
9262 (AGS_SOUND_ABILITY_MIDI));
9263 ags_recall_set_behaviour_flags((AgsRecall *) route_lv2_audio_run,
9264 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
9265
9266 ags_audio_add_recall(audio, (GObject *) route_lv2_audio_run, TRUE);
9267 recall = g_list_prepend(recall,
9268 route_lv2_audio_run);
9269
9270 g_object_set(play_container,
9271 "recall-audio-run", route_lv2_audio_run,
9272 NULL);
9273 ags_connectable_connect(AGS_CONNECTABLE(route_lv2_audio_run));
9274 }
9275
9276 /* recall */
9277 if((AGS_RECALL_FACTORY_RECALL & (create_flags)) != 0){
9278 if(recall_container == NULL){
9279 recall_container = ags_recall_container_new();
9280 }
9281
9282 ags_audio_add_recall_container(audio, (GObject *) recall_container);
9283
9284 route_lv2_audio = (AgsRouteLv2Audio *) g_object_new(AGS_TYPE_ROUTE_LV2_AUDIO,
9285 "output-soundcard", output_soundcard,
9286 "audio", audio,
9287 "recall-container", recall_container,
9288 NULL);
9289 ags_recall_set_flags((AgsRecall *) route_lv2_audio,
9290 (AGS_RECALL_TEMPLATE));
9291 ags_recall_set_ability_flags((AgsRecall *) route_lv2_audio,
9292 (AGS_SOUND_ABILITY_MIDI));
9293 ags_recall_set_behaviour_flags((AgsRecall *) route_lv2_audio,
9294 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
9295
9296 ags_audio_add_recall(audio, (GObject *) route_lv2_audio, FALSE);
9297 recall = g_list_prepend(recall,
9298 route_lv2_audio);
9299
9300 g_object_set(recall_container,
9301 "recall-audio", route_lv2_audio,
9302 NULL);
9303 ags_connectable_connect(AGS_CONNECTABLE(route_lv2_audio));
9304
9305 route_lv2_audio_run = (AgsRouteLv2AudioRun *) g_object_new(AGS_TYPE_ROUTE_LV2_AUDIO_RUN,
9306 "output-soundcard", output_soundcard,
9307 "recall-audio", route_lv2_audio,
9308 "recall-container", recall_container,
9309 //TODO:JK: add missing dependency "route_lv2-audio"
9310 NULL);
9311 ags_recall_set_flags((AgsRecall *) route_lv2_audio_run,
9312 (AGS_RECALL_TEMPLATE));
9313 ags_recall_set_ability_flags((AgsRecall *) route_lv2_audio_run,
9314 (AGS_SOUND_ABILITY_MIDI));
9315 ags_recall_set_behaviour_flags((AgsRecall *) route_lv2_audio_run,
9316 (((AGS_RECALL_FACTORY_OUTPUT & create_flags) != 0) ? AGS_SOUND_BEHAVIOUR_CHAINED_TO_OUTPUT: AGS_SOUND_BEHAVIOUR_CHAINED_TO_INPUT));
9317
9318 ags_audio_add_recall(audio, (GObject *) route_lv2_audio_run, FALSE);
9319 recall = g_list_prepend(recall,
9320 route_lv2_audio_run);
9321
9322 g_object_set(recall_container,
9323 "recall-audio-run", route_lv2_audio_run,
9324 NULL);
9325 ags_connectable_connect(AGS_CONNECTABLE(route_lv2_audio_run));
9326 }
9327
9328 /* return instantiated recall */
9329 recall = g_list_reverse(recall);
9330 g_list_foreach(recall,
9331 (GFunc) g_object_ref,
9332 NULL);
9333
9334 return(recall);
9335 }
9336
9337 /**
9338 * ags_recall_factory_create:
9339 * @audio: an #AgsAudio that should keep the recalls
9340 * @play_container: an #AgsRecallContainer to indetify what recall to use
9341 * @recall_container: an #AgsRecallContainer to indetify what recall to use
9342 * @plugin_name: the plugin identifier to instantiate
9343 * @start_audio_channel: the first audio channel to apply
9344 * @stop_audio_channel: the last audio channel to apply
9345 * @start_pad: the first pad to apply
9346 * @stop_pad: the last pad to apply
9347 * @create_flags: modify the behaviour of this function
9348 * @recall_flags: flags to be set for #AgsRecall
9349 *
9350 * Instantiate #AgsRecall by this factory.
9351 *
9352 * Returns: (element-type AgsAudio.Recall) (transfer full): The #GList-struct containing #AgsRecall
9353 *
9354 * Deprecated: 3.4.0: deprecated by new ags-fx engine, check <ags/audio/ags_fx_factory.h>.
9355 *
9356 * Since: 3.0.0
9357 */
9358 GList*
ags_recall_factory_create(AgsAudio * audio,AgsRecallContainer * play_container,AgsRecallContainer * recall_container,gchar * plugin_name,guint start_audio_channel,guint stop_audio_channel,guint start_pad,guint stop_pad,guint create_flags,guint recall_flags)9359 ags_recall_factory_create(AgsAudio *audio,
9360 AgsRecallContainer *play_container, AgsRecallContainer *recall_container,
9361 gchar *plugin_name,
9362 guint start_audio_channel, guint stop_audio_channel,
9363 guint start_pad, guint stop_pad,
9364 guint create_flags, guint recall_flags)
9365 {
9366 GList *recall;
9367
9368 if(plugin_name == NULL){
9369 return(NULL);
9370 }
9371
9372 recall = NULL;
9373
9374 #ifdef AGS_DEBUG
9375 g_message("AgsRecallFactory creating: %s[%d,%d]", plugin_name, stop_pad, stop_audio_channel);
9376 #endif
9377
9378 if(!strncmp(plugin_name,
9379 "ags-delay",
9380 10)){
9381 recall = ags_recall_factory_create_delay(audio,
9382 play_container, recall_container,
9383 plugin_name,
9384 start_audio_channel, stop_audio_channel,
9385 start_pad, stop_pad,
9386 create_flags, recall_flags);
9387 }else if(!strncmp(plugin_name,
9388 "ags-count-beats",
9389 16)){
9390 recall = ags_recall_factory_create_count_beats(audio,
9391 play_container, recall_container,
9392 plugin_name,
9393 start_audio_channel, stop_audio_channel,
9394 start_pad, stop_pad,
9395 create_flags, recall_flags);
9396 }else if(!strncmp(plugin_name,
9397 "ags-stream",
9398 11)){
9399 recall = ags_recall_factory_create_stream(audio,
9400 play_container, recall_container,
9401 plugin_name,
9402 start_audio_channel, stop_audio_channel,
9403 start_pad, stop_pad,
9404 create_flags, recall_flags);
9405 }else if(!strncmp(plugin_name,
9406 "ags-rt-stream",
9407 14)){
9408 recall = ags_recall_factory_create_rt_stream(audio,
9409 play_container, recall_container,
9410 plugin_name,
9411 start_audio_channel, stop_audio_channel,
9412 start_pad, stop_pad,
9413 create_flags, recall_flags);
9414 }else if(!strncmp(plugin_name,
9415 "ags-feed",
9416 9)){
9417 recall = ags_recall_factory_create_feed(audio,
9418 play_container, recall_container,
9419 plugin_name,
9420 start_audio_channel, stop_audio_channel,
9421 start_pad, stop_pad,
9422 create_flags, recall_flags);
9423 }else if(!strncmp(plugin_name,
9424 "ags-loop",
9425 9)){
9426 recall = ags_recall_factory_create_loop(audio,
9427 play_container, recall_container,
9428 plugin_name,
9429 start_audio_channel, stop_audio_channel,
9430 start_pad, stop_pad,
9431 create_flags, recall_flags);
9432 }else if(!strncmp(plugin_name,
9433 "ags-play-master",
9434 16)){
9435 recall = ags_recall_factory_create_play_master(audio,
9436 play_container, recall_container,
9437 plugin_name,
9438 start_audio_channel, stop_audio_channel,
9439 start_pad, stop_pad,
9440 create_flags, recall_flags);
9441 }else if(!strncmp(plugin_name,
9442 "ags-prepare",
9443 12)){
9444 recall = ags_recall_factory_create_prepare(audio,
9445 play_container, recall_container,
9446 plugin_name,
9447 start_audio_channel, stop_audio_channel,
9448 start_pad, stop_pad,
9449 create_flags, recall_flags);
9450 }else if(!strncmp(plugin_name,
9451 "ags-copy",
9452 9)){
9453 recall = ags_recall_factory_create_copy(audio,
9454 play_container, recall_container,
9455 plugin_name,
9456 start_audio_channel, stop_audio_channel,
9457 start_pad, stop_pad,
9458 create_flags, recall_flags);
9459 }else if(!strncmp(plugin_name,
9460 "ags-buffer",
9461 11)){
9462 recall = ags_recall_factory_create_buffer(audio,
9463 play_container, recall_container,
9464 plugin_name,
9465 start_audio_channel, stop_audio_channel,
9466 start_pad, stop_pad,
9467 create_flags, recall_flags);
9468 }else if(!strncmp(plugin_name,
9469 "ags-play",
9470 9)){
9471 recall = ags_recall_factory_create_play(audio,
9472 play_container, recall_container,
9473 plugin_name,
9474 start_audio_channel, stop_audio_channel,
9475 start_pad, stop_pad,
9476 create_flags, recall_flags);
9477 }else if(!strncmp(plugin_name,
9478 "ags-copy-pattern",
9479 17)){
9480 recall = ags_recall_factory_create_copy_pattern(audio,
9481 play_container, recall_container,
9482 plugin_name,
9483 start_audio_channel, stop_audio_channel,
9484 start_pad, stop_pad,
9485 create_flags, recall_flags);
9486 }else if(!strncmp(plugin_name,
9487 "ags-play-wave",
9488 14)){
9489 recall = ags_recall_factory_create_play_wave(audio,
9490 play_container, recall_container,
9491 plugin_name,
9492 start_audio_channel, stop_audio_channel,
9493 start_pad, stop_pad,
9494 create_flags, recall_flags);
9495 }else if(!strncmp(plugin_name,
9496 "ags-capture-wave",
9497 17)){
9498 recall = ags_recall_factory_create_capture_wave(audio,
9499 play_container, recall_container,
9500 plugin_name,
9501 start_audio_channel, stop_audio_channel,
9502 start_pad, stop_pad,
9503 create_flags, recall_flags);
9504 }else if(!strncmp(plugin_name,
9505 "ags-play-dssi",
9506 14)){
9507 recall = ags_recall_factory_create_play_dssi(audio,
9508 play_container, recall_container,
9509 plugin_name,
9510 start_audio_channel, stop_audio_channel,
9511 start_pad, stop_pad,
9512 create_flags, recall_flags);
9513 }else if(!strncmp(plugin_name,
9514 "ags-play-lv2",
9515 13)){
9516 recall = ags_recall_factory_create_play_lv2(audio,
9517 play_container, recall_container,
9518 plugin_name,
9519 start_audio_channel, stop_audio_channel,
9520 start_pad, stop_pad,
9521 create_flags, recall_flags);
9522 }else if(!strncmp(plugin_name,
9523 "ags-play-notation",
9524 18)){
9525 recall = ags_recall_factory_create_play_notation(audio,
9526 play_container, recall_container,
9527 plugin_name,
9528 start_audio_channel, stop_audio_channel,
9529 start_pad, stop_pad,
9530 create_flags, recall_flags);
9531 }else if(!strncmp(plugin_name,
9532 "ags-peak",
9533 9)){
9534 recall = ags_recall_factory_create_peak(audio,
9535 play_container, recall_container,
9536 plugin_name,
9537 start_audio_channel, stop_audio_channel,
9538 start_pad, stop_pad,
9539 create_flags, recall_flags);
9540 }else if(!strncmp(plugin_name,
9541 "ags-analyse",
9542 12)){
9543 recall = ags_recall_factory_create_analyse(audio,
9544 play_container, recall_container,
9545 plugin_name,
9546 start_audio_channel, stop_audio_channel,
9547 start_pad, stop_pad,
9548 create_flags, recall_flags);
9549 }else if(!strncmp(plugin_name,
9550 "ags-mute",
9551 9)){
9552 recall = ags_recall_factory_create_mute(audio,
9553 play_container, recall_container,
9554 plugin_name,
9555 start_audio_channel, stop_audio_channel,
9556 start_pad, stop_pad,
9557 create_flags, recall_flags);
9558 }else if(!strncmp(plugin_name,
9559 "ags-volume",
9560 11)){
9561 recall = ags_recall_factory_create_volume(audio,
9562 play_container, recall_container,
9563 plugin_name,
9564 start_audio_channel, stop_audio_channel,
9565 start_pad, stop_pad,
9566 create_flags, recall_flags);
9567 }else if(!strncmp(plugin_name,
9568 "ags-eq10",
9569 9)){
9570 recall = ags_recall_factory_create_eq10(audio,
9571 play_container, recall_container,
9572 plugin_name,
9573 start_audio_channel, stop_audio_channel,
9574 start_pad, stop_pad,
9575 create_flags, recall_flags);
9576 }else if(!strncmp(plugin_name,
9577 "ags-envelope",
9578 13)){
9579 recall = ags_recall_factory_create_envelope(audio,
9580 play_container, recall_container,
9581 plugin_name,
9582 start_audio_channel, stop_audio_channel,
9583 start_pad, stop_pad,
9584 create_flags, recall_flags);
9585 }else if(!strncmp(plugin_name,
9586 "ags-lfo",
9587 8)){
9588 recall = ags_recall_factory_create_lfo(audio,
9589 play_container, recall_container,
9590 plugin_name,
9591 start_audio_channel, stop_audio_channel,
9592 start_pad, stop_pad,
9593 create_flags, recall_flags);
9594 }else if(!strncmp(plugin_name,
9595 "ags-ladspa",
9596 11)){
9597 recall = ags_recall_factory_create_ladspa(audio,
9598 play_container, recall_container,
9599 plugin_name,
9600 start_audio_channel, stop_audio_channel,
9601 start_pad, stop_pad,
9602 create_flags, recall_flags);
9603 }else if(!strncmp(plugin_name,
9604 "ags-dssi",
9605 9)){
9606 recall = ags_recall_factory_create_dssi(audio,
9607 play_container, recall_container,
9608 plugin_name,
9609 start_audio_channel, stop_audio_channel,
9610 start_pad, stop_pad,
9611 create_flags, recall_flags);
9612 }else if(!strncmp(plugin_name,
9613 "ags-lv2",
9614 8)){
9615 recall = ags_recall_factory_create_lv2(audio,
9616 play_container, recall_container,
9617 plugin_name,
9618 start_audio_channel, stop_audio_channel,
9619 start_pad, stop_pad,
9620 create_flags, recall_flags);
9621 }else if(!strncmp(plugin_name,
9622 "ags-record-midi",
9623 16)){
9624 recall = ags_recall_factory_create_record_midi(audio,
9625 play_container, recall_container,
9626 plugin_name,
9627 start_audio_channel, stop_audio_channel,
9628 start_pad, stop_pad,
9629 create_flags, recall_flags);
9630 }else if(!strncmp(plugin_name,
9631 "ags-route-dssi",
9632 15)){
9633 recall = ags_recall_factory_create_route_dssi(audio,
9634 play_container, recall_container,
9635 plugin_name,
9636 start_audio_channel, stop_audio_channel,
9637 start_pad, stop_pad,
9638 create_flags, recall_flags);
9639 }else if(!strncmp(plugin_name,
9640 "ags-route-lv2",
9641 14)){
9642 recall = ags_recall_factory_create_route_lv2(audio,
9643 play_container, recall_container,
9644 plugin_name,
9645 start_audio_channel, stop_audio_channel,
9646 start_pad, stop_pad,
9647 create_flags, recall_flags);
9648 }
9649
9650 return(recall);
9651 }
9652
9653 /**
9654 * ags_recall_factory_new:
9655 *
9656 * Create a new instance of #AgsRecallFactory
9657 *
9658 * Returns: the new #AgsRecallFactory
9659 *
9660 * Deprecated: 3.4.0: deprecated by new ags-fx engine, check <ags/audio/ags_fx_factory.h>.
9661 *
9662 * Since: 3.0.0
9663 */
9664 AgsRecallFactory*
ags_recall_factory_new()9665 ags_recall_factory_new()
9666 {
9667 AgsRecallFactory *recall_factory;
9668
9669 recall_factory = (AgsRecallFactory *) g_object_new(AGS_TYPE_RECALL_FACTORY,
9670 NULL);
9671
9672 return(recall_factory);
9673 }
9674