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