1 /* GSequencer - Advanced GTK Sequencer
2 * Copyright (C) 2005-2020 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/fx/ags_fx_lv2_audio.h>
21
22 #include <ags/plugin/ags_lv2_manager.h>
23 #include <ags/plugin/ags_lv2_plugin.h>
24 #include <ags/plugin/ags_base_plugin.h>
25 #include <ags/plugin/ags_plugin_port.h>
26
27 #include <ags/audio/ags_input.h>
28 #include <ags/audio/ags_recall_container.h>
29 #include <ags/audio/ags_port_util.h>
30
31 #include <ags/audio/fx/ags_fx_lv2_channel.h>
32
33 #include <ags/i18n.h>
34
35 void ags_fx_lv2_audio_class_init(AgsFxLv2AudioClass *fx_lv2_audio);
36 void ags_fx_lv2_audio_init(AgsFxLv2Audio *fx_lv2_audio);
37 void ags_fx_lv2_audio_dispose(GObject *gobject);
38 void ags_fx_lv2_audio_finalize(GObject *gobject);
39
40 void ags_fx_lv2_audio_notify_audio_callback(GObject *gobject,
41 GParamSpec *pspec,
42 gpointer user_data);
43 void ags_fx_lv2_audio_notify_filename_callback(GObject *gobject,
44 GParamSpec *pspec,
45 gpointer user_data);
46 void ags_fx_lv2_audio_notify_effect_callback(GObject *gobject,
47 GParamSpec *pspec,
48 gpointer user_data);
49 void ags_fx_lv2_audio_notify_buffer_size_callback(GObject *gobject,
50 GParamSpec *pspec,
51 gpointer user_data);
52 void ags_fx_lv2_audio_notify_samplerate_callback(GObject *gobject,
53 GParamSpec *pspec,
54 gpointer user_data);
55
56 void ags_fx_lv2_audio_set_audio_channels_callback(AgsAudio *audio,
57 guint audio_channels, guint audio_channels_old,
58 AgsFxLv2Audio *fx_lv2_audio);
59 void ags_fx_lv2_audio_set_pads_callback(AgsAudio *audio,
60 GType channel_type,
61 guint pads, guint pads_old,
62 AgsFxLv2Audio *fx_lv2_audio);
63
64 /**
65 * SECTION:ags_fx_lv2_audio
66 * @short_description: fx lv2 audio
67 * @title: AgsFxLv2Audio
68 * @section_id:
69 * @include: ags/audio/fx/ags_fx_lv2_audio.h
70 *
71 * The #AgsFxLv2Audio class provides ports to the effect processor.
72 */
73
74 static gpointer ags_fx_lv2_audio_parent_class = NULL;
75
76 const gchar *ags_fx_lv2_audio_plugin_name = "ags-fx-lv2";
77
78 const gchar *ags_fx_lv2_audio_specifier[] = {
79 NULL,
80 };
81
82 const gchar *ags_fx_lv2_audio_control_port[] = {
83 NULL,
84 };
85
86 enum{
87 PROP_0,
88 };
89
90 GType
ags_fx_lv2_audio_get_type()91 ags_fx_lv2_audio_get_type()
92 {
93 static volatile gsize g_define_type_id__volatile = 0;
94
95 if(g_once_init_enter (&g_define_type_id__volatile)){
96 GType ags_type_fx_lv2_audio = 0;
97
98 static const GTypeInfo ags_fx_lv2_audio_info = {
99 sizeof (AgsFxLv2AudioClass),
100 NULL, /* base_init */
101 NULL, /* base_finalize */
102 (GClassInitFunc) ags_fx_lv2_audio_class_init,
103 NULL, /* class_finalize */
104 NULL, /* class_audio */
105 sizeof (AgsFxLv2Audio),
106 0, /* n_preallocs */
107 (GInstanceInitFunc) ags_fx_lv2_audio_init,
108 };
109
110 ags_type_fx_lv2_audio = g_type_register_static(AGS_TYPE_FX_NOTATION_AUDIO,
111 "AgsFxLv2Audio",
112 &ags_fx_lv2_audio_info,
113 0);
114
115 g_once_init_leave(&g_define_type_id__volatile, ags_type_fx_lv2_audio);
116 }
117
118 return g_define_type_id__volatile;
119 }
120
121 void
ags_fx_lv2_audio_class_init(AgsFxLv2AudioClass * fx_lv2_audio)122 ags_fx_lv2_audio_class_init(AgsFxLv2AudioClass *fx_lv2_audio)
123 {
124 GObjectClass *gobject;
125
126 GParamSpec *param_spec;
127
128 ags_fx_lv2_audio_parent_class = g_type_class_peek_parent(fx_lv2_audio);
129
130 /* GObjectClass */
131 gobject = (GObjectClass *) fx_lv2_audio;
132
133 gobject->dispose = ags_fx_lv2_audio_dispose;
134 gobject->finalize = ags_fx_lv2_audio_finalize;
135
136 /* properties */
137 }
138
139 void
ags_fx_lv2_audio_init(AgsFxLv2Audio * fx_lv2_audio)140 ags_fx_lv2_audio_init(AgsFxLv2Audio *fx_lv2_audio)
141 {
142 guint i;
143
144 g_signal_connect(fx_lv2_audio, "notify::audio",
145 G_CALLBACK(ags_fx_lv2_audio_notify_audio_callback), NULL);
146
147 g_signal_connect(fx_lv2_audio, "notify::filename",
148 G_CALLBACK(ags_fx_lv2_audio_notify_filename_callback), NULL);
149
150 g_signal_connect(fx_lv2_audio, "notify::effect",
151 G_CALLBACK(ags_fx_lv2_audio_notify_effect_callback), NULL);
152
153 g_signal_connect(fx_lv2_audio, "notify::buffer-size",
154 G_CALLBACK(ags_fx_lv2_audio_notify_buffer_size_callback), NULL);
155
156 g_signal_connect(fx_lv2_audio, "notify::samplerate",
157 G_CALLBACK(ags_fx_lv2_audio_notify_samplerate_callback), NULL);
158
159 AGS_RECALL(fx_lv2_audio)->name = "ags-fx-lv2";
160 AGS_RECALL(fx_lv2_audio)->version = AGS_RECALL_DEFAULT_VERSION;
161 AGS_RECALL(fx_lv2_audio)->build_id = AGS_RECALL_DEFAULT_BUILD_ID;
162 AGS_RECALL(fx_lv2_audio)->xml_type = "ags-fx-lv2-audio";
163
164 fx_lv2_audio->flags = 0;
165
166 fx_lv2_audio->output_port_count = 0;
167 fx_lv2_audio->output_port = NULL;
168
169 fx_lv2_audio->input_port_count = 0;
170 fx_lv2_audio->input_port = NULL;
171
172 fx_lv2_audio->bank = 0;
173 fx_lv2_audio->program = 0;
174
175 /* scope data */
176 for(i = 0; i < AGS_SOUND_SCOPE_LAST; i++){
177 if(i == AGS_SOUND_SCOPE_PLAYBACK ||
178 i == AGS_SOUND_SCOPE_NOTATION ||
179 i == AGS_SOUND_SCOPE_MIDI){
180 fx_lv2_audio->scope_data[i] = ags_fx_lv2_audio_scope_data_alloc();
181
182 fx_lv2_audio->scope_data[i]->parent = fx_lv2_audio;
183 }else{
184 fx_lv2_audio->scope_data[i] = NULL;
185 }
186 }
187
188 fx_lv2_audio->lv2_plugin = NULL;
189
190 fx_lv2_audio->lv2_port = NULL;
191 }
192
193 void
ags_fx_lv2_audio_dispose(GObject * gobject)194 ags_fx_lv2_audio_dispose(GObject *gobject)
195 {
196 AgsFxLv2Audio *fx_lv2_audio;
197
198 fx_lv2_audio = AGS_FX_LV2_AUDIO(gobject);
199
200 /* call parent */
201 G_OBJECT_CLASS(ags_fx_lv2_audio_parent_class)->dispose(gobject);
202 }
203
204 void
ags_fx_lv2_audio_finalize(GObject * gobject)205 ags_fx_lv2_audio_finalize(GObject *gobject)
206 {
207 AgsPort **iter;
208 AgsFxLv2Audio *fx_lv2_audio;
209
210 guint i;
211
212 fx_lv2_audio = AGS_FX_LV2_AUDIO(gobject);
213
214 g_free(fx_lv2_audio->output_port);
215 g_free(fx_lv2_audio->input_port);
216
217 for(i = 0; i < AGS_SOUND_SCOPE_LAST; i++){
218 if(i == AGS_SOUND_SCOPE_PLAYBACK ||
219 i == AGS_SOUND_SCOPE_NOTATION ||
220 i == AGS_SOUND_SCOPE_MIDI){
221 ags_fx_lv2_audio_scope_data_free(fx_lv2_audio->scope_data[i]);
222 }
223 }
224
225 if(fx_lv2_audio->lv2_plugin != NULL){
226 g_object_unref(fx_lv2_audio->lv2_plugin);
227 }
228
229 if(fx_lv2_audio->lv2_port != NULL){
230 for(iter = fx_lv2_audio->lv2_port; iter[0] != NULL; iter++){
231 g_object_unref(iter[0]);
232 }
233
234 g_free(fx_lv2_audio->lv2_port);
235 }
236
237 /* call parent */
238 G_OBJECT_CLASS(ags_fx_lv2_audio_parent_class)->finalize(gobject);
239 }
240
241 void
ags_fx_lv2_audio_notify_audio_callback(GObject * gobject,GParamSpec * pspec,gpointer user_data)242 ags_fx_lv2_audio_notify_audio_callback(GObject *gobject,
243 GParamSpec *pspec,
244 gpointer user_data)
245 {
246 AgsAudio *audio;
247 AgsFxLv2Audio *fx_lv2_audio;
248
249 fx_lv2_audio = AGS_FX_LV2_AUDIO(gobject);
250
251 /* get audio */
252 audio = NULL;
253
254 g_object_get(fx_lv2_audio,
255 "audio", &audio,
256 NULL);
257
258 g_signal_connect_after((GObject *) audio, "set-audio-channels",
259 G_CALLBACK(ags_fx_lv2_audio_set_audio_channels_callback), fx_lv2_audio);
260
261 g_signal_connect_after((GObject *) audio, "set-pads",
262 G_CALLBACK(ags_fx_lv2_audio_set_pads_callback), fx_lv2_audio);
263 }
264
265 void
ags_fx_lv2_audio_notify_filename_callback(GObject * gobject,GParamSpec * pspec,gpointer user_data)266 ags_fx_lv2_audio_notify_filename_callback(GObject *gobject,
267 GParamSpec *pspec,
268 gpointer user_data)
269 {
270 //TODO:JK: implement me
271 }
272
273 void
ags_fx_lv2_audio_notify_effect_callback(GObject * gobject,GParamSpec * pspec,gpointer user_data)274 ags_fx_lv2_audio_notify_effect_callback(GObject *gobject,
275 GParamSpec *pspec,
276 gpointer user_data)
277 {
278 //TODO:JK: implement me
279 }
280
281 void
ags_fx_lv2_audio_notify_buffer_size_callback(GObject * gobject,GParamSpec * pspec,gpointer user_data)282 ags_fx_lv2_audio_notify_buffer_size_callback(GObject *gobject,
283 GParamSpec *pspec,
284 gpointer user_data)
285 {
286 AgsFxLv2Audio *fx_lv2_audio;
287
288 AgsLv2Plugin *lv2_plugin;
289
290 guint output_port_count, input_port_count;
291 guint buffer_size;
292 guint i, j, k;
293 gboolean is_live_instrument;
294
295 GRecMutex *recall_mutex;
296
297 fx_lv2_audio = AGS_FX_LV2_AUDIO(gobject);
298
299 /* get recall mutex */
300 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(fx_lv2_audio);
301
302 /* get lv2 plugin */
303 g_rec_mutex_lock(recall_mutex);
304
305 lv2_plugin = fx_lv2_audio->lv2_plugin;
306
307 g_rec_mutex_unlock(recall_mutex);
308
309 if(lv2_plugin == NULL ||
310 !ags_base_plugin_test_flags((AgsBasePlugin *) lv2_plugin, AGS_BASE_PLUGIN_IS_INSTRUMENT)){
311 return;
312 }
313
314 /* get buffer size */
315 g_object_get(fx_lv2_audio,
316 "buffer-size", &buffer_size,
317 NULL);
318
319 is_live_instrument = ags_fx_lv2_audio_test_flags(fx_lv2_audio, AGS_FX_LV2_AUDIO_LIVE_INSTRUMENT);
320
321 /* reallocate buffer - apply buffer size */
322 g_rec_mutex_lock(recall_mutex);
323
324 output_port_count = fx_lv2_audio->output_port_count;
325 input_port_count = fx_lv2_audio->input_port_count;
326
327 for(i = 0; i < AGS_SOUND_SCOPE_LAST; i++){
328 AgsFxLv2AudioScopeData *scope_data;
329
330 scope_data = fx_lv2_audio->scope_data[i];
331
332 if(i == AGS_SOUND_SCOPE_PLAYBACK ||
333 i == AGS_SOUND_SCOPE_NOTATION ||
334 i == AGS_SOUND_SCOPE_MIDI){
335 for(j = 0; j < scope_data->audio_channels; j++){
336 AgsFxLv2AudioChannelData *channel_data;
337
338 channel_data = scope_data->channel_data[j];
339
340 if(is_live_instrument){
341 if(output_port_count > 0 &&
342 buffer_size > 0){
343 if(channel_data->output == NULL){
344 channel_data->output = (float *) g_malloc(output_port_count * buffer_size * sizeof(float));
345 }else{
346 channel_data->output = (float *) g_realloc(channel_data->output,
347 output_port_count * buffer_size * sizeof(float));
348 }
349 }
350
351 if(input_port_count > 0 &&
352 buffer_size > 0){
353 if(channel_data->input == NULL){
354 channel_data->input = (float *) g_malloc(input_port_count * buffer_size * sizeof(float));
355 }else{
356 channel_data->input = (float *) g_realloc(channel_data->input,
357 input_port_count * buffer_size * sizeof(float));
358 }
359 }
360 }
361
362 if(!is_live_instrument){
363 for(k = 0; k < AGS_SEQUENCER_MAX_MIDI_KEYS; k++){
364 AgsFxLv2AudioInputData *input_data;
365
366 input_data = channel_data->input_data[k];
367
368 if(output_port_count > 0 &&
369 buffer_size > 0){
370 if(input_data->output == NULL){
371 input_data->output = (float *) g_malloc(output_port_count * buffer_size * sizeof(float));
372 }else{
373 input_data->output = (float *) g_realloc(input_data->output,
374 output_port_count * buffer_size * sizeof(float));
375 }
376 }
377
378 if(input_port_count > 0 &&
379 buffer_size > 0){
380 if(input_data->input == NULL){
381 input_data->input = (float *) g_malloc(input_port_count * buffer_size * sizeof(float));
382 }else{
383 input_data->input = (float *) g_realloc(input_data->input,
384 input_port_count * buffer_size * sizeof(float));
385 }
386 }
387 }
388 }
389 }
390 }
391 }
392
393 g_rec_mutex_unlock(recall_mutex);
394 }
395
396 void
ags_fx_lv2_audio_notify_samplerate_callback(GObject * gobject,GParamSpec * pspec,gpointer user_data)397 ags_fx_lv2_audio_notify_samplerate_callback(GObject *gobject,
398 GParamSpec *pspec,
399 gpointer user_data)
400 {
401 AgsAudio *audio;
402 AgsChannel *start_input;
403 AgsRecallContainer *recall_container;
404
405 AgsFxLv2Audio *fx_lv2_audio;
406
407 AgsLv2Plugin *lv2_plugin;
408
409 GList *start_recall_channel, *recall_channel;
410
411 guint input_pads;
412 guint audio_channels;
413 guint output_port_count, input_port_count;
414 guint buffer_size;
415 guint samplerate;
416 guint i, j, k;
417 gboolean is_live_instrument;
418
419 GRecMutex *recall_mutex;
420 GRecMutex *base_plugin_mutex;
421
422 void (*deactivate)(LV2_Handle Instance);
423 void (*cleanup)(LV2_Handle Instance);
424
425 fx_lv2_audio = AGS_FX_LV2_AUDIO(gobject);
426
427 /* get recall mutex */
428 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(fx_lv2_audio);
429
430 /* get lv2 plugin */
431 g_rec_mutex_lock(recall_mutex);
432
433 lv2_plugin = fx_lv2_audio->lv2_plugin;
434
435 g_rec_mutex_unlock(recall_mutex);
436
437 if(lv2_plugin == NULL ||
438 !ags_base_plugin_test_flags((AgsBasePlugin *) lv2_plugin, AGS_BASE_PLUGIN_IS_INSTRUMENT)){
439 return;
440 }
441
442 audio = NULL;
443
444 recall_container = NULL;
445
446 buffer_size = AGS_SOUNDCARD_DEFAULT_BUFFER_SIZE;
447 samplerate = AGS_SOUNDCARD_DEFAULT_SAMPLERATE;
448
449 g_object_get(fx_lv2_audio,
450 "audio", &audio,
451 "recall-container", &recall_container,
452 "buffer-size", &buffer_size,
453 "samplerate", &samplerate,
454 NULL);
455
456 start_recall_channel = ags_recall_container_get_recall_channel(recall_container);
457
458 start_input = NULL;
459
460 input_pads = 0;
461 audio_channels = 0;
462
463 g_object_get(audio,
464 "input", &start_input,
465 "input-pads", &input_pads,
466 "audio-channels", &audio_channels,
467 NULL);
468
469 /* get port count */
470 g_rec_mutex_lock(recall_mutex);
471
472 output_port_count = fx_lv2_audio->output_port_count;
473 input_port_count = fx_lv2_audio->input_port_count;
474
475 g_rec_mutex_unlock(recall_mutex);
476
477 /* get deactivate and cleanup */
478 base_plugin_mutex = NULL;
479
480 deactivate = NULL;
481 cleanup = NULL;
482
483 if(lv2_plugin != NULL){
484 gpointer plugin_descriptor;
485
486 base_plugin_mutex = AGS_BASE_PLUGIN_GET_OBJ_MUTEX(lv2_plugin);
487
488 g_rec_mutex_lock(base_plugin_mutex);
489
490 plugin_descriptor = AGS_BASE_PLUGIN(lv2_plugin)->plugin_descriptor;
491
492 deactivate = AGS_LV2_PLUGIN_DESCRIPTOR(plugin_descriptor)->deactivate;
493 cleanup = AGS_LV2_PLUGIN_DESCRIPTOR(plugin_descriptor)->cleanup;
494
495 g_rec_mutex_unlock(base_plugin_mutex);
496 }
497
498 is_live_instrument = ags_fx_lv2_audio_test_flags(fx_lv2_audio, AGS_FX_LV2_AUDIO_LIVE_INSTRUMENT);
499
500 /* reallocate buffer - apply buffer size */
501 g_rec_mutex_lock(recall_mutex);
502
503 for(i = 0; i < AGS_SOUND_SCOPE_LAST; i++){
504 AgsFxLv2AudioScopeData *scope_data;
505
506 scope_data = fx_lv2_audio->scope_data[i];
507
508 if(i == AGS_SOUND_SCOPE_PLAYBACK ||
509 i == AGS_SOUND_SCOPE_NOTATION ||
510 i == AGS_SOUND_SCOPE_MIDI){
511 for(j = 0; j < scope_data->audio_channels; j++){
512 AgsFxLv2AudioChannelData *channel_data;
513
514 channel_data = scope_data->channel_data[j];
515
516 if(is_live_instrument){
517 AgsPort **iter;
518
519 guint nth;
520
521 if(deactivate != NULL &&
522 channel_data->lv2_handle != NULL){
523 deactivate(channel_data->lv2_handle[0]);
524 }
525
526 if(cleanup != NULL &&
527 channel_data->lv2_handle != NULL){
528 cleanup(channel_data->lv2_handle[0]);
529 }
530
531 channel_data->lv2_handle = ags_base_plugin_instantiate((AgsBasePlugin *) lv2_plugin,
532 samplerate, buffer_size);
533
534 for(nth = 0; nth < output_port_count; nth++){
535 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
536 channel_data->lv2_handle[0],
537 fx_lv2_audio->output_port[nth],
538 &(channel_data->output[nth]));
539 }
540
541 for(nth = 0; nth < input_port_count; nth++){
542 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
543 channel_data->lv2_handle[0],
544 fx_lv2_audio->input_port[nth],
545 &(channel_data->input[nth]));
546 }
547
548 if(fx_lv2_audio->lv2_port != NULL){
549 for(iter = fx_lv2_audio->lv2_port; iter[0] != NULL; iter++){
550 AgsPluginPort *plugin_port;
551
552 guint port_index;
553
554 plugin_port = NULL;
555
556 port_index = 0;
557
558 g_object_get(iter[0],
559 "plugin-port", &plugin_port,
560 NULL);
561
562 g_object_get(plugin_port,
563 "port-index", &port_index,
564 NULL);
565
566 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
567 channel_data->lv2_handle[0],
568 port_index,
569 &(iter[0]->port_value.ags_port_float));
570
571 if(plugin_port != NULL){
572 g_object_unref(plugin_port);
573 }
574 }
575 }
576 }
577
578 if(!is_live_instrument){
579 for(k = 0; k < AGS_SEQUENCER_MAX_MIDI_KEYS; k++){
580 AgsFxLv2AudioInputData *input_data;
581
582 input_data = channel_data->input_data[k];
583
584 if(deactivate != NULL &&
585 input_data->lv2_handle != NULL){
586 deactivate(input_data->lv2_handle[0]);
587 }
588
589 if(cleanup != NULL &&
590 input_data->lv2_handle != NULL){
591 cleanup(input_data->lv2_handle[0]);
592 }
593
594 input_data->lv2_handle = ags_base_plugin_instantiate((AgsBasePlugin *) lv2_plugin,
595 samplerate, buffer_size);
596 }
597 }
598 }
599 }
600 }
601
602 if(!is_live_instrument){
603 for(j = 0; j < audio_channels; j++){
604 for(k = 0; k < input_pads; k++){
605 AgsChannel *input;
606
607 input = ags_channel_nth(start_input,
608 k * audio_channels + j);
609
610 recall_channel = ags_recall_template_find_provider(start_recall_channel, (GObject *) input);
611
612 if(recall_channel != NULL){
613 ags_fx_lv2_channel_load_port(recall_channel->data);
614 }
615
616 if(input != NULL){
617 g_object_unref(input);
618 }
619 }
620 }
621 }
622
623 g_rec_mutex_unlock(recall_mutex);
624
625 /* unref */
626 if(start_input != NULL){
627 g_object_unref(start_input);
628 }
629
630 if(recall_container != NULL){
631 g_object_unref(recall_container);
632 }
633 }
634
635 void
ags_fx_lv2_audio_set_audio_channels_callback(AgsAudio * audio,guint audio_channels,guint audio_channels_old,AgsFxLv2Audio * fx_lv2_audio)636 ags_fx_lv2_audio_set_audio_channels_callback(AgsAudio *audio,
637 guint audio_channels, guint audio_channels_old,
638 AgsFxLv2Audio *fx_lv2_audio)
639 {
640 AgsChannel *start_input;
641 AgsRecallContainer *recall_container;
642
643 AgsLv2Plugin *lv2_plugin;
644
645 GList *start_recall_channel, *recall_channel;
646
647 guint input_pads;
648 guint output_port_count, input_port_count;
649 guint buffer_size;
650 guint samplerate;
651 guint i, j, k;
652 gboolean is_live_instrument;
653
654 GRecMutex *recall_mutex;
655
656 /* get recall mutex */
657 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(fx_lv2_audio);
658
659 /* get lv2 plugin */
660 g_rec_mutex_lock(recall_mutex);
661
662 lv2_plugin = fx_lv2_audio->lv2_plugin;
663
664 g_rec_mutex_unlock(recall_mutex);
665
666 if(lv2_plugin == NULL ||
667 !ags_base_plugin_test_flags((AgsBasePlugin *) lv2_plugin, AGS_BASE_PLUGIN_IS_INSTRUMENT)){
668 return;
669 }
670
671 start_input = NULL;
672
673 input_pads = 0;
674
675 g_object_get(audio,
676 "input", &start_input,
677 "input-pads", &input_pads,
678 NULL);
679
680 /* recall container, buffer size and samplerate */
681 recall_container = NULL;
682
683 buffer_size = AGS_SOUNDCARD_DEFAULT_BUFFER_SIZE;
684 samplerate = AGS_SOUNDCARD_DEFAULT_SAMPLERATE;
685
686 g_object_get(fx_lv2_audio,
687 "recall-container", &recall_container,
688 "buffer-size", &buffer_size,
689 "samplerate", &samplerate,
690 NULL);
691
692 start_recall_channel = ags_recall_container_get_recall_channel(recall_container);
693
694 /* get LV2 plugin */
695 g_rec_mutex_lock(recall_mutex);
696
697 output_port_count = fx_lv2_audio->output_port_count;
698 input_port_count = fx_lv2_audio->input_port_count;
699
700 g_rec_mutex_unlock(recall_mutex);
701
702 /* allocate channel data */
703 is_live_instrument = ags_fx_lv2_audio_test_flags(fx_lv2_audio, AGS_FX_LV2_AUDIO_LIVE_INSTRUMENT);
704
705 g_rec_mutex_lock(recall_mutex);
706
707 for(i = 0; i < AGS_SOUND_SCOPE_LAST; i++){
708 AgsFxLv2AudioScopeData *scope_data;
709
710 scope_data = fx_lv2_audio->scope_data[i];
711
712 if(i == AGS_SOUND_SCOPE_PLAYBACK ||
713 i == AGS_SOUND_SCOPE_NOTATION ||
714 i == AGS_SOUND_SCOPE_MIDI){
715 if(scope_data->audio_channels > audio_channels){
716 for(j = scope_data->audio_channels; j < audio_channels; j++){
717 AgsFxLv2AudioChannelData *channel_data;
718
719 channel_data = scope_data->channel_data[j];
720
721 ags_fx_lv2_audio_channel_data_free(channel_data);
722 }
723 }
724
725 if(scope_data->channel_data == NULL){
726 scope_data->channel_data = (AgsFxLv2AudioChannelData **) g_malloc(audio_channels * sizeof(AgsFxLv2AudioChannelData *));
727 }else{
728 scope_data->channel_data = (AgsFxLv2AudioChannelData **) g_realloc(scope_data->channel_data,
729 audio_channels * sizeof(AgsFxLv2AudioChannelData *));
730 }
731
732 if(scope_data->audio_channels < audio_channels){
733 for(j = scope_data->audio_channels; j < audio_channels; j++){
734 AgsFxLv2AudioChannelData *channel_data;
735
736 channel_data =
737 scope_data->channel_data[j] = ags_fx_lv2_audio_channel_data_alloc();
738
739 if(is_live_instrument){
740 AgsPort **iter;
741
742 guint nth;
743
744 channel_data->lv2_handle = ags_base_plugin_instantiate((AgsBasePlugin *) lv2_plugin,
745 samplerate, buffer_size);
746
747 if(output_port_count > 0 &&
748 buffer_size > 0){
749 if(channel_data->output == NULL){
750 channel_data->output = (float *) g_malloc(output_port_count * buffer_size * sizeof(float));
751 }else{
752 channel_data->output = (float *) g_realloc(channel_data->output,
753 output_port_count * buffer_size * sizeof(float));
754 }
755 }
756
757 if(input_port_count > 0 &&
758 buffer_size > 0){
759 if(channel_data->input == NULL){
760 channel_data->input = (float *) g_malloc(input_port_count * buffer_size * sizeof(float));
761 }else{
762 channel_data->input = (float *) g_realloc(channel_data->input,
763 input_port_count * buffer_size * sizeof(float));
764 }
765 }
766
767 for(nth = 0; nth < output_port_count; nth++){
768 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
769 channel_data->lv2_handle[0],
770 fx_lv2_audio->output_port[nth],
771 &(channel_data->output[nth]));
772 }
773
774 for(nth = 0; nth < input_port_count; nth++){
775 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
776 channel_data->lv2_handle[0],
777 fx_lv2_audio->input_port[nth],
778 &(channel_data->input[nth]));
779 }
780
781 for(iter = fx_lv2_audio->lv2_port; iter[0] != NULL; iter++){
782 AgsPluginPort *plugin_port;
783
784 guint port_index;
785
786 plugin_port = NULL;
787
788 port_index = 0;
789
790 g_object_get(iter[0],
791 "plugin-port", &plugin_port,
792 NULL);
793
794 g_object_get(plugin_port,
795 "port-index", &port_index,
796 NULL);
797
798 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
799 channel_data->lv2_handle[0],
800 port_index,
801 &(iter[0]->port_value.ags_port_float));
802
803 if(plugin_port != NULL){
804 g_object_unref(plugin_port);
805 }
806 }
807 }
808
809 if(!is_live_instrument){
810 for(k = 0; k < AGS_SEQUENCER_MAX_MIDI_KEYS; k++){
811 AgsFxLv2AudioInputData *input_data;
812
813 input_data = channel_data->input_data[k];
814
815 input_data->lv2_handle = ags_base_plugin_instantiate((AgsBasePlugin *) lv2_plugin,
816 samplerate, buffer_size);
817
818 if(output_port_count > 0 &&
819 buffer_size > 0){
820 if(input_data->output == NULL){
821 input_data->output = (float *) g_malloc(output_port_count * buffer_size * sizeof(float));
822 }else{
823 input_data->output = (float *) g_realloc(input_data->output,
824 output_port_count * buffer_size * sizeof(float));
825 }
826 }
827
828 if(input_port_count > 0 &&
829 buffer_size > 0){
830 if(input_data->input == NULL){
831 input_data->input = (float *) g_malloc(input_port_count * buffer_size * sizeof(float));
832 }else{
833 input_data->input = (float *) g_realloc(input_data->input,
834 input_port_count * buffer_size * sizeof(float));
835 }
836 }
837 }
838 }
839 }
840 }
841
842 scope_data->audio_channels = audio_channels;
843 }
844 }
845
846 if(!is_live_instrument &&
847 audio_channels_old < audio_channels){
848 for(j = audio_channels_old; j < audio_channels; j++){
849 for(k = 0; k < input_pads; k++){
850 AgsChannel *input;
851
852 input = ags_channel_nth(start_input,
853 k * audio_channels + j);
854
855 recall_channel = ags_recall_template_find_provider(start_recall_channel, (GObject *) input);
856
857 if(recall_channel != NULL){
858 ags_fx_lv2_channel_load_port(recall_channel->data);
859 }
860
861 if(input != NULL){
862 g_object_unref(input);
863 }
864 }
865 }
866 }
867
868 g_rec_mutex_unlock(recall_mutex);
869
870 if(start_input != NULL){
871 g_object_unref(start_input);
872 }
873
874 if(recall_container != NULL){
875 g_object_unref(recall_container);
876 }
877 }
878
879 void
ags_fx_lv2_audio_set_pads_callback(AgsAudio * audio,GType channel_type,guint pads,guint pads_old,AgsFxLv2Audio * fx_lv2_audio)880 ags_fx_lv2_audio_set_pads_callback(AgsAudio *audio,
881 GType channel_type,
882 guint pads, guint pads_old,
883 AgsFxLv2Audio *fx_lv2_audio)
884 {
885 AgsChannel *start_input;
886 AgsRecallContainer *recall_container;
887
888 GList *start_recall_channel, *recall_channel;
889
890 guint audio_channels;
891 guint j, k;
892 gboolean is_live_instrument;
893
894 GRecMutex *recall_mutex;
895
896 if(!g_type_is_a(channel_type, AGS_TYPE_INPUT)){
897 return;
898 }
899
900 /* get recall mutex */
901 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(fx_lv2_audio);
902
903 /* get LV2 plugin and port */
904 is_live_instrument = ags_fx_lv2_audio_test_flags(fx_lv2_audio, AGS_FX_LV2_AUDIO_LIVE_INSTRUMENT);
905
906 if(is_live_instrument){
907 return;
908 }
909
910 start_input = NULL;
911
912 audio_channels = 0;
913
914 g_object_get(audio,
915 "input", &start_input,
916 "audio-channels", &audio_channels,
917 NULL);
918
919 recall_container = NULL;
920
921 g_object_get(fx_lv2_audio,
922 "recall-container", &recall_container,
923 NULL);
924
925 start_recall_channel = ags_recall_container_get_recall_channel(recall_container);
926
927 /* connect */
928 if(pads_old < pads){
929 for(j = 0; j < audio_channels; j++){
930 for(k = pads_old; k < pads; k++){
931 AgsChannel *input;
932
933 input = ags_channel_nth(start_input,
934 k * audio_channels + j);
935
936 recall_channel = ags_recall_template_find_provider(start_recall_channel, (GObject *) input);
937
938 if(recall_channel != NULL){
939 ags_fx_lv2_channel_load_port(recall_channel->data);
940 }
941
942 if(input != NULL){
943 g_object_unref(input);
944 }
945 }
946 }
947 }
948
949 /* disconnect */
950 if(pads < pads_old){
951 //NOTE:JK: this won't work see AgsFxLv2Channel::finalize()
952 }
953
954 if(start_input != NULL){
955 g_object_unref(start_input);
956 }
957
958 if(recall_container != NULL){
959 g_object_unref(recall_container);
960 }
961 }
962
963 /**
964 * ags_fx_lv2_audio_scope_data_alloc:
965 *
966 * Allocate #AgsFxLv2AudioScopeData-struct
967 *
968 * Returns: the new #AgsFxLv2AudioScopeData-struct
969 *
970 * Since: 3.3.0
971 */
972 AgsFxLv2AudioScopeData*
ags_fx_lv2_audio_scope_data_alloc()973 ags_fx_lv2_audio_scope_data_alloc()
974 {
975 AgsFxLv2AudioScopeData *scope_data;
976
977 scope_data = (AgsFxLv2AudioScopeData *) g_malloc(sizeof(AgsFxLv2AudioScopeData));
978
979 g_rec_mutex_init(&(scope_data->strct_mutex));
980
981 scope_data->parent = NULL;
982
983 scope_data->audio_channels = 0;
984
985 scope_data->channel_data = NULL;
986
987 return(scope_data);
988 }
989
990 /**
991 * ags_fx_lv2_audio_scope_data_free:
992 * @scope_data: the #AgsFxLv2AudioScopeData-struct
993 *
994 * Free @scope_data.
995 *
996 * Since: 3.3.0
997 */
998 void
ags_fx_lv2_audio_scope_data_free(AgsFxLv2AudioScopeData * scope_data)999 ags_fx_lv2_audio_scope_data_free(AgsFxLv2AudioScopeData *scope_data)
1000 {
1001 guint i;
1002
1003 if(scope_data == NULL){
1004 return;
1005 }
1006
1007 for(i = 0; i < scope_data->audio_channels; i++){
1008 ags_fx_lv2_audio_channel_data_free(scope_data->channel_data[i]);
1009 }
1010
1011 g_free(scope_data);
1012 }
1013
1014 /**
1015 * ags_fx_lv2_audio_channel_data_alloc:
1016 *
1017 * Allocate #AgsFxLv2AudioChannelData-struct
1018 *
1019 * Returns: the new #AgsFxLv2AudioChannelData-struct
1020 *
1021 * Since: 3.3.0
1022 */
1023 AgsFxLv2AudioChannelData*
ags_fx_lv2_audio_channel_data_alloc()1024 ags_fx_lv2_audio_channel_data_alloc()
1025 {
1026 AgsFxLv2AudioChannelData *channel_data;
1027
1028 guint i;
1029
1030 channel_data = (AgsFxLv2AudioChannelData *) g_malloc(sizeof(AgsFxLv2AudioChannelData));
1031
1032 g_rec_mutex_init(&(channel_data->strct_mutex));
1033
1034 channel_data->parent = NULL;
1035
1036 channel_data->event_count = 0;
1037
1038 channel_data->output = NULL;
1039 channel_data->input = NULL;
1040
1041 channel_data->event_port = NULL;
1042 channel_data->atom_port = NULL;
1043
1044 channel_data->lv2_handle = NULL;
1045
1046 for(i = 0; i < AGS_SEQUENCER_MAX_MIDI_KEYS; i++){
1047 channel_data->input_data[i] = ags_fx_lv2_audio_input_data_alloc();
1048
1049 channel_data->input_data[i]->parent = channel_data;
1050 }
1051
1052 return(channel_data);
1053 }
1054
1055 /**
1056 * ags_fx_lv2_audio_channel_data_free:
1057 * @channel_data: the #AgsFxLv2AudioChannelData-struct
1058 *
1059 * Free @channel_data.
1060 *
1061 * Since: 3.3.0
1062 */
1063 void
ags_fx_lv2_audio_channel_data_free(AgsFxLv2AudioChannelData * channel_data)1064 ags_fx_lv2_audio_channel_data_free(AgsFxLv2AudioChannelData *channel_data)
1065 {
1066 AgsLv2Plugin *lv2_plugin;
1067
1068 guint i;
1069
1070 if(channel_data == NULL){
1071 return;
1072 }
1073
1074 g_free(channel_data->output);
1075 g_free(channel_data->input);
1076
1077 ags_lv2_plugin_event_buffer_free(channel_data->event_port);
1078 ags_lv2_plugin_atom_sequence_free(channel_data->atom_port);
1079
1080 if(channel_data->lv2_handle != NULL){
1081 gpointer plugin_descriptor;
1082
1083 GRecMutex *base_plugin_mutex;
1084
1085 void (*deactivate)(LV2_Handle instance);
1086 void (*cleanup)(LV2_Handle instance);
1087
1088 lv2_plugin = NULL;
1089
1090 deactivate = NULL;
1091 cleanup = NULL;
1092
1093 base_plugin_mutex = NULL;
1094
1095 if(channel_data->parent != NULL &&
1096 AGS_FX_LV2_AUDIO_SCOPE_DATA(channel_data->parent)->parent != NULL){
1097 lv2_plugin = AGS_FX_LV2_AUDIO(AGS_FX_LV2_AUDIO_SCOPE_DATA(channel_data->parent)->parent)->lv2_plugin;
1098 }
1099
1100 if(lv2_plugin != NULL){
1101 base_plugin_mutex = AGS_BASE_PLUGIN_GET_OBJ_MUTEX(lv2_plugin);
1102
1103 g_rec_mutex_lock(base_plugin_mutex);
1104
1105 plugin_descriptor = AGS_BASE_PLUGIN(lv2_plugin)->plugin_descriptor;
1106
1107 deactivate = AGS_LV2_PLUGIN_DESCRIPTOR(plugin_descriptor)->deactivate;
1108 cleanup = AGS_LV2_PLUGIN_DESCRIPTOR(plugin_descriptor)->cleanup;
1109
1110 g_rec_mutex_unlock(base_plugin_mutex);
1111 }
1112
1113 if(deactivate != NULL &&
1114 channel_data->lv2_handle != NULL){
1115 deactivate(channel_data->lv2_handle[0]);
1116 }
1117
1118 if(cleanup != NULL &&
1119 channel_data->lv2_handle != NULL){
1120 cleanup(channel_data->lv2_handle[0]);
1121 }
1122 }
1123
1124 for(i = 0; i < AGS_SEQUENCER_MAX_MIDI_KEYS; i++){
1125 ags_fx_lv2_audio_input_data_free(channel_data->input_data[i]);
1126 }
1127
1128 g_free(channel_data);
1129 }
1130
1131 /**
1132 * ags_fx_lv2_audio_input_data_alloc:
1133 *
1134 * Allocate #AgsFxLv2AudioInputData-struct
1135 *
1136 * Returns: the new #AgsFxLv2AudioInputData-struct
1137 *
1138 * Since: 3.3.0
1139 */
1140 AgsFxLv2AudioInputData*
ags_fx_lv2_audio_input_data_alloc()1141 ags_fx_lv2_audio_input_data_alloc()
1142 {
1143 AgsFxLv2AudioInputData *input_data;
1144
1145 input_data = (AgsFxLv2AudioInputData *) g_malloc(sizeof(AgsFxLv2AudioInputData));
1146
1147 g_rec_mutex_init(&(input_data->strct_mutex));
1148
1149 input_data->parent = NULL;
1150
1151 input_data->output = NULL;
1152 input_data->input = NULL;
1153
1154 input_data->event_port = NULL;
1155 input_data->atom_port = NULL;
1156
1157 input_data->lv2_handle = NULL;
1158
1159 input_data->event_buffer = (snd_seq_event_t *) g_malloc(sizeof(snd_seq_event_t));
1160
1161 input_data->event_buffer->type = SND_SEQ_EVENT_NOTEON;
1162
1163 input_data->event_buffer->data.note.channel = 0;
1164 input_data->event_buffer->data.note.note = 0;
1165 input_data->event_buffer->data.note.velocity = 127;
1166
1167 input_data->key_on = 0;
1168
1169 return(input_data);
1170 }
1171
1172 /**
1173 * ags_fx_lv2_audio_input_data_free:
1174 * @input_data: the #AgsFxLv2AudioInputData-struct
1175 *
1176 * Free @input_data.
1177 *
1178 * Since: 3.3.0
1179 */
1180 void
ags_fx_lv2_audio_input_data_free(AgsFxLv2AudioInputData * input_data)1181 ags_fx_lv2_audio_input_data_free(AgsFxLv2AudioInputData *input_data)
1182 {
1183 AgsLv2Plugin *lv2_plugin;
1184
1185 if(input_data == NULL){
1186 return;
1187 }
1188
1189 g_free(input_data->output);
1190 g_free(input_data->input);
1191
1192 ags_lv2_plugin_event_buffer_free(input_data->event_port);
1193 ags_lv2_plugin_atom_sequence_free(input_data->atom_port);
1194
1195 if(input_data->lv2_handle != NULL){
1196 gpointer plugin_descriptor;
1197
1198 GRecMutex *base_plugin_mutex;
1199
1200 void (*deactivate)(LV2_Handle instance);
1201 void (*cleanup)(LV2_Handle instance);
1202
1203 lv2_plugin = NULL;
1204
1205 deactivate = NULL;
1206 cleanup = NULL;
1207
1208 base_plugin_mutex = NULL;
1209
1210 if(input_data->parent != NULL &&
1211 AGS_FX_LV2_AUDIO_CHANNEL_DATA(input_data->parent)->parent != NULL &&
1212 AGS_FX_LV2_AUDIO_SCOPE_DATA(AGS_FX_LV2_AUDIO_CHANNEL_DATA(input_data->parent)->parent)->parent != NULL){
1213 lv2_plugin = AGS_FX_LV2_AUDIO(AGS_FX_LV2_AUDIO_SCOPE_DATA(AGS_FX_LV2_AUDIO_CHANNEL_DATA(input_data->parent)->parent)->parent)->lv2_plugin;
1214 }
1215
1216 if(lv2_plugin != NULL){
1217 base_plugin_mutex = AGS_BASE_PLUGIN_GET_OBJ_MUTEX(lv2_plugin);
1218
1219 g_rec_mutex_lock(base_plugin_mutex);
1220
1221 plugin_descriptor = AGS_BASE_PLUGIN(lv2_plugin)->plugin_descriptor;
1222
1223 deactivate = AGS_LV2_PLUGIN_DESCRIPTOR(plugin_descriptor)->deactivate;
1224 cleanup = AGS_LV2_PLUGIN_DESCRIPTOR(plugin_descriptor)->cleanup;
1225
1226 g_rec_mutex_unlock(base_plugin_mutex);
1227 }
1228
1229 if(deactivate != NULL){
1230 deactivate(input_data->lv2_handle[0]);
1231 }
1232
1233 if(cleanup != NULL){
1234 cleanup(input_data->lv2_handle[0]);
1235 }
1236 }
1237
1238 g_free(input_data->event_buffer);
1239
1240 g_free(input_data);
1241 }
1242
1243 /**
1244 * ags_fx_lv2_audio_test_flags:
1245 * @fx_lv2_audio: the #AgsFxLv2Audio
1246 * @flags: the flags
1247 *
1248 * Test @flags of @fx_lv2_audio.
1249 *
1250 * Returns: %TRUE on success, otherwise %FALSE
1251 *
1252 * Since: 3.3.0
1253 */
1254 gboolean
ags_fx_lv2_audio_test_flags(AgsFxLv2Audio * fx_lv2_audio,guint flags)1255 ags_fx_lv2_audio_test_flags(AgsFxLv2Audio *fx_lv2_audio, guint flags)
1256 {
1257 gboolean success;
1258
1259 GRecMutex *recall_mutex;
1260
1261 if(!AGS_IS_FX_LV2_AUDIO(fx_lv2_audio)){
1262 return(FALSE);
1263 }
1264
1265 /* get recall mutex */
1266 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(fx_lv2_audio);
1267
1268 /* test flags */
1269 g_rec_mutex_lock(recall_mutex);
1270
1271 success = ((flags & (fx_lv2_audio->flags)) != 0) ? TRUE: FALSE;
1272
1273 g_rec_mutex_unlock(recall_mutex);
1274
1275 return(success);
1276 }
1277
1278 /**
1279 * ags_fx_lv2_audio_set_flags:
1280 * @fx_lv2_audio: the #AgsFxLv2Audio
1281 * @flags: the flags
1282 *
1283 * Set @flags of @fx_lv2_audio.
1284 *
1285 * Since: 3.3.0
1286 */
1287 void
ags_fx_lv2_audio_set_flags(AgsFxLv2Audio * fx_lv2_audio,guint flags)1288 ags_fx_lv2_audio_set_flags(AgsFxLv2Audio *fx_lv2_audio, guint flags)
1289 {
1290 GRecMutex *recall_mutex;
1291
1292 if(!AGS_IS_FX_LV2_AUDIO(fx_lv2_audio)){
1293 return;
1294 }
1295
1296 /* get recall mutex */
1297 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(fx_lv2_audio);
1298
1299 /* set flags */
1300 g_rec_mutex_lock(recall_mutex);
1301
1302 fx_lv2_audio->flags |= flags;
1303
1304 g_rec_mutex_unlock(recall_mutex);
1305 }
1306
1307 /**
1308 * ags_fx_lv2_audio_unset_flags:
1309 * @fx_lv2_audio: the #AgsFxLv2Audio
1310 * @flags: the flags
1311 *
1312 * Unset @flags of @fx_lv2_audio.
1313 *
1314 * Since: 3.3.0
1315 */
1316 void
ags_fx_lv2_audio_unset_flags(AgsFxLv2Audio * fx_lv2_audio,guint flags)1317 ags_fx_lv2_audio_unset_flags(AgsFxLv2Audio *fx_lv2_audio, guint flags)
1318 {
1319 GRecMutex *recall_mutex;
1320
1321 if(!AGS_IS_FX_LV2_AUDIO(fx_lv2_audio)){
1322 return;
1323 }
1324
1325 /* get recall mutex */
1326 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(fx_lv2_audio);
1327
1328 /* set flags */
1329 g_rec_mutex_lock(recall_mutex);
1330
1331 fx_lv2_audio->flags &= (~flags);
1332
1333 g_rec_mutex_unlock(recall_mutex);
1334 }
1335
1336 /**
1337 * ags_fx_lv2_audio_load_plugin:
1338 * @fx_lv2_audio: the #AgsFxLv2Audio
1339 *
1340 * Load plugin of @fx_lv2_audio.
1341 *
1342 * Since: 3.3.0
1343 */
1344 void
ags_fx_lv2_audio_load_plugin(AgsFxLv2Audio * fx_lv2_audio)1345 ags_fx_lv2_audio_load_plugin(AgsFxLv2Audio *fx_lv2_audio)
1346 {
1347 AgsLv2Manager *lv2_manager;
1348 AgsLv2Plugin *lv2_plugin;
1349
1350 gchar *filename, *effect;
1351
1352 guint buffer_size;
1353 guint samplerate;
1354
1355 GRecMutex *recall_mutex;
1356
1357 if(!AGS_IS_FX_LV2_AUDIO(fx_lv2_audio)){
1358 return;
1359 }
1360
1361 lv2_manager = ags_lv2_manager_get_instance();
1362
1363 /* get recall mutex */
1364 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(fx_lv2_audio);
1365
1366 /* get filename and effect */
1367 filename = NULL;
1368 effect = NULL;
1369
1370 buffer_size = AGS_SOUNDCARD_DEFAULT_BUFFER_SIZE;
1371 samplerate = AGS_SOUNDCARD_DEFAULT_SAMPLERATE;
1372
1373 g_object_get(fx_lv2_audio,
1374 "filename", &filename,
1375 "effect", &effect,
1376 "buffer-size", &buffer_size,
1377 "samplerate", &samplerate,
1378 NULL);
1379
1380 /* check if already loaded */
1381 g_rec_mutex_lock(recall_mutex);
1382
1383 lv2_plugin = fx_lv2_audio->lv2_plugin;
1384
1385 if(lv2_plugin == NULL){
1386 lv2_plugin =
1387 fx_lv2_audio->lv2_plugin = ags_lv2_manager_find_lv2_plugin(lv2_manager,
1388 filename, effect);
1389 g_object_ref(lv2_plugin);
1390 }
1391
1392 g_rec_mutex_unlock(recall_mutex);
1393
1394 if(lv2_plugin == NULL ||
1395 !ags_base_plugin_test_flags((AgsBasePlugin *) lv2_plugin, AGS_BASE_PLUGIN_IS_INSTRUMENT)){
1396 g_free(filename);
1397 g_free(effect);
1398
1399 return;
1400 }
1401
1402 if(lv2_plugin != NULL){
1403 guint i, j, k;
1404 gboolean is_live_instrument;
1405
1406 is_live_instrument = ags_fx_lv2_audio_test_flags(fx_lv2_audio, AGS_FX_LV2_AUDIO_LIVE_INSTRUMENT);
1407
1408 /* set lv2 plugin */
1409 g_rec_mutex_lock(recall_mutex);
1410
1411 for(i = 0; i < AGS_SOUND_SCOPE_LAST; i++){
1412 AgsFxLv2AudioScopeData *scope_data;
1413
1414 scope_data = fx_lv2_audio->scope_data[i];
1415
1416 if(i == AGS_SOUND_SCOPE_PLAYBACK ||
1417 i == AGS_SOUND_SCOPE_NOTATION ||
1418 i == AGS_SOUND_SCOPE_MIDI){
1419 for(j = 0; j < scope_data->audio_channels; j++){
1420 AgsFxLv2AudioChannelData *channel_data;
1421
1422 channel_data = scope_data->channel_data[j];
1423
1424 if(is_live_instrument){
1425 if(channel_data->lv2_handle == NULL){
1426 channel_data->lv2_handle = ags_base_plugin_instantiate((AgsBasePlugin *) lv2_plugin,
1427 samplerate, buffer_size);
1428 }
1429 }
1430
1431 if(!is_live_instrument){
1432 for(k = 0; k < AGS_SEQUENCER_MAX_MIDI_KEYS; k++){
1433 AgsFxLv2AudioInputData *input_data;
1434
1435 input_data = channel_data->input_data[k];
1436
1437 if(input_data->lv2_handle == NULL){
1438 input_data->lv2_handle = ags_base_plugin_instantiate((AgsBasePlugin *) lv2_plugin,
1439 samplerate, buffer_size);
1440 }
1441 }
1442 }
1443 }
1444 }
1445 }
1446
1447 g_rec_mutex_unlock(recall_mutex);
1448 }
1449
1450 g_free(filename);
1451 g_free(effect);
1452 }
1453
1454 void
ags_fx_lv2_audio_load_port(AgsFxLv2Audio * fx_lv2_audio)1455 ags_fx_lv2_audio_load_port(AgsFxLv2Audio *fx_lv2_audio)
1456 {
1457 AgsAudio *audio;
1458 AgsChannel *start_input;
1459 AgsRecallContainer *recall_container;
1460 AgsPort **lv2_port;
1461
1462 AgsLv2Plugin *lv2_plugin;
1463
1464 GList *start_recall_channel, *recall_channel;
1465 GList *start_plugin_port, *plugin_port;
1466
1467 guint *output_port;
1468 guint *input_port;
1469
1470 guint input_pads;
1471 guint audio_channels;
1472 guint output_port_count, input_port_count;
1473 guint control_port_count;
1474 guint event_port;
1475 guint atom_port;
1476 guint buffer_size;
1477 guint nth;
1478 guint i, j, k;
1479 gboolean is_live_instrument;
1480 gboolean has_atom_port;
1481 gboolean has_event_port;
1482
1483 GRecMutex *recall_mutex;
1484
1485 if(!AGS_IS_FX_LV2_AUDIO(fx_lv2_audio)){
1486 return;
1487 }
1488
1489 /* get recall mutex */
1490 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(fx_lv2_audio);
1491
1492 g_rec_mutex_lock(recall_mutex);
1493
1494 if(fx_lv2_audio->lv2_port != NULL){
1495 g_rec_mutex_unlock(recall_mutex);
1496
1497 return;
1498 }
1499
1500 lv2_plugin = fx_lv2_audio->lv2_plugin;
1501
1502 g_rec_mutex_unlock(recall_mutex);
1503
1504 if(lv2_plugin == NULL ||
1505 !ags_base_plugin_test_flags((AgsBasePlugin *) lv2_plugin, AGS_BASE_PLUGIN_IS_INSTRUMENT)){
1506 return;
1507 }
1508
1509 audio = NULL;
1510
1511 recall_container = NULL;
1512
1513 g_object_get(fx_lv2_audio,
1514 "audio", &audio,
1515 "recall-container", &recall_container,
1516 "buffer-size", &buffer_size,
1517 NULL);
1518
1519 start_recall_channel = ags_recall_container_get_recall_channel(recall_container);
1520
1521 start_input = NULL;
1522
1523 input_pads = 0;
1524 audio_channels = 0;
1525
1526 g_object_get(audio,
1527 "input", &start_input,
1528 "input-pads", &input_pads,
1529 "audio-channels", &audio_channels,
1530 NULL);
1531
1532 /* get LV2 plugin and port */
1533 g_rec_mutex_lock(recall_mutex);
1534
1535 lv2_port = fx_lv2_audio->lv2_port;
1536
1537 g_rec_mutex_unlock(recall_mutex);
1538
1539 g_object_get(lv2_plugin,
1540 "plugin-port", &start_plugin_port,
1541 NULL);
1542
1543 /* get control port count */
1544 plugin_port = start_plugin_port;
1545
1546 output_port = NULL;
1547 input_port = NULL;
1548
1549 output_port_count = 0;
1550 input_port_count = 0;
1551
1552 has_event_port = FALSE;
1553 event_port = 0;
1554
1555 has_atom_port = FALSE;
1556 atom_port = 0;
1557
1558 control_port_count = 0;
1559
1560 is_live_instrument = ags_fx_lv2_audio_test_flags(fx_lv2_audio, AGS_FX_LV2_AUDIO_LIVE_INSTRUMENT);
1561
1562 while(plugin_port != NULL){
1563 guint port_index;
1564
1565 g_object_get(plugin_port->data,
1566 "port-index", &port_index,
1567 NULL);
1568
1569 if(ags_plugin_port_test_flags(plugin_port->data,
1570 AGS_PLUGIN_PORT_CONTROL)){
1571 control_port_count++;
1572 }else if(ags_plugin_port_test_flags(plugin_port->data,
1573 AGS_PLUGIN_PORT_AUDIO)){
1574 if(ags_plugin_port_test_flags(plugin_port->data,
1575 AGS_PLUGIN_PORT_INPUT)){
1576 if(input_port == NULL){
1577 input_port = (guint *) g_malloc(sizeof(guint));
1578 }else{
1579 input_port = (guint *) g_realloc(input_port,
1580 (input_port_count + 1) * sizeof(guint));
1581 }
1582
1583 input_port[input_port_count] = port_index;
1584 input_port_count++;
1585 }else if(ags_plugin_port_test_flags(plugin_port->data,
1586 AGS_PLUGIN_PORT_OUTPUT)){
1587 if(output_port == NULL){
1588 output_port = (guint *) g_malloc(sizeof(guint));
1589 }else{
1590 output_port = (guint *) g_realloc(output_port,
1591 (output_port_count + 1) * sizeof(guint));
1592 }
1593
1594 output_port[output_port_count] = port_index;
1595 output_port_count++;
1596 }
1597 }
1598
1599 if(ags_plugin_port_test_flags(plugin_port->data,
1600 AGS_PLUGIN_PORT_INPUT)){
1601 if(ags_plugin_port_test_flags(plugin_port->data, AGS_PLUGIN_PORT_EVENT)){
1602 has_event_port = TRUE;
1603
1604 event_port = port_index;
1605 }else if(ags_plugin_port_test_flags(plugin_port->data, AGS_PLUGIN_PORT_ATOM)){
1606 has_atom_port = TRUE;
1607
1608 atom_port = port_index;
1609 }
1610 }
1611
1612 plugin_port = plugin_port->next;
1613 }
1614
1615 g_rec_mutex_lock(recall_mutex);
1616
1617 fx_lv2_audio->output_port_count = output_port_count;
1618 fx_lv2_audio->output_port = output_port;
1619
1620 fx_lv2_audio->input_port_count = input_port_count;
1621 fx_lv2_audio->input_port = input_port;
1622
1623 fx_lv2_audio->has_event_port = has_event_port;
1624 fx_lv2_audio->event_port = event_port;
1625
1626 fx_lv2_audio->has_atom_port = has_atom_port;
1627 fx_lv2_audio->atom_port = atom_port;
1628
1629 g_rec_mutex_unlock(recall_mutex);
1630
1631 /* */
1632 if(is_live_instrument){
1633 if(control_port_count > 0){
1634 lv2_port = (AgsPort **) g_malloc((control_port_count + 1) * sizeof(AgsPort *));
1635
1636 plugin_port = start_plugin_port;
1637
1638 for(nth = 0; nth < control_port_count && plugin_port != NULL;){
1639 if(ags_plugin_port_test_flags(plugin_port->data,
1640 AGS_PLUGIN_PORT_CONTROL)){
1641 AgsPluginPort *current_plugin_port;
1642
1643 gchar *plugin_name;
1644 gchar *specifier;
1645 gchar *control_port;
1646
1647 guint port_index;
1648
1649 GValue default_value = {0,};
1650
1651 GRecMutex *plugin_port_mutex;
1652
1653 current_plugin_port = AGS_PLUGIN_PORT(plugin_port->data);
1654
1655 /* get plugin port mutex */
1656 plugin_port_mutex = AGS_PLUGIN_PORT_GET_OBJ_MUTEX(current_plugin_port);
1657
1658 /* plugin name, specifier and control port */
1659 plugin_name = g_strdup_printf("lv2-<%s>", lv2_plugin->uri);
1660
1661 specifier = NULL;
1662
1663 port_index = 0;
1664
1665 g_object_get(current_plugin_port,
1666 "port-name", &specifier,
1667 "port-index", &port_index,
1668 NULL);
1669
1670 control_port = g_strdup_printf("%u/%u",
1671 nth,
1672 control_port_count);
1673
1674 /* default value */
1675 g_value_init(&default_value,
1676 G_TYPE_FLOAT);
1677
1678 g_rec_mutex_lock(plugin_port_mutex);
1679
1680 g_value_copy(current_plugin_port->default_value,
1681 &default_value);
1682
1683 g_rec_mutex_unlock(plugin_port_mutex);
1684
1685 /* lv2 port */
1686 lv2_port[nth] = g_object_new(AGS_TYPE_PORT,
1687 "plugin-name", plugin_name,
1688 "specifier", specifier,
1689 "control-port", control_port,
1690 "port-value-is-pointer", FALSE,
1691 "port-value-type", G_TYPE_FLOAT,
1692 NULL);
1693
1694 if(ags_plugin_port_test_flags(current_plugin_port,
1695 AGS_PLUGIN_PORT_OUTPUT)){
1696 ags_port_set_flags(lv2_port[nth], AGS_PORT_IS_OUTPUT);
1697
1698 ags_recall_set_flags((AgsRecall *) fx_lv2_audio,
1699 AGS_RECALL_HAS_OUTPUT_PORT);
1700
1701 }else{
1702 if(!ags_plugin_port_test_flags(current_plugin_port,
1703 AGS_PLUGIN_PORT_INTEGER) &&
1704 !ags_plugin_port_test_flags(current_plugin_port,
1705 AGS_PLUGIN_PORT_TOGGLED)){
1706 ags_port_set_flags(lv2_port[nth], AGS_PORT_INFINITE_RANGE);
1707 }
1708 }
1709
1710 g_object_set(lv2_port[nth],
1711 "plugin-port", current_plugin_port,
1712 NULL);
1713
1714 ags_port_util_load_lv2_conversion(lv2_port[nth],
1715 current_plugin_port);
1716
1717 ags_port_safe_write_raw(lv2_port[nth],
1718 &default_value);
1719
1720 ags_recall_add_port((AgsRecall *) fx_lv2_audio,
1721 lv2_port[nth]);
1722
1723 /* connect port */
1724 for(i = 0; i < AGS_SOUND_SCOPE_LAST; i++){
1725 AgsFxLv2AudioScopeData *scope_data;
1726
1727 scope_data = fx_lv2_audio->scope_data[i];
1728
1729 if(i == AGS_SOUND_SCOPE_PLAYBACK ||
1730 i == AGS_SOUND_SCOPE_NOTATION ||
1731 i == AGS_SOUND_SCOPE_MIDI){
1732 for(j = 0; j < scope_data->audio_channels; j++){
1733 AgsFxLv2AudioChannelData *channel_data;
1734
1735 channel_data = scope_data->channel_data[j];
1736
1737 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
1738 channel_data->lv2_handle[0],
1739 port_index,
1740 &(lv2_port[nth]->port_value.ags_port_float));
1741 }
1742 }
1743 }
1744
1745 g_free(plugin_name);
1746 g_free(specifier);
1747 g_free(control_port);
1748
1749 g_value_unset(&default_value);
1750
1751 nth++;
1752 }
1753
1754 plugin_port = plugin_port->next;
1755 }
1756
1757 lv2_port[nth] = NULL;
1758 }
1759 }else{
1760 for(j = 0; j < audio_channels; j++){
1761 for(k = 0; k < input_pads; k++){
1762 AgsChannel *input;
1763
1764 input = ags_channel_nth(start_input,
1765 k * audio_channels + j);
1766
1767 recall_channel = ags_recall_template_find_provider(start_recall_channel, (GObject *) input);
1768
1769 if(recall_channel != NULL){
1770 ags_fx_lv2_channel_load_port(recall_channel->data);
1771 }
1772
1773 if(input != NULL){
1774 g_object_unref(input);
1775 }
1776 }
1777 }
1778 }
1779
1780 /* set LV2 output */
1781 g_rec_mutex_lock(recall_mutex);
1782
1783 for(i = 0; i < AGS_SOUND_SCOPE_LAST; i++){
1784 AgsFxLv2AudioScopeData *scope_data;
1785
1786 scope_data = fx_lv2_audio->scope_data[i];
1787
1788 if(i == AGS_SOUND_SCOPE_PLAYBACK ||
1789 i == AGS_SOUND_SCOPE_NOTATION ||
1790 i == AGS_SOUND_SCOPE_MIDI){
1791 for(j = 0; j < scope_data->audio_channels; j++){
1792 AgsFxLv2AudioChannelData *channel_data;
1793
1794 channel_data = scope_data->channel_data[j];
1795
1796 if(is_live_instrument){
1797 guint nth;
1798
1799 if(channel_data->output == NULL &&
1800 output_port_count > 0 &&
1801 buffer_size > 0){
1802 channel_data->output = (float *) g_malloc(output_port_count * buffer_size * sizeof(float));
1803 }
1804
1805 if(channel_data->input == NULL &&
1806 input_port_count > 0 &&
1807 buffer_size > 0){
1808 channel_data->input = (float *) g_malloc(input_port_count * buffer_size * sizeof(float));
1809 }
1810
1811 for(nth = 0; nth < output_port_count; nth++){
1812 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
1813 channel_data->lv2_handle[0],
1814 output_port[nth],
1815 &(channel_data->output[nth]));
1816 }
1817
1818 for(nth = 0; nth < input_port_count; nth++){
1819 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
1820 channel_data->lv2_handle[0],
1821 input_port[nth],
1822 &(channel_data->input[nth]));
1823 }
1824
1825 if(has_event_port){
1826 channel_data->event_port = ags_lv2_plugin_event_buffer_alloc(AGS_FX_LV2_AUDIO_DEFAULT_MIDI_LENGHT);
1827
1828 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
1829 channel_data->lv2_handle[0],
1830 event_port,
1831 channel_data->event_port);
1832 }
1833
1834 if(has_atom_port){
1835 channel_data->atom_port = ags_lv2_plugin_alloc_atom_sequence(AGS_FX_LV2_AUDIO_DEFAULT_MIDI_LENGHT);
1836
1837 ags_base_plugin_connect_port((AgsBasePlugin *) lv2_plugin,
1838 channel_data->lv2_handle[0],
1839 atom_port,
1840 channel_data->atom_port);
1841 }
1842
1843 ags_base_plugin_activate((AgsBasePlugin *) lv2_plugin,
1844 channel_data->lv2_handle[0]);
1845 }
1846 }
1847 }
1848 }
1849
1850 fx_lv2_audio->lv2_port = lv2_port;
1851
1852 g_rec_mutex_unlock(recall_mutex);
1853
1854 /* unref */
1855 if(audio != NULL){
1856 g_object_unref(audio);
1857 }
1858
1859 if(start_input != NULL){
1860 g_object_unref(start_input);
1861 }
1862
1863 if(recall_container != NULL){
1864 g_object_unref(recall_container);
1865 }
1866
1867 g_list_free_full(start_plugin_port,
1868 (GDestroyNotify) g_object_unref);
1869 }
1870
1871 /**
1872 * ags_fx_lv2_audio_change_program:
1873 * @fx_lv2_audio: the #AgsFxLv2Audio
1874 * @bank_index: the bank index
1875 * @program_index: the program index
1876 *
1877 * Change program of @fx_lv2_audio.
1878 *
1879 * Since: 3.3.0
1880 */
1881 void
ags_fx_lv2_audio_change_program(AgsFxLv2Audio * fx_lv2_audio,guint bank_index,guint program_index)1882 ags_fx_lv2_audio_change_program(AgsFxLv2Audio *fx_lv2_audio,
1883 guint bank_index,
1884 guint program_index)
1885 {
1886 AgsLv2Plugin *lv2_plugin;
1887
1888 GRecMutex *recall_mutex;
1889
1890 if(!AGS_IS_FX_LV2_AUDIO(fx_lv2_audio)){
1891 return;
1892 }
1893
1894 /* get recall mutex */
1895 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(fx_lv2_audio);
1896
1897 /* get LV2 plugin and port */
1898 g_rec_mutex_lock(recall_mutex);
1899
1900 lv2_plugin = fx_lv2_audio->lv2_plugin;
1901
1902 g_rec_mutex_unlock(recall_mutex);
1903
1904 if(lv2_plugin == NULL ||
1905 !ags_base_plugin_test_flags((AgsBasePlugin *) lv2_plugin, AGS_BASE_PLUGIN_IS_INSTRUMENT)){
1906 return;
1907 }
1908
1909 if(lv2_plugin != NULL){
1910 guint i, j, k;
1911 gboolean is_live_instrument;
1912
1913 is_live_instrument = ags_fx_lv2_audio_test_flags(fx_lv2_audio, AGS_FX_LV2_AUDIO_LIVE_INSTRUMENT);
1914
1915 /* set lv2 plugin */
1916 g_object_ref(lv2_plugin);
1917
1918 g_rec_mutex_lock(recall_mutex);
1919
1920 fx_lv2_audio->lv2_plugin = lv2_plugin;
1921
1922 for(i = 0; i < AGS_SOUND_SCOPE_LAST; i++){
1923 AgsFxLv2AudioScopeData *scope_data;
1924
1925 scope_data = fx_lv2_audio->scope_data[i];
1926
1927 if(i == AGS_SOUND_SCOPE_PLAYBACK ||
1928 i == AGS_SOUND_SCOPE_NOTATION ||
1929 i == AGS_SOUND_SCOPE_MIDI){
1930 for(j = 0; j < scope_data->audio_channels; j++){
1931 AgsFxLv2AudioChannelData *channel_data;
1932
1933 channel_data = scope_data->channel_data[j];
1934
1935 if(is_live_instrument){
1936 ags_lv2_plugin_change_program(lv2_plugin,
1937 channel_data->lv2_handle[0],
1938 bank_index,
1939 program_index);
1940 }
1941
1942 if(!is_live_instrument){
1943 for(k = 0; k < AGS_SEQUENCER_MAX_MIDI_KEYS; k++){
1944 AgsFxLv2AudioInputData *input_data;
1945
1946 input_data = channel_data->input_data[k];
1947
1948 ags_lv2_plugin_change_program(lv2_plugin,
1949 input_data->lv2_handle[0],
1950 bank_index,
1951 program_index);
1952 }
1953 }
1954 }
1955 }
1956 }
1957
1958 g_rec_mutex_unlock(recall_mutex);
1959 }
1960 }
1961
1962 /**
1963 * ags_fx_lv2_audio_new:
1964 * @audio: the #AgsAudio
1965 *
1966 * Create a new instance of #AgsFxLv2Audio
1967 *
1968 * Returns: the new #AgsFxLv2Audio
1969 *
1970 * Since: 3.3.0
1971 */
1972 AgsFxLv2Audio*
ags_fx_lv2_audio_new(AgsAudio * audio)1973 ags_fx_lv2_audio_new(AgsAudio *audio)
1974 {
1975 AgsFxLv2Audio *fx_lv2_audio;
1976
1977 fx_lv2_audio = (AgsFxLv2Audio *) g_object_new(AGS_TYPE_FX_LV2_AUDIO,
1978 "audio", audio,
1979 NULL);
1980
1981 return(fx_lv2_audio);
1982 }
1983