1 /* public domain */

     2 #include "qemu-common.h"

     3 #include "audio.h"

     4 

     5 #include <pulse/simple.h>

     6 #include <pulse/error.h>

     7 

     8 #define AUDIO_CAP "pulseaudio"

     9 #include "audio_int.h"

    10 #include "audio_pt_int.h"

    11 

    12 typedef struct {

    13     HWVoiceOut hw;

    14     int done;

    15     int live;

    16     int decr;

    17     int rpos;

    18     pa_simple *s;

    19     void *pcm_buf;

    20     struct audio_pt pt;

    21 } PAVoiceOut;

    22 

    23 typedef struct {

    24     HWVoiceIn hw;

    25     int done;

    26     int dead;

    27     int incr;

    28     int wpos;

    29     pa_simple *s;

    30     void *pcm_buf;

    31     struct audio_pt pt;

    32 } PAVoiceIn;

    33 

    34 static struct {

    35     int samples;

    36     int divisor;

    37     char *server;

    38     char *sink;

    39     char *source;

    40 } conf = {

    41     1024,

    42     2,

    43     NULL,

    44     NULL,

    45     NULL

    46 };

    47 

    48 static void GCC_FMT_ATTR (2, 3) qpa_logerr (int err, const char *fmt, ...)

    49 {

    50     va_list ap;

    51 

    52     va_start (ap, fmt);

    53     AUD_vlog (AUDIO_CAP, fmt, ap);

    54     va_end (ap);

    55 

    56     AUD_log (AUDIO_CAP, "Reason: %s\n", pa_strerror (err));

    57 }

    58 

    59 static void *qpa_thread_out (void *arg)

    60 {

    61     PAVoiceOut *pa = arg;

    62     HWVoiceOut *hw = &pa->hw;

    63     int threshold;

    64 

    65     threshold = conf.divisor ? hw->samples / conf.divisor : 0;

    66 

    67     if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {

    68         return NULL;

    69     }

    70 

    71     for (;;) {

    72         int decr, to_mix, rpos;

    73 

    74         for (;;) {

    75             if (pa->done) {

    76                 goto exit;

    77             }

    78 

    79             if (pa->live > threshold) {

    80                 break;

    81             }

    82 

    83             if (audio_pt_wait (&pa->pt, AUDIO_FUNC)) {

    84                 goto exit;

    85             }

    86         }

    87 

    88         decr = to_mix = pa->live;

    89         rpos = hw->rpos;

    90 

    91         if (audio_pt_unlock (&pa->pt, AUDIO_FUNC)) {

    92             return NULL;

    93         }

    94 

    95         while (to_mix) {

    96             int error;

    97             int chunk = audio_MIN (to_mix, hw->samples - rpos);

    98             struct st_sample *src = hw->mix_buf + rpos;

    99 

   100             hw->clip (pa->pcm_buf, src, chunk);

   101 

   102             if (pa_simple_write (pa->s, pa->pcm_buf,

   103                                  chunk << hw->info.shift, &error) < 0) {

   104                 qpa_logerr (error, "pa_simple_write failed\n");

   105                 return NULL;

   106             }

   107 

   108             rpos = (rpos + chunk) % hw->samples;

   109             to_mix -= chunk;

   110         }

   111 

   112         if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {

   113             return NULL;

   114         }

   115 

   116         pa->rpos = rpos;

   117         pa->live -= decr;

   118         pa->decr += decr;

   119     }

   120 

   121  exit:

   122     audio_pt_unlock (&pa->pt, AUDIO_FUNC);

   123     return NULL;

   124 }

   125 

   126 static int qpa_run_out (HWVoiceOut *hw)

   127 {

   128     int live, decr;

   129     PAVoiceOut *pa = (PAVoiceOut *) hw;

   130 

   131     if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {

   132         return 0;

   133     }

   134 

   135     live = audio_pcm_hw_get_live_out (hw);

   136     decr = audio_MIN (live, pa->decr);

   137     pa->decr -= decr;

   138     pa->live = live - decr;

   139     hw->rpos = pa->rpos;

   140     if (pa->live > 0) {

   141         audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);

   142     }

   143     else {

   144         audio_pt_unlock (&pa->pt, AUDIO_FUNC);

   145     }

   146     return decr;

   147 }

   148 

   149 static int qpa_write (SWVoiceOut *sw, void *buf, int len)

   150 {

   151     return audio_pcm_sw_write (sw, buf, len);

   152 }

   153 

   154 /* capture */

   155 static void *qpa_thread_in (void *arg)

   156 {

   157     PAVoiceIn *pa = arg;

   158     HWVoiceIn *hw = &pa->hw;

   159     int threshold;

   160 

   161     threshold = conf.divisor ? hw->samples / conf.divisor : 0;

   162 

   163     if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {

   164         return NULL;

   165     }

   166 

   167     for (;;) {

   168         int incr, to_grab, wpos;

   169 

   170         for (;;) {

   171             if (pa->done) {

   172                 goto exit;

   173             }

   174 

   175             if (pa->dead > threshold) {

   176                 break;

   177             }

   178 

   179             if (audio_pt_wait (&pa->pt, AUDIO_FUNC)) {

   180                 goto exit;

   181             }

   182         }

   183 

   184         incr = to_grab = pa->dead;

   185         wpos = hw->wpos;

   186 

   187         if (audio_pt_unlock (&pa->pt, AUDIO_FUNC)) {

   188             return NULL;

   189         }

   190 

   191         while (to_grab) {

   192             int error;

   193             int chunk = audio_MIN (to_grab, hw->samples - wpos);

   194             void *buf = advance (pa->pcm_buf, wpos);

   195 

   196             if (pa_simple_read (pa->s, buf,

   197                                 chunk << hw->info.shift, &error) < 0) {

   198                 qpa_logerr (error, "pa_simple_read failed\n");

   199                 return NULL;

   200             }

   201 

   202             hw->conv (hw->conv_buf + wpos, buf, chunk, &nominal_volume);

   203             wpos = (wpos + chunk) % hw->samples;

   204             to_grab -= chunk;

   205         }

   206 

   207         if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {

   208             return NULL;

   209         }

   210 

   211         pa->wpos = wpos;

   212         pa->dead -= incr;

   213         pa->incr += incr;

   214     }

   215 

   216  exit:

   217     audio_pt_unlock (&pa->pt, AUDIO_FUNC);

   218     return NULL;

   219 }

   220 

   221 static int qpa_run_in (HWVoiceIn *hw)

   222 {

   223     int live, incr, dead;

   224     PAVoiceIn *pa = (PAVoiceIn *) hw;

   225 

   226     if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {

   227         return 0;

   228     }

   229 

   230     live = audio_pcm_hw_get_live_in (hw);

   231     dead = hw->samples - live;

   232     incr = audio_MIN (dead, pa->incr);

   233     pa->incr -= incr;

   234     pa->dead = dead - incr;

   235     hw->wpos = pa->wpos;

   236     if (pa->dead > 0) {

   237         audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);

   238     }

   239     else {

   240         audio_pt_unlock (&pa->pt, AUDIO_FUNC);

   241     }

   242     return incr;

   243 }

   244 

   245 static int qpa_read (SWVoiceIn *sw, void *buf, int len)

   246 {

   247     return audio_pcm_sw_read (sw, buf, len);

   248 }

   249 

   250 static pa_sample_format_t audfmt_to_pa (audfmt_e afmt, int endianness)

   251 {

   252     int format;

   253 

   254     switch (afmt) {

   255     case AUD_FMT_S8:

   256     case AUD_FMT_U8:

   257         format = PA_SAMPLE_U8;

   258         break;

   259     case AUD_FMT_S16:

   260     case AUD_FMT_U16:

   261         format = endianness ? PA_SAMPLE_S16BE : PA_SAMPLE_S16LE;

   262         break;

   263     case AUD_FMT_S32:

   264     case AUD_FMT_U32:

   265         format = endianness ? PA_SAMPLE_S32BE : PA_SAMPLE_S32LE;

   266         break;

   267     default:

   268         dolog ("Internal logic error: Bad audio format %d\n", afmt);

   269         format = PA_SAMPLE_U8;

   270         break;

   271     }

   272     return format;

   273 }

   274 

   275 static audfmt_e pa_to_audfmt (pa_sample_format_t fmt, int *endianness)

   276 {

   277     switch (fmt) {

   278     case PA_SAMPLE_U8:

   279         return AUD_FMT_U8;

   280     case PA_SAMPLE_S16BE:

   281         *endianness = 1;

   282         return AUD_FMT_S16;

   283     case PA_SAMPLE_S16LE:

   284         *endianness = 0;

   285         return AUD_FMT_S16;

   286     case PA_SAMPLE_S32BE:

   287         *endianness = 1;

   288         return AUD_FMT_S32;

   289     case PA_SAMPLE_S32LE:

   290         *endianness = 0;

   291         return AUD_FMT_S32;

   292     default:

   293         dolog ("Internal logic error: Bad pa_sample_format %d\n", fmt);

   294         return AUD_FMT_U8;

   295     }

   296 }

   297 

   298 static int qpa_init_out (HWVoiceOut *hw, struct audsettings *as)

   299 {

   300     int error;

   301     static pa_sample_spec ss;

   302     struct audsettings obt_as = *as;

   303     PAVoiceOut *pa = (PAVoiceOut *) hw;

   304 

   305     ss.format = audfmt_to_pa (as->fmt, as->endianness);

   306     ss.channels = as->nchannels;

   307     ss.rate = as->freq;

   308 

   309     obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);

   310 

   311     pa->s = pa_simple_new (

   312         conf.server,

   313         "qemu",

   314         PA_STREAM_PLAYBACK,

   315         conf.sink,

   316         "pcm.playback",

   317         &ss,

   318         NULL,                   /* channel map */

   319         NULL,                   /* buffering attributes */

   320         &error

   321         );

   322     if (!pa->s) {

   323         qpa_logerr (error, "pa_simple_new for playback failed\n");

   324         goto fail1;

   325     }

   326 

   327     audio_pcm_init_info (&hw->info, &obt_as);

   328     hw->samples = conf.samples;

   329     pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);

   330     if (!pa->pcm_buf) {

   331         dolog ("Could not allocate buffer (%d bytes)\n",

   332                hw->samples << hw->info.shift);

   333         goto fail2;

   334     }

   335 

   336     if (audio_pt_init (&pa->pt, qpa_thread_out, hw, AUDIO_CAP, AUDIO_FUNC)) {

   337         goto fail3;

   338     }

   339 

   340     return 0;

   341 

   342  fail3:

   343     free (pa->pcm_buf);

   344     pa->pcm_buf = NULL;

   345  fail2:

   346     pa_simple_free (pa->s);

   347     pa->s = NULL;

   348  fail1:

   349     return -1;

   350 }

   351 

   352 static int qpa_init_in (HWVoiceIn *hw, struct audsettings *as)

   353 {

   354     int error;

   355     static pa_sample_spec ss;

   356     struct audsettings obt_as = *as;

   357     PAVoiceIn *pa = (PAVoiceIn *) hw;

   358 

   359     ss.format = audfmt_to_pa (as->fmt, as->endianness);

   360     ss.channels = as->nchannels;

   361     ss.rate = as->freq;

   362 

   363     obt_as.fmt = pa_to_audfmt (ss.format, &obt_as.endianness);

   364 

   365     pa->s = pa_simple_new (

   366         conf.server,

   367         "qemu",

   368         PA_STREAM_RECORD,

   369         conf.source,

   370         "pcm.capture",

   371         &ss,

   372         NULL,                   /* channel map */

   373         NULL,                   /* buffering attributes */

   374         &error

   375         );

   376     if (!pa->s) {

   377         qpa_logerr (error, "pa_simple_new for capture failed\n");

   378         goto fail1;

   379     }

   380 

   381     audio_pcm_init_info (&hw->info, &obt_as);

   382     hw->samples = conf.samples;

   383     pa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);

   384     if (!pa->pcm_buf) {

   385         dolog ("Could not allocate buffer (%d bytes)\n",

   386                hw->samples << hw->info.shift);

   387         goto fail2;

   388     }

   389 

   390     if (audio_pt_init (&pa->pt, qpa_thread_in, hw, AUDIO_CAP, AUDIO_FUNC)) {

   391         goto fail3;

   392     }

   393 

   394     return 0;

   395 

   396  fail3:

   397     free (pa->pcm_buf);

   398     pa->pcm_buf = NULL;

   399  fail2:

   400     pa_simple_free (pa->s);

   401     pa->s = NULL;

   402  fail1:

   403     return -1;

   404 }

   405 

   406 static void qpa_fini_out (HWVoiceOut *hw)

   407 {

   408     void *ret;

   409     PAVoiceOut *pa = (PAVoiceOut *) hw;

   410 

   411     audio_pt_lock (&pa->pt, AUDIO_FUNC);

   412     pa->done = 1;

   413     audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);

   414     audio_pt_join (&pa->pt, &ret, AUDIO_FUNC);

   415 

   416     if (pa->s) {

   417         pa_simple_free (pa->s);

   418         pa->s = NULL;

   419     }

   420 

   421     audio_pt_fini (&pa->pt, AUDIO_FUNC);

   422     qemu_free (pa->pcm_buf);

   423     pa->pcm_buf = NULL;

   424 }

   425 

   426 static void qpa_fini_in (HWVoiceIn *hw)

   427 {

   428     void *ret;

   429     PAVoiceIn *pa = (PAVoiceIn *) hw;

   430 

   431     audio_pt_lock (&pa->pt, AUDIO_FUNC);

   432     pa->done = 1;

   433     audio_pt_unlock_and_signal (&pa->pt, AUDIO_FUNC);

   434     audio_pt_join (&pa->pt, &ret, AUDIO_FUNC);

   435 

   436     if (pa->s) {

   437         pa_simple_free (pa->s);

   438         pa->s = NULL;

   439     }

   440 

   441     audio_pt_fini (&pa->pt, AUDIO_FUNC);

   442     qemu_free (pa->pcm_buf);

   443     pa->pcm_buf = NULL;

   444 }

   445 

   446 static int qpa_ctl_out (HWVoiceOut *hw, int cmd, ...)

   447 {

   448     (void) hw;

   449     (void) cmd;

   450     return 0;

   451 }

   452 

   453 static int qpa_ctl_in (HWVoiceIn *hw, int cmd, ...)

   454 {

   455     (void) hw;

   456     (void) cmd;

   457     return 0;

   458 }

   459 

   460 /* common */

   461 static void *qpa_audio_init (void)

   462 {

   463     return &conf;

   464 }

   465 

   466 static void qpa_audio_fini (void *opaque)

   467 {

   468     (void) opaque;

   469 }

   470 

   471 struct audio_option qpa_options[] = {

   472     {"SAMPLES", AUD_OPT_INT, &conf.samples,

   473      "buffer size in samples", NULL, 0},

   474 

   475     {"DIVISOR", AUD_OPT_INT, &conf.divisor,

   476      "threshold divisor", NULL, 0},

   477 

   478     {"SERVER", AUD_OPT_STR, &conf.server,

   479      "server address", NULL, 0},

   480 

   481     {"SINK", AUD_OPT_STR, &conf.sink,

   482      "sink device name", NULL, 0},

   483 

   484     {"SOURCE", AUD_OPT_STR, &conf.source,

   485      "source device name", NULL, 0},

   486 

   487     {NULL, 0, NULL, NULL, NULL, 0}

   488 };

   489 

   490 static struct audio_pcm_ops qpa_pcm_ops = {

   491     qpa_init_out,

   492     qpa_fini_out,

   493     qpa_run_out,

   494     qpa_write,

   495     qpa_ctl_out,

   496     qpa_init_in,

   497     qpa_fini_in,

   498     qpa_run_in,

   499     qpa_read,

   500     qpa_ctl_in

   501 };

   502 

   503 struct audio_driver pa_audio_driver = {

   504     INIT_FIELD (name           = ) "pa",

   505     INIT_FIELD (descr          = ) "http://www.pulseaudio.org/",

   506     INIT_FIELD (options        = ) qpa_options,

   507     INIT_FIELD (init           = ) qpa_audio_init,

   508     INIT_FIELD (fini           = ) qpa_audio_fini,

   509     INIT_FIELD (pcm_ops        = ) &qpa_pcm_ops,

   510     INIT_FIELD (can_be_default = ) 0,

   511     INIT_FIELD (max_voices_out = ) INT_MAX,

   512     INIT_FIELD (max_voices_in  = ) INT_MAX,

   513     INIT_FIELD (voice_size_out = ) sizeof (PAVoiceOut),

   514     INIT_FIELD (voice_size_in  = ) sizeof (PAVoiceIn)

   515 };