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/object/ags_soundcard.h>
21
22 void ags_soundcard_class_init(AgsSoundcardInterface *ginterface);
23
24 /**
25 * SECTION:ags_soundcard
26 * @short_description: unique access to soundcards
27 * @title: AgsSoundcard
28 * @section_id: AgsSoundcard
29 * @include: ags/object/ags_soundcard.h
30 *
31 * The #AgsSoundcard interface gives you a unique access to audio devices.
32 */
33
34 enum {
35 TIC,
36 OFFSET_CHANGED,
37 STOP,
38 LAST_SIGNAL,
39 };
40
41 static guint soundcard_signals[LAST_SIGNAL];
42
43 GType
ags_soundcard_get_type()44 ags_soundcard_get_type()
45 {
46 static volatile gsize g_define_type_id__volatile = 0;
47
48 if(g_once_init_enter (&g_define_type_id__volatile)){
49 GType ags_type_soundcard = 0;
50
51 ags_type_soundcard = g_type_register_static_simple(G_TYPE_INTERFACE,
52 "AgsSoundcard",
53 sizeof(AgsSoundcardInterface),
54 (GClassInitFunc) ags_soundcard_class_init,
55 0, NULL, 0);
56
57 g_once_init_leave(&g_define_type_id__volatile, ags_type_soundcard);
58 }
59
60 return g_define_type_id__volatile;
61 }
62
63 GType
ags_soundcard_format_get_type()64 ags_soundcard_format_get_type()
65 {
66 static volatile gsize g_enum_type_id__volatile;
67
68 if(g_once_init_enter (&g_enum_type_id__volatile)){
69 static const GEnumValue values[] = {
70 { AGS_SOUNDCARD_SIGNED_8_BIT, "AGS_SOUNDCARD_SIGNED_8_BIT", "soundcard-signed-8-bit" },
71 { AGS_SOUNDCARD_SIGNED_16_BIT, "AGS_SOUNDCARD_SIGNED_16_BIT", "soundcard-signed-16-bit" },
72 { AGS_SOUNDCARD_SIGNED_24_BIT, "AGS_SOUNDCARD_SIGNED_24_BIT", "soundcard-signed-24-bit" },
73 { AGS_SOUNDCARD_SIGNED_32_BIT, "AGS_SOUNDCARD_SIGNED_32_BIT", "soundcard-signed-32-bit" },
74 { AGS_SOUNDCARD_SIGNED_64_BIT, "AGS_SOUNDCARD_SIGNED_64_BIT", "soundcard-signed-64-bit" },
75 { AGS_SOUNDCARD_FLOAT, "AGS_SOUNDCARD_FLOAT", "soundcard-float" },
76 { AGS_SOUNDCARD_DOUBLE, "AGS_SOUNDCARD_DOUBLE", "soundcard-double" },
77 { AGS_SOUNDCARD_COMPLEX, "AGS_SOUNDCARD_COMPLEX", "soundcard-complex" },
78 { 0, NULL, NULL }
79 };
80
81 GType g_enum_type_id = g_enum_register_static(g_intern_static_string("AgsSoundcardFormat"), values);
82
83 g_once_init_leave (&g_enum_type_id__volatile, g_enum_type_id);
84 }
85
86 return g_enum_type_id__volatile;
87 }
88
89 GType
ags_soundcard_capability_get_type()90 ags_soundcard_capability_get_type()
91 {
92 static volatile gsize g_flags_type_id__volatile;
93
94 if(g_once_init_enter (&g_flags_type_id__volatile)){
95 static const GFlagsValue values[] = {
96 { AGS_SOUNDCARD_CAPABILITY_PLAYBACK, "AGS_SOUNDCARD_CAPABILITY_PLAYBACK", "soundcard-capability-playback" },
97 { AGS_SOUNDCARD_CAPABILITY_CAPTURE, "AGS_SOUNDCARD_CAPABILITY_CAPTURE", "soundcard-capability-capture" },
98 { AGS_SOUNDCARD_CAPABILITY_DUPLEX, "AGS_SOUNDCARD_CAPABILITY_DUPLEX", "soundcard-capability-duplex" },
99 { 0, NULL, NULL }
100 };
101
102 GType g_flags_type_id = g_flags_register_static(g_intern_static_string("AgsSoundcardCapability"), values);
103
104 g_once_init_leave (&g_flags_type_id__volatile, g_flags_type_id);
105 }
106
107 return g_flags_type_id__volatile;
108 }
109
110 GQuark
ags_soundcard_error_quark()111 ags_soundcard_error_quark()
112 {
113 return(g_quark_from_static_string("ags-soundcard-error-quark"));
114 }
115
116 void
ags_soundcard_class_init(AgsSoundcardInterface * ginterface)117 ags_soundcard_class_init(AgsSoundcardInterface *ginterface)
118 {
119 /**
120 * AgsSoundcard::tic:
121 * @soundcard: the #AgsSoundcard object
122 *
123 * The ::tic signal is emitted every tic of the soundcard. This notifies
124 * about a newly played buffer.
125 *
126 * Since: 3.0.0
127 */
128 soundcard_signals[TIC] =
129 g_signal_new("tic",
130 G_TYPE_FROM_INTERFACE(ginterface),
131 G_SIGNAL_RUN_LAST,
132 G_STRUCT_OFFSET(AgsSoundcardInterface, tic),
133 NULL, NULL,
134 g_cclosure_marshal_VOID__VOID,
135 G_TYPE_NONE, 0);
136
137 /**
138 * AgsSoundcard::offset-changed:
139 * @soundcard: the #AgsSoundcard object
140 * @note_offset: new notation offset
141 *
142 * The ::offset-changed signal notifies about changed position within
143 * notation.
144 *
145 * Since: 3.0.0
146 */
147 soundcard_signals[OFFSET_CHANGED] =
148 g_signal_new("offset-changed",
149 G_TYPE_FROM_INTERFACE(ginterface),
150 G_SIGNAL_RUN_LAST,
151 G_STRUCT_OFFSET(AgsSoundcardInterface, offset_changed),
152 NULL, NULL,
153 g_cclosure_marshal_VOID__UINT,
154 G_TYPE_NONE, 1,
155 G_TYPE_UINT);
156
157 /**
158 * AgsSoundcard::stop:
159 * @soundcard: the #AgsSoundcard object
160 *
161 * The ::stop signal is emitted every stop of the soundcard. This notifies
162 * about a newly played buffer.
163 *
164 * Since: 3.0.0
165 */
166 soundcard_signals[STOP] =
167 g_signal_new("stop",
168 G_TYPE_FROM_INTERFACE(ginterface),
169 G_SIGNAL_RUN_LAST,
170 G_STRUCT_OFFSET(AgsSoundcardInterface, stop),
171 NULL, NULL,
172 g_cclosure_marshal_VOID__VOID,
173 G_TYPE_NONE, 0);
174 }
175
176 /**
177 * ags_soundcard_set_device:
178 * @soundcard: the #AgsSoundcard
179 * @card_id: the device to set
180 *
181 * Set device.
182 *
183 * Since: 3.0.0
184 */
185 void
ags_soundcard_set_device(AgsSoundcard * soundcard,gchar * card_id)186 ags_soundcard_set_device(AgsSoundcard *soundcard,
187 gchar *card_id)
188 {
189 AgsSoundcardInterface *soundcard_interface;
190
191 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
192 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
193 g_return_if_fail(soundcard_interface->set_device);
194 soundcard_interface->set_device(soundcard,
195 card_id);
196 }
197
198 /**
199 * ags_soundcard_get_device:
200 * @soundcard: the #AgsSoundcard
201 *
202 * Get device.
203 *
204 * Returns: the device's identifier
205 *
206 * Since: 3.0.0
207 */
208 gchar*
ags_soundcard_get_device(AgsSoundcard * soundcard)209 ags_soundcard_get_device(AgsSoundcard *soundcard)
210 {
211 AgsSoundcardInterface *soundcard_interface;
212
213 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), NULL);
214 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
215 g_return_val_if_fail(soundcard_interface->get_device, NULL);
216
217 return(soundcard_interface->get_device(soundcard));
218 }
219
220 /**
221 * ags_soundcard_get_presets:
222 * @soundcard: the #AgsSoundcard
223 * @channels: (out): the audio channels
224 * @rate: (out): the samplerate
225 * @buffer_size: (out): the buffer size
226 * @format: (out): the format
227 *
228 * Get presets.
229 *
230 * Since: 3.0.0
231 */
232 void
ags_soundcard_get_presets(AgsSoundcard * soundcard,guint * channels,guint * rate,guint * buffer_size,guint * format)233 ags_soundcard_get_presets(AgsSoundcard *soundcard,
234 guint *channels,
235 guint *rate,
236 guint *buffer_size,
237 guint *format)
238 {
239 AgsSoundcardInterface *soundcard_interface;
240
241 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
242 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
243 g_return_if_fail(soundcard_interface->get_presets);
244 soundcard_interface->get_presets(soundcard,
245 channels,
246 rate,
247 buffer_size,
248 format);
249 }
250
251 /**
252 * ags_soundcard_set_presets:
253 * @soundcard: the #AgsSoundcard
254 * @channels: the audio channels
255 * @rate: the samplerate
256 * @buffer_size: the buffer size
257 * @format: the format
258 *
259 * Set presets.
260 *
261 * Since: 3.0.0
262 */
263 void
ags_soundcard_set_presets(AgsSoundcard * soundcard,guint channels,guint rate,guint buffer_size,guint format)264 ags_soundcard_set_presets(AgsSoundcard *soundcard,
265 guint channels,
266 guint rate,
267 guint buffer_size,
268 guint format)
269 {
270 AgsSoundcardInterface *soundcard_interface;
271
272 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
273 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
274 g_return_if_fail(soundcard_interface->set_presets);
275 soundcard_interface->set_presets(soundcard,
276 channels,
277 rate,
278 buffer_size,
279 format);
280 }
281
282 /**
283 * ags_soundcard_list_cards:
284 * @soundcard: the #AgsSoundcard
285 * @card_id: (element-type utf8) (out callee-allocates) (array zero-terminated=1) (transfer full): a list containing card ids
286 * @card_name: (element-type utf8) (out callee-allocates) (array zero-terminated=1) (transfer full): a list containing card names
287 *
288 * Retrieve @card_id and @card_name as a list of strings.
289 *
290 * Since: 3.0.0
291 */
292 void
ags_soundcard_list_cards(AgsSoundcard * soundcard,GList ** card_id,GList ** card_name)293 ags_soundcard_list_cards(AgsSoundcard *soundcard,
294 GList **card_id, GList **card_name)
295 {
296 AgsSoundcardInterface *soundcard_interface;
297
298 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
299 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
300 g_return_if_fail(soundcard_interface->list_cards);
301 soundcard_interface->list_cards(soundcard, card_id, card_name);
302 }
303
304 /**
305 * ags_soundcard_pcm_info:
306 * @soundcard: the #AgsSoundcard
307 * @card_id: the selected soundcard by its string identifier
308 * @channels_min: (out): min channels supported
309 * @channels_max: (out): max channels supported
310 * @rate_min: (out): min samplerate supported
311 * @rate_max: (out): max samplerate supported
312 * @buffer_size_min: (out): min buffer size supported by soundcard
313 * @buffer_size_max: (out): max buffer size supported by soundcard
314 * @error: an error that may occure
315 *
316 * Retrieve detailed information of @card_id soundcard.
317 *
318 * Since: 3.0.0
319 */
320 void
ags_soundcard_pcm_info(AgsSoundcard * soundcard,gchar * card_id,guint * channels_min,guint * channels_max,guint * rate_min,guint * rate_max,guint * buffer_size_min,guint * buffer_size_max,GError ** error)321 ags_soundcard_pcm_info(AgsSoundcard *soundcard, gchar *card_id,
322 guint *channels_min, guint *channels_max,
323 guint *rate_min, guint *rate_max,
324 guint *buffer_size_min, guint *buffer_size_max,
325 GError **error)
326 {
327 AgsSoundcardInterface *soundcard_interface;
328
329 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
330 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
331 g_return_if_fail(soundcard_interface->pcm_info);
332 soundcard_interface->pcm_info(soundcard, card_id,
333 channels_min, channels_max,
334 rate_min, rate_max,
335 buffer_size_min, buffer_size_max,
336 error);
337 }
338
339 /**
340 * ags_soundcard_get_capability:
341 * @soundcard: the #AgsSoundcard
342 *
343 * Retrieve #AgsSoundcardCapability-enum information.
344 *
345 * Returns: the capablities flags
346 *
347 * Since: 3.0.0
348 */
349 guint
ags_soundcard_get_capability(AgsSoundcard * soundcard)350 ags_soundcard_get_capability(AgsSoundcard *soundcard)
351 {
352 AgsSoundcardInterface *soundcard_interface;
353
354 guint capability;
355
356 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), 0);
357 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
358 g_return_val_if_fail(soundcard_interface->pcm_info, 0);
359
360 capability = soundcard_interface->get_capability(soundcard);
361
362 return(capability);
363 }
364
365 /**
366 * ags_soundcard_is_available:
367 * @soundcard: the #AgsSoundcard
368 *
369 * Get available.
370 *
371 * Returns: %TRUE if available, else %FALSE
372 *
373 * Since: 3.0.0
374 */
375 gboolean
ags_soundcard_is_available(AgsSoundcard * soundcard)376 ags_soundcard_is_available(AgsSoundcard *soundcard)
377 {
378 AgsSoundcardInterface *soundcard_interface;
379
380 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), FALSE);
381 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
382 g_return_val_if_fail(soundcard_interface->is_available, FALSE);
383
384 return(soundcard_interface->is_available(soundcard));
385 }
386
387 /**
388 * ags_soundcard_is_starting:
389 * @soundcard: the #AgsSoundcard
390 *
391 * Get starting.
392 *
393 * Returns: %TRUE if starting, else %FALSE
394 *
395 * Since: 3.0.0
396 */
397 gboolean
ags_soundcard_is_starting(AgsSoundcard * soundcard)398 ags_soundcard_is_starting(AgsSoundcard *soundcard)
399 {
400 AgsSoundcardInterface *soundcard_interface;
401
402 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), FALSE);
403 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
404 g_return_val_if_fail(soundcard_interface->is_starting, FALSE);
405
406 return(soundcard_interface->is_starting(soundcard));
407 }
408
409 /**
410 * ags_soundcard_is_playing:
411 * @soundcard: the #AgsSoundcard
412 *
413 * Get playing.
414 *
415 * Returns: %TRUE if playing, else %FALSE
416 *
417 * Since: 3.0.0
418 */
419 gboolean
ags_soundcard_is_playing(AgsSoundcard * soundcard)420 ags_soundcard_is_playing(AgsSoundcard *soundcard)
421 {
422 AgsSoundcardInterface *soundcard_interface;
423
424 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), FALSE);
425 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
426 g_return_val_if_fail(soundcard_interface->is_playing, FALSE);
427
428 return(soundcard_interface->is_playing(soundcard));
429 }
430
431 /**
432 * ags_soundcard_is_recording:
433 * @soundcard: the #AgsSoundcard
434 *
435 * Get recording.
436 *
437 * Returns: %TRUE if recording, else %FALSE
438 *
439 * Since: 3.0.0
440 */
441 gboolean
ags_soundcard_is_recording(AgsSoundcard * soundcard)442 ags_soundcard_is_recording(AgsSoundcard *soundcard)
443 {
444 AgsSoundcardInterface *soundcard_interface;
445
446 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), FALSE);
447 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
448 g_return_val_if_fail(soundcard_interface->is_recording, FALSE);
449
450 return(soundcard_interface->is_recording(soundcard));
451 }
452
453 /**
454 * ags_soundcard_get_uptime:
455 * @soundcard: the #AgsSoundcard
456 *
457 * Get playback time as string.
458 *
459 * Returns: playback time as string
460 *
461 * Since: 3.0.0
462 */
463 gchar*
ags_soundcard_get_uptime(AgsSoundcard * soundcard)464 ags_soundcard_get_uptime(AgsSoundcard *soundcard)
465 {
466 AgsSoundcardInterface *soundcard_interface;
467
468 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), NULL);
469 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
470 g_return_val_if_fail(soundcard_interface->get_uptime, NULL);
471
472 return(soundcard_interface->get_uptime(soundcard));
473 }
474
475 /**
476 * ags_soundcard_play_init:
477 * @soundcard: the #AgsSoundcard
478 * @error: an error that may occure
479 *
480 * Initializes the soundcard for playback.
481 *
482 * Since: 3.0.0
483 */
484 void
ags_soundcard_play_init(AgsSoundcard * soundcard,GError ** error)485 ags_soundcard_play_init(AgsSoundcard *soundcard,
486 GError **error)
487 {
488 AgsSoundcardInterface *soundcard_interface;
489
490 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
491 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
492 g_return_if_fail(soundcard_interface->play_init);
493 soundcard_interface->play_init(soundcard,
494 error);
495 }
496
497 /**
498 * ags_soundcard_play:
499 * @soundcard: the #AgsSoundcard
500 * @error: an error that may occure
501 *
502 * Plays the current buffer of soundcard.
503 *
504 * Since: 3.0.0
505 */
506 void
ags_soundcard_play(AgsSoundcard * soundcard,GError ** error)507 ags_soundcard_play(AgsSoundcard *soundcard,
508 GError **error)
509 {
510 AgsSoundcardInterface *soundcard_interface;
511
512 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
513 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
514 g_return_if_fail(soundcard_interface->play);
515 soundcard_interface->play(soundcard,
516 error);
517 }
518
519 /**
520 * ags_soundcard_record_init:
521 * @soundcard: the #AgsSoundcard
522 * @error: an error that may occure
523 *
524 * Initializes the soundcard for recordback.
525 *
526 * Since: 3.0.0
527 */
528 void
ags_soundcard_record_init(AgsSoundcard * soundcard,GError ** error)529 ags_soundcard_record_init(AgsSoundcard *soundcard,
530 GError **error)
531 {
532 AgsSoundcardInterface *soundcard_interface;
533
534 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
535 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
536 g_return_if_fail(soundcard_interface->record_init);
537 soundcard_interface->record_init(soundcard,
538 error);
539 }
540
541 /**
542 * ags_soundcard_record:
543 * @soundcard: the #AgsSoundcard
544 * @error: an error that may occure
545 *
546 * Records the current buffer of soundcard.
547 *
548 * Since: 3.0.0
549 */
550 void
ags_soundcard_record(AgsSoundcard * soundcard,GError ** error)551 ags_soundcard_record(AgsSoundcard *soundcard,
552 GError **error)
553 {
554 AgsSoundcardInterface *soundcard_interface;
555
556 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
557 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
558 g_return_if_fail(soundcard_interface->record);
559 soundcard_interface->record(soundcard,
560 error);
561 }
562
563 /**
564 * ags_soundcard_stop:
565 * @soundcard: the #AgsSoundcard
566 *
567 * Stops the soundcard from playing to it.
568 *
569 * Since: 3.0.0
570 */
571 void
ags_soundcard_stop(AgsSoundcard * soundcard)572 ags_soundcard_stop(AgsSoundcard *soundcard)
573 {
574 g_signal_emit(soundcard, soundcard_signals[STOP], 0);
575 }
576
577 /**
578 * ags_soundcard_tic:
579 * @soundcard: the #AgsSoundcard
580 *
581 * Every call to play may generate a tic.
582 *
583 * Since: 3.0.0
584 */
585 void
ags_soundcard_tic(AgsSoundcard * soundcard)586 ags_soundcard_tic(AgsSoundcard *soundcard)
587 {
588 g_signal_emit(soundcard, soundcard_signals[TIC], 0);
589 }
590
591 /**
592 * ags_soundcard_offset_changed:
593 * @soundcard: the #AgsSoundcard
594 * @note_offset: the current note offset
595 *
596 * Callback when counter expires minor note offset.
597 *
598 * Since: 3.0.0
599 */
600 void
ags_soundcard_offset_changed(AgsSoundcard * soundcard,guint note_offset)601 ags_soundcard_offset_changed(AgsSoundcard *soundcard,
602 guint note_offset)
603 {
604 g_signal_emit(soundcard,
605 soundcard_signals[OFFSET_CHANGED],
606 0,
607 note_offset);
608 }
609
610 /**
611 * ags_soundcard_get_buffer:
612 * @soundcard: the #AgsSoundcard
613 *
614 * Get current playback buffer.
615 *
616 * Returns: current playback buffer
617 *
618 * Since: 3.0.0
619 */
620 void*
ags_soundcard_get_buffer(AgsSoundcard * soundcard)621 ags_soundcard_get_buffer(AgsSoundcard *soundcard)
622 {
623 AgsSoundcardInterface *soundcard_interface;
624
625 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), NULL);
626 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
627 g_return_val_if_fail(soundcard_interface->get_buffer, NULL);
628
629 return(soundcard_interface->get_buffer(soundcard));
630 }
631
632 /**
633 * ags_soundcard_get_next_buffer:
634 * @soundcard: the #AgsSoundcard
635 *
636 * Get future playback buffer.
637 *
638 * Returns: next playback buffer
639 *
640 * Since: 3.0.0
641 */
642 void*
ags_soundcard_get_next_buffer(AgsSoundcard * soundcard)643 ags_soundcard_get_next_buffer(AgsSoundcard *soundcard)
644 {
645 AgsSoundcardInterface *soundcard_interface;
646
647 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), NULL);
648 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
649 g_return_val_if_fail(soundcard_interface->get_next_buffer, NULL);
650
651 return(soundcard_interface->get_next_buffer(soundcard));
652 }
653
654 /**
655 * ags_soundcard_get_prev_buffer:
656 * @soundcard: the #AgsSoundcard
657 *
658 * Get future playback buffer.
659 *
660 * Returns: prev playback buffer
661 *
662 * Since: 3.0.0
663 */
664 void*
ags_soundcard_get_prev_buffer(AgsSoundcard * soundcard)665 ags_soundcard_get_prev_buffer(AgsSoundcard *soundcard)
666 {
667 AgsSoundcardInterface *soundcard_interface;
668
669 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), NULL);
670 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
671 g_return_val_if_fail(soundcard_interface->get_prev_buffer, NULL);
672
673 return(soundcard_interface->get_prev_buffer(soundcard));
674 }
675
676 /**
677 * ags_soundcard_lock_buffer:
678 * @soundcard: the #AgsSoundcard
679 * @buffer: the buffer to lock
680 *
681 * Lock @buffer.
682 *
683 * Since: 3.0.0
684 */
685 void
ags_soundcard_lock_buffer(AgsSoundcard * soundcard,void * buffer)686 ags_soundcard_lock_buffer(AgsSoundcard *soundcard,
687 void *buffer)
688 {
689 AgsSoundcardInterface *soundcard_interface;
690
691 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
692 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
693 g_return_if_fail(soundcard_interface->lock_buffer);
694
695 soundcard_interface->lock_buffer(soundcard,
696 buffer);
697 }
698
699 /**
700 * ags_soundcard_unlock_buffer:
701 * @soundcard: the #AgsSoundcard
702 * @buffer: the buffer to unlock
703 *
704 * Unlock @buffer.
705 *
706 * Since: 3.0.0
707 */
708 void
ags_soundcard_unlock_buffer(AgsSoundcard * soundcard,void * buffer)709 ags_soundcard_unlock_buffer(AgsSoundcard *soundcard,
710 void *buffer)
711 {
712 AgsSoundcardInterface *soundcard_interface;
713
714 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
715 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
716 g_return_if_fail(soundcard_interface->unlock_buffer);
717
718 soundcard_interface->unlock_buffer(soundcard,
719 buffer);
720 }
721
722 /**
723 * ags_soundcard_set_bpm:
724 * @soundcard: the #AgsSoundcard
725 * @bpm: the bpm to set
726 *
727 * Set current playback bpm.
728 *
729 * Since: 3.0.0
730 */
731 void
ags_soundcard_set_bpm(AgsSoundcard * soundcard,gdouble bpm)732 ags_soundcard_set_bpm(AgsSoundcard *soundcard,
733 gdouble bpm)
734 {
735 AgsSoundcardInterface *soundcard_interface;
736
737 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
738 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
739 g_return_if_fail(soundcard_interface->set_bpm);
740 soundcard_interface->set_bpm(soundcard,
741 bpm);
742 }
743
744 /**
745 * ags_soundcard_get_bpm:
746 * @soundcard: the #AgsSoundcard
747 *
748 * Get current playback bpm.
749 *
750 * Returns: bpm
751 *
752 * Since: 3.0.0
753 */
754 gdouble
ags_soundcard_get_bpm(AgsSoundcard * soundcard)755 ags_soundcard_get_bpm(AgsSoundcard *soundcard)
756 {
757 AgsSoundcardInterface *soundcard_interface;
758
759 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), G_MAXUINT);
760 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
761 g_return_val_if_fail(soundcard_interface->get_bpm, G_MAXUINT);
762
763 return(soundcard_interface->get_bpm(soundcard));
764 }
765
766 /**
767 * ags_soundcard_set_delay_factor:
768 * @soundcard: the #AgsSoundcard
769 * @delay_factor: the delay factor to set
770 *
771 * Set current playback delay factor.
772 *
773 * Since: 3.0.0
774 */
775 void
ags_soundcard_set_delay_factor(AgsSoundcard * soundcard,gdouble delay_factor)776 ags_soundcard_set_delay_factor(AgsSoundcard *soundcard,
777 gdouble delay_factor)
778 {
779 AgsSoundcardInterface *soundcard_interface;
780
781 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
782 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
783 g_return_if_fail(soundcard_interface->set_delay_factor);
784 soundcard_interface->set_delay_factor(soundcard,
785 delay_factor);
786 }
787
788 /**
789 * ags_soundcard_get_delay_factor:
790 * @soundcard: the #AgsSoundcard
791 *
792 * Get current playback delay factor.
793 *
794 * Returns: delay factor
795 *
796 * Since: 3.0.0
797 */
798 gdouble
ags_soundcard_get_delay_factor(AgsSoundcard * soundcard)799 ags_soundcard_get_delay_factor(AgsSoundcard *soundcard)
800 {
801 AgsSoundcardInterface *soundcard_interface;
802
803 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), G_MAXDOUBLE);
804 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
805 g_return_val_if_fail(soundcard_interface->get_delay_factor, G_MAXDOUBLE);
806
807 return(soundcard_interface->get_delay_factor(soundcard));
808 }
809
810 /**
811 * ags_soundcard_get_absolute_delay:
812 * @soundcard: the #AgsSoundcard
813 *
814 * Get current playback delay.
815 *
816 * Returns: delay
817 *
818 * Since: 3.0.0
819 */
820 gdouble
ags_soundcard_get_absolute_delay(AgsSoundcard * soundcard)821 ags_soundcard_get_absolute_delay(AgsSoundcard *soundcard)
822 {
823 AgsSoundcardInterface *soundcard_interface;
824
825 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), G_MAXDOUBLE);
826 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
827 g_return_val_if_fail(soundcard_interface->get_absolute_delay, G_MAXDOUBLE);
828
829 return(soundcard_interface->get_absolute_delay(soundcard));
830 }
831
832 /**
833 * ags_soundcard_get_delay:
834 * @soundcard: the #AgsSoundcard
835 *
836 * Get current playback delay.
837 *
838 * Returns: delay
839 *
840 * Since: 3.0.0
841 */
842 gdouble
ags_soundcard_get_delay(AgsSoundcard * soundcard)843 ags_soundcard_get_delay(AgsSoundcard *soundcard)
844 {
845 AgsSoundcardInterface *soundcard_interface;
846
847 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), G_MAXDOUBLE);
848 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
849 g_return_val_if_fail(soundcard_interface->get_delay, G_MAXDOUBLE);
850
851 return(soundcard_interface->get_delay(soundcard));
852 }
853
854 /**
855 * ags_soundcard_get_attack:
856 * @soundcard: the #AgsSoundcard
857 *
858 * Get current playback attack.
859 *
860 * Returns: attack
861 *
862 * Since: 3.0.0
863 */
864 guint
ags_soundcard_get_attack(AgsSoundcard * soundcard)865 ags_soundcard_get_attack(AgsSoundcard *soundcard)
866 {
867 AgsSoundcardInterface *soundcard_interface;
868
869 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), G_MAXUINT);
870 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
871 g_return_val_if_fail(soundcard_interface->get_attack, G_MAXUINT);
872
873 return(soundcard_interface->get_attack(soundcard));
874 }
875
876 /**
877 * ags_soundcard_get_delay_counter:
878 * @soundcard: the #AgsSoundcard
879 *
880 * Get current playback note offset.
881 *
882 * Returns: offset
883 *
884 * Since: 3.0.0
885 */
886 guint
ags_soundcard_get_delay_counter(AgsSoundcard * soundcard)887 ags_soundcard_get_delay_counter(AgsSoundcard *soundcard)
888 {
889 AgsSoundcardInterface *soundcard_interface;
890
891 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), G_MAXUINT);
892 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
893 g_return_val_if_fail(soundcard_interface->get_delay_counter, G_MAXUINT);
894
895 return(soundcard_interface->get_delay_counter(soundcard));
896 }
897
898 /**
899 * ags_soundcard_set_start_note_offset:
900 * @soundcard: the #AgsSoundcard
901 * @start_note_offset: the start note offset to set
902 *
903 * Set start playback note offset.
904 *
905 * Since: 3.0.0
906 */
907 void
ags_soundcard_set_start_note_offset(AgsSoundcard * soundcard,guint start_note_offset)908 ags_soundcard_set_start_note_offset(AgsSoundcard *soundcard,
909 guint start_note_offset)
910 {
911 AgsSoundcardInterface *soundcard_interface;
912
913 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
914 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
915 g_return_if_fail(soundcard_interface->set_start_note_offset);
916 soundcard_interface->set_start_note_offset(soundcard,
917 start_note_offset);
918 }
919
920 /**
921 * ags_soundcard_get_start_note_offset:
922 * @soundcard: the #AgsSoundcard
923 *
924 * Get start playback note offset.
925 *
926 * Returns: the start note offset
927 *
928 * Since: 3.0.0
929 */
930 guint
ags_soundcard_get_start_note_offset(AgsSoundcard * soundcard)931 ags_soundcard_get_start_note_offset(AgsSoundcard *soundcard)
932 {
933 AgsSoundcardInterface *soundcard_interface;
934
935 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), G_MAXUINT);
936 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
937 g_return_val_if_fail(soundcard_interface->get_start_note_offset, G_MAXUINT);
938
939 return(soundcard_interface->get_start_note_offset(soundcard));
940 }
941
942 /**
943 * ags_soundcard_set_note_offset:
944 * @soundcard: the #AgsSoundcard
945 * @note_offset: the note offset to set
946 *
947 * Set current playback note offset.
948 *
949 * Since: 3.0.0
950 */
951 void
ags_soundcard_set_note_offset(AgsSoundcard * soundcard,guint note_offset)952 ags_soundcard_set_note_offset(AgsSoundcard *soundcard,
953 guint note_offset)
954 {
955 AgsSoundcardInterface *soundcard_interface;
956
957 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
958 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
959 g_return_if_fail(soundcard_interface->set_note_offset);
960 soundcard_interface->set_note_offset(soundcard,
961 note_offset);
962 }
963
964 /**
965 * ags_soundcard_get_note_offset:
966 * @soundcard: the #AgsSoundcard
967 *
968 * Get current playback note offset.
969 *
970 * Returns: the current note offset
971 *
972 * Since: 3.0.0
973 */
974 guint
ags_soundcard_get_note_offset(AgsSoundcard * soundcard)975 ags_soundcard_get_note_offset(AgsSoundcard *soundcard)
976 {
977 AgsSoundcardInterface *soundcard_interface;
978
979 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), G_MAXUINT);
980 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
981 g_return_val_if_fail(soundcard_interface->get_note_offset, G_MAXUINT);
982
983 return(soundcard_interface->get_note_offset(soundcard));
984 }
985
986 /**
987 * ags_soundcard_set_note_offset_absolute:
988 * @soundcard: the #AgsSoundcard
989 * @note_offset: the note offset to set
990 *
991 * Set current playback note offset.
992 *
993 * Since: 3.0.0
994 */
995 void
ags_soundcard_set_note_offset_absolute(AgsSoundcard * soundcard,guint note_offset)996 ags_soundcard_set_note_offset_absolute(AgsSoundcard *soundcard,
997 guint note_offset)
998 {
999 AgsSoundcardInterface *soundcard_interface;
1000
1001 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
1002 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
1003 g_return_if_fail(soundcard_interface->set_note_offset_absolute);
1004 soundcard_interface->set_note_offset_absolute(soundcard,
1005 note_offset);
1006 }
1007
1008 /**
1009 * ags_soundcard_get_note_offset_absolute:
1010 * @soundcard: the #AgsSoundcard
1011 *
1012 * Get current playback note offset.
1013 *
1014 * Returns: offset
1015 *
1016 * Since: 3.0.0
1017 */
1018 guint
ags_soundcard_get_note_offset_absolute(AgsSoundcard * soundcard)1019 ags_soundcard_get_note_offset_absolute(AgsSoundcard *soundcard)
1020 {
1021 AgsSoundcardInterface *soundcard_interface;
1022
1023 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), G_MAXUINT);
1024 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
1025 g_return_val_if_fail(soundcard_interface->get_note_offset_absolute, G_MAXUINT);
1026
1027 return(soundcard_interface->get_note_offset_absolute(soundcard));
1028 }
1029
1030 /**
1031 * ags_soundcard_set_loop:
1032 * @soundcard: the #AgsSoundcard
1033 * @loop_left: loop position of region
1034 * @loop_right: loop position of region
1035 * @do_loop: if %TRUE do loop, else don't loop
1036 *
1037 * Set loop parameters of @soundcard.
1038 *
1039 * Since: 3.0.0
1040 */
1041 void
ags_soundcard_set_loop(AgsSoundcard * soundcard,guint loop_left,guint loop_right,gboolean do_loop)1042 ags_soundcard_set_loop(AgsSoundcard *soundcard,
1043 guint loop_left, guint loop_right,
1044 gboolean do_loop)
1045 {
1046 AgsSoundcardInterface *soundcard_interface;
1047
1048 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
1049 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
1050 g_return_if_fail(soundcard_interface->set_loop);
1051 soundcard_interface->set_loop(soundcard,
1052 loop_left, loop_right,
1053 do_loop);
1054 }
1055
1056 /**
1057 * ags_soundcard_get_loop:
1058 * @soundcard: the #AgsSoundcard
1059 * @loop_left: (out): return location of loop position's region
1060 * @loop_right: (out): return location of loop position's region
1061 * @do_loop: (out): return location of do loop
1062 *
1063 * Get loop parameters of @soundcard.
1064 *
1065 * Since: 3.0.0
1066 */
1067 void
ags_soundcard_get_loop(AgsSoundcard * soundcard,guint * loop_left,guint * loop_right,gboolean * do_loop)1068 ags_soundcard_get_loop(AgsSoundcard *soundcard,
1069 guint *loop_left, guint *loop_right,
1070 gboolean *do_loop)
1071 {
1072 AgsSoundcardInterface *soundcard_interface;
1073
1074 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
1075 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
1076 g_return_if_fail(soundcard_interface->get_loop);
1077 soundcard_interface->get_loop(soundcard,
1078 loop_left, loop_right,
1079 do_loop);
1080 }
1081
1082 /**
1083 * ags_soundcard_get_loop_offset:
1084 * @soundcard: the #AgsSoundcard
1085 *
1086 * Get current playback loop offset.
1087 *
1088 * Returns: offset
1089 *
1090 * Since: 3.0.0
1091 */
1092 guint
ags_soundcard_get_loop_offset(AgsSoundcard * soundcard)1093 ags_soundcard_get_loop_offset(AgsSoundcard *soundcard)
1094 {
1095 AgsSoundcardInterface *soundcard_interface;
1096
1097 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), 0);
1098 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
1099 g_return_val_if_fail(soundcard_interface->get_loop_offset, 0);
1100
1101 return(soundcard_interface->get_loop_offset(soundcard));
1102 }
1103
1104 /**
1105 * ags_soundcard_get_sub_block_count:
1106 * @soundcard: the #AgsSoundcard
1107 *
1108 * Get sub block count.
1109 *
1110 * Returns: the sub block count
1111 *
1112 * Since: 3.0.0
1113 */
1114 guint
ags_soundcard_get_sub_block_count(AgsSoundcard * soundcard)1115 ags_soundcard_get_sub_block_count(AgsSoundcard *soundcard)
1116 {
1117 AgsSoundcardInterface *soundcard_interface;
1118
1119 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), 0);
1120 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
1121 g_return_val_if_fail(soundcard_interface->get_sub_block_count, 0);
1122
1123 return(soundcard_interface->get_sub_block_count(soundcard));
1124 }
1125
1126 /**
1127 * ags_soundcard_trylock_sub_block:
1128 * @soundcard: the #AgsSoundcard
1129 * @buffer: the buffer to lock
1130 * @sub_block: and its sub block
1131 *
1132 * Trylock sub block.
1133 *
1134 * Returns: %TRUE on success, otherwise %FALSE
1135 *
1136 * Since: 3.0.0
1137 */
1138 gboolean
ags_soundcard_trylock_sub_block(AgsSoundcard * soundcard,void * buffer,guint sub_block)1139 ags_soundcard_trylock_sub_block(AgsSoundcard *soundcard,
1140 void *buffer, guint sub_block)
1141 {
1142 AgsSoundcardInterface *soundcard_interface;
1143
1144 g_return_val_if_fail(AGS_IS_SOUNDCARD(soundcard), FALSE);
1145 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
1146 g_return_val_if_fail(soundcard_interface->trylock_sub_block, FALSE);
1147
1148 return(soundcard_interface->trylock_sub_block(soundcard,
1149 buffer, sub_block));
1150 }
1151
1152 /**
1153 * ags_soundcard_unlock_sub_block:
1154 * @soundcard: the #AgsSoundcard
1155 * @buffer: the buffer to lock
1156 * @sub_block: and its sub block
1157 *
1158 * Unlock sub block.
1159 *
1160 * Since: 3.0.0
1161 */
1162 void
ags_soundcard_unlock_sub_block(AgsSoundcard * soundcard,void * buffer,guint sub_block)1163 ags_soundcard_unlock_sub_block(AgsSoundcard *soundcard,
1164 void *buffer, guint sub_block)
1165 {
1166 AgsSoundcardInterface *soundcard_interface;
1167
1168 g_return_if_fail(AGS_IS_SOUNDCARD(soundcard));
1169 soundcard_interface = AGS_SOUNDCARD_GET_INTERFACE(soundcard);
1170 g_return_if_fail(soundcard_interface->unlock_sub_block);
1171
1172 soundcard_interface->unlock_sub_block(soundcard,
1173 buffer, sub_block);
1174 }
1175