malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 1 | /* public domain */ |
Peter Maydell | 6086a56 | 2016-01-18 17:33:52 +0000 | [diff] [blame] | 2 | #include "qemu/osdep.h" |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 3 | #include "qemu-common.h" |
| 4 | #include "audio.h" |
| 5 | |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 6 | #include <pulse/pulseaudio.h> |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 7 | |
| 8 | #define AUDIO_CAP "pulseaudio" |
| 9 | #include "audio_int.h" |
| 10 | #include "audio_pt_int.h" |
| 11 | |
| 12 | typedef struct { |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 13 | int samples; |
| 14 | char *server; |
| 15 | char *sink; |
| 16 | char *source; |
| 17 | } PAConf; |
| 18 | |
| 19 | typedef struct { |
| 20 | PAConf conf; |
| 21 | pa_threaded_mainloop *mainloop; |
| 22 | pa_context *context; |
| 23 | } paaudio; |
| 24 | |
| 25 | typedef struct { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 26 | HWVoiceOut hw; |
| 27 | int done; |
| 28 | int live; |
| 29 | int decr; |
| 30 | int rpos; |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 31 | pa_stream *stream; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 32 | void *pcm_buf; |
| 33 | struct audio_pt pt; |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 34 | paaudio *g; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 35 | } PAVoiceOut; |
| 36 | |
| 37 | typedef struct { |
| 38 | HWVoiceIn hw; |
| 39 | int done; |
| 40 | int dead; |
| 41 | int incr; |
| 42 | int wpos; |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 43 | pa_stream *stream; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 44 | void *pcm_buf; |
| 45 | struct audio_pt pt; |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 46 | const void *read_data; |
| 47 | size_t read_index, read_length; |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 48 | paaudio *g; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 49 | } PAVoiceIn; |
| 50 | |
Kővágó, Zoltán | 49dd6d0 | 2015-06-03 23:03:53 +0200 | [diff] [blame] | 51 | static void qpa_audio_fini(void *opaque); |
| 52 | |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 53 | static void GCC_FMT_ATTR (2, 3) qpa_logerr (int err, const char *fmt, ...) |
| 54 | { |
| 55 | va_list ap; |
| 56 | |
| 57 | va_start (ap, fmt); |
| 58 | AUD_vlog (AUDIO_CAP, fmt, ap); |
| 59 | va_end (ap); |
| 60 | |
| 61 | AUD_log (AUDIO_CAP, "Reason: %s\n", pa_strerror (err)); |
| 62 | } |
| 63 | |
Gerd Hoffmann | 8f473dd | 2012-05-03 22:41:28 +0200 | [diff] [blame] | 64 | #ifndef PA_CONTEXT_IS_GOOD |
| 65 | static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x) |
| 66 | { |
| 67 | return |
| 68 | x == PA_CONTEXT_CONNECTING || |
| 69 | x == PA_CONTEXT_AUTHORIZING || |
| 70 | x == PA_CONTEXT_SETTING_NAME || |
| 71 | x == PA_CONTEXT_READY; |
| 72 | } |
| 73 | #endif |
| 74 | |
| 75 | #ifndef PA_STREAM_IS_GOOD |
| 76 | static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x) |
| 77 | { |
| 78 | return |
| 79 | x == PA_STREAM_CREATING || |
| 80 | x == PA_STREAM_READY; |
| 81 | } |
| 82 | #endif |
| 83 | |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 84 | #define CHECK_SUCCESS_GOTO(c, rerror, expression, label) \ |
| 85 | do { \ |
| 86 | if (!(expression)) { \ |
| 87 | if (rerror) { \ |
| 88 | *(rerror) = pa_context_errno ((c)->context); \ |
| 89 | } \ |
| 90 | goto label; \ |
| 91 | } \ |
Eric Blake | 2562755 | 2017-12-01 17:24:32 -0600 | [diff] [blame] | 92 | } while (0) |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 93 | |
| 94 | #define CHECK_DEAD_GOTO(c, stream, rerror, label) \ |
| 95 | do { \ |
| 96 | if (!(c)->context || !PA_CONTEXT_IS_GOOD (pa_context_get_state((c)->context)) || \ |
| 97 | !(stream) || !PA_STREAM_IS_GOOD (pa_stream_get_state ((stream)))) { \ |
| 98 | if (((c)->context && pa_context_get_state ((c)->context) == PA_CONTEXT_FAILED) || \ |
| 99 | ((stream) && pa_stream_get_state ((stream)) == PA_STREAM_FAILED)) { \ |
| 100 | if (rerror) { \ |
| 101 | *(rerror) = pa_context_errno ((c)->context); \ |
| 102 | } \ |
| 103 | } else { \ |
| 104 | if (rerror) { \ |
| 105 | *(rerror) = PA_ERR_BADSTATE; \ |
| 106 | } \ |
| 107 | } \ |
| 108 | goto label; \ |
| 109 | } \ |
Eric Blake | 2562755 | 2017-12-01 17:24:32 -0600 | [diff] [blame] | 110 | } while (0) |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 111 | |
| 112 | static int qpa_simple_read (PAVoiceIn *p, void *data, size_t length, int *rerror) |
| 113 | { |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 114 | paaudio *g = p->g; |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 115 | |
| 116 | pa_threaded_mainloop_lock (g->mainloop); |
| 117 | |
| 118 | CHECK_DEAD_GOTO (g, p->stream, rerror, unlock_and_fail); |
| 119 | |
| 120 | while (length > 0) { |
| 121 | size_t l; |
| 122 | |
| 123 | while (!p->read_data) { |
| 124 | int r; |
| 125 | |
| 126 | r = pa_stream_peek (p->stream, &p->read_data, &p->read_length); |
| 127 | CHECK_SUCCESS_GOTO (g, rerror, r == 0, unlock_and_fail); |
| 128 | |
| 129 | if (!p->read_data) { |
| 130 | pa_threaded_mainloop_wait (g->mainloop); |
| 131 | CHECK_DEAD_GOTO (g, p->stream, rerror, unlock_and_fail); |
| 132 | } else { |
| 133 | p->read_index = 0; |
| 134 | } |
| 135 | } |
| 136 | |
| 137 | l = p->read_length < length ? p->read_length : length; |
| 138 | memcpy (data, (const uint8_t *) p->read_data+p->read_index, l); |
| 139 | |
| 140 | data = (uint8_t *) data + l; |
| 141 | length -= l; |
| 142 | |
| 143 | p->read_index += l; |
| 144 | p->read_length -= l; |
| 145 | |
| 146 | if (!p->read_length) { |
| 147 | int r; |
| 148 | |
| 149 | r = pa_stream_drop (p->stream); |
| 150 | p->read_data = NULL; |
| 151 | p->read_length = 0; |
| 152 | p->read_index = 0; |
| 153 | |
| 154 | CHECK_SUCCESS_GOTO (g, rerror, r == 0, unlock_and_fail); |
| 155 | } |
| 156 | } |
| 157 | |
| 158 | pa_threaded_mainloop_unlock (g->mainloop); |
| 159 | return 0; |
| 160 | |
| 161 | unlock_and_fail: |
| 162 | pa_threaded_mainloop_unlock (g->mainloop); |
| 163 | return -1; |
| 164 | } |
| 165 | |
| 166 | static int qpa_simple_write (PAVoiceOut *p, const void *data, size_t length, int *rerror) |
| 167 | { |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 168 | paaudio *g = p->g; |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 169 | |
| 170 | pa_threaded_mainloop_lock (g->mainloop); |
| 171 | |
| 172 | CHECK_DEAD_GOTO (g, p->stream, rerror, unlock_and_fail); |
| 173 | |
| 174 | while (length > 0) { |
| 175 | size_t l; |
| 176 | int r; |
| 177 | |
| 178 | while (!(l = pa_stream_writable_size (p->stream))) { |
| 179 | pa_threaded_mainloop_wait (g->mainloop); |
| 180 | CHECK_DEAD_GOTO (g, p->stream, rerror, unlock_and_fail); |
| 181 | } |
| 182 | |
| 183 | CHECK_SUCCESS_GOTO (g, rerror, l != (size_t) -1, unlock_and_fail); |
| 184 | |
| 185 | if (l > length) { |
| 186 | l = length; |
| 187 | } |
| 188 | |
| 189 | r = pa_stream_write (p->stream, data, l, NULL, 0LL, PA_SEEK_RELATIVE); |
| 190 | CHECK_SUCCESS_GOTO (g, rerror, r >= 0, unlock_and_fail); |
| 191 | |
| 192 | data = (const uint8_t *) data + l; |
| 193 | length -= l; |
| 194 | } |
| 195 | |
| 196 | pa_threaded_mainloop_unlock (g->mainloop); |
| 197 | return 0; |
| 198 | |
| 199 | unlock_and_fail: |
| 200 | pa_threaded_mainloop_unlock (g->mainloop); |
| 201 | return -1; |
| 202 | } |
| 203 | |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 204 | static void *qpa_thread_out (void *arg) |
| 205 | { |
| 206 | PAVoiceOut *pa = arg; |
| 207 | HWVoiceOut *hw = &pa->hw; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 208 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 209 | if (audio_pt_lock(&pa->pt, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 210 | return NULL; |
| 211 | } |
| 212 | |
| 213 | for (;;) { |
| 214 | int decr, to_mix, rpos; |
| 215 | |
| 216 | for (;;) { |
| 217 | if (pa->done) { |
| 218 | goto exit; |
| 219 | } |
| 220 | |
Gerd Hoffmann | 6315633 | 2011-01-24 22:07:44 +0100 | [diff] [blame] | 221 | if (pa->live > 0) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 222 | break; |
| 223 | } |
| 224 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 225 | if (audio_pt_wait(&pa->pt, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 226 | goto exit; |
| 227 | } |
| 228 | } |
| 229 | |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 230 | decr = to_mix = audio_MIN (pa->live, pa->g->conf.samples >> 2); |
Gerd Hoffmann | 6315633 | 2011-01-24 22:07:44 +0100 | [diff] [blame] | 231 | rpos = pa->rpos; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 232 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 233 | if (audio_pt_unlock(&pa->pt, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 234 | return NULL; |
| 235 | } |
| 236 | |
| 237 | while (to_mix) { |
| 238 | int error; |
| 239 | int chunk = audio_MIN (to_mix, hw->samples - rpos); |
malc | 1ea879e | 2008-12-03 22:48:44 +0000 | [diff] [blame] | 240 | struct st_sample *src = hw->mix_buf + rpos; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 241 | |
| 242 | hw->clip (pa->pcm_buf, src, chunk); |
| 243 | |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 244 | if (qpa_simple_write (pa, pa->pcm_buf, |
| 245 | chunk << hw->info.shift, &error) < 0) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 246 | qpa_logerr (error, "pa_simple_write failed\n"); |
| 247 | return NULL; |
| 248 | } |
| 249 | |
| 250 | rpos = (rpos + chunk) % hw->samples; |
| 251 | to_mix -= chunk; |
| 252 | } |
| 253 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 254 | if (audio_pt_lock(&pa->pt, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 255 | return NULL; |
| 256 | } |
| 257 | |
| 258 | pa->rpos = rpos; |
Gerd Hoffmann | 6315633 | 2011-01-24 22:07:44 +0100 | [diff] [blame] | 259 | pa->live -= decr; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 260 | pa->decr += decr; |
| 261 | } |
| 262 | |
| 263 | exit: |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 264 | audio_pt_unlock(&pa->pt, __func__); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 265 | return NULL; |
| 266 | } |
| 267 | |
malc | bdff253 | 2009-09-18 11:37:39 +0400 | [diff] [blame] | 268 | static int qpa_run_out (HWVoiceOut *hw, int live) |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 269 | { |
malc | bdff253 | 2009-09-18 11:37:39 +0400 | [diff] [blame] | 270 | int decr; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 271 | PAVoiceOut *pa = (PAVoiceOut *) hw; |
| 272 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 273 | if (audio_pt_lock(&pa->pt, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 274 | return 0; |
| 275 | } |
| 276 | |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 277 | decr = audio_MIN (live, pa->decr); |
| 278 | pa->decr -= decr; |
| 279 | pa->live = live - decr; |
| 280 | hw->rpos = pa->rpos; |
| 281 | if (pa->live > 0) { |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 282 | audio_pt_unlock_and_signal(&pa->pt, __func__); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 283 | } |
| 284 | else { |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 285 | audio_pt_unlock(&pa->pt, __func__); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 286 | } |
| 287 | return decr; |
| 288 | } |
| 289 | |
| 290 | static int qpa_write (SWVoiceOut *sw, void *buf, int len) |
| 291 | { |
| 292 | return audio_pcm_sw_write (sw, buf, len); |
| 293 | } |
| 294 | |
| 295 | /* capture */ |
| 296 | static void *qpa_thread_in (void *arg) |
| 297 | { |
| 298 | PAVoiceIn *pa = arg; |
| 299 | HWVoiceIn *hw = &pa->hw; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 300 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 301 | if (audio_pt_lock(&pa->pt, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 302 | return NULL; |
| 303 | } |
| 304 | |
| 305 | for (;;) { |
| 306 | int incr, to_grab, wpos; |
| 307 | |
| 308 | for (;;) { |
| 309 | if (pa->done) { |
| 310 | goto exit; |
| 311 | } |
| 312 | |
Gerd Hoffmann | 6315633 | 2011-01-24 22:07:44 +0100 | [diff] [blame] | 313 | if (pa->dead > 0) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 314 | break; |
| 315 | } |
| 316 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 317 | if (audio_pt_wait(&pa->pt, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 318 | goto exit; |
| 319 | } |
| 320 | } |
| 321 | |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 322 | incr = to_grab = audio_MIN (pa->dead, pa->g->conf.samples >> 2); |
Gerd Hoffmann | 6315633 | 2011-01-24 22:07:44 +0100 | [diff] [blame] | 323 | wpos = pa->wpos; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 324 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 325 | if (audio_pt_unlock(&pa->pt, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 326 | return NULL; |
| 327 | } |
| 328 | |
| 329 | while (to_grab) { |
| 330 | int error; |
| 331 | int chunk = audio_MIN (to_grab, hw->samples - wpos); |
| 332 | void *buf = advance (pa->pcm_buf, wpos); |
| 333 | |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 334 | if (qpa_simple_read (pa, buf, |
| 335 | chunk << hw->info.shift, &error) < 0) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 336 | qpa_logerr (error, "pa_simple_read failed\n"); |
| 337 | return NULL; |
| 338 | } |
| 339 | |
Michael Walle | 00e0767 | 2011-01-05 01:05:47 +0100 | [diff] [blame] | 340 | hw->conv (hw->conv_buf + wpos, buf, chunk); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 341 | wpos = (wpos + chunk) % hw->samples; |
| 342 | to_grab -= chunk; |
| 343 | } |
| 344 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 345 | if (audio_pt_lock(&pa->pt, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 346 | return NULL; |
| 347 | } |
| 348 | |
| 349 | pa->wpos = wpos; |
| 350 | pa->dead -= incr; |
| 351 | pa->incr += incr; |
| 352 | } |
| 353 | |
| 354 | exit: |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 355 | audio_pt_unlock(&pa->pt, __func__); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 356 | return NULL; |
| 357 | } |
| 358 | |
| 359 | static int qpa_run_in (HWVoiceIn *hw) |
| 360 | { |
| 361 | int live, incr, dead; |
| 362 | PAVoiceIn *pa = (PAVoiceIn *) hw; |
| 363 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 364 | if (audio_pt_lock(&pa->pt, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 365 | return 0; |
| 366 | } |
| 367 | |
| 368 | live = audio_pcm_hw_get_live_in (hw); |
| 369 | dead = hw->samples - live; |
| 370 | incr = audio_MIN (dead, pa->incr); |
| 371 | pa->incr -= incr; |
| 372 | pa->dead = dead - incr; |
| 373 | hw->wpos = pa->wpos; |
| 374 | if (pa->dead > 0) { |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 375 | audio_pt_unlock_and_signal(&pa->pt, __func__); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 376 | } |
| 377 | else { |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 378 | audio_pt_unlock(&pa->pt, __func__); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 379 | } |
| 380 | return incr; |
| 381 | } |
| 382 | |
| 383 | static int qpa_read (SWVoiceIn *sw, void *buf, int len) |
| 384 | { |
| 385 | return audio_pcm_sw_read (sw, buf, len); |
| 386 | } |
| 387 | |
| 388 | static pa_sample_format_t audfmt_to_pa (audfmt_e afmt, int endianness) |
| 389 | { |
| 390 | int format; |
| 391 | |
| 392 | switch (afmt) { |
| 393 | case AUD_FMT_S8: |
| 394 | case AUD_FMT_U8: |
| 395 | format = PA_SAMPLE_U8; |
| 396 | break; |
| 397 | case AUD_FMT_S16: |
| 398 | case AUD_FMT_U16: |
| 399 | format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE; |
| 400 | break; |
| 401 | case AUD_FMT_S32: |
| 402 | case AUD_FMT_U32: |
| 403 | format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE; |
| 404 | break; |
| 405 | default: |
| 406 | dolog ("Internal logic error: Bad audio format %d\n", afmt); |
| 407 | format = PA_SAMPLE_U8; |
| 408 | break; |
| 409 | } |
| 410 | return format; |
| 411 | } |
| 412 | |
| 413 | static audfmt_e pa_to_audfmt (pa_sample_format_t fmt, int *endianness) |
| 414 | { |
| 415 | switch (fmt) { |
| 416 | case PA_SAMPLE_U8: |
| 417 | return AUD_FMT_U8; |
| 418 | case PA_SAMPLE_S16BE: |
| 419 | *endianness = 1; |
| 420 | return AUD_FMT_S16; |
| 421 | case PA_SAMPLE_S16LE: |
| 422 | *endianness = 0; |
| 423 | return AUD_FMT_S16; |
| 424 | case PA_SAMPLE_S32BE: |
| 425 | *endianness = 1; |
| 426 | return AUD_FMT_S32; |
| 427 | case PA_SAMPLE_S32LE: |
| 428 | *endianness = 0; |
| 429 | return AUD_FMT_S32; |
| 430 | default: |
| 431 | dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt); |
| 432 | return AUD_FMT_U8; |
| 433 | } |
| 434 | } |
| 435 | |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 436 | static void context_state_cb (pa_context *c, void *userdata) |
| 437 | { |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 438 | paaudio *g = userdata; |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 439 | |
| 440 | switch (pa_context_get_state(c)) { |
| 441 | case PA_CONTEXT_READY: |
| 442 | case PA_CONTEXT_TERMINATED: |
| 443 | case PA_CONTEXT_FAILED: |
| 444 | pa_threaded_mainloop_signal (g->mainloop, 0); |
| 445 | break; |
| 446 | |
| 447 | case PA_CONTEXT_UNCONNECTED: |
| 448 | case PA_CONTEXT_CONNECTING: |
| 449 | case PA_CONTEXT_AUTHORIZING: |
| 450 | case PA_CONTEXT_SETTING_NAME: |
| 451 | break; |
| 452 | } |
| 453 | } |
| 454 | |
| 455 | static void stream_state_cb (pa_stream *s, void * userdata) |
| 456 | { |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 457 | paaudio *g = userdata; |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 458 | |
| 459 | switch (pa_stream_get_state (s)) { |
| 460 | |
| 461 | case PA_STREAM_READY: |
| 462 | case PA_STREAM_FAILED: |
| 463 | case PA_STREAM_TERMINATED: |
| 464 | pa_threaded_mainloop_signal (g->mainloop, 0); |
| 465 | break; |
| 466 | |
| 467 | case PA_STREAM_UNCONNECTED: |
| 468 | case PA_STREAM_CREATING: |
| 469 | break; |
| 470 | } |
| 471 | } |
| 472 | |
| 473 | static void stream_request_cb (pa_stream *s, size_t length, void *userdata) |
| 474 | { |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 475 | paaudio *g = userdata; |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 476 | |
| 477 | pa_threaded_mainloop_signal (g->mainloop, 0); |
| 478 | } |
| 479 | |
| 480 | static pa_stream *qpa_simple_new ( |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 481 | paaudio *g, |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 482 | const char *name, |
| 483 | pa_stream_direction_t dir, |
| 484 | const char *dev, |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 485 | const pa_sample_spec *ss, |
| 486 | const pa_channel_map *map, |
| 487 | const pa_buffer_attr *attr, |
| 488 | int *rerror) |
| 489 | { |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 490 | int r; |
| 491 | pa_stream *stream; |
| 492 | |
| 493 | pa_threaded_mainloop_lock (g->mainloop); |
| 494 | |
| 495 | stream = pa_stream_new (g->context, name, ss, map); |
| 496 | if (!stream) { |
| 497 | goto fail; |
| 498 | } |
| 499 | |
| 500 | pa_stream_set_state_callback (stream, stream_state_cb, g); |
| 501 | pa_stream_set_read_callback (stream, stream_request_cb, g); |
| 502 | pa_stream_set_write_callback (stream, stream_request_cb, g); |
| 503 | |
| 504 | if (dir == PA_STREAM_PLAYBACK) { |
| 505 | r = pa_stream_connect_playback (stream, dev, attr, |
| 506 | PA_STREAM_INTERPOLATE_TIMING |
Gerd Hoffmann | 8f473dd | 2012-05-03 22:41:28 +0200 | [diff] [blame] | 507 | #ifdef PA_STREAM_ADJUST_LATENCY |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 508 | |PA_STREAM_ADJUST_LATENCY |
Gerd Hoffmann | 8f473dd | 2012-05-03 22:41:28 +0200 | [diff] [blame] | 509 | #endif |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 510 | |PA_STREAM_AUTO_TIMING_UPDATE, NULL, NULL); |
| 511 | } else { |
| 512 | r = pa_stream_connect_record (stream, dev, attr, |
| 513 | PA_STREAM_INTERPOLATE_TIMING |
Gerd Hoffmann | 8f473dd | 2012-05-03 22:41:28 +0200 | [diff] [blame] | 514 | #ifdef PA_STREAM_ADJUST_LATENCY |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 515 | |PA_STREAM_ADJUST_LATENCY |
Gerd Hoffmann | 8f473dd | 2012-05-03 22:41:28 +0200 | [diff] [blame] | 516 | #endif |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 517 | |PA_STREAM_AUTO_TIMING_UPDATE); |
| 518 | } |
| 519 | |
| 520 | if (r < 0) { |
| 521 | goto fail; |
| 522 | } |
| 523 | |
| 524 | pa_threaded_mainloop_unlock (g->mainloop); |
| 525 | |
| 526 | return stream; |
| 527 | |
| 528 | fail: |
| 529 | pa_threaded_mainloop_unlock (g->mainloop); |
| 530 | |
| 531 | if (stream) { |
| 532 | pa_stream_unref (stream); |
| 533 | } |
| 534 | |
Gerd Hoffmann | d6c05bb | 2012-04-25 18:19:41 +0200 | [diff] [blame] | 535 | *rerror = pa_context_errno (g->context); |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 536 | |
| 537 | return NULL; |
| 538 | } |
| 539 | |
Kővágó, Zoltán | 5706db1 | 2015-06-03 23:03:47 +0200 | [diff] [blame] | 540 | static int qpa_init_out(HWVoiceOut *hw, struct audsettings *as, |
| 541 | void *drv_opaque) |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 542 | { |
| 543 | int error; |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 544 | pa_sample_spec ss; |
| 545 | pa_buffer_attr ba; |
malc | 1ea879e | 2008-12-03 22:48:44 +0000 | [diff] [blame] | 546 | struct audsettings obt_as = *as; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 547 | PAVoiceOut *pa = (PAVoiceOut *) hw; |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 548 | paaudio *g = pa->g = drv_opaque; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 549 | |
| 550 | ss.format = audfmt_to_pa (as->fmt, as->endianness); |
| 551 | ss.channels = as->nchannels; |
| 552 | ss.rate = as->freq; |
| 553 | |
Gerd Hoffmann | e6d16fa | 2011-01-24 22:07:45 +0100 | [diff] [blame] | 554 | /* |
Gerd Hoffmann | 0e8ae61 | 2013-12-02 10:49:13 +0100 | [diff] [blame] | 555 | * qemu audio tick runs at 100 Hz (by default), so processing |
| 556 | * data chunks worth 10 ms of sound should be a good fit. |
Gerd Hoffmann | e6d16fa | 2011-01-24 22:07:45 +0100 | [diff] [blame] | 557 | */ |
Gerd Hoffmann | 0e8ae61 | 2013-12-02 10:49:13 +0100 | [diff] [blame] | 558 | ba.tlength = pa_usec_to_bytes (10 * 1000, &ss); |
| 559 | ba.minreq = pa_usec_to_bytes (5 * 1000, &ss); |
Gerd Hoffmann | e6d16fa | 2011-01-24 22:07:45 +0100 | [diff] [blame] | 560 | ba.maxlength = -1; |
| 561 | ba.prebuf = -1; |
| 562 | |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 563 | obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness); |
| 564 | |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 565 | pa->stream = qpa_simple_new ( |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 566 | g, |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 567 | "qemu", |
| 568 | PA_STREAM_PLAYBACK, |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 569 | g->conf.sink, |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 570 | &ss, |
| 571 | NULL, /* channel map */ |
Gerd Hoffmann | e6d16fa | 2011-01-24 22:07:45 +0100 | [diff] [blame] | 572 | &ba, /* buffering attributes */ |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 573 | &error |
| 574 | ); |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 575 | if (!pa->stream) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 576 | qpa_logerr (error, "pa_simple_new for playback failed\n"); |
| 577 | goto fail1; |
| 578 | } |
| 579 | |
| 580 | audio_pcm_init_info (&hw->info, &obt_as); |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 581 | hw->samples = g->conf.samples; |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 582 | pa->pcm_buf = audio_calloc(__func__, hw->samples, 1 << hw->info.shift); |
Gerd Hoffmann | 6315633 | 2011-01-24 22:07:44 +0100 | [diff] [blame] | 583 | pa->rpos = hw->rpos; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 584 | if (!pa->pcm_buf) { |
| 585 | dolog ("Could not allocate buffer (%d bytes)\n", |
| 586 | hw->samples << hw->info.shift); |
| 587 | goto fail2; |
| 588 | } |
| 589 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 590 | if (audio_pt_init(&pa->pt, qpa_thread_out, hw, AUDIO_CAP, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 591 | goto fail3; |
| 592 | } |
| 593 | |
| 594 | return 0; |
| 595 | |
| 596 | fail3: |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 597 | g_free (pa->pcm_buf); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 598 | pa->pcm_buf = NULL; |
| 599 | fail2: |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 600 | if (pa->stream) { |
| 601 | pa_stream_unref (pa->stream); |
| 602 | pa->stream = NULL; |
| 603 | } |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 604 | fail1: |
| 605 | return -1; |
| 606 | } |
| 607 | |
Kővágó, Zoltán | 5706db1 | 2015-06-03 23:03:47 +0200 | [diff] [blame] | 608 | static int qpa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque) |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 609 | { |
| 610 | int error; |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 611 | pa_sample_spec ss; |
malc | 1ea879e | 2008-12-03 22:48:44 +0000 | [diff] [blame] | 612 | struct audsettings obt_as = *as; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 613 | PAVoiceIn *pa = (PAVoiceIn *) hw; |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 614 | paaudio *g = pa->g = drv_opaque; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 615 | |
| 616 | ss.format = audfmt_to_pa (as->fmt, as->endianness); |
| 617 | ss.channels = as->nchannels; |
| 618 | ss.rate = as->freq; |
| 619 | |
| 620 | obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness); |
| 621 | |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 622 | pa->stream = qpa_simple_new ( |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 623 | g, |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 624 | "qemu", |
| 625 | PA_STREAM_RECORD, |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 626 | g->conf.source, |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 627 | &ss, |
| 628 | NULL, /* channel map */ |
| 629 | NULL, /* buffering attributes */ |
| 630 | &error |
| 631 | ); |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 632 | if (!pa->stream) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 633 | qpa_logerr (error, "pa_simple_new for capture failed\n"); |
| 634 | goto fail1; |
| 635 | } |
| 636 | |
| 637 | audio_pcm_init_info (&hw->info, &obt_as); |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 638 | hw->samples = g->conf.samples; |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 639 | pa->pcm_buf = audio_calloc(__func__, hw->samples, 1 << hw->info.shift); |
Gerd Hoffmann | 6315633 | 2011-01-24 22:07:44 +0100 | [diff] [blame] | 640 | pa->wpos = hw->wpos; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 641 | if (!pa->pcm_buf) { |
| 642 | dolog ("Could not allocate buffer (%d bytes)\n", |
| 643 | hw->samples << hw->info.shift); |
| 644 | goto fail2; |
| 645 | } |
| 646 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 647 | if (audio_pt_init(&pa->pt, qpa_thread_in, hw, AUDIO_CAP, __func__)) { |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 648 | goto fail3; |
| 649 | } |
| 650 | |
| 651 | return 0; |
| 652 | |
| 653 | fail3: |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 654 | g_free (pa->pcm_buf); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 655 | pa->pcm_buf = NULL; |
| 656 | fail2: |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 657 | if (pa->stream) { |
| 658 | pa_stream_unref (pa->stream); |
| 659 | pa->stream = NULL; |
| 660 | } |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 661 | fail1: |
| 662 | return -1; |
| 663 | } |
| 664 | |
| 665 | static void qpa_fini_out (HWVoiceOut *hw) |
| 666 | { |
| 667 | void *ret; |
| 668 | PAVoiceOut *pa = (PAVoiceOut *) hw; |
| 669 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 670 | audio_pt_lock(&pa->pt, __func__); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 671 | pa->done = 1; |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 672 | audio_pt_unlock_and_signal(&pa->pt, __func__); |
| 673 | audio_pt_join(&pa->pt, &ret, __func__); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 674 | |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 675 | if (pa->stream) { |
| 676 | pa_stream_unref (pa->stream); |
| 677 | pa->stream = NULL; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 678 | } |
| 679 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 680 | audio_pt_fini(&pa->pt, __func__); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 681 | g_free (pa->pcm_buf); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 682 | pa->pcm_buf = NULL; |
| 683 | } |
| 684 | |
| 685 | static void qpa_fini_in (HWVoiceIn *hw) |
| 686 | { |
| 687 | void *ret; |
| 688 | PAVoiceIn *pa = (PAVoiceIn *) hw; |
| 689 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 690 | audio_pt_lock(&pa->pt, __func__); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 691 | pa->done = 1; |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 692 | audio_pt_unlock_and_signal(&pa->pt, __func__); |
| 693 | audio_pt_join(&pa->pt, &ret, __func__); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 694 | |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 695 | if (pa->stream) { |
| 696 | pa_stream_unref (pa->stream); |
| 697 | pa->stream = NULL; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 698 | } |
| 699 | |
Alistair Francis | 470bcab | 2018-02-03 09:43:02 +0100 | [diff] [blame] | 700 | audio_pt_fini(&pa->pt, __func__); |
Anthony Liguori | 7267c09 | 2011-08-20 22:09:37 -0500 | [diff] [blame] | 701 | g_free (pa->pcm_buf); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 702 | pa->pcm_buf = NULL; |
| 703 | } |
| 704 | |
| 705 | static int qpa_ctl_out (HWVoiceOut *hw, int cmd, ...) |
| 706 | { |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 707 | PAVoiceOut *pa = (PAVoiceOut *) hw; |
| 708 | pa_operation *op; |
| 709 | pa_cvolume v; |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 710 | paaudio *g = pa->g; |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 711 | |
Gerd Hoffmann | 8f473dd | 2012-05-03 22:41:28 +0200 | [diff] [blame] | 712 | #ifdef PA_CHECK_VERSION /* macro is present in 0.9.16+ */ |
| 713 | pa_cvolume_init (&v); /* function is present in 0.9.13+ */ |
| 714 | #endif |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 715 | |
| 716 | switch (cmd) { |
| 717 | case VOICE_VOLUME: |
| 718 | { |
| 719 | SWVoiceOut *sw; |
| 720 | va_list ap; |
| 721 | |
| 722 | va_start (ap, cmd); |
| 723 | sw = va_arg (ap, SWVoiceOut *); |
| 724 | va_end (ap); |
| 725 | |
| 726 | v.channels = 2; |
| 727 | v.values[0] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.l) / UINT32_MAX; |
| 728 | v.values[1] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.r) / UINT32_MAX; |
| 729 | |
| 730 | pa_threaded_mainloop_lock (g->mainloop); |
| 731 | |
| 732 | op = pa_context_set_sink_input_volume (g->context, |
| 733 | pa_stream_get_index (pa->stream), |
| 734 | &v, NULL, NULL); |
| 735 | if (!op) |
| 736 | qpa_logerr (pa_context_errno (g->context), |
| 737 | "set_sink_input_volume() failed\n"); |
| 738 | else |
| 739 | pa_operation_unref (op); |
| 740 | |
| 741 | op = pa_context_set_sink_input_mute (g->context, |
| 742 | pa_stream_get_index (pa->stream), |
| 743 | sw->vol.mute, NULL, NULL); |
| 744 | if (!op) { |
| 745 | qpa_logerr (pa_context_errno (g->context), |
| 746 | "set_sink_input_mute() failed\n"); |
| 747 | } else { |
| 748 | pa_operation_unref (op); |
| 749 | } |
| 750 | |
| 751 | pa_threaded_mainloop_unlock (g->mainloop); |
| 752 | } |
| 753 | } |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 754 | return 0; |
| 755 | } |
| 756 | |
| 757 | static int qpa_ctl_in (HWVoiceIn *hw, int cmd, ...) |
| 758 | { |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 759 | PAVoiceIn *pa = (PAVoiceIn *) hw; |
| 760 | pa_operation *op; |
| 761 | pa_cvolume v; |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 762 | paaudio *g = pa->g; |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 763 | |
Gerd Hoffmann | 8f473dd | 2012-05-03 22:41:28 +0200 | [diff] [blame] | 764 | #ifdef PA_CHECK_VERSION |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 765 | pa_cvolume_init (&v); |
Gerd Hoffmann | 8f473dd | 2012-05-03 22:41:28 +0200 | [diff] [blame] | 766 | #endif |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 767 | |
| 768 | switch (cmd) { |
| 769 | case VOICE_VOLUME: |
| 770 | { |
| 771 | SWVoiceIn *sw; |
| 772 | va_list ap; |
| 773 | |
| 774 | va_start (ap, cmd); |
| 775 | sw = va_arg (ap, SWVoiceIn *); |
| 776 | va_end (ap); |
| 777 | |
| 778 | v.channels = 2; |
| 779 | v.values[0] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.l) / UINT32_MAX; |
| 780 | v.values[1] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.r) / UINT32_MAX; |
| 781 | |
| 782 | pa_threaded_mainloop_lock (g->mainloop); |
| 783 | |
Peter Krempa | e58ff62 | 2016-05-11 12:31:04 +0200 | [diff] [blame] | 784 | op = pa_context_set_source_output_volume (g->context, |
| 785 | pa_stream_get_index (pa->stream), |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 786 | &v, NULL, NULL); |
| 787 | if (!op) { |
| 788 | qpa_logerr (pa_context_errno (g->context), |
Peter Krempa | e58ff62 | 2016-05-11 12:31:04 +0200 | [diff] [blame] | 789 | "set_source_output_volume() failed\n"); |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 790 | } else { |
| 791 | pa_operation_unref(op); |
| 792 | } |
| 793 | |
Peter Krempa | e58ff62 | 2016-05-11 12:31:04 +0200 | [diff] [blame] | 794 | op = pa_context_set_source_output_mute (g->context, |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 795 | pa_stream_get_index (pa->stream), |
| 796 | sw->vol.mute, NULL, NULL); |
| 797 | if (!op) { |
| 798 | qpa_logerr (pa_context_errno (g->context), |
Peter Krempa | e58ff62 | 2016-05-11 12:31:04 +0200 | [diff] [blame] | 799 | "set_source_output_mute() failed\n"); |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 800 | } else { |
| 801 | pa_operation_unref (op); |
| 802 | } |
| 803 | |
| 804 | pa_threaded_mainloop_unlock (g->mainloop); |
| 805 | } |
| 806 | } |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 807 | return 0; |
| 808 | } |
| 809 | |
| 810 | /* common */ |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 811 | static PAConf glob_conf = { |
| 812 | .samples = 4096, |
| 813 | }; |
| 814 | |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 815 | static void *qpa_audio_init (void) |
| 816 | { |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 817 | paaudio *g = g_malloc(sizeof(paaudio)); |
| 818 | g->conf = glob_conf; |
Kővágó, Zoltán | 49dd6d0 | 2015-06-03 23:03:53 +0200 | [diff] [blame] | 819 | g->mainloop = NULL; |
| 820 | g->context = NULL; |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 821 | |
| 822 | g->mainloop = pa_threaded_mainloop_new (); |
| 823 | if (!g->mainloop) { |
| 824 | goto fail; |
| 825 | } |
| 826 | |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 827 | g->context = pa_context_new (pa_threaded_mainloop_get_api (g->mainloop), |
| 828 | g->conf.server); |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 829 | if (!g->context) { |
| 830 | goto fail; |
| 831 | } |
| 832 | |
| 833 | pa_context_set_state_callback (g->context, context_state_cb, g); |
| 834 | |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 835 | if (pa_context_connect (g->context, g->conf.server, 0, NULL) < 0) { |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 836 | qpa_logerr (pa_context_errno (g->context), |
| 837 | "pa_context_connect() failed\n"); |
| 838 | goto fail; |
| 839 | } |
| 840 | |
| 841 | pa_threaded_mainloop_lock (g->mainloop); |
| 842 | |
| 843 | if (pa_threaded_mainloop_start (g->mainloop) < 0) { |
| 844 | goto unlock_and_fail; |
| 845 | } |
| 846 | |
| 847 | for (;;) { |
| 848 | pa_context_state_t state; |
| 849 | |
| 850 | state = pa_context_get_state (g->context); |
| 851 | |
| 852 | if (state == PA_CONTEXT_READY) { |
| 853 | break; |
| 854 | } |
| 855 | |
| 856 | if (!PA_CONTEXT_IS_GOOD (state)) { |
| 857 | qpa_logerr (pa_context_errno (g->context), |
| 858 | "Wrong context state\n"); |
| 859 | goto unlock_and_fail; |
| 860 | } |
| 861 | |
| 862 | /* Wait until the context is ready */ |
| 863 | pa_threaded_mainloop_wait (g->mainloop); |
| 864 | } |
| 865 | |
| 866 | pa_threaded_mainloop_unlock (g->mainloop); |
| 867 | |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 868 | return g; |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 869 | |
| 870 | unlock_and_fail: |
| 871 | pa_threaded_mainloop_unlock (g->mainloop); |
| 872 | fail: |
| 873 | AUD_log (AUDIO_CAP, "Failed to initialize PA context"); |
Kővágó, Zoltán | 49dd6d0 | 2015-06-03 23:03:53 +0200 | [diff] [blame] | 874 | qpa_audio_fini(g); |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 875 | return NULL; |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 876 | } |
| 877 | |
| 878 | static void qpa_audio_fini (void *opaque) |
| 879 | { |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 880 | paaudio *g = opaque; |
| 881 | |
| 882 | if (g->mainloop) { |
| 883 | pa_threaded_mainloop_stop (g->mainloop); |
| 884 | } |
| 885 | |
| 886 | if (g->context) { |
| 887 | pa_context_disconnect (g->context); |
| 888 | pa_context_unref (g->context); |
Marc-André Lureau | ea9ebc2 | 2012-04-17 14:32:41 +0200 | [diff] [blame] | 889 | } |
| 890 | |
| 891 | if (g->mainloop) { |
| 892 | pa_threaded_mainloop_free (g->mainloop); |
| 893 | } |
| 894 | |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 895 | g_free(g); |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 896 | } |
| 897 | |
| 898 | struct audio_option qpa_options[] = { |
malc | 98f9f48 | 2009-08-11 20:48:02 +0400 | [diff] [blame] | 899 | { |
| 900 | .name = "SAMPLES", |
| 901 | .tag = AUD_OPT_INT, |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 902 | .valp = &glob_conf.samples, |
malc | 98f9f48 | 2009-08-11 20:48:02 +0400 | [diff] [blame] | 903 | .descr = "buffer size in samples" |
| 904 | }, |
| 905 | { |
malc | 98f9f48 | 2009-08-11 20:48:02 +0400 | [diff] [blame] | 906 | .name = "SERVER", |
| 907 | .tag = AUD_OPT_STR, |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 908 | .valp = &glob_conf.server, |
malc | 98f9f48 | 2009-08-11 20:48:02 +0400 | [diff] [blame] | 909 | .descr = "server address" |
| 910 | }, |
| 911 | { |
| 912 | .name = "SINK", |
| 913 | .tag = AUD_OPT_STR, |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 914 | .valp = &glob_conf.sink, |
malc | 98f9f48 | 2009-08-11 20:48:02 +0400 | [diff] [blame] | 915 | .descr = "sink device name" |
| 916 | }, |
| 917 | { |
| 918 | .name = "SOURCE", |
| 919 | .tag = AUD_OPT_STR, |
Kővágó, Zoltán | 9a644c4 | 2015-06-03 23:03:49 +0200 | [diff] [blame] | 920 | .valp = &glob_conf.source, |
malc | 98f9f48 | 2009-08-11 20:48:02 +0400 | [diff] [blame] | 921 | .descr = "source device name" |
| 922 | }, |
Juan Quintela | 2700efa | 2009-08-11 02:31:16 +0200 | [diff] [blame] | 923 | { /* End of list */ } |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 924 | }; |
| 925 | |
blueswir1 | 35f4b58 | 2008-10-06 18:08:30 +0000 | [diff] [blame] | 926 | static struct audio_pcm_ops qpa_pcm_ops = { |
Juan Quintela | 1dd3e4d | 2009-08-11 02:31:15 +0200 | [diff] [blame] | 927 | .init_out = qpa_init_out, |
| 928 | .fini_out = qpa_fini_out, |
| 929 | .run_out = qpa_run_out, |
| 930 | .write = qpa_write, |
| 931 | .ctl_out = qpa_ctl_out, |
| 932 | |
| 933 | .init_in = qpa_init_in, |
| 934 | .fini_in = qpa_fini_in, |
| 935 | .run_in = qpa_run_in, |
| 936 | .read = qpa_read, |
| 937 | .ctl_in = qpa_ctl_in |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 938 | }; |
| 939 | |
Gerd Hoffmann | d3893a3 | 2018-03-06 08:40:47 +0100 | [diff] [blame] | 940 | static struct audio_driver pa_audio_driver = { |
Juan Quintela | bee37f3 | 2009-08-11 02:31:14 +0200 | [diff] [blame] | 941 | .name = "pa", |
| 942 | .descr = "http://www.pulseaudio.org/", |
| 943 | .options = qpa_options, |
| 944 | .init = qpa_audio_init, |
| 945 | .fini = qpa_audio_fini, |
| 946 | .pcm_ops = &qpa_pcm_ops, |
Michael S. Tsirkin | 1a4ea1e | 2009-10-13 16:08:55 +0200 | [diff] [blame] | 947 | .can_be_default = 1, |
Juan Quintela | bee37f3 | 2009-08-11 02:31:14 +0200 | [diff] [blame] | 948 | .max_voices_out = INT_MAX, |
| 949 | .max_voices_in = INT_MAX, |
| 950 | .voice_size_out = sizeof (PAVoiceOut), |
Marc-André Lureau | 6e7a7f3 | 2012-04-17 14:32:43 +0200 | [diff] [blame] | 951 | .voice_size_in = sizeof (PAVoiceIn), |
| 952 | .ctl_caps = VOICE_VOLUME_CAP |
malc | b8e59f1 | 2008-07-02 21:03:08 +0000 | [diff] [blame] | 953 | }; |
Gerd Hoffmann | d3893a3 | 2018-03-06 08:40:47 +0100 | [diff] [blame] | 954 | |
| 955 | static void register_audio_pa(void) |
| 956 | { |
| 957 | audio_driver_register(&pa_audio_driver); |
| 958 | } |
| 959 | type_init(register_audio_pa); |