1 /* GSequencer - Advanced GTK Sequencer
2 * Copyright (C) 2005-2021 Joël Krähemann
3 *
4 * This file is part of GSequencer.
5 *
6 * GSequencer is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * GSequencer is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with GSequencer. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <ags/X/ags_soundcard_editor.h>
21 #include <ags/X/ags_soundcard_editor_callbacks.h>
22
23 #include <ags/X/ags_audio_preferences.h>
24
25 #include <ags/config.h>
26 #include <ags/i18n.h>
27
28 void ags_soundcard_editor_class_init(AgsSoundcardEditorClass *soundcard_editor);
29 void ags_soundcard_editor_connectable_interface_init(AgsConnectableInterface *connectable);
30 void ags_soundcard_editor_applicable_interface_init(AgsApplicableInterface *applicable);
31 void ags_soundcard_editor_init(AgsSoundcardEditor *soundcard_editor);
32 static void ags_soundcard_editor_finalize(GObject *gobject);
33
34 void ags_soundcard_editor_connect(AgsConnectable *connectable);
35 void ags_soundcard_editor_disconnect(AgsConnectable *connectable);
36
37 void ags_soundcard_editor_set_update(AgsApplicable *applicable, gboolean update);
38 void ags_soundcard_editor_apply(AgsApplicable *applicable);
39 void ags_soundcard_editor_reset(AgsApplicable *applicable);
40
41 /**
42 * SECTION:ags_soundcard_editor
43 * @short_description: A composite widget to configure soundcard
44 * @title: AgsSoundcardEditor
45 * @section_id:
46 * @include: ags/X/ags_soundcard_editor.h
47 *
48 * #AgsSoundcardEditor enables you to make preferences of soundcard, audio channels,
49 * samplerate and buffer size.
50 */
51
52 static gpointer ags_soundcard_editor_parent_class = NULL;
53
54 GType
ags_soundcard_editor_get_type(void)55 ags_soundcard_editor_get_type(void)
56 {
57 static volatile gsize g_define_type_id__volatile = 0;
58
59 if(g_once_init_enter (&g_define_type_id__volatile)){
60 GType ags_type_soundcard_editor = 0;
61
62 static const GTypeInfo ags_soundcard_editor_info = {
63 sizeof (AgsSoundcardEditorClass),
64 NULL, /* base_init */
65 NULL, /* base_finalize */
66 (GClassInitFunc) ags_soundcard_editor_class_init,
67 NULL, /* class_finalize */
68 NULL, /* class_data */
69 sizeof (AgsSoundcardEditor),
70 0, /* n_preallocs */
71 (GInstanceInitFunc) ags_soundcard_editor_init,
72 };
73
74 static const GInterfaceInfo ags_connectable_interface_info = {
75 (GInterfaceInitFunc) ags_soundcard_editor_connectable_interface_init,
76 NULL, /* interface_finalize */
77 NULL, /* interface_data */
78 };
79
80 static const GInterfaceInfo ags_applicable_interface_info = {
81 (GInterfaceInitFunc) ags_soundcard_editor_applicable_interface_init,
82 NULL, /* interface_finalize */
83 NULL, /* interface_data */
84 };
85
86 ags_type_soundcard_editor = g_type_register_static(GTK_TYPE_BOX,
87 "AgsSoundcardEditor", &ags_soundcard_editor_info,
88 0);
89
90 g_type_add_interface_static(ags_type_soundcard_editor,
91 AGS_TYPE_CONNECTABLE,
92 &ags_connectable_interface_info);
93
94 g_type_add_interface_static(ags_type_soundcard_editor,
95 AGS_TYPE_APPLICABLE,
96 &ags_applicable_interface_info);
97
98 g_once_init_leave(&g_define_type_id__volatile, ags_type_soundcard_editor);
99 }
100
101 return g_define_type_id__volatile;
102 }
103
104 void
ags_soundcard_editor_class_init(AgsSoundcardEditorClass * soundcard_editor)105 ags_soundcard_editor_class_init(AgsSoundcardEditorClass *soundcard_editor)
106 {
107 GObjectClass *gobject;
108
109 ags_soundcard_editor_parent_class = g_type_class_peek_parent(soundcard_editor);
110
111 /* GtkObjectClass */
112 gobject = (GObjectClass *) soundcard_editor;
113
114 gobject->finalize = ags_soundcard_editor_finalize;
115 }
116
117 void
ags_soundcard_editor_connectable_interface_init(AgsConnectableInterface * connectable)118 ags_soundcard_editor_connectable_interface_init(AgsConnectableInterface *connectable)
119 {
120 connectable->is_ready = NULL;
121 connectable->is_connected = NULL;
122 connectable->connect = ags_soundcard_editor_connect;
123 connectable->disconnect = ags_soundcard_editor_disconnect;
124 }
125
126 void
ags_soundcard_editor_applicable_interface_init(AgsApplicableInterface * applicable)127 ags_soundcard_editor_applicable_interface_init(AgsApplicableInterface *applicable)
128 {
129 applicable->set_update = ags_soundcard_editor_set_update;
130 applicable->apply = ags_soundcard_editor_apply;
131 applicable->reset = ags_soundcard_editor_reset;
132 }
133
134 void
ags_soundcard_editor_init(AgsSoundcardEditor * soundcard_editor)135 ags_soundcard_editor_init(AgsSoundcardEditor *soundcard_editor)
136 {
137 GtkGrid *grid;
138 GtkLabel *label;
139
140 guint y0;
141
142 gtk_orientable_set_orientation(GTK_ORIENTABLE(soundcard_editor),
143 GTK_ORIENTATION_VERTICAL);
144
145 soundcard_editor->flags = 0;
146
147 soundcard_editor->soundcard = NULL;
148 soundcard_editor->soundcard_thread = NULL;
149
150 grid = (GtkGrid *) gtk_grid_new();
151 gtk_box_pack_start(GTK_BOX(soundcard_editor),
152 GTK_WIDGET(grid),
153 FALSE, FALSE,
154 2);
155
156 y0 = 0;
157
158 /* backend */
159 label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL,
160 "label", i18n("backend"),
161 "xalign", 0.0,
162 NULL);
163
164 gtk_widget_set_valign((GtkWidget *) label,
165 GTK_ALIGN_FILL);
166 gtk_widget_set_halign((GtkWidget *) label,
167 GTK_ALIGN_FILL);
168
169 gtk_grid_attach(grid,
170 GTK_WIDGET(label),
171 0, y0,
172 1, 1);
173
174 soundcard_editor->backend = (GtkComboBoxText *) gtk_combo_box_text_new();
175
176 gtk_widget_set_valign((GtkWidget *) soundcard_editor->backend,
177 GTK_ALIGN_FILL);
178 gtk_widget_set_halign((GtkWidget *) soundcard_editor->backend,
179 GTK_ALIGN_FILL);
180
181 gtk_grid_attach(grid,
182 GTK_WIDGET(soundcard_editor->backend),
183 1, y0,
184 1, 1);
185
186 #ifdef AGS_WITH_CORE_AUDIO
187 gtk_combo_box_text_append_text(soundcard_editor->backend,
188 "core-audio");
189 #endif
190
191 #ifdef AGS_WITH_PULSE
192 gtk_combo_box_text_append_text(soundcard_editor->backend,
193 "pulse");
194 #endif
195
196 #ifdef AGS_WITH_JACK
197 gtk_combo_box_text_append_text(soundcard_editor->backend,
198 "jack");
199 #endif
200
201 #ifdef AGS_WITH_WASAPI
202 gtk_combo_box_text_append_text(soundcard_editor->backend,
203 "wasapi");
204 #endif
205
206 #ifdef AGS_WITH_ALSA
207 gtk_combo_box_text_append_text(soundcard_editor->backend,
208 "alsa");
209 #endif
210
211 #ifdef AGS_WITH_OSS
212 gtk_combo_box_text_append_text(soundcard_editor->backend,
213 "oss");
214 #endif
215
216 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
217 0);
218
219 y0++;
220
221 /* sound card */
222 label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL,
223 "label", i18n("soundcard"),
224 "xalign", 0.0,
225 NULL);
226
227 gtk_widget_set_valign((GtkWidget *) label,
228 GTK_ALIGN_FILL);
229 gtk_widget_set_halign((GtkWidget *) label,
230 GTK_ALIGN_FILL);
231
232 gtk_grid_attach(grid,
233 GTK_WIDGET(label),
234 0, y0,
235 1, 1);
236
237 soundcard_editor->card = (GtkComboBoxText *) gtk_combo_box_text_new();
238
239 gtk_widget_set_valign((GtkWidget *) soundcard_editor->card,
240 GTK_ALIGN_FILL);
241 gtk_widget_set_halign((GtkWidget *) soundcard_editor->card,
242 GTK_ALIGN_FILL);
243
244 gtk_grid_attach(grid,
245 GTK_WIDGET(soundcard_editor->card),
246 1, y0,
247 1, 1);
248
249 y0++;
250
251 /* port */
252 soundcard_editor->port_hbox = NULL;
253 soundcard_editor->add_port = NULL;
254 soundcard_editor->remove_port = NULL;
255
256 soundcard_editor->port_hbox = (GtkBox *) gtk_box_new(GTK_ORIENTATION_HORIZONTAL,
257 0);
258
259 gtk_widget_set_valign((GtkWidget *) soundcard_editor->port_hbox,
260 GTK_ALIGN_FILL);
261 gtk_widget_set_halign((GtkWidget *) soundcard_editor->port_hbox,
262 GTK_ALIGN_FILL);
263
264 gtk_grid_attach(grid,
265 GTK_WIDGET(soundcard_editor->port_hbox),
266 2, y0,
267 1, 1);
268
269 soundcard_editor->add_port = (GtkButton *) gtk_button_new_with_mnemonic(i18n("_Add"));
270 gtk_box_pack_start((GtkBox *) soundcard_editor->port_hbox,
271 (GtkWidget *) soundcard_editor->add_port,
272 FALSE, FALSE,
273 0);
274
275 soundcard_editor->remove_port = (GtkButton *) gtk_button_new_with_mnemonic(i18n("_Remove"));
276 gtk_box_pack_start((GtkBox *) soundcard_editor->port_hbox,
277 (GtkWidget *) soundcard_editor->remove_port,
278 FALSE, FALSE,
279 0);
280
281 y0++;
282
283 /* capability */
284 label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL,
285 "label", i18n("capability"),
286 "xalign", 0.0,
287 NULL);
288
289 gtk_widget_set_valign((GtkWidget *) label,
290 GTK_ALIGN_FILL);
291 gtk_widget_set_halign((GtkWidget *) label,
292 GTK_ALIGN_FILL);
293
294 gtk_grid_attach(grid,
295 GTK_WIDGET(label),
296 0, y0,
297 1, 1);
298
299 soundcard_editor->capability = (GtkComboBoxText *) gtk_combo_box_text_new();
300
301 gtk_widget_set_valign((GtkWidget *) soundcard_editor->capability,
302 GTK_ALIGN_FILL);
303 gtk_widget_set_halign((GtkWidget *) soundcard_editor->capability,
304 GTK_ALIGN_FILL);
305
306 gtk_grid_attach(grid,
307 GTK_WIDGET(soundcard_editor->capability),
308 1, y0,
309 1, 1);
310
311 gtk_combo_box_text_append_text(soundcard_editor->capability,
312 "playback");
313
314 gtk_combo_box_text_append_text(soundcard_editor->capability,
315 "capture");
316
317 #if 0
318 gtk_combo_box_text_append_text(soundcard_editor->capability,
319 "duplex");
320 #endif
321
322 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->capability),
323 0);
324
325 y0++;
326
327 /* audio channels */
328 label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL,
329 "label", i18n("audio channels"),
330 "xalign", 0.0,
331 NULL);
332
333 gtk_widget_set_valign((GtkWidget *) label,
334 GTK_ALIGN_FILL);
335 gtk_widget_set_halign((GtkWidget *) label,
336 GTK_ALIGN_FILL);
337
338 gtk_grid_attach(grid,
339 GTK_WIDGET(label),
340 0, y0,
341 1, 1);
342
343 soundcard_editor->audio_channels = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 24.0, 1.0);
344 gtk_spin_button_set_value(soundcard_editor->audio_channels,
345 2);
346
347 gtk_widget_set_valign((GtkWidget *) soundcard_editor->audio_channels,
348 GTK_ALIGN_FILL);
349 gtk_widget_set_halign((GtkWidget *) soundcard_editor->audio_channels,
350 GTK_ALIGN_FILL);
351
352 gtk_grid_attach(grid,
353 GTK_WIDGET(soundcard_editor->audio_channels),
354 1, y0,
355 1, 1);
356
357 y0++;
358
359 /* samplerate */
360 label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL,
361 "label", i18n("samplerate"),
362 "xalign", 0.0,
363 NULL);
364
365 gtk_widget_set_valign((GtkWidget *) label,
366 GTK_ALIGN_FILL);
367 gtk_widget_set_halign((GtkWidget *) label,
368 GTK_ALIGN_FILL);
369
370 gtk_grid_attach(grid,
371 GTK_WIDGET(label),
372 0, y0,
373 1, 1);
374
375 soundcard_editor->samplerate = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 192000.0, 1.0);
376 gtk_spin_button_set_value(soundcard_editor->samplerate, 44100);
377
378 gtk_widget_set_valign((GtkWidget *) soundcard_editor->samplerate,
379 GTK_ALIGN_FILL);
380 gtk_widget_set_halign((GtkWidget *) soundcard_editor->samplerate,
381 GTK_ALIGN_FILL);
382
383 gtk_grid_attach(grid,
384 GTK_WIDGET(soundcard_editor->samplerate),
385 1, y0,
386 1, 1);
387
388 y0++;
389
390 /* buffer size */
391 label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL,
392 "label", i18n("buffer size"),
393 "xalign", 0.0,
394 NULL);
395
396 gtk_widget_set_valign((GtkWidget *) label,
397 GTK_ALIGN_FILL);
398 gtk_widget_set_halign((GtkWidget *) label,
399 GTK_ALIGN_FILL);
400
401 gtk_grid_attach(grid,
402 GTK_WIDGET(label),
403 0, y0,
404 1, 1);
405
406 soundcard_editor->buffer_size = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 65535.0, 1.0);
407 gtk_spin_button_set_value(soundcard_editor->buffer_size,
408 512.0);
409
410 gtk_widget_set_valign((GtkWidget *) soundcard_editor->buffer_size,
411 GTK_ALIGN_FILL);
412 gtk_widget_set_halign((GtkWidget *) soundcard_editor->buffer_size,
413 GTK_ALIGN_FILL);
414
415 gtk_grid_attach(grid,
416 GTK_WIDGET(soundcard_editor->buffer_size),
417 1, y0,
418 1, 1);
419
420 y0++;
421
422 /* format */
423 label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL,
424 "label", i18n("format"),
425 "xalign", 0.0,
426 NULL);
427
428 gtk_widget_set_valign((GtkWidget *) label,
429 GTK_ALIGN_FILL);
430 gtk_widget_set_halign((GtkWidget *) label,
431 GTK_ALIGN_FILL);
432
433 gtk_grid_attach(grid,
434 GTK_WIDGET(label),
435 0, y0,
436 1, 1);
437
438 soundcard_editor->format = (GtkComboBoxText *) gtk_combo_box_text_new();
439
440 gtk_widget_set_valign((GtkWidget *) soundcard_editor->format,
441 GTK_ALIGN_FILL);
442 gtk_widget_set_halign((GtkWidget *) soundcard_editor->format,
443 GTK_ALIGN_FILL);
444
445 gtk_grid_attach(grid,
446 GTK_WIDGET(soundcard_editor->format),
447 1, y0,
448 1, 1);
449
450 gtk_combo_box_text_append_text(soundcard_editor->format,
451 "8");
452 gtk_combo_box_text_append_text(soundcard_editor->format,
453 "16");
454 gtk_combo_box_text_append_text(soundcard_editor->format,
455 "24");
456 gtk_combo_box_text_append_text(soundcard_editor->format,
457 "32");
458 gtk_combo_box_text_append_text(soundcard_editor->format,
459 "64");
460
461 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->format),
462 1);
463
464 y0++;
465
466 /* use cache */
467 soundcard_editor->use_cache = gtk_check_button_new_with_label(i18n("use cache"));
468 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(soundcard_editor->use_cache),
469 TRUE);
470
471 gtk_widget_set_valign((GtkWidget *) soundcard_editor->use_cache,
472 GTK_ALIGN_FILL);
473 gtk_widget_set_halign((GtkWidget *) soundcard_editor->use_cache,
474 GTK_ALIGN_FILL);
475
476 gtk_grid_attach(grid,
477 GTK_WIDGET(soundcard_editor->use_cache),
478 0, y0,
479 2, 1);
480
481 y0++;
482
483 /* cache buffer size */
484 label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL,
485 "label", i18n("cache buffer size"),
486 "xalign", 0.0,
487 NULL);
488
489 gtk_widget_set_valign((GtkWidget *) label,
490 GTK_ALIGN_FILL);
491 gtk_widget_set_halign((GtkWidget *) label,
492 GTK_ALIGN_FILL);
493
494 gtk_grid_attach(grid,
495 GTK_WIDGET(label),
496 0, y0,
497 1, 1);
498
499 soundcard_editor->cache_buffer_size = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 65535.0, 1.0);
500 gtk_spin_button_set_value(soundcard_editor->cache_buffer_size,
501 4096.0);
502
503 gtk_widget_set_valign((GtkWidget *) soundcard_editor->cache_buffer_size,
504 GTK_ALIGN_FILL);
505 gtk_widget_set_halign((GtkWidget *) soundcard_editor->cache_buffer_size,
506 GTK_ALIGN_FILL);
507
508 gtk_grid_attach(grid,
509 GTK_WIDGET(soundcard_editor->cache_buffer_size),
510 1, y0,
511 1, 1);
512
513 #if !defined(AGS_WITH_CORE_AUDIO) && defined(AGS_WITH_PULSE)
514 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->capability),
515 FALSE);
516 #else
517 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->capability),
518 TRUE);
519 #endif
520
521 #if defined(AGS_WITH_CORE_AUDIO) || defined(AGS_WITH_PULSE)
522 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->use_cache),
523 TRUE);
524 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->cache_buffer_size),
525 TRUE);
526 #else
527 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->use_cache),
528 FALSE);
529 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->cache_buffer_size),
530 FALSE);
531 #endif
532
533 y0++;
534
535 #if defined(AGS_WITH_WASAPI)
536 /* wasapi share mode */
537 soundcard_editor->wasapi_share_mode_label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL,
538 "label", i18n("WASAPI share mode"),
539 "xalign", 0.0,
540 NULL);
541
542 gtk_widget_set_valign((GtkWidget *) soundcard_editor->wasapi_share_mode_label,
543 GTK_ALIGN_FILL);
544 gtk_widget_set_halign((GtkWidget *) soundcard_editor->wasapi_share_mode_label,
545 GTK_ALIGN_FILL);
546
547 gtk_grid_attach(grid,
548 GTK_WIDGET(soundcard_editor->wasapi_share_mode_label),
549 0, y0,
550 1, 1);
551
552 soundcard_editor->wasapi_share_mode = (GtkComboBoxText *) gtk_combo_box_text_new();
553
554 gtk_widget_set_valign((GtkWidget *) soundcard_editor->wasapi_share_mode,
555 GTK_ALIGN_FILL);
556 gtk_widget_set_halign((GtkWidget *) soundcard_editor->wasapi_share_mode,
557 GTK_ALIGN_FILL);
558
559 gtk_grid_attach(grid,
560 GTK_WIDGET(soundcard_editor->wasapi_share_mode),
561 1, y0,
562 1, 1);
563
564 gtk_combo_box_text_append_text(soundcard_editor->wasapi_share_mode,
565 "exclusive");
566
567 gtk_combo_box_text_append_text(soundcard_editor->wasapi_share_mode,
568 "shared");
569
570 y0++;
571
572 /* wasapi buffer size */
573 soundcard_editor->wasapi_buffer_size_label = (GtkLabel *) g_object_new(GTK_TYPE_LABEL,
574 "label", i18n("WASAPI buffer size"),
575 "xalign", 0.0,
576 NULL);
577
578 gtk_widget_set_valign((GtkWidget *) soundcard_editor->wasapi_buffer_size_label,
579 GTK_ALIGN_FILL);
580 gtk_widget_set_halign((GtkWidget *) soundcard_editor->wasapi_buffer_size_label,
581 GTK_ALIGN_FILL);
582
583 gtk_grid_attach(grid,
584 GTK_WIDGET(soundcard_editor->wasapi_buffer_size_label),
585 0, y0,
586 1, 1);
587
588 soundcard_editor->wasapi_buffer_size = (GtkSpinButton *) gtk_spin_button_new_with_range(1.0, 65535.0, 1.0);
589 gtk_spin_button_set_value(soundcard_editor->wasapi_buffer_size,
590 8192.0);
591
592 gtk_widget_set_valign((GtkWidget *) soundcard_editor->wasapi_buffer_size,
593 GTK_ALIGN_FILL);
594 gtk_widget_set_halign((GtkWidget *) soundcard_editor->wasapi_buffer_size,
595 GTK_ALIGN_FILL);
596
597 gtk_grid_attach(grid,
598 GTK_WIDGET(soundcard_editor->wasapi_buffer_size),
599 1, y0,
600 1, 1);
601
602 y0++;
603 #else
604 soundcard_editor->wasapi_share_mode_label = NULL;
605 soundcard_editor->wasapi_share_mode = NULL;
606
607 soundcard_editor->wasapi_buffer_size_label = NULL;
608 soundcard_editor->wasapi_buffer_size = NULL;
609 #endif
610
611 /* */
612 // soundcard_editor->remove = NULL;
613
614 soundcard_editor->remove = (GtkButton *) gtk_button_new_with_mnemonic(i18n("_Remove"));
615
616 gtk_widget_set_valign((GtkWidget *) soundcard_editor->remove,
617 GTK_ALIGN_FILL);
618 gtk_widget_set_halign((GtkWidget *) soundcard_editor->remove,
619 GTK_ALIGN_FILL);
620
621 gtk_grid_attach(grid,
622 GTK_WIDGET(soundcard_editor->remove),
623 2, y0,
624 1, 1);
625
626 y0++;
627 }
628
629 static void
ags_soundcard_editor_finalize(GObject * gobject)630 ags_soundcard_editor_finalize(GObject *gobject)
631 {
632 //TODO:JK: implement me
633
634 G_OBJECT_CLASS(ags_soundcard_editor_parent_class)->finalize(gobject);
635 }
636
637 void
ags_soundcard_editor_connect(AgsConnectable * connectable)638 ags_soundcard_editor_connect(AgsConnectable *connectable)
639 {
640 AgsSoundcardEditor *soundcard_editor;
641
642 soundcard_editor = AGS_SOUNDCARD_EDITOR(connectable);
643
644 if((AGS_SOUNDCARD_EDITOR_CONNECTED & (soundcard_editor->flags)) != 0){
645 return;
646 }
647
648 soundcard_editor->flags |= AGS_SOUNDCARD_EDITOR_CONNECTED;
649
650 /* backend and card */
651 g_signal_connect_after(G_OBJECT(soundcard_editor->backend), "changed",
652 G_CALLBACK(ags_soundcard_editor_backend_changed_callback), soundcard_editor);
653
654 g_signal_connect_after(G_OBJECT(soundcard_editor->card), "changed",
655 G_CALLBACK(ags_soundcard_editor_card_changed_callback), soundcard_editor);
656
657 /* add / remove port */
658 g_signal_connect(G_OBJECT(soundcard_editor->add_port), "clicked",
659 G_CALLBACK(ags_soundcard_editor_add_port_callback), soundcard_editor);
660
661 g_signal_connect(G_OBJECT(soundcard_editor->remove_port), "clicked",
662 G_CALLBACK(ags_soundcard_editor_remove_port_callback), soundcard_editor);
663
664 /* presets */
665 g_signal_connect_after(G_OBJECT(soundcard_editor->audio_channels), "changed",
666 G_CALLBACK(ags_soundcard_editor_audio_channels_changed_callback), soundcard_editor);
667
668 g_signal_connect_after(G_OBJECT(soundcard_editor->samplerate), "changed",
669 G_CALLBACK(ags_soundcard_editor_samplerate_changed_callback), soundcard_editor);
670
671 g_signal_connect_after(G_OBJECT(soundcard_editor->buffer_size), "changed",
672 G_CALLBACK(ags_soundcard_editor_buffer_size_changed_callback), soundcard_editor);
673
674 g_signal_connect_after(G_OBJECT(soundcard_editor->format), "changed",
675 G_CALLBACK(ags_soundcard_editor_format_changed_callback), soundcard_editor);
676 }
677
678 void
ags_soundcard_editor_disconnect(AgsConnectable * connectable)679 ags_soundcard_editor_disconnect(AgsConnectable *connectable)
680 {
681 AgsSoundcardEditor *soundcard_editor;
682
683 soundcard_editor = AGS_SOUNDCARD_EDITOR(connectable);
684
685 if((AGS_SOUNDCARD_EDITOR_CONNECTED & (soundcard_editor->flags)) == 0){
686 return;
687 }
688
689 soundcard_editor->flags &= (~AGS_SOUNDCARD_EDITOR_CONNECTED);
690
691 /* backend and card */
692 g_object_disconnect(G_OBJECT(soundcard_editor->backend),
693 "any_signal::changed",
694 G_CALLBACK(ags_soundcard_editor_backend_changed_callback),
695 soundcard_editor,
696 NULL);
697
698 g_object_disconnect(G_OBJECT(soundcard_editor->card),
699 "any_signal::changed",
700 G_CALLBACK(ags_soundcard_editor_card_changed_callback),
701 soundcard_editor,
702 NULL);
703
704 /* add / remove port */
705 g_object_disconnect(G_OBJECT(soundcard_editor->add_port),
706 "any_signal::clicked",
707 G_CALLBACK(ags_soundcard_editor_add_port_callback),
708 soundcard_editor,
709 NULL);
710
711 g_object_disconnect(G_OBJECT(soundcard_editor->remove_port),
712 "any_signal::clicked",
713 G_CALLBACK(ags_soundcard_editor_remove_port_callback),
714 soundcard_editor,
715 NULL);
716
717 /* presets */
718 g_object_disconnect(G_OBJECT(soundcard_editor->audio_channels),
719 "any_signal::changed",
720 G_CALLBACK(ags_soundcard_editor_audio_channels_changed_callback),
721 soundcard_editor,
722 NULL);
723
724 g_object_disconnect(G_OBJECT(soundcard_editor->samplerate),
725 "any_signal::changed",
726 G_CALLBACK(ags_soundcard_editor_samplerate_changed_callback),
727 soundcard_editor,
728 NULL);
729
730 g_object_disconnect(G_OBJECT(soundcard_editor->buffer_size),
731 "any_signal::changed",
732 G_CALLBACK(ags_soundcard_editor_buffer_size_changed_callback),
733 soundcard_editor,
734 NULL);
735
736 g_object_disconnect(G_OBJECT(soundcard_editor->format),
737 "any_signal::changed",
738 G_CALLBACK(ags_soundcard_editor_format_changed_callback),
739 soundcard_editor,
740 NULL);
741 }
742
743 void
ags_soundcard_editor_set_update(AgsApplicable * applicable,gboolean update)744 ags_soundcard_editor_set_update(AgsApplicable *applicable, gboolean update)
745 {
746 //TODO:JK: implement me
747 }
748
749 void
ags_soundcard_editor_apply(AgsApplicable * applicable)750 ags_soundcard_editor_apply(AgsApplicable *applicable)
751 {
752 AgsAudioPreferences *audio_preferences;
753 AgsSoundcardEditor *soundcard_editor;
754
755 GtkListStore *model;
756 GtkTreeIter current;
757
758 AgsConfig *config;
759
760 GList *list;
761
762 gchar *soundcard_group;
763 gchar *backend;
764 gchar *capability;
765 char *device, *str;
766 #if defined AGS_WITH_WASAPI
767 gchar *wasapi_share_mode;
768 #endif
769
770 gint nth;
771 guint channels;
772 guint samplerate;
773 guint buffer_size;
774 guint cache_buffer_size;
775 guint format;
776 #if defined AGS_WITH_WASAPI
777 guint wasapi_buffer_size;
778 #endif
779 gboolean use_core_audio, use_pulse, use_jack, use_wasapi, use_alsa, use_oss;
780
781 GValue value = {0,};
782
783 soundcard_editor = AGS_SOUNDCARD_EDITOR(applicable);
784 audio_preferences = (AgsAudioPreferences *) gtk_widget_get_ancestor(GTK_WIDGET(soundcard_editor),
785 AGS_TYPE_AUDIO_PREFERENCES);
786
787 config = ags_config_get_instance();
788
789 list = gtk_container_get_children((GtkContainer *) audio_preferences->soundcard_editor);
790 nth = g_list_index(list,
791 soundcard_editor);
792
793 if(nth < 0){
794 return;
795 }
796
797 soundcard_group = g_strdup_printf("%s-%d",
798 AGS_CONFIG_SOUNDCARD,
799 nth);
800 g_list_free(list);
801
802 /* backend */
803 #if defined AGS_WITH_WASAPI
804 use_wasapi = TRUE;
805
806 use_core_audio = FALSE;
807
808 use_pulse = FALSE;
809 #elif defined AGS_WITH_CORE_AUDIO
810 use_wasapi = FALSE;
811
812 use_core_audio = TRUE;
813
814 use_pulse = FALSE;
815 #else
816 use_wasapi = FALSE;
817
818 use_core_audio = FALSE;
819
820 use_pulse = TRUE;
821 #endif
822
823 use_jack = FALSE;
824 use_alsa = FALSE;
825 use_oss = FALSE;
826
827 backend = gtk_combo_box_text_get_active_text(soundcard_editor->backend);
828 ags_config_set_value(config,
829 soundcard_group,
830 "backend",
831 backend);
832
833 if(backend != NULL){
834 if(!g_ascii_strncasecmp(backend,
835 "core-audio",
836 11)){
837 use_core_audio = TRUE;
838 }else if(!g_ascii_strncasecmp(backend,
839 "pulse",
840 6)){
841 use_pulse = TRUE;
842 }else if(!g_ascii_strncasecmp(backend,
843 "jack",
844 5)){
845 use_jack = TRUE;
846
847 use_wasapi = FALSE;
848 use_core_audio = FALSE;
849 use_pulse = FALSE;
850 }else if(!g_ascii_strncasecmp(backend,
851 "wasapi",
852 7)){
853 use_wasapi = TRUE;
854 }else if(!g_ascii_strncasecmp(backend,
855 "alsa",
856 5)){
857 use_alsa = TRUE;
858
859 use_wasapi = FALSE;
860 use_core_audio = FALSE;
861 use_pulse = FALSE;
862 }else if(!g_ascii_strncasecmp(backend,
863 "oss",
864 4)){
865 use_oss = TRUE;
866
867 use_wasapi = FALSE;
868 use_core_audio = FALSE;
869 use_pulse = FALSE;
870 }
871 }
872
873 capability = gtk_combo_box_text_get_active_text(soundcard_editor->capability);
874 ags_config_set_value(config,
875 soundcard_group,
876 "capability",
877 capability);
878
879 /* buffer size */
880 buffer_size = gtk_spin_button_get_value(soundcard_editor->buffer_size);
881 str = g_strdup_printf("%u",
882 buffer_size);
883 ags_config_set_value(config,
884 soundcard_group,
885 "buffer-size",
886 str);
887 g_free(str);
888
889 /* pcm channels */
890 channels = gtk_spin_button_get_value(soundcard_editor->audio_channels);
891 str = g_strdup_printf("%u",
892 channels);
893 ags_config_set_value(config,
894 soundcard_group,
895 "pcm-channels",
896 str);
897 g_free(str);
898
899 /* format */
900 format = 0;
901
902 switch(gtk_combo_box_get_active(GTK_COMBO_BOX(soundcard_editor->format))){
903 case 0:
904 format = AGS_SOUNDCARD_SIGNED_8_BIT;
905 break;
906 case 1:
907 format = AGS_SOUNDCARD_SIGNED_16_BIT;
908 break;
909 case 2:
910 format = AGS_SOUNDCARD_SIGNED_24_BIT;
911 break;
912 case 3:
913 format = AGS_SOUNDCARD_SIGNED_32_BIT;
914 break;
915 case 4:
916 format = AGS_SOUNDCARD_SIGNED_64_BIT;
917 break;
918 }
919
920 str = g_strdup_printf("%u",
921 format);
922 ags_config_set_value(config,
923 soundcard_group,
924 "format",
925 str);
926 g_free(str);
927
928 /* samplerate */
929 samplerate = gtk_spin_button_get_value(soundcard_editor->samplerate);
930 str = g_strdup_printf("%u",
931 samplerate);
932 ags_config_set_value(config,
933 soundcard_group,
934 "samplerate",
935 str);
936 g_free(str);
937
938 /* device */
939 model = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->card)));
940
941 if(gtk_combo_box_get_active_iter(GTK_COMBO_BOX(soundcard_editor->card),
942 ¤t)){
943 gtk_tree_model_get_value(GTK_TREE_MODEL(model),
944 ¤t,
945 0,
946 &value);
947 device = g_value_get_string(&value);
948
949 if(!g_ascii_strcasecmp(device, "(null)")){
950 device = NULL;
951 }
952 }else{
953 device = NULL;
954 }
955
956 /* handle */
957 #ifdef AGS_DEBUG
958 g_message("%s", device);
959 #endif
960
961 if(use_core_audio){
962 ags_config_set_value(config,
963 soundcard_group,
964 "device",
965 device);
966 }else if(use_pulse){
967 ags_config_set_value(config,
968 soundcard_group,
969 "device",
970 device);
971 }else if(use_jack){
972 ags_config_set_value(config,
973 soundcard_group,
974 "device",
975 device);
976 }else if(use_wasapi){
977 ags_config_set_value(config,
978 soundcard_group,
979 "device",
980 device);
981 }else if(use_alsa){
982 ags_config_set_value(config,
983 soundcard_group,
984 "device",
985 device);
986 }else if(use_oss){
987 ags_config_set_value(config,
988 soundcard_group,
989 "device",
990 device);
991 }
992
993 if(AGS_IS_PULSE_DEVOUT(soundcard_editor->soundcard) ||
994 AGS_IS_CORE_AUDIO_DEVOUT(soundcard_editor->soundcard)){
995 ags_config_set_value(config,
996 soundcard_group,
997 "use-cache",
998 (gtk_toggle_button_get_active((GtkToggleButton *) soundcard_editor->use_cache) ? "true": "false"));
999
1000 cache_buffer_size = gtk_spin_button_get_value(soundcard_editor->cache_buffer_size);
1001 str = g_strdup_printf("%u",
1002 cache_buffer_size);
1003 ags_config_set_value(config,
1004 soundcard_group,
1005 "cache-buffer-size",
1006 str);
1007 g_free(str);
1008 }
1009
1010 #if defined AGS_WITH_WASAPI
1011 wasapi_share_mode = gtk_combo_box_text_get_active_text(soundcard_editor->wasapi_share_mode);
1012 ags_config_set_value(config,
1013 soundcard_group,
1014 "wasapi-share-mode",
1015 wasapi_share_mode);
1016
1017 /* buffer size */
1018 wasapi_buffer_size = gtk_spin_button_get_value(soundcard_editor->wasapi_buffer_size);
1019 str = g_strdup_printf("%u",
1020 wasapi_buffer_size);
1021 ags_config_set_value(config,
1022 soundcard_group,
1023 "wasapi-buffer-size",
1024 str);
1025 g_free(str);
1026 #endif
1027 }
1028
1029 void
ags_soundcard_editor_reset(AgsApplicable * applicable)1030 ags_soundcard_editor_reset(AgsApplicable *applicable)
1031 {
1032 AgsSoundcardEditor *soundcard_editor;
1033
1034 GObject *soundcard;
1035
1036 GList *card_id, *card_id_start, *card_name, *card_name_start;
1037
1038 gchar *backend, *device, *tmp;
1039 #if defined AGS_WITH_WASAPI
1040 gchar *wasapi_share_mode;
1041 #endif
1042
1043 guint capability;
1044 guint nth;
1045 guint channels, channels_min, channels_max;
1046 guint samplerate, samplerate_min, samplerate_max;
1047 guint buffer_size, buffer_size_min, buffer_size_max;
1048 guint format;
1049 #if defined AGS_WITH_WASAPI
1050 guint wasapi_buffer_size;
1051 #endif
1052 gboolean found_card;
1053
1054 GError *error;
1055
1056 soundcard_editor = AGS_SOUNDCARD_EDITOR(applicable);
1057
1058 if((AGS_SOUNDCARD_EDITOR_BLOCK_RESET & (soundcard_editor->flags)) != 0){
1059 return;
1060 }
1061
1062 soundcard_editor->flags |= AGS_SOUNDCARD_EDITOR_BLOCK_RESET;
1063
1064 soundcard = soundcard_editor->soundcard;
1065
1066 /* refresh */
1067 backend = NULL;
1068 capability = 0;
1069
1070 if(AGS_IS_CORE_AUDIO_DEVOUT(soundcard)){
1071 backend = "core-audio";
1072
1073 capability = AGS_SOUNDCARD_CAPABILITY_PLAYBACK;
1074 }else if(AGS_IS_PULSE_DEVOUT(soundcard)){
1075 backend = "pulse";
1076
1077 capability = AGS_SOUNDCARD_CAPABILITY_PLAYBACK;
1078 }else if(AGS_IS_JACK_DEVOUT(soundcard)){
1079 backend = "jack";
1080
1081 capability = AGS_SOUNDCARD_CAPABILITY_PLAYBACK;
1082 }else if(AGS_IS_WASAPI_DEVOUT(soundcard)){
1083 backend = "wasapi";
1084
1085 capability = AGS_SOUNDCARD_CAPABILITY_PLAYBACK;
1086 }else if(AGS_IS_DEVOUT(soundcard)){
1087 if((AGS_DEVOUT_ALSA & (AGS_DEVOUT(soundcard)->flags)) != 0){
1088 backend = "alsa";
1089 }else if((AGS_DEVOUT_OSS & (AGS_DEVOUT(soundcard)->flags)) != 0){
1090 backend = "oss";
1091 }
1092
1093 capability = AGS_SOUNDCARD_CAPABILITY_PLAYBACK;
1094 }else if(AGS_IS_CORE_AUDIO_DEVIN(soundcard)){
1095 backend = "core-audio";
1096
1097 capability = AGS_SOUNDCARD_CAPABILITY_CAPTURE;
1098 }else if(AGS_IS_PULSE_DEVIN(soundcard)){
1099 backend = "pulse";
1100
1101 capability = AGS_SOUNDCARD_CAPABILITY_CAPTURE;
1102 }else if(AGS_IS_JACK_DEVIN(soundcard)){
1103 backend = "jack";
1104
1105 capability = AGS_SOUNDCARD_CAPABILITY_CAPTURE;
1106 }else if(AGS_IS_WASAPI_DEVIN(soundcard)){
1107 backend = "wasapi";
1108
1109 capability = AGS_SOUNDCARD_CAPABILITY_CAPTURE;
1110 }else if(AGS_IS_DEVIN(soundcard)){
1111 if((AGS_DEVIN_ALSA & (AGS_DEVIN(soundcard)->flags)) != 0){
1112 backend = "alsa";
1113 }else if((AGS_DEVIN_OSS & (AGS_DEVIN(soundcard)->flags)) != 0){
1114 backend = "oss";
1115 }
1116
1117 capability = AGS_SOUNDCARD_CAPABILITY_CAPTURE;
1118 }
1119
1120 if(backend != NULL){
1121 GtkTreeModel *model;
1122 GtkTreeIter current;
1123
1124 gint nth_backend;
1125 guint i;
1126
1127 GValue value = {0,};
1128
1129 model = gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->backend));
1130 nth_backend = -1;
1131
1132 if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model),
1133 ¤t)){
1134 i = 0;
1135
1136 do{
1137 gchar *str;
1138
1139 gtk_tree_model_get_value(GTK_TREE_MODEL(model),
1140 ¤t,
1141 0,
1142 &value);
1143
1144 str = g_value_get_string(&value);
1145
1146 if(str != NULL &&
1147 !g_strcmp0(backend,
1148 str)){
1149 nth_backend = i;
1150
1151 g_value_unset(&value);
1152
1153 break;
1154 }
1155
1156 g_value_unset(&value);
1157
1158 i++;
1159 }while(gtk_tree_model_iter_next(GTK_TREE_MODEL(model),
1160 ¤t));
1161 }
1162
1163 if(!g_ascii_strncasecmp(backend,
1164 "core-audio",
1165 11)){
1166 #ifdef AGS_WITH_CORE_AUDIO
1167 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1168 nth_backend);
1169 #else
1170 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1171 -1);
1172 #endif
1173
1174 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->capability),
1175 TRUE);
1176
1177 // ags_soundcard_editor_load_core_audio_card(soundcard_editor);
1178 }else if(!g_ascii_strncasecmp(backend,
1179 "pulse",
1180 6)){
1181 #ifdef AGS_WITH_PULSE
1182 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1183 nth_backend);
1184 #else
1185 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1186 -1);
1187 #endif
1188
1189 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->capability),
1190 0);
1191 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->capability),
1192 FALSE);
1193 // ags_soundcard_editor_load_pulse_card(soundcard_editor);
1194 }else if(!g_ascii_strncasecmp(backend,
1195 "jack",
1196 5)){
1197 #ifdef AGS_WITH_JACK
1198 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1199 nth_backend);
1200 #else
1201 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1202 -1);
1203 #endif
1204
1205 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->use_cache),
1206 FALSE);
1207 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->cache_buffer_size),
1208 FALSE);
1209
1210 // ags_soundcard_editor_load_jack_card(soundcard_editor);
1211 }else if(!g_ascii_strncasecmp(backend,
1212 "wasapi",
1213 7)){
1214 #ifdef AGS_WITH_WASAPI
1215 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1216 nth_backend);
1217 #else
1218 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1219 -1);
1220 #endif
1221
1222 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->capability),
1223 TRUE);
1224
1225 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->use_cache),
1226 FALSE);
1227 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->cache_buffer_size),
1228 FALSE);
1229
1230 // ags_soundcard_editor_load_wasapi_card(soundcard_editor);
1231 }else if(!g_ascii_strncasecmp(backend,
1232 "alsa",
1233 5)){
1234 #ifdef AGS_WITH_ALSA
1235 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1236 nth_backend);
1237 #else
1238 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1239 -1);
1240 #endif
1241
1242 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->capability),
1243 TRUE);
1244
1245 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->use_cache),
1246 FALSE);
1247 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->cache_buffer_size),
1248 FALSE);
1249
1250 // ags_soundcard_editor_load_alsa_card(soundcard_editor);
1251 }else if(!g_ascii_strncasecmp(backend,
1252 "oss",
1253 4)){
1254 #ifdef AGS_WITH_OSS
1255 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1256 nth_backend);
1257 #else
1258 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1259 -1);
1260 #endif
1261
1262 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->capability),
1263 TRUE);
1264
1265 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->use_cache),
1266 FALSE);
1267 gtk_widget_set_sensitive(GTK_WIDGET(soundcard_editor->cache_buffer_size),
1268 FALSE);
1269
1270 // ags_soundcard_editor_load_oss_card(soundcard_editor);
1271 }
1272 }
1273
1274 /* */
1275 device = ags_soundcard_get_device(AGS_SOUNDCARD(soundcard));
1276
1277 card_id = NULL;
1278 card_name = NULL;
1279
1280 ags_soundcard_list_cards(AGS_SOUNDCARD(soundcard),
1281 &card_id_start, &card_name_start);
1282
1283 card_id = card_id_start;
1284 card_name = card_name_start;
1285
1286 nth = 0;
1287 found_card = FALSE;
1288
1289 gtk_list_store_clear(GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->card))));
1290
1291 while(card_id != NULL){
1292 //FIXME:JK: work-around for alsa-handle
1293 tmp = card_id->data;
1294
1295 if(tmp != NULL &&
1296 device != NULL){
1297 if(!g_ascii_strcasecmp(tmp,
1298 device)){
1299 found_card = TRUE;
1300 }
1301 }else{
1302 if(tmp == NULL &&
1303 device == NULL){
1304 found_card = TRUE;
1305 }
1306 }
1307
1308 if(tmp != NULL){
1309 gtk_combo_box_text_append_text(soundcard_editor->card,
1310 tmp);
1311 }
1312
1313 if(!found_card){
1314 nth++;
1315 }
1316
1317 card_id = card_id->next;
1318 card_name = card_name->next;
1319 }
1320
1321 if(!found_card){
1322 nth = 0;
1323 }
1324
1325 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->card),
1326 nth);
1327
1328 if(card_id_start != NULL){
1329 g_list_free_full(card_id_start,
1330 g_free);
1331 g_list_free_full(card_name_start,
1332 g_free);
1333 }
1334
1335 /* capability */
1336 switch(capability){
1337 case AGS_SOUNDCARD_CAPABILITY_PLAYBACK:
1338 {
1339 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->capability),
1340 0);
1341 }
1342 break;
1343 case AGS_SOUNDCARD_CAPABILITY_CAPTURE:
1344 {
1345 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->capability),
1346 1);
1347 }
1348 break;
1349 case AGS_SOUNDCARD_CAPABILITY_DUPLEX:
1350 {
1351 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->capability),
1352 2);
1353 }
1354 break;
1355 }
1356
1357 /* */
1358 ags_soundcard_get_presets(AGS_SOUNDCARD(soundcard),
1359 &channels,
1360 &samplerate,
1361 &buffer_size,
1362 &format);
1363
1364 /* */
1365 gtk_spin_button_set_value(soundcard_editor->audio_channels,
1366 (gdouble) channels);
1367 gtk_spin_button_set_value(soundcard_editor->samplerate,
1368 (gdouble) samplerate);
1369 gtk_spin_button_set_value(soundcard_editor->buffer_size,
1370 (gdouble) buffer_size);
1371
1372 switch(format){
1373 case AGS_SOUNDCARD_SIGNED_8_BIT:
1374 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->format),
1375 0);
1376 break;
1377 case AGS_SOUNDCARD_SIGNED_16_BIT:
1378 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->format),
1379 1);
1380 break;
1381 case AGS_SOUNDCARD_SIGNED_24_BIT:
1382 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->format),
1383 2);
1384 break;
1385 case AGS_SOUNDCARD_SIGNED_32_BIT:
1386 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->format),
1387 3);
1388 break;
1389 case AGS_SOUNDCARD_SIGNED_64_BIT:
1390 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->format),
1391 4);
1392 break;
1393 }
1394
1395 /* */
1396 if(device != NULL &&
1397 soundcard != NULL){
1398 error = NULL;
1399 ags_soundcard_pcm_info(AGS_SOUNDCARD(soundcard),
1400 device,
1401 &channels_min, &channels_max,
1402 &samplerate_min, &samplerate_max,
1403 &buffer_size_min, &buffer_size_max,
1404 &error);
1405
1406 if(error != NULL){
1407 channels_min = 0.0;
1408 channels_max = 24.0;
1409 samplerate_min = 8000.0;
1410 samplerate_max = 192000.0;
1411 buffer_size_min = 2.0;
1412 buffer_size_max = 65535.0;
1413
1414 g_message("%s", error->message);
1415
1416 g_error_free(error);
1417 }
1418 }else{
1419 channels_min = 0.0;
1420 channels_max = 24.0;
1421 samplerate_min = 8000.0;
1422 samplerate_max = 192000.0;
1423 buffer_size_min = 2.0;
1424 buffer_size_max = 65535.0;
1425 }
1426
1427 gtk_spin_button_set_range(soundcard_editor->audio_channels,
1428 channels_min, channels_max);
1429 gtk_spin_button_set_range(soundcard_editor->samplerate,
1430 samplerate_min, samplerate_max);
1431 gtk_spin_button_set_range(soundcard_editor->buffer_size,
1432 buffer_size_min, buffer_size_max);
1433
1434 soundcard_editor->flags &= (~AGS_SOUNDCARD_EDITOR_BLOCK_RESET);
1435
1436 if(AGS_IS_PULSE_DEVOUT(soundcard)){
1437 GList *start_port, *port;
1438
1439 guint cache_buffer_size;
1440 gboolean use_cache;
1441
1442 GRecMutex *pulse_port_mutex;
1443
1444 g_object_get(soundcard,
1445 "pulse-port", &start_port,
1446 NULL);
1447
1448 port = start_port;
1449
1450 if(port != NULL){
1451 pulse_port_mutex = AGS_PULSE_PORT_GET_OBJ_MUTEX(port->data);
1452
1453 /* read use cache and cache buffer size */
1454 g_rec_mutex_lock(pulse_port_mutex);
1455
1456 use_cache = AGS_PULSE_PORT(port->data)->use_cache;
1457 cache_buffer_size = AGS_PULSE_PORT(port->data)->cache_buffer_size;
1458
1459 g_rec_mutex_unlock(pulse_port_mutex);
1460
1461 /* reset */
1462 gtk_toggle_button_set_active((GtkToggleButton *) soundcard_editor->use_cache,
1463 use_cache);
1464
1465 gtk_spin_button_set_value(soundcard_editor->cache_buffer_size,
1466 cache_buffer_size);
1467 }
1468
1469 g_list_free_full(start_port,
1470 g_object_unref);
1471 }else if(AGS_IS_CORE_AUDIO_DEVOUT(soundcard)){
1472 GList *start_port, *port;
1473
1474 guint cache_buffer_size;
1475 gboolean use_cache;
1476
1477 GRecMutex *core_audio_port_mutex;
1478
1479 g_object_get(soundcard,
1480 "core-audio-port", &start_port,
1481 NULL);
1482
1483 port = start_port;
1484
1485 if(port != NULL){
1486 core_audio_port_mutex = AGS_CORE_AUDIO_PORT_GET_OBJ_MUTEX(port->data);
1487
1488 /* read use cache and cache buffer size */
1489 g_rec_mutex_lock(core_audio_port_mutex);
1490
1491 use_cache = AGS_CORE_AUDIO_PORT(port->data)->use_cache;
1492 cache_buffer_size = AGS_CORE_AUDIO_PORT(port->data)->cache_buffer_size;
1493
1494 g_rec_mutex_unlock(core_audio_port_mutex);
1495
1496 /* reset */
1497 gtk_toggle_button_set_active((GtkToggleButton *) soundcard_editor->use_cache,
1498 use_cache);
1499
1500 gtk_spin_button_set_value(soundcard_editor->cache_buffer_size,
1501 cache_buffer_size);
1502 }
1503
1504 g_list_free_full(start_port,
1505 g_object_unref);
1506 }else{
1507 gtk_toggle_button_set_active(soundcard_editor->use_cache,
1508 FALSE);
1509 }
1510
1511 #if defined AGS_WITH_WASAPI
1512 if(AGS_IS_WASAPI_DEVOUT(soundcard)){
1513 GRecMutex *mutex;
1514
1515 mutex = AGS_WASAPI_DEVOUT_GET_OBJ_MUTEX(AGS_WASAPI_DEVOUT(soundcard));
1516
1517 g_rec_mutex_lock(mutex);
1518
1519 wasapi_buffer_size = AGS_WASAPI_DEVOUT(soundcard)->wasapi_buffer_size;
1520
1521 g_rec_mutex_unlock(mutex);
1522
1523 gtk_spin_button_set_value(soundcard_editor->wasapi_buffer_size,
1524 (gdouble) wasapi_buffer_size);
1525
1526 if(ags_wasapi_devout_test_flags(soundcard,
1527 AGS_WASAPI_DEVOUT_SHARE_MODE_EXCLUSIVE)){
1528 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->wasapi_share_mode),
1529 0);
1530 }else{
1531 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->wasapi_share_mode),
1532 1);
1533 }
1534 }else if(AGS_IS_WASAPI_DEVIN(soundcard)){
1535 GRecMutex *mutex;
1536
1537 mutex = AGS_WASAPI_DEVIN_GET_OBJ_MUTEX(AGS_WASAPI_DEVIN(soundcard));
1538
1539 g_rec_mutex_lock(mutex);
1540
1541 wasapi_buffer_size = AGS_WASAPI_DEVIN(soundcard)->wasapi_buffer_size;
1542
1543 g_rec_mutex_unlock(mutex);
1544
1545 gtk_spin_button_set_value(soundcard_editor->wasapi_buffer_size,
1546 (gdouble) wasapi_buffer_size);
1547
1548 if(ags_wasapi_devin_test_flags(soundcard,
1549 AGS_WASAPI_DEVIN_SHARE_MODE_EXCLUSIVE)){
1550 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->wasapi_share_mode),
1551 0);
1552 }else{
1553 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->wasapi_share_mode),
1554 1);
1555 }
1556 }
1557 #endif
1558 }
1559
1560 void
ags_soundcard_editor_add_port(AgsSoundcardEditor * soundcard_editor,gchar * device)1561 ags_soundcard_editor_add_port(AgsSoundcardEditor *soundcard_editor,
1562 gchar *device)
1563 {
1564 AgsPulseServer *pulse_server;
1565 AgsPulseDevout *pulse_devout;
1566
1567 AgsJackServer *jack_server;
1568 AgsJackDevout *jack_devout;
1569
1570 AgsCoreAudioServer *core_audio_server;
1571 AgsCoreAudioDevout *core_audio_devout;
1572
1573 AgsThread *main_loop;
1574 AgsThread *soundcard_thread, *default_soundcard_thread;
1575 AgsThread *export_thread;
1576
1577 AgsApplicationContext *application_context;
1578
1579 GObject *soundcard;
1580
1581 GType server_type;
1582
1583 GList *start_sound_server, *sound_server;
1584 GList *start_soundcard;
1585 GList *card_name, *card_uri;
1586
1587 gchar *backend;
1588
1589 gboolean use_core_audio, use_pulse, use_jack;
1590 gboolean is_output;
1591 gboolean initial_soundcard;
1592
1593 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
1594 return;
1595 }
1596
1597 application_context = ags_application_context_get_instance();
1598
1599 core_audio_server = NULL;
1600 core_audio_devout = NULL;
1601
1602 pulse_server = NULL;
1603 pulse_devout = NULL;
1604
1605 jack_server = NULL;
1606 jack_devout = NULL;
1607
1608 soundcard = NULL;
1609
1610 server_type = G_TYPE_NONE;
1611
1612 backend = NULL;
1613
1614 use_core_audio = FALSE;
1615 use_pulse = FALSE;
1616 use_jack = FALSE;
1617
1618 is_output = (gtk_combo_box_get_active(GTK_COMBO_BOX(soundcard_editor->capability)) == 0) ? TRUE: FALSE;
1619
1620 initial_soundcard = FALSE;
1621
1622 /* determine backend */
1623 backend = gtk_combo_box_text_get_active_text(soundcard_editor->backend);
1624
1625 if(backend != NULL){
1626 if(!g_ascii_strncasecmp(backend,
1627 "core-audio",
1628 11)){
1629 server_type = AGS_TYPE_CORE_AUDIO_SERVER;
1630
1631 use_core_audio = TRUE;
1632 }else if(!g_ascii_strncasecmp(backend,
1633 "pulse",
1634 6)){
1635 server_type = AGS_TYPE_PULSE_SERVER;
1636
1637 use_pulse = TRUE;
1638 }else if(!g_ascii_strncasecmp(backend,
1639 "jack",
1640 5)){
1641 server_type = AGS_TYPE_JACK_SERVER;
1642
1643 use_jack = TRUE;
1644 }
1645 }
1646
1647 /* create soundcard */
1648 sound_server =
1649 start_sound_server = ags_sound_provider_get_sound_server(AGS_SOUND_PROVIDER(application_context));
1650
1651 if((sound_server = ags_list_util_find_type(start_sound_server,
1652 server_type)) != NULL){
1653 if(use_core_audio){
1654 core_audio_server = AGS_CORE_AUDIO_SERVER(sound_server->data);
1655
1656 core_audio_devout = (AgsCoreAudioDevout *) ags_sound_server_register_soundcard(AGS_SOUND_SERVER(core_audio_server),
1657 is_output);
1658 soundcard = (GObject *) core_audio_devout;
1659 }else if(use_pulse){
1660 pulse_server = AGS_PULSE_SERVER(sound_server->data);
1661
1662 pulse_devout = (AgsPulseDevout *) ags_sound_server_register_soundcard(AGS_SOUND_SERVER(pulse_server),
1663 is_output);
1664 soundcard = (GObject *) pulse_devout;
1665 }else if(use_jack){
1666 jack_server = AGS_JACK_SERVER(sound_server->data);
1667
1668 jack_devout = (AgsJackDevout *) ags_sound_server_register_soundcard(AGS_SOUND_SERVER(jack_server),
1669 is_output);
1670 soundcard = (GObject *) jack_devout;
1671 }
1672 }else{
1673 g_warning("sound server not found");
1674
1675 g_list_free_full(start_sound_server,
1676 g_object_unref);
1677
1678 return;
1679 }
1680
1681 if(soundcard == NULL){
1682 g_list_free_full(start_sound_server,
1683 g_object_unref);
1684
1685 return;
1686 }
1687
1688 /* add new */
1689 main_loop = ags_concurrency_provider_get_main_loop(AGS_CONCURRENCY_PROVIDER(application_context));
1690
1691 if(ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(application_context)) == NULL){
1692 initial_soundcard = TRUE;
1693 }
1694
1695 soundcard_editor->soundcard = soundcard;
1696
1697 start_soundcard = ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(application_context));
1698 g_list_foreach(start_soundcard,
1699 (GFunc) g_object_unref,
1700 NULL);
1701
1702 start_soundcard = g_list_append(start_soundcard,
1703 soundcard);
1704 ags_sound_provider_set_soundcard(AGS_SOUND_PROVIDER(application_context),
1705 start_soundcard);
1706
1707 /* add AgsAudio to AgsSoundcard */
1708 #if 0
1709 if(initial_soundcard){
1710 GList *machine, *machine_start;
1711 GList *start_list, *list;
1712
1713 machine =
1714 machine_start = gtk_container_get_children(GTK_CONTAINER(window->machines));
1715
1716 while(machine != NULL){
1717 g_object_ref(G_OBJECT(AGS_MACHINE(machine->data)->audio));
1718
1719 list =
1720 start_list = ags_sound_provider_get_audio(AGS_SOUND_PROVIDER(application_context));
1721 g_list_foreach(start_list,
1722 (GFunc) g_object_unref,
1723 NULL);
1724
1725 list = g_list_append(start_list,
1726 AGS_MACHINE(machine->data)->audio);
1727 ags_sound_provider_set_audio(AGS_SOUND_PROVIDER(application_context),
1728 start_list);
1729
1730 machine = machine->next;
1731 }
1732 g_list_free(machine_start);
1733 }
1734 #endif
1735
1736 g_object_ref(soundcard);
1737
1738 soundcard_thread = (AgsThread *) ags_soundcard_thread_new(soundcard,
1739 ags_soundcard_get_capability(AGS_SOUNDCARD(soundcard)));
1740 soundcard_editor->soundcard_thread = (GObject *) soundcard_thread;
1741
1742 ags_thread_add_child_extended(main_loop,
1743 soundcard_thread,
1744 TRUE, TRUE);
1745
1746 if((default_soundcard_thread = (AgsThread *) ags_sound_provider_get_default_soundcard_thread(AGS_SOUND_PROVIDER(application_context))) == NULL){
1747 ags_sound_provider_set_default_soundcard_thread(AGS_SOUND_PROVIDER(application_context),
1748 (GObject *) soundcard_thread);
1749 }else{
1750 g_object_unref(default_soundcard_thread);
1751 }
1752
1753 /* export thread */
1754 export_thread = (AgsThread *) ags_export_thread_new(soundcard,
1755 NULL);
1756 ags_thread_add_child_extended(main_loop,
1757 (AgsThread *) export_thread,
1758 TRUE, TRUE);
1759
1760 /* */
1761 card_name = NULL;
1762 card_uri = NULL;
1763 ags_soundcard_list_cards(AGS_SOUNDCARD(soundcard),
1764 &card_uri, &card_name);
1765
1766 gtk_list_store_clear(GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->card))));
1767
1768 while(card_uri != NULL){
1769 if(card_uri->data != NULL){
1770 gtk_combo_box_text_append_text(soundcard_editor->card,
1771 card_uri->data);
1772 }
1773
1774 card_uri = card_uri->next;
1775 }
1776
1777 /* unref */
1778 g_object_unref(main_loop);
1779 }
1780
1781 void
ags_soundcard_editor_remove_port(AgsSoundcardEditor * soundcard_editor,gchar * device)1782 ags_soundcard_editor_remove_port(AgsSoundcardEditor *soundcard_editor,
1783 gchar *device)
1784 {
1785 AgsCoreAudioServer *core_audio_server;
1786 AgsCoreAudioDevout *core_audio_devout;
1787
1788 AgsPulseServer *pulse_server;
1789 AgsPulseDevout *pulse_devout;
1790
1791 AgsJackServer *jack_server;
1792 AgsJackDevout *jack_devout;
1793
1794 AgsApplicationContext *application_context;
1795 AgsThread *main_loop;
1796
1797 GObject *soundcard;
1798
1799 GType server_type;
1800
1801 GList *machine, *machine_start;
1802 GList *start_sound_server, *sound_server;
1803 GList *start_list, *list;
1804 GList *card_id;
1805
1806 gchar *backend;
1807
1808 gboolean use_core_audio, use_pulse, use_jack;
1809
1810 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
1811 return;
1812 }
1813
1814 application_context = ags_application_context_get_instance();
1815
1816 core_audio_server = NULL;
1817 core_audio_devout = NULL;
1818
1819 pulse_server = NULL;
1820 pulse_devout = NULL;
1821
1822 jack_server = NULL;
1823 jack_devout = NULL;
1824
1825 soundcard = NULL;
1826
1827 server_type = G_TYPE_NONE;
1828
1829 backend = NULL;
1830
1831 use_core_audio = FALSE;
1832 use_pulse = FALSE;
1833 use_jack = FALSE;
1834
1835 /* determine backend */
1836 backend = gtk_combo_box_text_get_active_text(soundcard_editor->backend);
1837
1838 if(backend != NULL){
1839 if(!g_ascii_strncasecmp(backend,
1840 "core-audio",
1841 6)){
1842 server_type = AGS_TYPE_CORE_AUDIO_SERVER;
1843
1844 use_core_audio = TRUE;
1845 }else if(!g_ascii_strncasecmp(backend,
1846 "pulse",
1847 6)){
1848 server_type = AGS_TYPE_PULSE_SERVER;
1849
1850 use_pulse = TRUE;
1851 }else if(!g_ascii_strncasecmp(backend,
1852 "jack",
1853 5)){
1854 server_type = AGS_TYPE_JACK_SERVER;
1855
1856 use_jack = TRUE;
1857 }
1858 }
1859
1860 /* destroy soundcard */
1861 start_sound_server = ags_sound_provider_get_sound_server(AGS_SOUND_PROVIDER(application_context));
1862
1863 if((sound_server = ags_list_util_find_type(start_sound_server,
1864 server_type)) == NULL){
1865 g_list_free_full(start_sound_server,
1866 g_object_unref);
1867
1868 g_warning("sound server not found");
1869
1870 return;
1871 }
1872
1873 g_list_free_full(start_sound_server,
1874 g_object_unref);
1875
1876 main_loop = ags_concurrency_provider_get_main_loop(AGS_CONCURRENCY_PROVIDER(application_context));
1877
1878 list =
1879 start_list = ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(application_context));
1880
1881 while(list != NULL){
1882 if(use_core_audio){
1883 if(AGS_IS_CORE_AUDIO_DEVOUT(list->data) &&
1884 !g_ascii_strcasecmp(ags_soundcard_get_device(AGS_SOUNDCARD(list->data)),
1885 device)){
1886 core_audio_devout = list->data;
1887 soundcard = (GObject *) core_audio_devout;
1888
1889 break;
1890 }
1891 }else if(use_pulse){
1892 if(AGS_IS_PULSE_DEVOUT(list->data) &&
1893 !g_ascii_strcasecmp(ags_soundcard_get_device(AGS_SOUNDCARD(list->data)),
1894 device)){
1895 pulse_devout = list->data;
1896 soundcard = (GObject *) pulse_devout;
1897
1898 break;
1899 }
1900 }else if(use_jack){
1901 if(AGS_IS_JACK_DEVOUT(list->data) &&
1902 !g_ascii_strcasecmp(ags_soundcard_get_device(AGS_SOUNDCARD(list->data)),
1903 device)){
1904 jack_devout = list->data;
1905 soundcard = (GObject *) jack_devout;
1906
1907 break;
1908 }
1909 }
1910
1911 list = list->next;
1912 }
1913
1914 g_list_free_full(start_list,
1915 g_object_unref);
1916
1917 if(soundcard == NULL){
1918 return;
1919 }
1920
1921 /* remove AgsSoundcard from AgsAudio */
1922 #if 0
1923 machine =
1924 machine_start = gtk_container_get_children(GTK_CONTAINER(window->machines));
1925
1926 while(machine != NULL){
1927 if(AGS_MACHINE(machine->data)->audio->soundcard == soundcard){
1928 g_object_set(AGS_MACHINE(machine->data)->audio,
1929 "soundcard", NULL,
1930 NULL);
1931
1932 g_object_unref(G_OBJECT(AGS_MACHINE(machine->data)->audio));
1933 }
1934
1935 machine = machine->next;
1936 }
1937
1938 ags_sound_provider_set_audio(AGS_SOUND_PROVIDER(application_context),
1939 NULL);
1940 g_list_free(machine_start);
1941 #endif
1942
1943 /* */
1944 gtk_list_store_clear(GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->card))));
1945 gtk_combo_box_set_active(GTK_COMBO_BOX(soundcard_editor->backend),
1946 -1);
1947
1948 #if 0
1949 if(server != NULL){
1950 ags_sound_server_unregister_soundcard(AGS_SOUND_SERVER(server),
1951 soundcard);
1952 }
1953 #endif
1954
1955 /* remove */
1956 if(soundcard == soundcard_editor->soundcard){
1957 soundcard_editor->soundcard = NULL;
1958 }
1959
1960 #if 0
1961 if(soundcard != NULL){
1962 ags_sound_provider_set_soundcard(AGS_SOUND_PROVIDER(application_context),
1963 g_list_remove(ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(application_context)),
1964 soundcard));
1965 g_object_unref(soundcard);
1966 }
1967
1968 if(soundcard_editor->soundcard_thread != NULL){
1969 ags_thread_stop((AgsThread *) soundcard_editor->soundcard_thread);
1970
1971 ags_thread_remove_child(main_loop,
1972 (AgsThread *) soundcard_editor->soundcard_thread);
1973
1974 // g_object_unref(soundcard_editor->soundcard_thread);
1975
1976 soundcard_editor->soundcard_thread = NULL;
1977 }
1978 #endif
1979
1980 /* unref */
1981 g_object_unref(main_loop);
1982 }
1983
1984 void
ags_soundcard_editor_add_soundcard(AgsSoundcardEditor * soundcard_editor,GObject * soundcard)1985 ags_soundcard_editor_add_soundcard(AgsSoundcardEditor *soundcard_editor,
1986 GObject *soundcard)
1987 {
1988 AgsThread *main_loop;
1989 AgsThread *soundcard_thread, *default_soundcard_thread;
1990 AgsThread *export_thread;
1991
1992 AgsApplicationContext *application_context;
1993
1994 GList *start_list;
1995
1996 gboolean initial_soundcard;
1997
1998 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
1999 return;
2000 }
2001
2002 if(soundcard == NULL ||
2003 AGS_IS_CORE_AUDIO_DEVOUT(soundcard) ||
2004 AGS_IS_PULSE_DEVOUT(soundcard) ||
2005 AGS_IS_JACK_DEVOUT(soundcard)){
2006 return;
2007 }
2008
2009 if((AGS_SOUNDCARD_EDITOR_BLOCK_ADD & (soundcard_editor->flags)) != 0){
2010 return;
2011 }
2012
2013 soundcard_editor->flags |= AGS_SOUNDCARD_EDITOR_BLOCK_ADD;
2014
2015 application_context = ags_application_context_get_instance();
2016
2017 initial_soundcard = FALSE;
2018
2019 if(AGS_IS_DEVOUT(soundcard)){
2020 if((AGS_DEVOUT_ALSA & (AGS_DEVOUT(soundcard)->flags)) != 0){
2021 ags_soundcard_set_device(AGS_SOUNDCARD(soundcard),
2022 "hw:0,0");
2023 }else if((AGS_DEVOUT_OSS & (AGS_DEVOUT(soundcard)->flags)) != 0){
2024 ags_soundcard_set_device(AGS_SOUNDCARD(soundcard),
2025 "/dev/dsp0");
2026 }else{
2027 g_warning("unknown soundcard implementation");
2028 }
2029 }else if(AGS_IS_WASAPI_DEVOUT(soundcard)){
2030 //nothing
2031 }else{
2032 g_warning("unknown soundcard implementation");
2033 }
2034
2035 /* */
2036 start_list = ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(application_context));
2037
2038 if(g_list_find(start_list,
2039 soundcard) != NULL){
2040 soundcard_editor->flags &= (~AGS_SOUNDCARD_EDITOR_BLOCK_ADD);
2041
2042 g_list_free_full(start_list,
2043 g_object_unref);
2044
2045 return;
2046 }
2047
2048 main_loop = ags_concurrency_provider_get_main_loop(AGS_CONCURRENCY_PROVIDER(application_context));
2049
2050 if(start_list == NULL){
2051 initial_soundcard = TRUE;
2052 }
2053
2054 soundcard_editor->soundcard = soundcard;
2055
2056 g_list_foreach(start_list,
2057 (GFunc) g_object_unref,
2058 NULL);
2059
2060 start_list = g_list_append(start_list,
2061 soundcard);
2062 ags_sound_provider_set_soundcard(AGS_SOUND_PROVIDER(application_context),
2063 start_list);
2064
2065 /* add AgsAudio to AgsSoundcard */
2066 #if 0
2067 if(initial_soundcard){
2068 GList *machine, *machine_start;
2069 GList *list;
2070
2071 machine =
2072 machine_start = gtk_container_get_children(GTK_CONTAINER(window->machines));
2073
2074 while(machine != NULL){
2075 g_object_ref(G_OBJECT(AGS_MACHINE(machine->data)->audio));
2076
2077 list = ags_sound_provider_get_audio(AGS_SOUND_PROVIDER(application_context));
2078 list = g_list_prepend(list,
2079 AGS_MACHINE(machine->data)->audio);
2080 ags_sound_provider_set_audio(AGS_SOUND_PROVIDER(application_context),
2081 list);
2082
2083 g_object_set(AGS_MACHINE(machine->data)->audio,
2084 "soundcard", soundcard,
2085 NULL);
2086
2087 machine = machine->next;
2088 }
2089
2090
2091 g_list_free(machine_start);
2092 }
2093 #endif
2094
2095 g_object_ref(soundcard);
2096
2097 soundcard_thread = (AgsThread *) ags_soundcard_thread_new(soundcard,
2098 ags_soundcard_get_capability(AGS_SOUNDCARD(soundcard)));
2099 soundcard_editor->soundcard_thread = (GObject *) soundcard_thread;
2100
2101 ags_thread_add_child_extended(main_loop,
2102 soundcard_thread,
2103 TRUE, TRUE);
2104
2105 if((default_soundcard_thread = (AgsThread *) ags_sound_provider_get_default_soundcard_thread(AGS_SOUND_PROVIDER(application_context))) == NULL){
2106 ags_sound_provider_set_default_soundcard_thread(AGS_SOUND_PROVIDER(application_context),
2107 (GObject *) soundcard_thread);
2108 }else{
2109 g_object_unref(default_soundcard_thread);
2110 }
2111
2112 /* export thread */
2113 export_thread = (AgsThread *) ags_export_thread_new(soundcard,
2114 NULL);
2115 ags_thread_add_child_extended(main_loop,
2116 (AgsThread *) export_thread,
2117 TRUE, TRUE);
2118
2119 soundcard_editor->flags &= (~AGS_SOUNDCARD_EDITOR_BLOCK_ADD);
2120
2121 /* unref */
2122 g_object_unref(main_loop);
2123 }
2124
2125 void
ags_soundcard_editor_remove_soundcard(AgsSoundcardEditor * soundcard_editor,GObject * soundcard)2126 ags_soundcard_editor_remove_soundcard(AgsSoundcardEditor *soundcard_editor,
2127 GObject *soundcard)
2128 {
2129 AgsThread *main_loop;
2130 AgsThread *soundcard_thread;
2131
2132 AgsApplicationContext *application_context;
2133
2134 GList *machine, *machine_start;
2135
2136 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
2137 return;
2138 }
2139
2140 if(soundcard == NULL ||
2141 AGS_IS_CORE_AUDIO_DEVOUT(soundcard) ||
2142 AGS_IS_PULSE_DEVOUT(soundcard) ||
2143 AGS_IS_JACK_DEVOUT(soundcard)){
2144 return;
2145 }
2146
2147 application_context = ags_application_context_get_instance();
2148
2149 main_loop = ags_concurrency_provider_get_main_loop(AGS_CONCURRENCY_PROVIDER(application_context));
2150
2151 /* remove AgsSoundcard from AgsAudio */
2152 #if 0
2153 machine =
2154 machine_start = gtk_container_get_children(window->machines);
2155
2156 while(machine != NULL){
2157 if(AGS_MACHINE(machine->data)->audio->soundcard == soundcard){
2158 g_object_set(AGS_MACHINE(machine->data)->audio,
2159 "soundcard", NULL,
2160 NULL);
2161
2162 g_object_unref(G_OBJECT(AGS_MACHINE(machine->data)->audio));
2163 }
2164
2165 machine = machine->next;
2166 }
2167
2168 ags_sound_provider_set_audio(AGS_SOUND_PROVIDER(application_context),
2169 NULL);
2170 g_list_free(machine_start);
2171 #endif
2172
2173 /* */
2174 if(soundcard == soundcard_editor->soundcard){
2175 soundcard_editor->soundcard = NULL;
2176 }
2177
2178 #if 0
2179 if(soundcard != NULL){
2180 ags_sound_provider_set_soundcard(AGS_SOUND_PROVIDER(application_context),
2181 g_list_remove(ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(application_context)),
2182 soundcard));
2183 g_object_unref(soundcard);
2184 }
2185 #endif
2186
2187 #if 0
2188 if(soundcard_editor->soundcard_thread != NULL){
2189 ags_thread_stop((AgsThread *) soundcard_editor->soundcard_thread);
2190
2191 ags_thread_remove_child(main_loop,
2192 (AgsThread *) soundcard_editor->soundcard_thread);
2193
2194 // g_object_unref(soundcard_editor->soundcard_thread);
2195
2196 soundcard_editor->soundcard_thread = NULL;
2197 }
2198 #endif
2199
2200 /* unref */
2201 g_object_unref(main_loop);
2202 }
2203
2204 void
ags_soundcard_editor_load_core_audio_card(AgsSoundcardEditor * soundcard_editor)2205 ags_soundcard_editor_load_core_audio_card(AgsSoundcardEditor *soundcard_editor)
2206 {
2207 AgsCoreAudioDevout *core_audio_devout;
2208
2209 AgsApplicationContext *application_context;
2210
2211 GList *start_sound_server, *sound_server;
2212 GList *start_soundcard, *soundcard;
2213 GList *card_id;
2214
2215 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
2216 return;
2217 }
2218
2219 application_context = ags_application_context_get_instance();
2220
2221 /* create soundcard */
2222 sound_server =
2223 start_sound_server = ags_sound_provider_get_sound_server(AGS_SOUND_PROVIDER(application_context));
2224
2225 if(sound_server == NULL){
2226 g_warning("sound server not found");
2227
2228 return;
2229 }
2230
2231 soundcard =
2232 start_soundcard = ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(application_context));
2233 core_audio_devout = NULL;
2234
2235 while(soundcard != NULL){
2236 if(AGS_IS_CORE_AUDIO_DEVOUT(soundcard->data)){
2237 core_audio_devout = soundcard->data;
2238 break;
2239 }
2240
2241 soundcard = soundcard->next;
2242 }
2243
2244 card_id = NULL;
2245 ags_soundcard_list_cards(AGS_SOUNDCARD(core_audio_devout),
2246 &card_id, NULL);
2247
2248 gtk_list_store_clear(GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->card))));
2249
2250 while(card_id != NULL){
2251 if(card_id->data != NULL){
2252 gtk_combo_box_text_append_text(soundcard_editor->card,
2253 card_id->data);
2254 }
2255
2256 card_id = card_id->next;
2257 }
2258
2259 /* unref */
2260 g_list_free_full(start_sound_server,
2261 g_object_unref);
2262
2263 g_list_free_full(start_soundcard,
2264 g_object_unref);
2265 }
2266
2267 void
ags_soundcard_editor_load_pulse_card(AgsSoundcardEditor * soundcard_editor)2268 ags_soundcard_editor_load_pulse_card(AgsSoundcardEditor *soundcard_editor)
2269 {
2270 AgsPulseDevout *pulse_devout;
2271
2272 AgsApplicationContext *application_context;
2273
2274 GList *start_sound_server, *sound_server;
2275 GList *start_soundcard, *soundcard;
2276 GList *card_id;
2277
2278 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
2279 return;
2280 }
2281
2282 application_context = ags_application_context_get_instance();
2283
2284 /* create soundcard */
2285 sound_server =
2286 start_sound_server = ags_sound_provider_get_sound_server(AGS_SOUND_PROVIDER(application_context));
2287
2288 if(sound_server == NULL){
2289 g_warning("sound server not found");
2290
2291 return;
2292 }
2293
2294 soundcard =
2295 start_soundcard = ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(application_context));
2296 pulse_devout = NULL;
2297
2298 while(soundcard != NULL){
2299 if(AGS_IS_PULSE_DEVOUT(soundcard->data)){
2300 pulse_devout = soundcard->data;
2301 break;
2302 }
2303
2304 soundcard = soundcard->next;
2305 }
2306
2307 card_id = NULL;
2308 ags_soundcard_list_cards(AGS_SOUNDCARD(pulse_devout),
2309 &card_id, NULL);
2310
2311 gtk_list_store_clear(GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->card))));
2312
2313 while(card_id != NULL){
2314 if(card_id->data != NULL){
2315 gtk_combo_box_text_append_text(soundcard_editor->card,
2316 card_id->data);
2317 }
2318
2319 card_id = card_id->next;
2320 }
2321
2322 /* unref */
2323 g_list_free_full(start_sound_server,
2324 g_object_unref);
2325
2326 g_list_free_full(start_soundcard,
2327 g_object_unref);
2328 }
2329
2330 void
ags_soundcard_editor_load_jack_card(AgsSoundcardEditor * soundcard_editor)2331 ags_soundcard_editor_load_jack_card(AgsSoundcardEditor *soundcard_editor)
2332 {
2333 AgsJackDevout *jack_devout;
2334
2335 AgsApplicationContext *application_context;
2336
2337 GList *start_sound_server, *sound_server;
2338 GList *start_soundcard, *soundcard;
2339 GList *card_id;
2340
2341 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
2342 return;
2343 }
2344
2345 application_context = ags_application_context_get_instance();
2346
2347 /* create soundcard */
2348 sound_server =
2349 start_sound_server = ags_sound_provider_get_sound_server(AGS_SOUND_PROVIDER(application_context));
2350
2351 if(sound_server == NULL){
2352 g_warning("sound server not found");
2353
2354 return;
2355 }
2356
2357 soundcard =
2358 start_soundcard = ags_sound_provider_get_soundcard(AGS_SOUND_PROVIDER(application_context));
2359 jack_devout = NULL;
2360
2361 while(soundcard != NULL){
2362 if(AGS_IS_JACK_DEVOUT(soundcard->data)){
2363 jack_devout = soundcard->data;
2364 break;
2365 }
2366
2367 soundcard = soundcard->next;
2368 }
2369
2370 card_id = NULL;
2371 ags_soundcard_list_cards(AGS_SOUNDCARD(jack_devout),
2372 &card_id, NULL);
2373
2374 gtk_list_store_clear(GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->card))));
2375
2376 while(card_id != NULL){
2377 if(card_id->data != NULL){
2378 gtk_combo_box_text_append_text(soundcard_editor->card,
2379 card_id->data);
2380 }
2381
2382 card_id = card_id->next;
2383 }
2384
2385 /* unref */
2386 g_list_free_full(start_sound_server,
2387 g_object_unref);
2388
2389 g_list_free_full(start_soundcard,
2390 g_object_unref);
2391 }
2392
2393 void
ags_soundcard_editor_load_wasapi_card(AgsSoundcardEditor * soundcard_editor)2394 ags_soundcard_editor_load_wasapi_card(AgsSoundcardEditor *soundcard_editor)
2395 {
2396 AgsDevout *devout;
2397
2398 GList *list;
2399 GList *card_id;
2400
2401 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
2402 return;
2403 }
2404
2405 if((AGS_SOUNDCARD_EDITOR_BLOCK_LOAD & (soundcard_editor->flags)) != 0){
2406 return;
2407 }
2408
2409 soundcard_editor->flags |= AGS_SOUNDCARD_EDITOR_BLOCK_LOAD;
2410
2411 /* */
2412 devout = g_object_new(AGS_TYPE_WASAPI_DEVOUT,
2413 NULL);
2414
2415 card_id = NULL;
2416 ags_soundcard_list_cards(AGS_SOUNDCARD(devout),
2417 &card_id, NULL);
2418
2419 gtk_list_store_clear(GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->card))));
2420
2421 while(card_id != NULL){
2422 if(card_id != NULL){
2423 if(card_id->data != NULL){
2424 gtk_combo_box_text_append_text(soundcard_editor->card,
2425 card_id->data);
2426 }else{
2427 gtk_combo_box_text_append_text(soundcard_editor->card,
2428 "(null)");
2429 }
2430 }
2431
2432 card_id = card_id->next;
2433 }
2434
2435 /* remove previous */
2436 if(soundcard_editor->soundcard != NULL){
2437 ags_soundcard_editor_remove_soundcard(soundcard_editor,
2438 (GObject *) soundcard_editor->soundcard);
2439 }
2440
2441 /* add new */
2442 ags_soundcard_editor_add_soundcard(soundcard_editor,
2443 (GObject *) devout);
2444
2445 /* */
2446 list = gtk_container_get_children((GtkContainer *) gtk_widget_get_parent(GTK_WIDGET(soundcard_editor)));
2447
2448 if(list->data == soundcard_editor){
2449 gtk_widget_set_sensitive((GtkWidget *) soundcard_editor->buffer_size,
2450 TRUE);
2451 }
2452
2453 g_list_free(list);
2454
2455 soundcard_editor->flags &= (~AGS_SOUNDCARD_EDITOR_BLOCK_LOAD);
2456 }
2457
2458 void
ags_soundcard_editor_load_alsa_card(AgsSoundcardEditor * soundcard_editor)2459 ags_soundcard_editor_load_alsa_card(AgsSoundcardEditor *soundcard_editor)
2460 {
2461 AgsDevout *devout;
2462
2463 GList *list;
2464 GList *card_id;
2465
2466 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
2467 return;
2468 }
2469
2470 if((AGS_SOUNDCARD_EDITOR_BLOCK_LOAD & (soundcard_editor->flags)) != 0){
2471 return;
2472 }
2473
2474 soundcard_editor->flags |= AGS_SOUNDCARD_EDITOR_BLOCK_LOAD;
2475
2476 /* */
2477 devout = g_object_new(AGS_TYPE_DEVOUT,
2478 NULL);
2479 devout->flags &= (~AGS_DEVOUT_OSS);
2480 devout->flags |= AGS_DEVOUT_ALSA;
2481
2482 card_id = NULL;
2483 ags_soundcard_list_cards(AGS_SOUNDCARD(devout),
2484 &card_id, NULL);
2485
2486 gtk_list_store_clear(GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->card))));
2487
2488 while(card_id != NULL){
2489 if(card_id != NULL){
2490 gtk_combo_box_text_append_text(soundcard_editor->card,
2491 card_id->data);
2492 }
2493
2494 card_id = card_id->next;
2495 }
2496
2497 /* remove previous */
2498 if(soundcard_editor->soundcard != NULL){
2499 ags_soundcard_editor_remove_soundcard(soundcard_editor,
2500 (GObject *) soundcard_editor->soundcard);
2501 }
2502
2503 /* add new */
2504 ags_soundcard_editor_add_soundcard(soundcard_editor,
2505 (GObject *) devout);
2506
2507 /* */
2508 list = gtk_container_get_children((GtkContainer *) gtk_widget_get_parent(GTK_WIDGET(soundcard_editor)));
2509
2510 if(list->data == soundcard_editor){
2511 gtk_widget_set_sensitive((GtkWidget *) soundcard_editor->buffer_size,
2512 TRUE);
2513 }
2514
2515 g_list_free(list);
2516
2517 soundcard_editor->flags &= (~AGS_SOUNDCARD_EDITOR_BLOCK_LOAD);
2518 }
2519
2520 void
ags_soundcard_editor_load_oss_card(AgsSoundcardEditor * soundcard_editor)2521 ags_soundcard_editor_load_oss_card(AgsSoundcardEditor *soundcard_editor)
2522 {
2523 AgsDevout *devout;
2524
2525 GList *list;
2526 GList *card_id;
2527
2528 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
2529 return;
2530 }
2531
2532 /* */
2533 devout = g_object_new(AGS_TYPE_DEVOUT,
2534 NULL);
2535 devout->flags &= (~AGS_DEVOUT_ALSA);
2536 devout->flags |= AGS_DEVOUT_OSS;
2537
2538 card_id = NULL;
2539 ags_soundcard_list_cards(AGS_SOUNDCARD(devout),
2540 &card_id, NULL);
2541
2542 gtk_list_store_clear(GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(soundcard_editor->card))));
2543
2544 while(card_id != NULL){
2545 if(card_id != NULL){
2546 gtk_combo_box_text_append_text(soundcard_editor->card,
2547 card_id->data);
2548 }
2549
2550 card_id = card_id->next;
2551 }
2552
2553 /* remove previous */
2554 if(soundcard_editor->soundcard != NULL){
2555 ags_soundcard_editor_remove_soundcard(soundcard_editor,
2556 (GObject *) soundcard_editor->soundcard);
2557 }
2558
2559 /* add new */
2560 ags_soundcard_editor_add_soundcard(soundcard_editor,
2561 (GObject *) devout);
2562
2563 /* */
2564 list = gtk_container_get_children((GtkContainer *) gtk_widget_get_parent(GTK_WIDGET(soundcard_editor)));
2565
2566 if(list->data == soundcard_editor){
2567 gtk_widget_set_sensitive((GtkWidget *) soundcard_editor->buffer_size,
2568 TRUE);
2569 }
2570
2571 g_list_free(list);
2572 }
2573
2574 void
ags_soundcard_editor_show_wasapi_control(AgsSoundcardEditor * soundcard_editor)2575 ags_soundcard_editor_show_wasapi_control(AgsSoundcardEditor *soundcard_editor)
2576 {
2577 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
2578 return;
2579 }
2580
2581 #if defined(AGS_WITH_WASAPI)
2582 gtk_widget_show(soundcard_editor->wasapi_share_mode_label);
2583 gtk_widget_show(soundcard_editor->wasapi_share_mode);
2584
2585 gtk_widget_show(soundcard_editor->wasapi_buffer_size_label);
2586 gtk_widget_show(soundcard_editor->wasapi_buffer_size);
2587 #endif
2588 }
2589
2590 void
ags_soundcard_editor_hide_wasapi_control(AgsSoundcardEditor * soundcard_editor)2591 ags_soundcard_editor_hide_wasapi_control(AgsSoundcardEditor *soundcard_editor)
2592 {
2593 if(!AGS_IS_SOUNDCARD_EDITOR(soundcard_editor)){
2594 return;
2595 }
2596
2597 #if defined(AGS_WITH_WASAPI)
2598 gtk_widget_hide(soundcard_editor->wasapi_share_mode_label);
2599 gtk_widget_hide(soundcard_editor->wasapi_share_mode);
2600
2601 gtk_widget_hide(soundcard_editor->wasapi_buffer_size_label);
2602 gtk_widget_hide(soundcard_editor->wasapi_buffer_size);
2603 #endif
2604 }
2605
2606 /**
2607 * ags_soundcard_editor_new:
2608 *
2609 * Create a new instance of #AgsSoundcardEditor
2610 *
2611 * Returns: the new #AgsSoundcardEditor
2612 *
2613 * Since: 3.0.0
2614 */
2615 AgsSoundcardEditor*
ags_soundcard_editor_new()2616 ags_soundcard_editor_new()
2617 {
2618 AgsSoundcardEditor *soundcard_editor;
2619
2620 soundcard_editor = (AgsSoundcardEditor *) g_object_new(AGS_TYPE_SOUNDCARD_EDITOR,
2621 NULL);
2622
2623 return(soundcard_editor);
2624 }
2625