Merge tag 'pull-request-2022-09-28' of https://gitlab.com/thuth/qemu into staging
[qemu.git] / audio / jackaudio.c
1 /*
2 * QEMU JACK Audio Connection Kit Client
3 *
4 * Copyright (c) 2020 Geoffrey McRae (gnif)
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "qemu/osdep.h"
26 #include "qemu/module.h"
27 #include "qemu/atomic.h"
28 #include "qemu/main-loop.h"
29 #include "audio.h"
30
31 #define AUDIO_CAP "jack"
32 #include "audio_int.h"
33
34 #include <jack/jack.h>
35 #include <jack/thread.h>
36
37 struct QJack;
38
39 typedef enum QJackState {
40 QJACK_STATE_DISCONNECTED,
41 QJACK_STATE_RUNNING,
42 QJACK_STATE_SHUTDOWN
43 }
44 QJackState;
45
46 typedef struct QJackBuffer {
47 int channels;
48 int frames;
49 uint32_t used;
50 int rptr, wptr;
51 float **data;
52 }
53 QJackBuffer;
54
55 typedef struct QJackClient {
56 AudiodevJackPerDirectionOptions *opt;
57
58 bool out;
59 bool enabled;
60 bool connect_ports;
61 int packets;
62
63 QJackState state;
64 jack_client_t *client;
65 jack_nframes_t freq;
66 QEMUBH *shutdown_bh;
67
68 struct QJack *j;
69 int nchannels;
70 int buffersize;
71 jack_port_t **port;
72 QJackBuffer fifo;
73 }
74 QJackClient;
75
76 typedef struct QJackOut {
77 HWVoiceOut hw;
78 QJackClient c;
79 }
80 QJackOut;
81
82 typedef struct QJackIn {
83 HWVoiceIn hw;
84 QJackClient c;
85 }
86 QJackIn;
87
88 static int qjack_client_init(QJackClient *c);
89 static void qjack_client_connect_ports(QJackClient *c);
90 static void qjack_client_fini(QJackClient *c);
91 static QemuMutex qjack_shutdown_lock;
92
93 static void qjack_buffer_create(QJackBuffer *buffer, int channels, int frames)
94 {
95 buffer->channels = channels;
96 buffer->frames = frames;
97 buffer->used = 0;
98 buffer->rptr = 0;
99 buffer->wptr = 0;
100 buffer->data = g_new(float *, channels);
101 for (int i = 0; i < channels; ++i) {
102 buffer->data[i] = g_new(float, frames);
103 }
104 }
105
106 static void qjack_buffer_clear(QJackBuffer *buffer)
107 {
108 assert(buffer->data);
109 qatomic_store_release(&buffer->used, 0);
110 buffer->rptr = 0;
111 buffer->wptr = 0;
112 }
113
114 static void qjack_buffer_free(QJackBuffer *buffer)
115 {
116 if (!buffer->data) {
117 return;
118 }
119
120 for (int i = 0; i < buffer->channels; ++i) {
121 g_free(buffer->data[i]);
122 }
123
124 g_free(buffer->data);
125 buffer->data = NULL;
126 }
127
128 /* write PCM interleaved */
129 static int qjack_buffer_write(QJackBuffer *buffer, float *data, int size)
130 {
131 assert(buffer->data);
132 const int samples = size / sizeof(float);
133 int frames = samples / buffer->channels;
134 const int avail = buffer->frames - qatomic_load_acquire(&buffer->used);
135
136 if (frames > avail) {
137 frames = avail;
138 }
139
140 int copy = frames;
141 int wptr = buffer->wptr;
142
143 while (copy) {
144
145 for (int c = 0; c < buffer->channels; ++c) {
146 buffer->data[c][wptr] = *data++;
147 }
148
149 if (++wptr == buffer->frames) {
150 wptr = 0;
151 }
152
153 --copy;
154 }
155
156 buffer->wptr = wptr;
157
158 qatomic_add(&buffer->used, frames);
159 return frames * buffer->channels * sizeof(float);
160 };
161
162 /* write PCM linear */
163 static int qjack_buffer_write_l(QJackBuffer *buffer, float **dest, int frames)
164 {
165 assert(buffer->data);
166 const int avail = buffer->frames - qatomic_load_acquire(&buffer->used);
167 int wptr = buffer->wptr;
168
169 if (frames > avail) {
170 frames = avail;
171 }
172
173 int right = buffer->frames - wptr;
174 if (right > frames) {
175 right = frames;
176 }
177
178 const int left = frames - right;
179 for (int c = 0; c < buffer->channels; ++c) {
180 memcpy(buffer->data[c] + wptr, dest[c] , right * sizeof(float));
181 memcpy(buffer->data[c] , dest[c] + right, left * sizeof(float));
182 }
183
184 wptr += frames;
185 if (wptr >= buffer->frames) {
186 wptr -= buffer->frames;
187 }
188 buffer->wptr = wptr;
189
190 qatomic_add(&buffer->used, frames);
191 return frames;
192 }
193
194 /* read PCM interleaved */
195 static int qjack_buffer_read(QJackBuffer *buffer, float *dest, int size)
196 {
197 assert(buffer->data);
198 const int samples = size / sizeof(float);
199 int frames = samples / buffer->channels;
200 const int avail = qatomic_load_acquire(&buffer->used);
201
202 if (frames > avail) {
203 frames = avail;
204 }
205
206 int copy = frames;
207 int rptr = buffer->rptr;
208
209 while (copy) {
210
211 for (int c = 0; c < buffer->channels; ++c) {
212 *dest++ = buffer->data[c][rptr];
213 }
214
215 if (++rptr == buffer->frames) {
216 rptr = 0;
217 }
218
219 --copy;
220 }
221
222 buffer->rptr = rptr;
223
224 qatomic_sub(&buffer->used, frames);
225 return frames * buffer->channels * sizeof(float);
226 }
227
228 /* read PCM linear */
229 static int qjack_buffer_read_l(QJackBuffer *buffer, float **dest, int frames)
230 {
231 assert(buffer->data);
232 int copy = frames;
233 const int used = qatomic_load_acquire(&buffer->used);
234 int rptr = buffer->rptr;
235
236 if (copy > used) {
237 copy = used;
238 }
239
240 int right = buffer->frames - rptr;
241 if (right > copy) {
242 right = copy;
243 }
244
245 const int left = copy - right;
246 for (int c = 0; c < buffer->channels; ++c) {
247 memcpy(dest[c] , buffer->data[c] + rptr, right * sizeof(float));
248 memcpy(dest[c] + right, buffer->data[c] , left * sizeof(float));
249 }
250
251 rptr += copy;
252 if (rptr >= buffer->frames) {
253 rptr -= buffer->frames;
254 }
255 buffer->rptr = rptr;
256
257 qatomic_sub(&buffer->used, copy);
258 return copy;
259 }
260
261 static int qjack_process(jack_nframes_t nframes, void *arg)
262 {
263 QJackClient *c = (QJackClient *)arg;
264
265 if (c->state != QJACK_STATE_RUNNING) {
266 return 0;
267 }
268
269 /* get the buffers for the ports */
270 float *buffers[c->nchannels];
271 for (int i = 0; i < c->nchannels; ++i) {
272 buffers[i] = jack_port_get_buffer(c->port[i], nframes);
273 }
274
275 if (c->out) {
276 if (likely(c->enabled)) {
277 qjack_buffer_read_l(&c->fifo, buffers, nframes);
278 } else {
279 for (int i = 0; i < c->nchannels; ++i) {
280 memset(buffers[i], 0, nframes * sizeof(float));
281 }
282 }
283 } else {
284 if (likely(c->enabled)) {
285 qjack_buffer_write_l(&c->fifo, buffers, nframes);
286 }
287 }
288
289 return 0;
290 }
291
292 static void qjack_port_registration(jack_port_id_t port, int reg, void *arg)
293 {
294 if (reg) {
295 QJackClient *c = (QJackClient *)arg;
296 c->connect_ports = true;
297 }
298 }
299
300 static int qjack_xrun(void *arg)
301 {
302 QJackClient *c = (QJackClient *)arg;
303 if (c->state != QJACK_STATE_RUNNING) {
304 return 0;
305 }
306
307 qjack_buffer_clear(&c->fifo);
308 return 0;
309 }
310
311 static void qjack_shutdown_bh(void *opaque)
312 {
313 QJackClient *c = (QJackClient *)opaque;
314 qjack_client_fini(c);
315 }
316
317 static void qjack_shutdown(void *arg)
318 {
319 QJackClient *c = (QJackClient *)arg;
320 c->state = QJACK_STATE_SHUTDOWN;
321 qemu_bh_schedule(c->shutdown_bh);
322 }
323
324 static void qjack_client_recover(QJackClient *c)
325 {
326 if (c->state != QJACK_STATE_DISCONNECTED) {
327 return;
328 }
329
330 /* packets is used simply to throttle this */
331 if (c->packets % 100 == 0) {
332
333 /* if enabled then attempt to recover */
334 if (c->enabled) {
335 dolog("attempting to reconnect to server\n");
336 qjack_client_init(c);
337 }
338 }
339 }
340
341 static size_t qjack_write(HWVoiceOut *hw, void *buf, size_t len)
342 {
343 QJackOut *jo = (QJackOut *)hw;
344 ++jo->c.packets;
345
346 if (jo->c.state != QJACK_STATE_RUNNING) {
347 qjack_client_recover(&jo->c);
348 return len;
349 }
350
351 qjack_client_connect_ports(&jo->c);
352 return qjack_buffer_write(&jo->c.fifo, buf, len);
353 }
354
355 static size_t qjack_read(HWVoiceIn *hw, void *buf, size_t len)
356 {
357 QJackIn *ji = (QJackIn *)hw;
358 ++ji->c.packets;
359
360 if (ji->c.state != QJACK_STATE_RUNNING) {
361 qjack_client_recover(&ji->c);
362 return len;
363 }
364
365 qjack_client_connect_ports(&ji->c);
366 return qjack_buffer_read(&ji->c.fifo, buf, len);
367 }
368
369 static void qjack_client_connect_ports(QJackClient *c)
370 {
371 if (!c->connect_ports || !c->opt->connect_ports) {
372 return;
373 }
374
375 c->connect_ports = false;
376 const char **ports;
377 ports = jack_get_ports(c->client, c->opt->connect_ports, NULL,
378 c->out ? JackPortIsInput : JackPortIsOutput);
379
380 if (!ports) {
381 return;
382 }
383
384 for (int i = 0; i < c->nchannels && ports[i]; ++i) {
385 const char *p = jack_port_name(c->port[i]);
386 if (jack_port_connected_to(c->port[i], ports[i])) {
387 continue;
388 }
389
390 if (c->out) {
391 dolog("connect %s -> %s\n", p, ports[i]);
392 jack_connect(c->client, p, ports[i]);
393 } else {
394 dolog("connect %s -> %s\n", ports[i], p);
395 jack_connect(c->client, ports[i], p);
396 }
397 }
398 }
399
400 static int qjack_client_init(QJackClient *c)
401 {
402 jack_status_t status;
403 char client_name[jack_client_name_size()];
404 jack_options_t options = JackNullOption;
405
406 if (c->state == QJACK_STATE_RUNNING) {
407 return 0;
408 }
409
410 c->connect_ports = true;
411
412 snprintf(client_name, sizeof(client_name), "%s-%s",
413 c->out ? "out" : "in",
414 c->opt->client_name ? c->opt->client_name : audio_application_name());
415
416 if (c->opt->exact_name) {
417 options |= JackUseExactName;
418 }
419
420 if (!c->opt->start_server) {
421 options |= JackNoStartServer;
422 }
423
424 if (c->opt->server_name) {
425 options |= JackServerName;
426 }
427
428 c->client = jack_client_open(client_name, options, &status,
429 c->opt->server_name);
430
431 if (c->client == NULL) {
432 dolog("jack_client_open failed: status = 0x%2.0x\n", status);
433 if (status & JackServerFailed) {
434 dolog("unable to connect to JACK server\n");
435 }
436 return -1;
437 }
438
439 c->freq = jack_get_sample_rate(c->client);
440
441 if (status & JackServerStarted) {
442 dolog("JACK server started\n");
443 }
444
445 if (status & JackNameNotUnique) {
446 dolog("JACK unique name assigned %s\n",
447 jack_get_client_name(c->client));
448 }
449
450 jack_set_process_callback(c->client, qjack_process , c);
451 jack_set_port_registration_callback(c->client, qjack_port_registration, c);
452 jack_set_xrun_callback(c->client, qjack_xrun, c);
453 jack_on_shutdown(c->client, qjack_shutdown, c);
454
455 /* allocate and register the ports */
456 c->port = g_new(jack_port_t *, c->nchannels);
457 for (int i = 0; i < c->nchannels; ++i) {
458
459 char port_name[16];
460 snprintf(
461 port_name,
462 sizeof(port_name),
463 c->out ? "output %d" : "input %d",
464 i);
465
466 c->port[i] = jack_port_register(
467 c->client,
468 port_name,
469 JACK_DEFAULT_AUDIO_TYPE,
470 c->out ? JackPortIsOutput : JackPortIsInput,
471 0);
472 }
473
474 /* activate the session */
475 jack_activate(c->client);
476 c->buffersize = jack_get_buffer_size(c->client);
477
478 /*
479 * ensure the buffersize is no smaller then 512 samples, some (all?) qemu
480 * virtual devices do not work correctly otherwise
481 */
482 if (c->buffersize < 512) {
483 c->buffersize = 512;
484 }
485
486 /* create a 3 period buffer */
487 qjack_buffer_create(&c->fifo, c->nchannels, c->buffersize * 3);
488
489 qjack_client_connect_ports(c);
490 c->state = QJACK_STATE_RUNNING;
491 return 0;
492 }
493
494 static int qjack_init_out(HWVoiceOut *hw, struct audsettings *as,
495 void *drv_opaque)
496 {
497 QJackOut *jo = (QJackOut *)hw;
498 Audiodev *dev = (Audiodev *)drv_opaque;
499
500 jo->c.out = true;
501 jo->c.enabled = false;
502 jo->c.nchannels = as->nchannels;
503 jo->c.opt = dev->u.jack.out;
504
505 jo->c.shutdown_bh = qemu_bh_new(qjack_shutdown_bh, &jo->c);
506
507 int ret = qjack_client_init(&jo->c);
508 if (ret != 0) {
509 qemu_bh_delete(jo->c.shutdown_bh);
510 return ret;
511 }
512
513 /* report the buffer size to qemu */
514 hw->samples = jo->c.buffersize;
515
516 /* report the audio format we support */
517 struct audsettings os = {
518 .freq = jo->c.freq,
519 .nchannels = jo->c.nchannels,
520 .fmt = AUDIO_FORMAT_F32,
521 .endianness = 0
522 };
523 audio_pcm_init_info(&hw->info, &os);
524
525 dolog("JACK output configured for %dHz (%d samples)\n",
526 jo->c.freq, jo->c.buffersize);
527
528 return 0;
529 }
530
531 static int qjack_init_in(HWVoiceIn *hw, struct audsettings *as,
532 void *drv_opaque)
533 {
534 QJackIn *ji = (QJackIn *)hw;
535 Audiodev *dev = (Audiodev *)drv_opaque;
536
537 ji->c.out = false;
538 ji->c.enabled = false;
539 ji->c.nchannels = as->nchannels;
540 ji->c.opt = dev->u.jack.in;
541
542 ji->c.shutdown_bh = qemu_bh_new(qjack_shutdown_bh, &ji->c);
543
544 int ret = qjack_client_init(&ji->c);
545 if (ret != 0) {
546 qemu_bh_delete(ji->c.shutdown_bh);
547 return ret;
548 }
549
550 /* report the buffer size to qemu */
551 hw->samples = ji->c.buffersize;
552
553 /* report the audio format we support */
554 struct audsettings is = {
555 .freq = ji->c.freq,
556 .nchannels = ji->c.nchannels,
557 .fmt = AUDIO_FORMAT_F32,
558 .endianness = 0
559 };
560 audio_pcm_init_info(&hw->info, &is);
561
562 dolog("JACK input configured for %dHz (%d samples)\n",
563 ji->c.freq, ji->c.buffersize);
564
565 return 0;
566 }
567
568 static void qjack_client_fini_locked(QJackClient *c)
569 {
570 switch (c->state) {
571 case QJACK_STATE_RUNNING:
572 jack_deactivate(c->client);
573 /* fallthrough */
574
575 case QJACK_STATE_SHUTDOWN:
576 jack_client_close(c->client);
577 c->client = NULL;
578
579 qjack_buffer_free(&c->fifo);
580 g_free(c->port);
581
582 c->state = QJACK_STATE_DISCONNECTED;
583 /* fallthrough */
584
585 case QJACK_STATE_DISCONNECTED:
586 break;
587 }
588 }
589
590 static void qjack_client_fini(QJackClient *c)
591 {
592 qemu_mutex_lock(&qjack_shutdown_lock);
593 qjack_client_fini_locked(c);
594 qemu_mutex_unlock(&qjack_shutdown_lock);
595 }
596
597 static void qjack_fini_out(HWVoiceOut *hw)
598 {
599 QJackOut *jo = (QJackOut *)hw;
600 qjack_client_fini(&jo->c);
601
602 qemu_bh_delete(jo->c.shutdown_bh);
603 }
604
605 static void qjack_fini_in(HWVoiceIn *hw)
606 {
607 QJackIn *ji = (QJackIn *)hw;
608 qjack_client_fini(&ji->c);
609
610 qemu_bh_delete(ji->c.shutdown_bh);
611 }
612
613 static void qjack_enable_out(HWVoiceOut *hw, bool enable)
614 {
615 QJackOut *jo = (QJackOut *)hw;
616 jo->c.enabled = enable;
617 }
618
619 static void qjack_enable_in(HWVoiceIn *hw, bool enable)
620 {
621 QJackIn *ji = (QJackIn *)hw;
622 ji->c.enabled = enable;
623 }
624
625 #if !defined(WIN32) && defined(CONFIG_PTHREAD_SETNAME_NP_W_TID)
626 static int qjack_thread_creator(jack_native_thread_t *thread,
627 const pthread_attr_t *attr, void *(*function)(void *), void *arg)
628 {
629 int ret = pthread_create(thread, attr, function, arg);
630 if (ret != 0) {
631 return ret;
632 }
633
634 /* set the name of the thread */
635 pthread_setname_np(*thread, "jack-client");
636
637 return ret;
638 }
639 #endif
640
641 static void *qjack_init(Audiodev *dev)
642 {
643 assert(dev->driver == AUDIODEV_DRIVER_JACK);
644 return dev;
645 }
646
647 static void qjack_fini(void *opaque)
648 {
649 }
650
651 static struct audio_pcm_ops jack_pcm_ops = {
652 .init_out = qjack_init_out,
653 .fini_out = qjack_fini_out,
654 .write = qjack_write,
655 .buffer_get_free = audio_generic_buffer_get_free,
656 .run_buffer_out = audio_generic_run_buffer_out,
657 .enable_out = qjack_enable_out,
658
659 .init_in = qjack_init_in,
660 .fini_in = qjack_fini_in,
661 .read = qjack_read,
662 .run_buffer_in = audio_generic_run_buffer_in,
663 .enable_in = qjack_enable_in
664 };
665
666 static struct audio_driver jack_driver = {
667 .name = "jack",
668 .descr = "JACK Audio Connection Kit Client",
669 .init = qjack_init,
670 .fini = qjack_fini,
671 .pcm_ops = &jack_pcm_ops,
672 .can_be_default = 1,
673 .max_voices_out = INT_MAX,
674 .max_voices_in = INT_MAX,
675 .voice_size_out = sizeof(QJackOut),
676 .voice_size_in = sizeof(QJackIn)
677 };
678
679 static void qjack_error(const char *msg)
680 {
681 dolog("E: %s\n", msg);
682 }
683
684 static void qjack_info(const char *msg)
685 {
686 dolog("I: %s\n", msg);
687 }
688
689 static void register_audio_jack(void)
690 {
691 qemu_mutex_init(&qjack_shutdown_lock);
692 audio_driver_register(&jack_driver);
693 #if !defined(WIN32) && defined(CONFIG_PTHREAD_SETNAME_NP_W_TID)
694 jack_set_thread_creator(qjack_thread_creator);
695 #endif
696 jack_set_error_function(qjack_error);
697 jack_set_info_function(qjack_info);
698 }
699 type_init(register_audio_jack);