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