paaudio.c - qemu - FORK: QEMU emulator

paaudio.c (24923B)
      1 /* public domain */
      2 
      3 #include "qemu/osdep.h"
      4 #include "qemu/module.h"
      5 #include "audio.h"
      6 #include "qapi/opts-visitor.h"
      7 
      8 #include <pulse/pulseaudio.h>
      9 
     10 #define AUDIO_CAP "pulseaudio"
     11 #include "audio_int.h"
     12 
     13 typedef struct PAConnection {
     14     char *server;
     15     int refcount;
     16     QTAILQ_ENTRY(PAConnection) list;
     17 
     18     pa_threaded_mainloop *mainloop;
     19     pa_context *context;
     20 } PAConnection;
     21 
     22 static QTAILQ_HEAD(PAConnectionHead, PAConnection) pa_conns =
     23     QTAILQ_HEAD_INITIALIZER(pa_conns);
     24 
     25 typedef struct {
     26     Audiodev *dev;
     27     PAConnection *conn;
     28 } paaudio;
     29 
     30 typedef struct {
     31     HWVoiceOut hw;
     32     pa_stream *stream;
     33     paaudio *g;
     34 } PAVoiceOut;
     35 
     36 typedef struct {
     37     HWVoiceIn hw;
     38     pa_stream *stream;
     39     const void *read_data;
     40     size_t read_length;
     41     paaudio *g;
     42 } PAVoiceIn;
     43 
     44 static void qpa_conn_fini(PAConnection *c);
     45 
     46 static void G_GNUC_PRINTF (2, 3) qpa_logerr (int err, const char *fmt, ...)
     47 {
     48     va_list ap;
     49 
     50     va_start (ap, fmt);
     51     AUD_vlog (AUDIO_CAP, fmt, ap);
     52     va_end (ap);
     53 
     54     AUD_log (AUDIO_CAP, "Reason: %s\n", pa_strerror (err));
     55 }
     56 
     57 #ifndef PA_CONTEXT_IS_GOOD
     58 static inline int PA_CONTEXT_IS_GOOD(pa_context_state_t x)
     59 {
     60     return
     61         x == PA_CONTEXT_CONNECTING ||
     62         x == PA_CONTEXT_AUTHORIZING ||
     63         x == PA_CONTEXT_SETTING_NAME ||
     64         x == PA_CONTEXT_READY;
     65 }
     66 #endif
     67 
     68 #ifndef PA_STREAM_IS_GOOD
     69 static inline int PA_STREAM_IS_GOOD(pa_stream_state_t x)
     70 {
     71     return
     72         x == PA_STREAM_CREATING ||
     73         x == PA_STREAM_READY;
     74 }
     75 #endif
     76 
     77 #define CHECK_SUCCESS_GOTO(c, expression, label, msg)           \
     78     do {                                                        \
     79         if (!(expression)) {                                    \
     80             qpa_logerr(pa_context_errno((c)->context), msg);    \
     81             goto label;                                         \
     82         }                                                       \
     83     } while (0)
     84 
     85 #define CHECK_DEAD_GOTO(c, stream, label, msg)                          \
     86     do {                                                                \
     87         if (!(c)->context || !PA_CONTEXT_IS_GOOD (pa_context_get_state((c)->context)) || \
     88             !(stream) || !PA_STREAM_IS_GOOD (pa_stream_get_state ((stream)))) { \
     89             if (((c)->context && pa_context_get_state ((c)->context) == PA_CONTEXT_FAILED) || \
     90                 ((stream) && pa_stream_get_state ((stream)) == PA_STREAM_FAILED)) { \
     91                 qpa_logerr(pa_context_errno((c)->context), msg);        \
     92             } else {                                                    \
     93                 qpa_logerr(PA_ERR_BADSTATE, msg);                       \
     94             }                                                           \
     95             goto label;                                                 \
     96         }                                                               \
     97     } while (0)
     98 
     99 static void *qpa_get_buffer_in(HWVoiceIn *hw, size_t *size)
    100 {
    101     PAVoiceIn *p = (PAVoiceIn *) hw;
    102     PAConnection *c = p->g->conn;
    103     int r;
    104 
    105     pa_threaded_mainloop_lock(c->mainloop);
    106 
    107     CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
    108                     "pa_threaded_mainloop_lock failed\n");
    109 
    110     if (!p->read_length) {
    111         r = pa_stream_peek(p->stream, &p->read_data, &p->read_length);
    112         CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
    113                            "pa_stream_peek failed\n");
    114     }
    115 
    116     *size = MIN(p->read_length, *size);
    117 
    118     pa_threaded_mainloop_unlock(c->mainloop);
    119     return (void *) p->read_data;
    120 
    121 unlock_and_fail:
    122     pa_threaded_mainloop_unlock(c->mainloop);
    123     *size = 0;
    124     return NULL;
    125 }
    126 
    127 static void qpa_put_buffer_in(HWVoiceIn *hw, void *buf, size_t size)
    128 {
    129     PAVoiceIn *p = (PAVoiceIn *) hw;
    130     PAConnection *c = p->g->conn;
    131     int r;
    132 
    133     pa_threaded_mainloop_lock(c->mainloop);
    134 
    135     CHECK_DEAD_GOTO(c, p->stream, unlock,
    136                     "pa_threaded_mainloop_lock failed\n");
    137 
    138     assert(buf == p->read_data && size <= p->read_length);
    139 
    140     p->read_data += size;
    141     p->read_length -= size;
    142 
    143     if (size && !p->read_length) {
    144         r = pa_stream_drop(p->stream);
    145         CHECK_SUCCESS_GOTO(c, r == 0, unlock, "pa_stream_drop failed\n");
    146     }
    147 
    148 unlock:
    149     pa_threaded_mainloop_unlock(c->mainloop);
    150 }
    151 
    152 static size_t qpa_read(HWVoiceIn *hw, void *data, size_t length)
    153 {
    154     PAVoiceIn *p = (PAVoiceIn *) hw;
    155     PAConnection *c = p->g->conn;
    156     size_t total = 0;
    157 
    158     pa_threaded_mainloop_lock(c->mainloop);
    159 
    160     CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
    161                     "pa_threaded_mainloop_lock failed\n");
    162     if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
    163         /* wait for stream to become ready */
    164         goto unlock;
    165     }
    166 
    167     while (total < length) {
    168         size_t l;
    169         int r;
    170 
    171         if (!p->read_length) {
    172             r = pa_stream_peek(p->stream, &p->read_data, &p->read_length);
    173             CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
    174                                "pa_stream_peek failed\n");
    175             if (!p->read_length) {
    176                 /* buffer is empty */
    177                 break;
    178             }
    179         }
    180 
    181         l = MIN(p->read_length, length - total);
    182         memcpy((char *)data + total, p->read_data, l);
    183 
    184         p->read_data += l;
    185         p->read_length -= l;
    186         total += l;
    187 
    188         if (!p->read_length) {
    189             r = pa_stream_drop(p->stream);
    190             CHECK_SUCCESS_GOTO(c, r == 0, unlock_and_fail,
    191                                "pa_stream_drop failed\n");
    192         }
    193     }
    194 
    195 unlock:
    196     pa_threaded_mainloop_unlock(c->mainloop);
    197     return total;
    198 
    199 unlock_and_fail:
    200     pa_threaded_mainloop_unlock(c->mainloop);
    201     return 0;
    202 }
    203 
    204 static size_t qpa_buffer_get_free(HWVoiceOut *hw)
    205 {
    206     PAVoiceOut *p = (PAVoiceOut *)hw;
    207     PAConnection *c = p->g->conn;
    208     size_t l;
    209 
    210     pa_threaded_mainloop_lock(c->mainloop);
    211 
    212     CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
    213                     "pa_threaded_mainloop_lock failed\n");
    214     if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
    215         /* wait for stream to become ready */
    216         l = 0;
    217         goto unlock;
    218     }
    219 
    220     l = pa_stream_writable_size(p->stream);
    221     CHECK_SUCCESS_GOTO(c, l != (size_t) -1, unlock_and_fail,
    222                        "pa_stream_writable_size failed\n");
    223 
    224 unlock:
    225     pa_threaded_mainloop_unlock(c->mainloop);
    226     return l;
    227 
    228 unlock_and_fail:
    229     pa_threaded_mainloop_unlock(c->mainloop);
    230     return 0;
    231 }
    232 
    233 static void *qpa_get_buffer_out(HWVoiceOut *hw, size_t *size)
    234 {
    235     PAVoiceOut *p = (PAVoiceOut *)hw;
    236     PAConnection *c = p->g->conn;
    237     void *ret;
    238     int r;
    239 
    240     pa_threaded_mainloop_lock(c->mainloop);
    241 
    242     CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
    243                     "pa_threaded_mainloop_lock failed\n");
    244 
    245     *size = -1;
    246     r = pa_stream_begin_write(p->stream, &ret, size);
    247     CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail,
    248                        "pa_stream_begin_write failed\n");
    249 
    250     pa_threaded_mainloop_unlock(c->mainloop);
    251     return ret;
    252 
    253 unlock_and_fail:
    254     pa_threaded_mainloop_unlock(c->mainloop);
    255     *size = 0;
    256     return NULL;
    257 }
    258 
    259 static size_t qpa_put_buffer_out(HWVoiceOut *hw, void *data, size_t length)
    260 {
    261     PAVoiceOut *p = (PAVoiceOut *)hw;
    262     PAConnection *c = p->g->conn;
    263     int r;
    264 
    265     pa_threaded_mainloop_lock(c->mainloop);
    266 
    267     CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
    268                     "pa_threaded_mainloop_lock failed\n");
    269 
    270     r = pa_stream_write(p->stream, data, length, NULL, 0LL, PA_SEEK_RELATIVE);
    271     CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail, "pa_stream_write failed\n");
    272 
    273     pa_threaded_mainloop_unlock(c->mainloop);
    274     return length;
    275 
    276 unlock_and_fail:
    277     pa_threaded_mainloop_unlock(c->mainloop);
    278     return 0;
    279 }
    280 
    281 static size_t qpa_write(HWVoiceOut *hw, void *data, size_t length)
    282 {
    283     PAVoiceOut *p = (PAVoiceOut *) hw;
    284     PAConnection *c = p->g->conn;
    285     size_t l;
    286     int r;
    287 
    288     pa_threaded_mainloop_lock(c->mainloop);
    289 
    290     CHECK_DEAD_GOTO(c, p->stream, unlock_and_fail,
    291                     "pa_threaded_mainloop_lock failed\n");
    292     if (pa_stream_get_state(p->stream) != PA_STREAM_READY) {
    293         /* wait for stream to become ready */
    294         l = 0;
    295         goto unlock;
    296     }
    297 
    298     l = pa_stream_writable_size(p->stream);
    299 
    300     CHECK_SUCCESS_GOTO(c, l != (size_t) -1, unlock_and_fail,
    301                        "pa_stream_writable_size failed\n");
    302 
    303     if (l > length) {
    304         l = length;
    305     }
    306 
    307     r = pa_stream_write(p->stream, data, l, NULL, 0LL, PA_SEEK_RELATIVE);
    308     CHECK_SUCCESS_GOTO(c, r >= 0, unlock_and_fail, "pa_stream_write failed\n");
    309 
    310 unlock:
    311     pa_threaded_mainloop_unlock(c->mainloop);
    312     return l;
    313 
    314 unlock_and_fail:
    315     pa_threaded_mainloop_unlock(c->mainloop);
    316     return 0;
    317 }
    318 
    319 static pa_sample_format_t audfmt_to_pa (AudioFormat afmt, int endianness)
    320 {
    321     int format;
    322 
    323     switch (afmt) {
    324     case AUDIO_FORMAT_S8:
    325     case AUDIO_FORMAT_U8:
    326         format = PA_SAMPLE_U8;
    327         break;
    328     case AUDIO_FORMAT_S16:
    329     case AUDIO_FORMAT_U16:
    330         format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE;
    331         break;
    332     case AUDIO_FORMAT_S32:
    333     case AUDIO_FORMAT_U32:
    334         format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE;
    335         break;
    336     case AUDIO_FORMAT_F32:
    337         format = endianness ? PA_SAMPLE_FLOAT32BE : PA_SAMPLE_FLOAT32LE;
    338         break;
    339     default:
    340         dolog ("Internal logic error: Bad audio format %d\n", afmt);
    341         format = PA_SAMPLE_U8;
    342         break;
    343     }
    344     return format;
    345 }
    346 
    347 static AudioFormat pa_to_audfmt (pa_sample_format_t fmt, int *endianness)
    348 {
    349     switch (fmt) {
    350     case PA_SAMPLE_U8:
    351         return AUDIO_FORMAT_U8;
    352     case PA_SAMPLE_S16BE:
    353         *endianness = 1;
    354         return AUDIO_FORMAT_S16;
    355     case PA_SAMPLE_S16LE:
    356         *endianness = 0;
    357         return AUDIO_FORMAT_S16;
    358     case PA_SAMPLE_S32BE:
    359         *endianness = 1;
    360         return AUDIO_FORMAT_S32;
    361     case PA_SAMPLE_S32LE:
    362         *endianness = 0;
    363         return AUDIO_FORMAT_S32;
    364     case PA_SAMPLE_FLOAT32BE:
    365         *endianness = 1;
    366         return AUDIO_FORMAT_F32;
    367     case PA_SAMPLE_FLOAT32LE:
    368         *endianness = 0;
    369         return AUDIO_FORMAT_F32;
    370     default:
    371         dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt);
    372         return AUDIO_FORMAT_U8;
    373     }
    374 }
    375 
    376 static void context_state_cb (pa_context *c, void *userdata)
    377 {
    378     PAConnection *conn = userdata;
    379 
    380     switch (pa_context_get_state(c)) {
    381     case PA_CONTEXT_READY:
    382     case PA_CONTEXT_TERMINATED:
    383     case PA_CONTEXT_FAILED:
    384         pa_threaded_mainloop_signal(conn->mainloop, 0);
    385         break;
    386 
    387     case PA_CONTEXT_UNCONNECTED:
    388     case PA_CONTEXT_CONNECTING:
    389     case PA_CONTEXT_AUTHORIZING:
    390     case PA_CONTEXT_SETTING_NAME:
    391         break;
    392     }
    393 }
    394 
    395 static void stream_state_cb (pa_stream *s, void * userdata)
    396 {
    397     PAConnection *c = userdata;
    398 
    399     switch (pa_stream_get_state (s)) {
    400 
    401     case PA_STREAM_READY:
    402     case PA_STREAM_FAILED:
    403     case PA_STREAM_TERMINATED:
    404         pa_threaded_mainloop_signal(c->mainloop, 0);
    405         break;
    406 
    407     case PA_STREAM_UNCONNECTED:
    408     case PA_STREAM_CREATING:
    409         break;
    410     }
    411 }
    412 
    413 static pa_stream *qpa_simple_new (
    414         PAConnection *c,
    415         const char *name,
    416         pa_stream_direction_t dir,
    417         const char *dev,
    418         const pa_sample_spec *ss,
    419         const pa_buffer_attr *attr,
    420         int *rerror)
    421 {
    422     int r;
    423     pa_stream *stream = NULL;
    424     pa_stream_flags_t flags;
    425     pa_channel_map map;
    426 
    427     pa_threaded_mainloop_lock(c->mainloop);
    428 
    429     pa_channel_map_init(&map);
    430     map.channels = ss->channels;
    431 
    432     /*
    433      * TODO: This currently expects the only frontend supporting more than 2
    434      * channels is the usb-audio.  We will need some means to set channel
    435      * order when a new frontend gains multi-channel support.
    436      */
    437     switch (ss->channels) {
    438     case 1:
    439         map.map[0] = PA_CHANNEL_POSITION_MONO;
    440         break;
    441 
    442     case 2:
    443         map.map[0] = PA_CHANNEL_POSITION_LEFT;
    444         map.map[1] = PA_CHANNEL_POSITION_RIGHT;
    445         break;
    446 
    447     case 6:
    448         map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
    449         map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
    450         map.map[2] = PA_CHANNEL_POSITION_CENTER;
    451         map.map[3] = PA_CHANNEL_POSITION_LFE;
    452         map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
    453         map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
    454         break;
    455 
    456     case 8:
    457         map.map[0] = PA_CHANNEL_POSITION_FRONT_LEFT;
    458         map.map[1] = PA_CHANNEL_POSITION_FRONT_RIGHT;
    459         map.map[2] = PA_CHANNEL_POSITION_CENTER;
    460         map.map[3] = PA_CHANNEL_POSITION_LFE;
    461         map.map[4] = PA_CHANNEL_POSITION_REAR_LEFT;
    462         map.map[5] = PA_CHANNEL_POSITION_REAR_RIGHT;
    463         map.map[6] = PA_CHANNEL_POSITION_SIDE_LEFT;
    464         map.map[7] = PA_CHANNEL_POSITION_SIDE_RIGHT;
    465         break;
    466 
    467     default:
    468         dolog("Internal error: unsupported channel count %d\n", ss->channels);
    469         goto fail;
    470     }
    471 
    472     stream = pa_stream_new(c->context, name, ss, &map);
    473     if (!stream) {
    474         goto fail;
    475     }
    476 
    477     pa_stream_set_state_callback(stream, stream_state_cb, c);
    478 
    479     flags = PA_STREAM_EARLY_REQUESTS;
    480 
    481     if (dev) {
    482         /* don't move the stream if the user specified a sink/source */
    483         flags |= PA_STREAM_DONT_MOVE;
    484     }
    485 
    486     if (dir == PA_STREAM_PLAYBACK) {
    487         r = pa_stream_connect_playback(stream, dev, attr, flags, NULL, NULL);
    488     } else {
    489         r = pa_stream_connect_record(stream, dev, attr, flags);
    490     }
    491 
    492     if (r < 0) {
    493         goto fail;
    494     }
    495 
    496     pa_threaded_mainloop_unlock(c->mainloop);
    497 
    498     return stream;
    499 
    500 fail:
    501     pa_threaded_mainloop_unlock(c->mainloop);
    502 
    503     if (stream) {
    504         pa_stream_unref (stream);
    505     }
    506 
    507     *rerror = pa_context_errno(c->context);
    508 
    509     return NULL;
    510 }
    511 
    512 static int qpa_init_out(HWVoiceOut *hw, struct audsettings *as,
    513                         void *drv_opaque)
    514 {
    515     int error;
    516     pa_sample_spec ss;
    517     pa_buffer_attr ba;
    518     struct audsettings obt_as = *as;
    519     PAVoiceOut *pa = (PAVoiceOut *) hw;
    520     paaudio *g = pa->g = drv_opaque;
    521     AudiodevPaOptions *popts = &g->dev->u.pa;
    522     AudiodevPaPerDirectionOptions *ppdo = popts->out;
    523     PAConnection *c = g->conn;
    524 
    525     ss.format = audfmt_to_pa (as->fmt, as->endianness);
    526     ss.channels = as->nchannels;
    527     ss.rate = as->freq;
    528 
    529     ba.tlength = pa_usec_to_bytes(ppdo->latency, &ss);
    530     ba.minreq = pa_usec_to_bytes(MIN(ppdo->latency >> 2,
    531                                      (g->dev->timer_period >> 2) * 3), &ss);
    532     ba.maxlength = -1;
    533     ba.prebuf = -1;
    534 
    535     obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
    536 
    537     pa->stream = qpa_simple_new (
    538         c,
    539         ppdo->has_stream_name ? ppdo->stream_name : g->dev->id,
    540         PA_STREAM_PLAYBACK,
    541         ppdo->has_name ? ppdo->name : NULL,
    542         &ss,
    543         &ba,                    /* buffering attributes */
    544         &error
    545         );
    546     if (!pa->stream) {
    547         qpa_logerr (error, "pa_simple_new for playback failed\n");
    548         goto fail1;
    549     }
    550 
    551     audio_pcm_init_info (&hw->info, &obt_as);
    552     /* hw->samples counts in frames */
    553     hw->samples = audio_buffer_frames(
    554         qapi_AudiodevPaPerDirectionOptions_base(ppdo), &obt_as, 46440);
    555 
    556     return 0;
    557 
    558  fail1:
    559     return -1;
    560 }
    561 
    562 static int qpa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
    563 {
    564     int error;
    565     pa_sample_spec ss;
    566     pa_buffer_attr ba;
    567     struct audsettings obt_as = *as;
    568     PAVoiceIn *pa = (PAVoiceIn *) hw;
    569     paaudio *g = pa->g = drv_opaque;
    570     AudiodevPaOptions *popts = &g->dev->u.pa;
    571     AudiodevPaPerDirectionOptions *ppdo = popts->in;
    572     PAConnection *c = g->conn;
    573 
    574     ss.format = audfmt_to_pa (as->fmt, as->endianness);
    575     ss.channels = as->nchannels;
    576     ss.rate = as->freq;
    577 
    578     ba.fragsize = pa_usec_to_bytes((g->dev->timer_period >> 1) * 3, &ss);
    579     ba.maxlength = pa_usec_to_bytes(
    580         MAX(ppdo->latency, g->dev->timer_period * 3), &ss);
    581     ba.minreq = -1;
    582     ba.prebuf = -1;
    583 
    584     obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);
    585 
    586     pa->stream = qpa_simple_new (
    587         c,
    588         ppdo->has_stream_name ? ppdo->stream_name : g->dev->id,
    589         PA_STREAM_RECORD,
    590         ppdo->has_name ? ppdo->name : NULL,
    591         &ss,
    592         &ba,                    /* buffering attributes */
    593         &error
    594         );
    595     if (!pa->stream) {
    596         qpa_logerr (error, "pa_simple_new for capture failed\n");
    597         goto fail1;
    598     }
    599 
    600     audio_pcm_init_info (&hw->info, &obt_as);
    601     /* hw->samples counts in frames */
    602     hw->samples = audio_buffer_frames(
    603         qapi_AudiodevPaPerDirectionOptions_base(ppdo), &obt_as, 46440);
    604 
    605     return 0;
    606 
    607  fail1:
    608     return -1;
    609 }
    610 
    611 static void qpa_simple_disconnect(PAConnection *c, pa_stream *stream)
    612 {
    613     int err;
    614 
    615     /*
    616      * wait until actually connects. workaround pa bug #247
    617      * https://gitlab.freedesktop.org/pulseaudio/pulseaudio/issues/247
    618      */
    619     while (pa_stream_get_state(stream) == PA_STREAM_CREATING) {
    620         pa_threaded_mainloop_wait(c->mainloop);
    621     }
    622 
    623     err = pa_stream_disconnect(stream);
    624     if (err != 0) {
    625         dolog("Failed to disconnect! err=%d\n", err);
    626     }
    627     pa_stream_unref(stream);
    628 }
    629 
    630 static void qpa_fini_out (HWVoiceOut *hw)
    631 {
    632     PAVoiceOut *pa = (PAVoiceOut *) hw;
    633 
    634     if (pa->stream) {
    635         PAConnection *c = pa->g->conn;
    636 
    637         pa_threaded_mainloop_lock(c->mainloop);
    638         qpa_simple_disconnect(c, pa->stream);
    639         pa->stream = NULL;
    640         pa_threaded_mainloop_unlock(c->mainloop);
    641     }
    642 }
    643 
    644 static void qpa_fini_in (HWVoiceIn *hw)
    645 {
    646     PAVoiceIn *pa = (PAVoiceIn *) hw;
    647 
    648     if (pa->stream) {
    649         PAConnection *c = pa->g->conn;
    650 
    651         pa_threaded_mainloop_lock(c->mainloop);
    652         if (pa->read_length) {
    653             int r = pa_stream_drop(pa->stream);
    654             if (r) {
    655                 qpa_logerr(pa_context_errno(c->context),
    656                            "pa_stream_drop failed\n");
    657             }
    658             pa->read_length = 0;
    659         }
    660         qpa_simple_disconnect(c, pa->stream);
    661         pa->stream = NULL;
    662         pa_threaded_mainloop_unlock(c->mainloop);
    663     }
    664 }
    665 
    666 static void qpa_volume_out(HWVoiceOut *hw, Volume *vol)
    667 {
    668     PAVoiceOut *pa = (PAVoiceOut *) hw;
    669     pa_operation *op;
    670     pa_cvolume v;
    671     PAConnection *c = pa->g->conn;
    672     int i;
    673 
    674 #ifdef PA_CHECK_VERSION    /* macro is present in 0.9.16+ */
    675     pa_cvolume_init (&v);  /* function is present in 0.9.13+ */
    676 #endif
    677 
    678     v.channels = vol->channels;
    679     for (i = 0; i < vol->channels; ++i) {
    680         v.values[i] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * vol->vol[i]) / 255;
    681     }
    682 
    683     pa_threaded_mainloop_lock(c->mainloop);
    684 
    685     op = pa_context_set_sink_input_volume(c->context,
    686                                           pa_stream_get_index(pa->stream),
    687                                           &v, NULL, NULL);
    688     if (!op) {
    689         qpa_logerr(pa_context_errno(c->context),
    690                    "set_sink_input_volume() failed\n");
    691     } else {
    692         pa_operation_unref(op);
    693     }
    694 
    695     op = pa_context_set_sink_input_mute(c->context,
    696                                         pa_stream_get_index(pa->stream),
    697                                         vol->mute, NULL, NULL);
    698     if (!op) {
    699         qpa_logerr(pa_context_errno(c->context),
    700                    "set_sink_input_mute() failed\n");
    701     } else {
    702         pa_operation_unref(op);
    703     }
    704 
    705     pa_threaded_mainloop_unlock(c->mainloop);
    706 }
    707 
    708 static void qpa_volume_in(HWVoiceIn *hw, Volume *vol)
    709 {
    710     PAVoiceIn *pa = (PAVoiceIn *) hw;
    711     pa_operation *op;
    712     pa_cvolume v;
    713     PAConnection *c = pa->g->conn;
    714     int i;
    715 
    716 #ifdef PA_CHECK_VERSION
    717     pa_cvolume_init (&v);
    718 #endif
    719 
    720     v.channels = vol->channels;
    721     for (i = 0; i < vol->channels; ++i) {
    722         v.values[i] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * vol->vol[i]) / 255;
    723     }
    724 
    725     pa_threaded_mainloop_lock(c->mainloop);
    726 
    727     op = pa_context_set_source_output_volume(c->context,
    728         pa_stream_get_index(pa->stream),
    729         &v, NULL, NULL);
    730     if (!op) {
    731         qpa_logerr(pa_context_errno(c->context),
    732                    "set_source_output_volume() failed\n");
    733     } else {
    734         pa_operation_unref(op);
    735     }
    736 
    737     op = pa_context_set_source_output_mute(c->context,
    738         pa_stream_get_index(pa->stream),
    739         vol->mute, NULL, NULL);
    740     if (!op) {
    741         qpa_logerr(pa_context_errno(c->context),
    742                    "set_source_output_mute() failed\n");
    743     } else {
    744         pa_operation_unref(op);
    745     }
    746 
    747     pa_threaded_mainloop_unlock(c->mainloop);
    748 }
    749 
    750 static int qpa_validate_per_direction_opts(Audiodev *dev,
    751                                            AudiodevPaPerDirectionOptions *pdo)
    752 {
    753     if (!pdo->has_latency) {
    754         pdo->has_latency = true;
    755         pdo->latency = 46440;
    756     }
    757     return 1;
    758 }
    759 
    760 /* common */
    761 static void *qpa_conn_init(const char *server)
    762 {
    763     PAConnection *c = g_new0(PAConnection, 1);
    764     QTAILQ_INSERT_TAIL(&pa_conns, c, list);
    765 
    766     c->mainloop = pa_threaded_mainloop_new();
    767     if (!c->mainloop) {
    768         goto fail;
    769     }
    770 
    771     c->context = pa_context_new(pa_threaded_mainloop_get_api(c->mainloop),
    772                                 audio_application_name());
    773     if (!c->context) {
    774         goto fail;
    775     }
    776 
    777     pa_context_set_state_callback(c->context, context_state_cb, c);
    778 
    779     if (pa_context_connect(c->context, server, 0, NULL) < 0) {
    780         qpa_logerr(pa_context_errno(c->context),
    781                    "pa_context_connect() failed\n");
    782         goto fail;
    783     }
    784 
    785     pa_threaded_mainloop_lock(c->mainloop);
    786 
    787     if (pa_threaded_mainloop_start(c->mainloop) < 0) {
    788         goto unlock_and_fail;
    789     }
    790 
    791     for (;;) {
    792         pa_context_state_t state;
    793 
    794         state = pa_context_get_state(c->context);
    795 
    796         if (state == PA_CONTEXT_READY) {
    797             break;
    798         }
    799 
    800         if (!PA_CONTEXT_IS_GOOD(state)) {
    801             qpa_logerr(pa_context_errno(c->context),
    802                        "Wrong context state\n");
    803             goto unlock_and_fail;
    804         }
    805 
    806         /* Wait until the context is ready */
    807         pa_threaded_mainloop_wait(c->mainloop);
    808     }
    809 
    810     pa_threaded_mainloop_unlock(c->mainloop);
    811     return c;
    812 
    813 unlock_and_fail:
    814     pa_threaded_mainloop_unlock(c->mainloop);
    815 fail:
    816     AUD_log (AUDIO_CAP, "Failed to initialize PA context");
    817     qpa_conn_fini(c);
    818     return NULL;
    819 }
    820 
    821 static void *qpa_audio_init(Audiodev *dev)
    822 {
    823     paaudio *g;
    824     AudiodevPaOptions *popts = &dev->u.pa;
    825     const char *server;
    826     PAConnection *c;
    827 
    828     assert(dev->driver == AUDIODEV_DRIVER_PA);
    829 
    830     if (!popts->has_server) {
    831         char pidfile[64];
    832         char *runtime;
    833         struct stat st;
    834 
    835         runtime = getenv("XDG_RUNTIME_DIR");
    836         if (!runtime) {
    837             return NULL;
    838         }
    839         snprintf(pidfile, sizeof(pidfile), "%s/pulse/pid", runtime);
    840         if (stat(pidfile, &st) != 0) {
    841             return NULL;
    842         }
    843     }
    844 
    845     if (!qpa_validate_per_direction_opts(dev, popts->in)) {
    846         return NULL;
    847     }
    848     if (!qpa_validate_per_direction_opts(dev, popts->out)) {
    849         return NULL;
    850     }
    851 
    852     g = g_new0(paaudio, 1);
    853     server = popts->has_server ? popts->server : NULL;
    854 
    855     g->dev = dev;
    856 
    857     QTAILQ_FOREACH(c, &pa_conns, list) {
    858         if (server == NULL || c->server == NULL ?
    859             server == c->server :
    860             strcmp(server, c->server) == 0) {
    861             g->conn = c;
    862             break;
    863         }
    864     }
    865     if (!g->conn) {
    866         g->conn = qpa_conn_init(server);
    867     }
    868     if (!g->conn) {
    869         g_free(g);
    870         return NULL;
    871     }
    872 
    873     ++g->conn->refcount;
    874     return g;
    875 }
    876 
    877 static void qpa_conn_fini(PAConnection *c)
    878 {
    879     if (c->mainloop) {
    880         pa_threaded_mainloop_stop(c->mainloop);
    881     }
    882 
    883     if (c->context) {
    884         pa_context_disconnect(c->context);
    885         pa_context_unref(c->context);
    886     }
    887 
    888     if (c->mainloop) {
    889         pa_threaded_mainloop_free(c->mainloop);
    890     }
    891 
    892     QTAILQ_REMOVE(&pa_conns, c, list);
    893     g_free(c);
    894 }
    895 
    896 static void qpa_audio_fini (void *opaque)
    897 {
    898     paaudio *g = opaque;
    899     PAConnection *c = g->conn;
    900 
    901     if (--c->refcount == 0) {
    902         qpa_conn_fini(c);
    903     }
    904 
    905     g_free(g);
    906 }
    907 
    908 static struct audio_pcm_ops qpa_pcm_ops = {
    909     .init_out = qpa_init_out,
    910     .fini_out = qpa_fini_out,
    911     .write    = qpa_write,
    912     .buffer_get_free = qpa_buffer_get_free,
    913     .get_buffer_out = qpa_get_buffer_out,
    914     .put_buffer_out = qpa_put_buffer_out,
    915     .volume_out = qpa_volume_out,
    916 
    917     .init_in  = qpa_init_in,
    918     .fini_in  = qpa_fini_in,
    919     .read     = qpa_read,
    920     .get_buffer_in = qpa_get_buffer_in,
    921     .put_buffer_in = qpa_put_buffer_in,
    922     .volume_in = qpa_volume_in
    923 };
    924 
    925 static struct audio_driver pa_audio_driver = {
    926     .name           = "pa",
    927     .descr          = "http://www.pulseaudio.org/",
    928     .init           = qpa_audio_init,
    929     .fini           = qpa_audio_fini,
    930     .pcm_ops        = &qpa_pcm_ops,
    931     .can_be_default = 1,
    932     .max_voices_out = INT_MAX,
    933     .max_voices_in  = INT_MAX,
    934     .voice_size_out = sizeof (PAVoiceOut),
    935     .voice_size_in  = sizeof (PAVoiceIn),
    936 };
    937 
    938 static void register_audio_pa(void)
    939 {
    940     audio_driver_register(&pa_audio_driver);
    941 }
    942 type_init(register_audio_pa);
	qemu FORK: QEMU emulator
	git clone https://git.neptards.moe/neptards/qemu.git
	Log \| Files \| Refs \| Submodules \| LICENSE