jackaudio.c 17 KB

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