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/recall/ags_capture_wave_audio.h>
21
22 #include <stdlib.h>
23 #include <string.h>
24
25 #include <ags/i18n.h>
26
27 void ags_capture_wave_audio_class_init(AgsCaptureWaveAudioClass *capture_wave_audio);
28 void ags_capture_wave_audio_init(AgsCaptureWaveAudio *capture_wave_audio);
29 void ags_capture_wave_audio_set_property(GObject *gobject,
30 guint prop_id,
31 const GValue *value,
32 GParamSpec *param_spec);
33 void ags_capture_wave_audio_get_property(GObject *gobject,
34 guint prop_id,
35 GValue *value,
36 GParamSpec *param_spec);
37 void ags_capture_wave_audio_finalize(GObject *gobject);
38
39 /**
40 * SECTION:ags_capture_wave_audio
41 * @short_description: capture audio wave
42 * @title: AgsCaptureWaveAudio
43 * @section_id:
44 * @include: ags/audio/recall/ags_capture_wave_audio.h
45 *
46 * The #AgsCaptureWaveAudio class provides ports to the effect processor.
47 */
48
49 enum{
50 PROP_0,
51 PROP_PLAYBACK,
52 PROP_REPLACE,
53 PROP_RECORD,
54 PROP_FILENAME,
55 PROP_FILE_AUDIO_CHANNELS,
56 PROP_FILE_SAMPLERATE,
57 PROP_FILE_BUFFER_SIZE,
58 PROP_FILE_FORMAT,
59 PROP_WAVE_LOOP,
60 PROP_WAVE_LOOP_START,
61 PROP_WAVE_LOOP_END,
62 };
63
64 static gpointer ags_capture_wave_audio_parent_class = NULL;
65
66 const gchar *ags_capture_wave_audio_plugin_name = "ags-capture-wave";
67 const gchar *ags_capture_wave_audio_specifier[] = {
68 "./playback[0]",
69 "./replace[0]",
70 "./record[0]",
71 "./filename[0]",
72 "./file-audio-channels[0]",
73 "./file-samplerate[0]",
74 "./file-buffer-size[0]",
75 "./file-format[0]",
76 "./wave_loop[0]",
77 "./wave_loop_start[0]",
78 "./wave_loop_end[0]",
79 };
80
81 const gchar *ags_capture_wave_audio_control_port[] = {
82 "1/11",
83 "2/11",
84 "3/11",
85 "4/11",
86 "5/11",
87 "6/11",
88 "7/11",
89 "8/11",
90 "9/11",
91 "10/11",
92 "11/11",
93 };
94
95 GType
ags_capture_wave_audio_get_type()96 ags_capture_wave_audio_get_type()
97 {
98 static volatile gsize g_define_type_id__volatile = 0;
99
100 if(g_once_init_enter (&g_define_type_id__volatile)){
101 GType ags_type_capture_wave_audio = 0;
102
103 static const GTypeInfo ags_capture_wave_audio_info = {
104 sizeof(AgsCaptureWaveAudioClass),
105 NULL, /* base_init */
106 NULL, /* base_finalize */
107 (GClassInitFunc) ags_capture_wave_audio_class_init,
108 NULL, /* class_finalize */
109 NULL, /* class_audio */
110 sizeof(AgsCaptureWaveAudio),
111 0, /* n_preallocs */
112 (GInstanceInitFunc) ags_capture_wave_audio_init,
113 };
114
115 ags_type_capture_wave_audio = g_type_register_static(AGS_TYPE_RECALL_AUDIO,
116 "AgsCaptureWaveAudio",
117 &ags_capture_wave_audio_info,
118 0);
119
120 g_once_init_leave(&g_define_type_id__volatile, ags_type_capture_wave_audio);
121 }
122
123 return g_define_type_id__volatile;
124 }
125
126 void
ags_capture_wave_audio_class_init(AgsCaptureWaveAudioClass * capture_wave_audio)127 ags_capture_wave_audio_class_init(AgsCaptureWaveAudioClass *capture_wave_audio)
128 {
129 GObjectClass *gobject;
130
131 GParamSpec *param_spec;
132
133 ags_capture_wave_audio_parent_class = g_type_class_peek_parent(capture_wave_audio);
134
135 /* GObjectClass */
136 gobject = (GObjectClass *) capture_wave_audio;
137
138 gobject->set_property = ags_capture_wave_audio_set_property;
139 gobject->get_property = ags_capture_wave_audio_get_property;
140
141 gobject->finalize = ags_capture_wave_audio_finalize;
142
143 /* properties */
144 /**
145 * AgsCaptureWaveAudio:playback:
146 *
147 * The playback port.
148 *
149 * Since: 3.0.0
150 */
151 param_spec = g_param_spec_object("playback",
152 i18n_pspec("if do playback"),
153 i18n_pspec("If playback should be performed"),
154 AGS_TYPE_PORT,
155 G_PARAM_READABLE | G_PARAM_WRITABLE);
156 g_object_class_install_property(gobject,
157 PROP_PLAYBACK,
158 param_spec);
159
160 /**
161 * AgsCaptureWaveAudio:replace:
162 *
163 * The replace port.
164 *
165 * Since: 3.0.0
166 */
167 param_spec = g_param_spec_object("replace",
168 i18n_pspec("if do replace"),
169 i18n_pspec("If audio data should be replaced"),
170 AGS_TYPE_PORT,
171 G_PARAM_READABLE | G_PARAM_WRITABLE);
172 g_object_class_install_property(gobject,
173 PROP_REPLACE,
174 param_spec);
175
176 /**
177 * AgsCaptureWaveAudio:record:
178 *
179 * The record port.
180 *
181 * Since: 3.0.0
182 */
183 param_spec = g_param_spec_object("record",
184 i18n_pspec("if do record"),
185 i18n_pspec("If record data for later use should be done"),
186 AGS_TYPE_PORT,
187 G_PARAM_READABLE | G_PARAM_WRITABLE);
188 g_object_class_install_property(gobject,
189 PROP_RECORD,
190 param_spec);
191
192 /**
193 * AgsCaptureWaveAudio:filename:
194 *
195 * The filename port.
196 *
197 * Since: 3.0.0
198 */
199 param_spec = g_param_spec_object("filename",
200 i18n_pspec("filename of record"),
201 i18n_pspec("The filename of record"),
202 AGS_TYPE_PORT,
203 G_PARAM_READABLE | G_PARAM_WRITABLE);
204 g_object_class_install_property(gobject,
205 PROP_FILENAME,
206 param_spec);
207
208 /**
209 * AgsCaptureWaveAudio:file-audio-channels:
210 *
211 * The file's audio channels port.
212 *
213 * Since: 3.0.0
214 */
215 param_spec = g_param_spec_object("file-audio-channels",
216 i18n_pspec("file audio channels"),
217 i18n_pspec("Audio channels count of file"),
218 AGS_TYPE_PORT,
219 G_PARAM_READABLE | G_PARAM_WRITABLE);
220 g_object_class_install_property(gobject,
221 PROP_FILE_AUDIO_CHANNELS,
222 param_spec);
223
224 /**
225 * AgsCaptureWaveAudio:file-samplerate:
226 *
227 * The file's samplerate port.
228 *
229 * Since: 3.0.0
230 */
231 param_spec = g_param_spec_object("file-samplerate",
232 i18n_pspec("file samplerate"),
233 i18n_pspec("Samplerate to use of file"),
234 AGS_TYPE_PORT,
235 G_PARAM_READABLE | G_PARAM_WRITABLE);
236 g_object_class_install_property(gobject,
237 PROP_FILE_SAMPLERATE,
238 param_spec);
239
240 /**
241 * AgsCaptureWaveAudio:file-buffer-size:
242 *
243 * The file's buffer size port.
244 *
245 * Since: 3.0.0
246 */
247 param_spec = g_param_spec_object("file-buffer-size",
248 i18n_pspec("files buffer size"),
249 i18n_pspec("Buffer size to use of file"),
250 AGS_TYPE_PORT,
251 G_PARAM_READABLE | G_PARAM_WRITABLE);
252 g_object_class_install_property(gobject,
253 PROP_FILE_BUFFER_SIZE,
254 param_spec);
255
256 /**
257 * AgsCaptureWaveAudio:format:
258 *
259 * The file's format port.
260 *
261 * Since: 3.0.0
262 */
263 param_spec = g_param_spec_object("file-format",
264 i18n_pspec("file format"),
265 i18n_pspec("Format to use of file"),
266 AGS_TYPE_PORT,
267 G_PARAM_READABLE | G_PARAM_WRITABLE);
268 g_object_class_install_property(gobject,
269 PROP_FILE_FORMAT,
270 param_spec);
271
272 /**
273 * AgsCaptureWaveAudio:wave-loop:
274 *
275 * Count until loop-end and start at loop-start.
276 *
277 * Since: 3.0.0
278 */
279 param_spec = g_param_spec_object("wave-loop",
280 i18n_pspec("wave loop capturing"),
281 i18n_pspec("Capture wave in a endless loop"),
282 AGS_TYPE_PORT,
283 G_PARAM_READABLE | G_PARAM_WRITABLE);
284 g_object_class_install_property(gobject,
285 PROP_WAVE_LOOP,
286 param_spec);
287
288 /**
289 * AgsCaptureWaveAudio:wave-loop-start:
290 *
291 * The wave's loop-start.
292 *
293 * Since: 3.0.0
294 */
295 param_spec = g_param_spec_object("wave_loop_start",
296 i18n_pspec("start beat of loop"),
297 i18n_pspec("The start beat of the wave loop"),
298 AGS_TYPE_PORT,
299 G_PARAM_READABLE | G_PARAM_WRITABLE);
300 g_object_class_install_property(gobject,
301 PROP_WAVE_LOOP_START,
302 param_spec);
303
304 /**
305 * AgsCaptureWaveAudio:wave-loop-end:
306 *
307 * The wave's loop-end.
308 *
309 * Since: 3.0.0
310 */
311 param_spec = g_param_spec_object("wave-loop-end",
312 i18n_pspec("end beat of wave loop"),
313 i18n_pspec("The end beat of the wave loop"),
314 AGS_TYPE_PORT,
315 G_PARAM_READABLE | G_PARAM_WRITABLE);
316 g_object_class_install_property(gobject,
317 PROP_WAVE_LOOP_END,
318 param_spec);
319 }
320
321 void
ags_capture_wave_audio_init(AgsCaptureWaveAudio * capture_wave_audio)322 ags_capture_wave_audio_init(AgsCaptureWaveAudio *capture_wave_audio)
323 {
324 GList *port;
325
326 guint i;
327
328 AGS_RECALL(capture_wave_audio)->name = "ags-capture-wave";
329 AGS_RECALL(capture_wave_audio)->version = AGS_RECALL_DEFAULT_VERSION;
330 AGS_RECALL(capture_wave_audio)->build_id = AGS_RECALL_DEFAULT_BUILD_ID;
331 AGS_RECALL(capture_wave_audio)->xml_type = "ags-capture-wave-audio";
332
333 port = NULL;
334 i = 0;
335
336 /* playback */
337 capture_wave_audio->playback = g_object_new(AGS_TYPE_PORT,
338 "plugin-name", ags_capture_wave_audio_plugin_name,
339 "specifier", ags_capture_wave_audio_specifier[i],
340 "control-port", ags_capture_wave_audio_control_port[i],
341 "port-value-is-pointer", FALSE,
342 "port-value-type", G_TYPE_BOOLEAN,
343 NULL);
344 g_object_ref(capture_wave_audio->playback);
345
346 capture_wave_audio->playback->port_value.ags_port_boolean = FALSE;
347
348 /* add to port */
349 port = g_list_prepend(port, capture_wave_audio->playback);
350 g_object_ref(capture_wave_audio->playback);
351
352 i++;
353
354 /* replace */
355 capture_wave_audio->replace = g_object_new(AGS_TYPE_PORT,
356 "plugin-name", ags_capture_wave_audio_plugin_name,
357 "specifier", ags_capture_wave_audio_specifier[i],
358 "control-port", ags_capture_wave_audio_control_port[i],
359 "port-value-is-pointer", FALSE,
360 "port-value-type", G_TYPE_BOOLEAN,
361 NULL);
362 g_object_ref(capture_wave_audio->replace);
363
364 capture_wave_audio->replace->port_value.ags_port_boolean = FALSE;
365
366 /* add to port */
367 port = g_list_prepend(port, capture_wave_audio->replace);
368 g_object_ref(capture_wave_audio->replace);
369
370 i++;
371
372 /* record */
373 capture_wave_audio->record = g_object_new(AGS_TYPE_PORT,
374 "plugin-name", ags_capture_wave_audio_plugin_name,
375 "specifier", ags_capture_wave_audio_specifier[i],
376 "control-port", ags_capture_wave_audio_control_port[i],
377 "port-value-is-pointer", FALSE,
378 "port-value-type", G_TYPE_BOOLEAN,
379 NULL);
380 g_object_ref(capture_wave_audio->record);
381
382 capture_wave_audio->record->port_value.ags_port_boolean = FALSE;
383
384 /* add to port */
385 port = g_list_prepend(port, capture_wave_audio->record);
386 g_object_ref(capture_wave_audio->record);
387
388 i++;
389
390 /* filename */
391 capture_wave_audio->filename = g_object_new(AGS_TYPE_PORT,
392 "plugin-name", ags_capture_wave_audio_plugin_name,
393 "specifier", ags_capture_wave_audio_specifier[i],
394 "control-port", ags_capture_wave_audio_control_port[i],
395 "port-value-is-pointer", FALSE,
396 "port-value-type", G_TYPE_POINTER,
397 NULL);
398 g_object_ref(capture_wave_audio->filename);
399
400 capture_wave_audio->filename->port_value.ags_port_pointer = NULL;
401
402 /* add to port */
403 port = g_list_prepend(port, capture_wave_audio->filename);
404 g_object_ref(capture_wave_audio->filename);
405
406 i++;
407
408 /* audio channels */
409 capture_wave_audio->file_audio_channels = g_object_new(AGS_TYPE_PORT,
410 "plugin-name", ags_capture_wave_audio_plugin_name,
411 "specifier", ags_capture_wave_audio_specifier[i],
412 "control-port", ags_capture_wave_audio_control_port[i],
413 "port-value-is-pointer", FALSE,
414 "port-value-type", G_TYPE_UINT64,
415 NULL);
416 g_object_ref(capture_wave_audio->file_audio_channels);
417
418 capture_wave_audio->file_audio_channels->port_value.ags_port_uint = AGS_SOUNDCARD_DEFAULT_PCM_CHANNELS;
419
420 /* add to port */
421 port = g_list_prepend(port, capture_wave_audio->file_audio_channels);
422 g_object_ref(capture_wave_audio->file_audio_channels);
423
424 i++;
425
426 /* samplerate */
427 capture_wave_audio->file_samplerate = g_object_new(AGS_TYPE_PORT,
428 "plugin-name", ags_capture_wave_audio_plugin_name,
429 "specifier", ags_capture_wave_audio_specifier[i],
430 "control-port", ags_capture_wave_audio_control_port[i],
431 "port-value-is-pointer", FALSE,
432 "port-value-type", G_TYPE_UINT64,
433 NULL);
434 g_object_ref(capture_wave_audio->file_samplerate);
435
436 capture_wave_audio->file_samplerate->port_value.ags_port_uint = AGS_SOUNDCARD_DEFAULT_SAMPLERATE;
437
438 /* add to port */
439 port = g_list_prepend(port, capture_wave_audio->file_samplerate);
440 g_object_ref(capture_wave_audio->file_samplerate);
441
442 i++;
443
444 /* buffer size */
445 capture_wave_audio->file_buffer_size = g_object_new(AGS_TYPE_PORT,
446 "plugin-name", ags_capture_wave_audio_plugin_name,
447 "specifier", ags_capture_wave_audio_specifier[i],
448 "control-port", ags_capture_wave_audio_control_port[i],
449 "port-value-is-pointer", FALSE,
450 "port-value-type", G_TYPE_UINT64,
451 NULL);
452 g_object_ref(capture_wave_audio->file_buffer_size);
453
454 capture_wave_audio->file_buffer_size->port_value.ags_port_uint = AGS_SOUNDCARD_DEFAULT_BUFFER_SIZE;
455
456 /* add to port */
457 port = g_list_prepend(port, capture_wave_audio->file_buffer_size);
458 g_object_ref(capture_wave_audio->file_buffer_size);
459
460 i++;
461
462 /* format */
463 capture_wave_audio->file_format = g_object_new(AGS_TYPE_PORT,
464 "plugin-name", ags_capture_wave_audio_plugin_name,
465 "specifier", ags_capture_wave_audio_specifier[i],
466 "control-port", ags_capture_wave_audio_control_port[i],
467 "port-value-is-pointer", FALSE,
468 "port-value-type", G_TYPE_UINT64,
469 NULL);
470 g_object_ref(capture_wave_audio->file_format);
471
472 capture_wave_audio->file_format->port_value.ags_port_uint = AGS_SOUNDCARD_DEFAULT_FORMAT;
473
474 /* add to port */
475 port = g_list_prepend(port, capture_wave_audio->file_format);
476 g_object_ref(capture_wave_audio->file_format);
477
478 i++;
479
480 /* wave loop */
481 capture_wave_audio->wave_loop = g_object_new(AGS_TYPE_PORT,
482 "plugin-name", ags_capture_wave_audio_plugin_name,
483 "specifier", ags_capture_wave_audio_specifier[i],
484 "control-port", ags_capture_wave_audio_control_port[i],
485 "port-value-is-pointer", FALSE,
486 "port-value-type", G_TYPE_BOOLEAN,
487 "port-value-size", sizeof(gboolean),
488 "port-value-length", 1,
489 NULL);
490 g_object_ref(capture_wave_audio->wave_loop);
491
492 capture_wave_audio->wave_loop->port_value.ags_port_boolean = FALSE;
493
494 /* add to port */
495 port = g_list_prepend(port, capture_wave_audio->wave_loop);
496 g_object_ref(capture_wave_audio->wave_loop);
497
498 i++;
499
500 /* wave-loop-start */
501 capture_wave_audio->wave_loop_start = g_object_new(AGS_TYPE_PORT,
502 "plugin-name", ags_capture_wave_audio_plugin_name,
503 "specifier", ags_capture_wave_audio_specifier[i],
504 "control-port", ags_capture_wave_audio_control_port[i],
505 "port-value-is-pointer", FALSE,
506 "port-value-type", G_TYPE_UINT64,
507 "port-value-size", sizeof(guint64),
508 "port-value-length", 1,
509 NULL);
510 g_object_ref(capture_wave_audio->wave_loop_start);
511
512 capture_wave_audio->wave_loop_start->port_value.ags_port_uint = 0;
513
514 /* add to port */
515 port = g_list_prepend(port, capture_wave_audio->wave_loop_start);
516 g_object_ref(capture_wave_audio->wave_loop_start);
517
518 i++;
519
520 /* wave-loop-end */
521 capture_wave_audio->wave_loop_end = g_object_new(AGS_TYPE_PORT,
522 "plugin-name", ags_capture_wave_audio_plugin_name,
523 "specifier", ags_capture_wave_audio_specifier[i],
524 "control-port", ags_capture_wave_audio_control_port[i],
525 "port-value-is-pointer", FALSE,
526 "port-value-type", G_TYPE_UINT64,
527 "port-value-size", sizeof(guint64),
528 "port-value-length", 1,
529 NULL);
530 g_object_ref(capture_wave_audio->wave_loop_end);
531
532 capture_wave_audio->wave_loop_end->port_value.ags_port_uint = 64;
533
534 /* add to port */
535 port = g_list_prepend(port, capture_wave_audio->wave_loop_end);
536 g_object_ref(capture_wave_audio->wave_loop_end);
537
538 i++;
539
540 /* set port */
541 AGS_RECALL(capture_wave_audio)->port = port;
542
543 /* the audio file */
544 g_rec_mutex_init(&(capture_wave_audio->audio_file_mutex));
545
546 capture_wave_audio->audio_file = NULL;
547 }
548
549 void
ags_capture_wave_audio_set_property(GObject * gobject,guint prop_id,const GValue * value,GParamSpec * param_spec)550 ags_capture_wave_audio_set_property(GObject *gobject,
551 guint prop_id,
552 const GValue *value,
553 GParamSpec *param_spec)
554 {
555 AgsCaptureWaveAudio *capture_wave_audio;
556
557 GRecMutex *recall_mutex;
558
559 capture_wave_audio = AGS_CAPTURE_WAVE_AUDIO(gobject);
560
561 /* get recall mutex */
562 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(capture_wave_audio);
563
564 switch(prop_id){
565 case PROP_PLAYBACK:
566 {
567 AgsPort *playback;
568
569 playback = (AgsPort *) g_value_get_object(value);
570
571 g_rec_mutex_lock(recall_mutex);
572
573 if(capture_wave_audio->playback == playback){
574 g_rec_mutex_unlock(recall_mutex);
575
576 return;
577 }
578
579 if(capture_wave_audio->playback != NULL){
580 g_object_unref(G_OBJECT(capture_wave_audio->playback));
581 }
582
583 if(playback != NULL){
584 g_object_ref(G_OBJECT(playback));
585 }
586
587 capture_wave_audio->playback = playback;
588
589 g_rec_mutex_unlock(recall_mutex);
590 }
591 break;
592 case PROP_REPLACE:
593 {
594 AgsPort *replace;
595
596 replace = (AgsPort *) g_value_get_object(value);
597
598 g_rec_mutex_lock(recall_mutex);
599
600 if(capture_wave_audio->replace == replace){
601 g_rec_mutex_unlock(recall_mutex);
602
603 return;
604 }
605
606 if(capture_wave_audio->replace != NULL){
607 g_object_unref(G_OBJECT(capture_wave_audio->replace));
608 }
609
610 if(replace != NULL){
611 g_object_ref(G_OBJECT(replace));
612 }
613
614 capture_wave_audio->replace = replace;
615
616 g_rec_mutex_unlock(recall_mutex);
617 }
618 break;
619 case PROP_RECORD:
620 {
621 AgsPort *record;
622
623 record = (AgsPort *) g_value_get_object(value);
624
625 g_rec_mutex_lock(recall_mutex);
626
627 if(capture_wave_audio->record == record){
628 g_rec_mutex_unlock(recall_mutex);
629
630 return;
631 }
632
633 if(capture_wave_audio->record != NULL){
634 g_object_unref(G_OBJECT(capture_wave_audio->record));
635 }
636
637 if(record != NULL){
638 g_object_ref(G_OBJECT(record));
639 }
640
641 capture_wave_audio->record = record;
642
643 g_rec_mutex_unlock(recall_mutex);
644 }
645 break;
646 case PROP_FILENAME:
647 {
648 AgsPort *filename;
649
650 filename = (AgsPort *) g_value_get_object(value);
651
652 g_rec_mutex_lock(recall_mutex);
653
654 if(capture_wave_audio->filename == filename){
655 g_rec_mutex_unlock(recall_mutex);
656
657 return;
658 }
659
660 if(capture_wave_audio->filename != NULL){
661 g_object_unref(G_OBJECT(capture_wave_audio->filename));
662 }
663
664 if(filename != NULL){
665 g_object_ref(G_OBJECT(filename));
666 }
667
668 capture_wave_audio->filename = filename;
669
670 g_rec_mutex_unlock(recall_mutex);
671 }
672 break;
673 case PROP_FILE_AUDIO_CHANNELS:
674 {
675 AgsPort *file_audio_channels;
676
677 file_audio_channels = (AgsPort *) g_value_get_object(value);
678
679 g_rec_mutex_lock(recall_mutex);
680
681 if(capture_wave_audio->file_audio_channels == file_audio_channels){
682 g_rec_mutex_unlock(recall_mutex);
683
684 return;
685 }
686
687 if(capture_wave_audio->file_audio_channels != NULL){
688 g_object_unref(G_OBJECT(capture_wave_audio->file_audio_channels));
689 }
690
691 if(file_audio_channels != NULL){
692 g_object_ref(G_OBJECT(file_audio_channels));
693 }
694
695 capture_wave_audio->file_audio_channels = file_audio_channels;
696
697 g_rec_mutex_unlock(recall_mutex);
698 }
699 break;
700 case PROP_FILE_SAMPLERATE:
701 {
702 AgsPort *file_samplerate;
703
704 file_samplerate = (AgsPort *) g_value_get_object(value);
705
706 g_rec_mutex_lock(recall_mutex);
707
708 if(capture_wave_audio->file_samplerate == file_samplerate){
709 g_rec_mutex_unlock(recall_mutex);
710
711 return;
712 }
713
714 if(capture_wave_audio->file_samplerate != NULL){
715 g_object_unref(G_OBJECT(capture_wave_audio->file_samplerate));
716 }
717
718 if(file_samplerate != NULL){
719 g_object_ref(G_OBJECT(file_samplerate));
720 }
721
722 capture_wave_audio->file_samplerate = file_samplerate;
723
724 g_rec_mutex_unlock(recall_mutex);
725 }
726 break;
727 case PROP_FILE_BUFFER_SIZE:
728 {
729 AgsPort *file_buffer_size;
730
731 file_buffer_size = (AgsPort *) g_value_get_object(value);
732
733 g_rec_mutex_lock(recall_mutex);
734
735 if(capture_wave_audio->file_buffer_size == file_buffer_size){
736 g_rec_mutex_unlock(recall_mutex);
737
738 return;
739 }
740
741 if(capture_wave_audio->file_buffer_size != NULL){
742 g_object_unref(G_OBJECT(capture_wave_audio->file_buffer_size));
743 }
744
745 if(file_buffer_size != NULL){
746 g_object_ref(G_OBJECT(file_buffer_size));
747 }
748
749 capture_wave_audio->file_buffer_size = file_buffer_size;
750
751 g_rec_mutex_unlock(recall_mutex);
752 }
753 break;
754 case PROP_FILE_FORMAT:
755 {
756 AgsPort *file_format;
757
758 file_format = (AgsPort *) g_value_get_object(value);
759
760 g_rec_mutex_lock(recall_mutex);
761
762 if(capture_wave_audio->file_format == file_format){
763 g_rec_mutex_unlock(recall_mutex);
764
765 return;
766 }
767
768 if(capture_wave_audio->file_format != NULL){
769 g_object_unref(G_OBJECT(capture_wave_audio->file_format));
770 }
771
772 if(file_format != NULL){
773 g_object_ref(G_OBJECT(file_format));
774 }
775
776 capture_wave_audio->file_format = file_format;
777
778 g_rec_mutex_unlock(recall_mutex);
779 }
780 break;
781 case PROP_WAVE_LOOP:
782 {
783 AgsPort *port;
784
785 port = (AgsPort *) g_value_get_object(value);
786
787 g_rec_mutex_lock(recall_mutex);
788
789 if(port == capture_wave_audio->wave_loop){
790 g_rec_mutex_unlock(recall_mutex);
791
792 return;
793 }
794
795 if(capture_wave_audio->wave_loop != NULL){
796 g_object_unref(G_OBJECT(capture_wave_audio->wave_loop));
797 }
798
799 if(port != NULL){
800 g_object_ref(G_OBJECT(port));
801 }
802
803 capture_wave_audio->wave_loop = port;
804
805 g_rec_mutex_unlock(recall_mutex);
806 }
807 break;
808 case PROP_WAVE_LOOP_START:
809 {
810 AgsPort *port;
811
812 port = (AgsPort *) g_value_get_object(value);
813
814 g_rec_mutex_lock(recall_mutex);
815
816 if(port == capture_wave_audio->wave_loop_start){
817 g_rec_mutex_unlock(recall_mutex);
818
819 return;
820 }
821
822 if(capture_wave_audio->wave_loop_start != NULL){
823 g_object_unref(G_OBJECT(capture_wave_audio->wave_loop_start));
824 }
825
826 if(port != NULL){
827 g_object_ref(G_OBJECT(port));
828 }
829
830 capture_wave_audio->wave_loop_start = port;
831
832 g_rec_mutex_unlock(recall_mutex);
833 }
834 break;
835 case PROP_WAVE_LOOP_END:
836 {
837 AgsPort *port;
838
839 port = (AgsPort *) g_value_get_object(value);
840
841 g_rec_mutex_lock(recall_mutex);
842
843 if(port == capture_wave_audio->wave_loop_end){
844 g_rec_mutex_unlock(recall_mutex);
845
846 return;
847 }
848
849 if(capture_wave_audio->wave_loop_end != NULL){
850 g_object_unref(G_OBJECT(capture_wave_audio->wave_loop_end));
851 }
852
853 if(port != NULL){
854 g_object_ref(G_OBJECT(port));
855 }
856
857 capture_wave_audio->wave_loop_end = port;
858
859 g_rec_mutex_unlock(recall_mutex);
860 }
861 break;
862 default:
863 G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
864 break;
865 }
866 }
867
868 void
ags_capture_wave_audio_get_property(GObject * gobject,guint prop_id,GValue * value,GParamSpec * param_spec)869 ags_capture_wave_audio_get_property(GObject *gobject,
870 guint prop_id,
871 GValue *value,
872 GParamSpec *param_spec)
873 {
874 AgsCaptureWaveAudio *capture_wave_audio;
875
876 GRecMutex *recall_mutex;
877
878 capture_wave_audio = AGS_CAPTURE_WAVE_AUDIO(gobject);
879
880 /* get recall mutex */
881 recall_mutex = AGS_RECALL_GET_OBJ_MUTEX(capture_wave_audio);
882
883 switch(prop_id){
884 case PROP_PLAYBACK:
885 {
886 g_rec_mutex_lock(recall_mutex);
887
888 g_value_set_object(value, capture_wave_audio->playback);
889
890 g_rec_mutex_unlock(recall_mutex);
891 }
892 break;
893 case PROP_REPLACE:
894 {
895 g_rec_mutex_lock(recall_mutex);
896
897 g_value_set_object(value, capture_wave_audio->replace);
898
899 g_rec_mutex_unlock(recall_mutex);
900 }
901 break;
902 case PROP_RECORD:
903 {
904 g_rec_mutex_lock(recall_mutex);
905
906 g_value_set_object(value, capture_wave_audio->record);
907
908 g_rec_mutex_unlock(recall_mutex);
909 }
910 break;
911 case PROP_FILENAME:
912 {
913 g_rec_mutex_lock(recall_mutex);
914
915 g_value_set_object(value, capture_wave_audio->filename);
916
917 g_rec_mutex_unlock(recall_mutex);
918 }
919 break;
920 case PROP_FILE_AUDIO_CHANNELS:
921 {
922 g_rec_mutex_lock(recall_mutex);
923
924 g_value_set_object(value, capture_wave_audio->file_audio_channels);
925
926 g_rec_mutex_unlock(recall_mutex);
927 }
928 break;
929 case PROP_FILE_SAMPLERATE:
930 {
931 g_rec_mutex_lock(recall_mutex);
932
933 g_value_set_object(value, capture_wave_audio->file_samplerate);
934
935 g_rec_mutex_unlock(recall_mutex);
936 }
937 break;
938 case PROP_FILE_BUFFER_SIZE:
939 {
940 g_rec_mutex_lock(recall_mutex);
941
942 g_value_set_object(value, capture_wave_audio->file_buffer_size);
943
944 g_rec_mutex_unlock(recall_mutex);
945 }
946 break;
947 case PROP_FILE_FORMAT:
948 {
949 g_rec_mutex_lock(recall_mutex);
950
951 g_value_set_object(value, capture_wave_audio->file_format);
952
953 g_rec_mutex_unlock(recall_mutex);
954 }
955 break;
956 case PROP_WAVE_LOOP:
957 {
958 g_rec_mutex_lock(recall_mutex);
959
960 g_value_set_object(value, capture_wave_audio->wave_loop);
961
962 g_rec_mutex_unlock(recall_mutex);
963 }
964 break;
965 case PROP_WAVE_LOOP_START:
966 {
967 g_rec_mutex_lock(recall_mutex);
968
969 g_value_set_object(value, capture_wave_audio->wave_loop_start);
970
971 g_rec_mutex_unlock(recall_mutex);
972 }
973 break;
974 case PROP_WAVE_LOOP_END:
975 {
976 g_rec_mutex_lock(recall_mutex);
977
978 g_value_set_object(value, capture_wave_audio->wave_loop_end);
979
980 g_rec_mutex_unlock(recall_mutex);
981 }
982 break;
983 default:
984 G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
985 break;
986 }
987 }
988
989 void
ags_capture_wave_audio_dispose(GObject * gobject)990 ags_capture_wave_audio_dispose(GObject *gobject)
991 {
992 AgsCaptureWaveAudio *capture_wave_audio;
993
994 capture_wave_audio = AGS_CAPTURE_WAVE_AUDIO(gobject);
995
996 /* playback */
997 if(capture_wave_audio->playback != NULL){
998 g_object_unref(capture_wave_audio->playback);
999
1000 capture_wave_audio->playback = NULL;
1001 }
1002
1003 /* replace */
1004 if(capture_wave_audio->replace != NULL){
1005 g_object_unref(capture_wave_audio->replace);
1006
1007 capture_wave_audio->replace = NULL;
1008 }
1009
1010 /* record */
1011 if(capture_wave_audio->record != NULL){
1012 g_object_unref(capture_wave_audio->record);
1013
1014 capture_wave_audio->record = NULL;
1015 }
1016
1017 /* filename */
1018 if(capture_wave_audio->filename != NULL){
1019 g_object_unref(capture_wave_audio->filename);
1020
1021 capture_wave_audio->filename = NULL;
1022 }
1023
1024 /* audio channels */
1025 if(capture_wave_audio->file_audio_channels != NULL){
1026 g_object_unref(capture_wave_audio->file_audio_channels);
1027
1028 capture_wave_audio->file_audio_channels = NULL;
1029 }
1030
1031 /* samplerate */
1032 if(capture_wave_audio->file_samplerate != NULL){
1033 g_object_unref(capture_wave_audio->file_samplerate);
1034
1035 capture_wave_audio->file_samplerate = NULL;
1036 }
1037
1038 /* buffer size */
1039 if(capture_wave_audio->file_buffer_size != NULL){
1040 g_object_unref(capture_wave_audio->file_buffer_size);
1041
1042 capture_wave_audio->file_buffer_size = NULL;
1043 }
1044
1045 /* format */
1046 if(capture_wave_audio->file_format != NULL){
1047 g_object_unref(capture_wave_audio->file_format);
1048
1049 capture_wave_audio->file_format = NULL;
1050 }
1051
1052 /* wave */
1053 if(capture_wave_audio->wave_loop != NULL){
1054 g_object_unref(G_OBJECT(capture_wave_audio->wave_loop));
1055
1056 capture_wave_audio->wave_loop = NULL;
1057 }
1058
1059 if(capture_wave_audio->wave_loop_start != NULL){
1060 g_object_unref(G_OBJECT(capture_wave_audio->wave_loop_start));
1061
1062 capture_wave_audio->wave_loop_start = NULL;
1063 }
1064
1065 if(capture_wave_audio->wave_loop_end != NULL){
1066 g_object_unref(G_OBJECT(capture_wave_audio->wave_loop_end));
1067
1068 capture_wave_audio->wave_loop_end = NULL;
1069 }
1070
1071 /* call parent */
1072 G_OBJECT_CLASS(ags_capture_wave_audio_parent_class)->dispose(gobject);
1073 }
1074
1075 void
ags_capture_wave_audio_finalize(GObject * gobject)1076 ags_capture_wave_audio_finalize(GObject *gobject)
1077 {
1078 AgsCaptureWaveAudio *capture_wave_audio;
1079
1080 capture_wave_audio = AGS_CAPTURE_WAVE_AUDIO(gobject);
1081
1082 /* playback */
1083 if(capture_wave_audio->playback != NULL){
1084 g_object_unref(capture_wave_audio->playback);
1085 }
1086
1087 /* replace */
1088 if(capture_wave_audio->replace != NULL){
1089 g_object_unref(capture_wave_audio->replace);
1090 }
1091
1092 /* record */
1093 if(capture_wave_audio->record != NULL){
1094 g_object_unref(capture_wave_audio->record);
1095 }
1096
1097 /* filename */
1098 if(capture_wave_audio->filename != NULL){
1099 g_object_unref(capture_wave_audio->filename);
1100 }
1101
1102 /* audio channels */
1103 if(capture_wave_audio->file_audio_channels != NULL){
1104 g_object_unref(capture_wave_audio->file_audio_channels);
1105 }
1106
1107 /* samplerate */
1108 if(capture_wave_audio->file_samplerate != NULL){
1109 g_object_unref(capture_wave_audio->file_samplerate);
1110 }
1111
1112 /* buffer size */
1113 if(capture_wave_audio->file_buffer_size != NULL){
1114 g_object_unref(capture_wave_audio->file_buffer_size);
1115 }
1116
1117 /* format */
1118 if(capture_wave_audio->file_format != NULL){
1119 g_object_unref(capture_wave_audio->file_format);
1120 }
1121
1122 /* wave */
1123 if(capture_wave_audio->wave_loop != NULL){
1124 g_object_unref(G_OBJECT(capture_wave_audio->wave_loop));
1125 }
1126
1127 if(capture_wave_audio->wave_loop_start != NULL){
1128 g_object_unref(G_OBJECT(capture_wave_audio->wave_loop_start));
1129 }
1130
1131 if(capture_wave_audio->wave_loop_end != NULL){
1132 g_object_unref(G_OBJECT(capture_wave_audio->wave_loop_end));
1133 }
1134
1135 if(capture_wave_audio->audio_file != NULL){
1136 g_object_unref(capture_wave_audio->audio_file);
1137 }
1138
1139 /* call parent */
1140 G_OBJECT_CLASS(ags_capture_wave_audio_parent_class)->finalize(gobject);
1141 }
1142
1143 /**
1144 * ags_capture_wave_audio_new:
1145 * @audio: the #AgsAudio
1146 *
1147 * Create a new instance of #AgsCaptureWaveAudio
1148 *
1149 * Returns: the new #AgsCaptureWaveAudio
1150 *
1151 * Since: 3.0.0
1152 */
1153 AgsCaptureWaveAudio*
ags_capture_wave_audio_new(AgsAudio * audio)1154 ags_capture_wave_audio_new(AgsAudio *audio)
1155 {
1156 AgsCaptureWaveAudio *capture_wave_audio;
1157
1158 capture_wave_audio = (AgsCaptureWaveAudio *) g_object_new(AGS_TYPE_CAPTURE_WAVE_AUDIO,
1159 "audio", audio,
1160 NULL);
1161
1162 return(capture_wave_audio);
1163 }
1164