1 /*

     2  * QEMU Audio subsystem

     3  *

     4  * Copyright (c) 2003-2005 Vassili Karpov (malc)

     5  *

     6  * Permission is hereby granted, free of charge, to any person obtaining a copy

     7  * of this software and associated documentation files (the "Software"), to deal

     8  * in the Software without restriction, including without limitation the rights

     9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

    10  * copies of the Software, and to permit persons to whom the Software is

    11  * furnished to do so, subject to the following conditions:

    12  *

    13  * The above copyright notice and this permission notice shall be included in

    14  * all copies or substantial portions of the Software.

    15  *

    16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

    19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

    21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

    22  * THE SOFTWARE.

    23  */

    24 #include "hw/hw.h"

    25 #include "audio.h"

    26 #include "console.h"

    27 #include "qemu-timer.h"

    28 #include "sysemu.h"

    29 

    30 #define AUDIO_CAP "audio"

    31 #include "audio_int.h"

    32 

    33 /* #define DEBUG_PLIVE */

    34 /* #define DEBUG_LIVE */

    35 /* #define DEBUG_OUT */

    36 /* #define DEBUG_CAPTURE */

    37 

    38 #define SW_NAME(sw) (sw)->name ? (sw)->name : "unknown"

    39 

    40 static struct audio_driver *drvtab[] = {

    41     AUDIO_DRIVERS

    42     &no_audio_driver,

    43     &wav_audio_driver

    44 };

    45 

    46 struct fixed_settings {

    47     int enabled;

    48     int nb_voices;

    49     int greedy;

    50     struct audsettings settings;

    51 };

    52 

    53 static struct {

    54     struct fixed_settings fixed_out;

    55     struct fixed_settings fixed_in;

    56     union {

    57         int hertz;

    58         int64_t ticks;

    59     } period;

    60     int plive;

    61     int log_to_monitor;

    62 } conf = {

    63     {                           /* DAC fixed settings */

    64         1,                      /* enabled */

    65         1,                      /* nb_voices */

    66         1,                      /* greedy */

    67         {

    68             44100,              /* freq */

    69             2,                  /* nchannels */

    70             AUD_FMT_S16,        /* fmt */

    71             AUDIO_HOST_ENDIANNESS

    72         }

    73     },

    74 

    75     {                           /* ADC fixed settings */

    76         1,                      /* enabled */

    77         1,                      /* nb_voices */

    78         1,                      /* greedy */

    79         {

    80             44100,              /* freq */

    81             2,                  /* nchannels */

    82             AUD_FMT_S16,        /* fmt */

    83             AUDIO_HOST_ENDIANNESS

    84         }

    85     },

    86 

    87     { 250 },                    /* period */

    88     0,                          /* plive */

    89     0                           /* log_to_monitor */

    90 };

    91 

    92 static AudioState glob_audio_state;

    93 

    94 struct mixeng_volume nominal_volume = {

    95     0,

    96 #ifdef FLOAT_MIXENG

    97     1.0,

    98     1.0

    99 #else

   100     1ULL << 32,

   101     1ULL << 32

   102 #endif

   103 };

   104 

   105 /* http://www.df.lth.se/~john_e/gems/gem002d.html */

   106 /* http://www.multi-platforms.com/Tips/PopCount.htm */

   107 uint32_t popcount (uint32_t u)

   108 {

   109     u = ((u&0x55555555) + ((u>>1)&0x55555555));

   110     u = ((u&0x33333333) + ((u>>2)&0x33333333));

   111     u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));

   112     u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));

   113     u = ( u&0x0000ffff) + (u>>16);

   114     return u;

   115 }

   116 

   117 inline uint32_t lsbindex (uint32_t u)

   118 {

   119     return popcount ((u&-u)-1);

   120 }

   121 

   122 #ifdef AUDIO_IS_FLAWLESS_AND_NO_CHECKS_ARE_REQURIED

   123 #error No its not

   124 #else

   125 int audio_bug (const char *funcname, int cond)

   126 {

   127     if (cond) {

   128         static int shown;

   129 

   130         AUD_log (NULL, "A bug was just triggered in %s\n", funcname);

   131         if (!shown) {

   132             shown = 1;

   133             AUD_log (NULL, "Save all your work and restart without audio\n");

   134             AUD_log (NULL, "Please send bug report to malc@pulsesoft.com\n");

   135             AUD_log (NULL, "I am sorry\n");

   136         }

   137         AUD_log (NULL, "Context:\n");

   138 

   139 #if defined AUDIO_BREAKPOINT_ON_BUG

   140 #  if defined HOST_I386

   141 #    if defined __GNUC__

   142         __asm__ ("int3");

   143 #    elif defined _MSC_VER

   144         _asm _emit 0xcc;

   145 #    else

   146         abort ();

   147 #    endif

   148 #  else

   149         abort ();

   150 #  endif

   151 #endif

   152     }

   153 

   154     return cond;

   155 }

   156 #endif

   157 

   158 static inline int audio_bits_to_index (int bits)

   159 {

   160     switch (bits) {

   161     case 8:

   162         return 0;

   163 

   164     case 16:

   165         return 1;

   166 

   167     case 32:

   168         return 2;

   169 

   170     default:

   171         audio_bug ("bits_to_index", 1);

   172         AUD_log (NULL, "invalid bits %d\n", bits);

   173         return 0;

   174     }

   175 }

   176 

   177 void *audio_calloc (const char *funcname, int nmemb, size_t size)

   178 {

   179     int cond;

   180     size_t len;

   181 

   182     len = nmemb * size;

   183     cond = !nmemb || !size;

   184     cond |= nmemb < 0;

   185     cond |= len < size;

   186 

   187     if (audio_bug ("audio_calloc", cond)) {

   188         AUD_log (NULL, "%s passed invalid arguments to audio_calloc\n",

   189                  funcname);

   190         AUD_log (NULL, "nmemb=%d size=%zu (len=%zu)\n", nmemb, size, len);

   191         return NULL;

   192     }

   193 

   194     return qemu_mallocz (len);

   195 }

   196 

   197 static char *audio_alloc_prefix (const char *s)

   198 {

   199     const char qemu_prefix[] = "QEMU_";

   200     size_t len;

   201     char *r;

   202 

   203     if (!s) {

   204         return NULL;

   205     }

   206 

   207     len = strlen (s);

   208     r = qemu_malloc (len + sizeof (qemu_prefix));

   209 

   210     if (r) {

   211         size_t i;

   212         char *u = r + sizeof (qemu_prefix) - 1;

   213 

   214         pstrcpy (r, len + sizeof (qemu_prefix), qemu_prefix);

   215         pstrcat (r, len + sizeof (qemu_prefix), s);

   216 

   217         for (i = 0; i < len; ++i) {

   218             u[i] = qemu_toupper(u[i]);

   219         }

   220     }

   221     return r;

   222 }

   223 

   224 static const char *audio_audfmt_to_string (audfmt_e fmt)

   225 {

   226     switch (fmt) {

   227     case AUD_FMT_U8:

   228         return "U8";

   229 

   230     case AUD_FMT_U16:

   231         return "U16";

   232 

   233     case AUD_FMT_S8:

   234         return "S8";

   235 

   236     case AUD_FMT_S16:

   237         return "S16";

   238 

   239     case AUD_FMT_U32:

   240         return "U32";

   241 

   242     case AUD_FMT_S32:

   243         return "S32";

   244     }

   245 

   246     dolog ("Bogus audfmt %d returning S16\n", fmt);

   247     return "S16";

   248 }

   249 

   250 static audfmt_e audio_string_to_audfmt (const char *s, audfmt_e defval,

   251                                         int *defaultp)

   252 {

   253     if (!strcasecmp (s, "u8")) {

   254         *defaultp = 0;

   255         return AUD_FMT_U8;

   256     }

   257     else if (!strcasecmp (s, "u16")) {

   258         *defaultp = 0;

   259         return AUD_FMT_U16;

   260     }

   261     else if (!strcasecmp (s, "u32")) {

   262         *defaultp = 0;

   263         return AUD_FMT_U32;

   264     }

   265     else if (!strcasecmp (s, "s8")) {

   266         *defaultp = 0;

   267         return AUD_FMT_S8;

   268     }

   269     else if (!strcasecmp (s, "s16")) {

   270         *defaultp = 0;

   271         return AUD_FMT_S16;

   272     }

   273     else if (!strcasecmp (s, "s32")) {

   274         *defaultp = 0;

   275         return AUD_FMT_S32;

   276     }

   277     else {

   278         dolog ("Bogus audio format `%s' using %s\n",

   279                s, audio_audfmt_to_string (defval));

   280         *defaultp = 1;

   281         return defval;

   282     }

   283 }

   284 

   285 static audfmt_e audio_get_conf_fmt (const char *envname,

   286                                     audfmt_e defval,

   287                                     int *defaultp)

   288 {

   289     const char *var = getenv (envname);

   290     if (!var) {

   291         *defaultp = 1;

   292         return defval;

   293     }

   294     return audio_string_to_audfmt (var, defval, defaultp);

   295 }

   296 

   297 static int audio_get_conf_int (const char *key, int defval, int *defaultp)

   298 {

   299     int val;

   300     char *strval;

   301 

   302     strval = getenv (key);

   303     if (strval) {

   304         *defaultp = 0;

   305         val = atoi (strval);

   306         return val;

   307     }

   308     else {

   309         *defaultp = 1;

   310         return defval;

   311     }

   312 }

   313 

   314 static const char *audio_get_conf_str (const char *key,

   315                                        const char *defval,

   316                                        int *defaultp)

   317 {

   318     const char *val = getenv (key);

   319     if (!val) {

   320         *defaultp = 1;

   321         return defval;

   322     }

   323     else {

   324         *defaultp = 0;

   325         return val;

   326     }

   327 }

   328 

   329 void AUD_vlog (const char *cap, const char *fmt, va_list ap)

   330 {

   331     if (conf.log_to_monitor) {

   332         if (cap) {

   333             term_printf ("%s: ", cap);

   334         }

   335 

   336         term_vprintf (fmt, ap);

   337     }

   338     else {

   339         if (cap) {

   340             fprintf (stderr, "%s: ", cap);

   341         }

   342 

   343         vfprintf (stderr, fmt, ap);

   344     }

   345 }

   346 

   347 void AUD_log (const char *cap, const char *fmt, ...)

   348 {

   349     va_list ap;

   350 

   351     va_start (ap, fmt);

   352     AUD_vlog (cap, fmt, ap);

   353     va_end (ap);

   354 }

   355 

   356 static void audio_print_options (const char *prefix,

   357                                  struct audio_option *opt)

   358 {

   359     char *uprefix;

   360 

   361     if (!prefix) {

   362         dolog ("No prefix specified\n");

   363         return;

   364     }

   365 

   366     if (!opt) {

   367         dolog ("No options\n");

   368         return;

   369     }

   370 

   371     uprefix = audio_alloc_prefix (prefix);

   372 

   373     for (; opt->name; opt++) {

   374         const char *state = "default";

   375         printf ("  %s_%s: ", uprefix, opt->name);

   376 

   377         if (opt->overriddenp && *opt->overriddenp) {

   378             state = "current";

   379         }

   380 

   381         switch (opt->tag) {

   382         case AUD_OPT_BOOL:

   383             {

   384                 int *intp = opt->valp;

   385                 printf ("boolean, %s = %d\n", state, *intp ? 1 : 0);

   386             }

   387             break;

   388 

   389         case AUD_OPT_INT:

   390             {

   391                 int *intp = opt->valp;

   392                 printf ("integer, %s = %d\n", state, *intp);

   393             }

   394             break;

   395 

   396         case AUD_OPT_FMT:

   397             {

   398                 audfmt_e *fmtp = opt->valp;

   399                 printf (

   400                     "format, %s = %s, (one of: U8 S8 U16 S16 U32 S32)\n",

   401                     state,

   402                     audio_audfmt_to_string (*fmtp)

   403                     );

   404             }

   405             break;

   406 

   407         case AUD_OPT_STR:

   408             {

   409                 const char **strp = opt->valp;

   410                 printf ("string, %s = %s\n",

   411                         state,

   412                         *strp ? *strp : "(not set)");

   413             }

   414             break;

   415 

   416         default:

   417             printf ("???\n");

   418             dolog ("Bad value tag for option %s_%s %d\n",

   419                    uprefix, opt->name, opt->tag);

   420             break;

   421         }

   422         printf ("    %s\n", opt->descr);

   423     }

   424 

   425     qemu_free (uprefix);

   426 }

   427 

   428 static void audio_process_options (const char *prefix,

   429                                    struct audio_option *opt)

   430 {

   431     char *optname;

   432     const char qemu_prefix[] = "QEMU_";

   433     size_t preflen, optlen;

   434 

   435     if (audio_bug (AUDIO_FUNC, !prefix)) {

   436         dolog ("prefix = NULL\n");

   437         return;

   438     }

   439 

   440     if (audio_bug (AUDIO_FUNC, !opt)) {

   441         dolog ("opt = NULL\n");

   442         return;

   443     }

   444 

   445     preflen = strlen (prefix);

   446 

   447     for (; opt->name; opt++) {

   448         size_t len, i;

   449         int def;

   450 

   451         if (!opt->valp) {

   452             dolog ("Option value pointer for `%s' is not set\n",

   453                    opt->name);

   454             continue;

   455         }

   456 

   457         len = strlen (opt->name);

   458         /* len of opt->name + len of prefix + size of qemu_prefix

   459          * (includes trailing zero) + zero + underscore (on behalf of

   460          * sizeof) */

   461         optlen = len + preflen + sizeof (qemu_prefix) + 1;

   462         optname = qemu_malloc (optlen);

   463         if (!optname) {

   464             dolog ("Could not allocate memory for option name `%s'\n",

   465                    opt->name);

   466             continue;

   467         }

   468 

   469         pstrcpy (optname, optlen, qemu_prefix);

   470 

   471         /* copy while upper-casing, including trailing zero */

   472         for (i = 0; i <= preflen; ++i) {

   473             optname[i + sizeof (qemu_prefix) - 1] = qemu_toupper(prefix[i]);

   474         }

   475         pstrcat (optname, optlen, "_");

   476         pstrcat (optname, optlen, opt->name);

   477 

   478         def = 1;

   479         switch (opt->tag) {

   480         case AUD_OPT_BOOL:

   481         case AUD_OPT_INT:

   482             {

   483                 int *intp = opt->valp;

   484                 *intp = audio_get_conf_int (optname, *intp, &def);

   485             }

   486             break;

   487 

   488         case AUD_OPT_FMT:

   489             {

   490                 audfmt_e *fmtp = opt->valp;

   491                 *fmtp = audio_get_conf_fmt (optname, *fmtp, &def);

   492             }

   493             break;

   494 

   495         case AUD_OPT_STR:

   496             {

   497                 const char **strp = opt->valp;

   498                 *strp = audio_get_conf_str (optname, *strp, &def);

   499             }

   500             break;

   501 

   502         default:

   503             dolog ("Bad value tag for option `%s' - %d\n",

   504                    optname, opt->tag);

   505             break;

   506         }

   507 

   508         if (!opt->overriddenp) {

   509             opt->overriddenp = &opt->overridden;

   510         }

   511         *opt->overriddenp = !def;

   512         qemu_free (optname);

   513     }

   514 }

   515 

   516 static void audio_print_settings (struct audsettings *as)

   517 {

   518     dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels);

   519 

   520     switch (as->fmt) {

   521     case AUD_FMT_S8:

   522         AUD_log (NULL, "S8");

   523         break;

   524     case AUD_FMT_U8:

   525         AUD_log (NULL, "U8");

   526         break;

   527     case AUD_FMT_S16:

   528         AUD_log (NULL, "S16");

   529         break;

   530     case AUD_FMT_U16:

   531         AUD_log (NULL, "U16");

   532         break;

   533     case AUD_FMT_S32:

   534         AUD_log (NULL, "S32");

   535         break;

   536     case AUD_FMT_U32:

   537         AUD_log (NULL, "U32");

   538         break;

   539     default:

   540         AUD_log (NULL, "invalid(%d)", as->fmt);

   541         break;

   542     }

   543 

   544     AUD_log (NULL, " endianness=");

   545     switch (as->endianness) {

   546     case 0:

   547         AUD_log (NULL, "little");

   548         break;

   549     case 1:

   550         AUD_log (NULL, "big");

   551         break;

   552     default:

   553         AUD_log (NULL, "invalid");

   554         break;

   555     }

   556     AUD_log (NULL, "\n");

   557 }

   558 

   559 static int audio_validate_settings (struct audsettings *as)

   560 {

   561     int invalid;

   562 

   563     invalid = as->nchannels != 1 && as->nchannels != 2;

   564     invalid |= as->endianness != 0 && as->endianness != 1;

   565 

   566     switch (as->fmt) {

   567     case AUD_FMT_S8:

   568     case AUD_FMT_U8:

   569     case AUD_FMT_S16:

   570     case AUD_FMT_U16:

   571     case AUD_FMT_S32:

   572     case AUD_FMT_U32:

   573         break;

   574     default:

   575         invalid = 1;

   576         break;

   577     }

   578 

   579     invalid |= as->freq <= 0;

   580     return invalid ? -1 : 0;

   581 }

   582 

   583 static int audio_pcm_info_eq (struct audio_pcm_info *info, struct audsettings *as)

   584 {

   585     int bits = 8, sign = 0;

   586 

   587     switch (as->fmt) {

   588     case AUD_FMT_S8:

   589         sign = 1;

   590     case AUD_FMT_U8:

   591         break;

   592 

   593     case AUD_FMT_S16:

   594         sign = 1;

   595     case AUD_FMT_U16:

   596         bits = 16;

   597         break;

   598 

   599     case AUD_FMT_S32:

   600         sign = 1;

   601     case AUD_FMT_U32:

   602         bits = 32;

   603         break;

   604     }

   605     return info->freq == as->freq

   606         && info->nchannels == as->nchannels

   607         && info->sign == sign

   608         && info->bits == bits

   609         && info->swap_endianness == (as->endianness != AUDIO_HOST_ENDIANNESS);

   610 }

   611 

   612 void audio_pcm_init_info (struct audio_pcm_info *info, struct audsettings *as)

   613 {

   614     int bits = 8, sign = 0, shift = 0;

   615 

   616     switch (as->fmt) {

   617     case AUD_FMT_S8:

   618         sign = 1;

   619     case AUD_FMT_U8:

   620         break;

   621 

   622     case AUD_FMT_S16:

   623         sign = 1;

   624     case AUD_FMT_U16:

   625         bits = 16;

   626         shift = 1;

   627         break;

   628 

   629     case AUD_FMT_S32:

   630         sign = 1;

   631     case AUD_FMT_U32:

   632         bits = 32;

   633         shift = 2;

   634         break;

   635     }

   636 

   637     info->freq = as->freq;

   638     info->bits = bits;

   639     info->sign = sign;

   640     info->nchannels = as->nchannels;

   641     info->shift = (as->nchannels == 2) + shift;

   642     info->align = (1 << info->shift) - 1;

   643     info->bytes_per_second = info->freq << info->shift;

   644     info->swap_endianness = (as->endianness != AUDIO_HOST_ENDIANNESS);

   645 }

   646 

   647 void audio_pcm_info_clear_buf (struct audio_pcm_info *info, void *buf, int len)

   648 {

   649     if (!len) {

   650         return;

   651     }

   652 

   653     if (info->sign) {

   654         memset (buf, 0x00, len << info->shift);

   655     }

   656     else {

   657         switch (info->bits) {

   658         case 8:

   659             memset (buf, 0x80, len << info->shift);

   660             break;

   661 

   662         case 16:

   663             {

   664                 int i;

   665                 uint16_t *p = buf;

   666                 int shift = info->nchannels - 1;

   667                 short s = INT16_MAX;

   668 

   669                 if (info->swap_endianness) {

   670                     s = bswap16 (s);

   671                 }

   672 

   673                 for (i = 0; i < len << shift; i++) {

   674                     p[i] = s;

   675                 }

   676             }

   677             break;

   678 

   679         case 32:

   680             {

   681                 int i;

   682                 uint32_t *p = buf;

   683                 int shift = info->nchannels - 1;

   684                 int32_t s = INT32_MAX;

   685 

   686                 if (info->swap_endianness) {

   687                     s = bswap32 (s);

   688                 }

   689 

   690                 for (i = 0; i < len << shift; i++) {

   691                     p[i] = s;

   692                 }

   693             }

   694             break;

   695 

   696         default:

   697             AUD_log (NULL, "audio_pcm_info_clear_buf: invalid bits %d\n",

   698                      info->bits);

   699             break;

   700         }

   701     }

   702 }

   703 

   704 /*

   705  * Capture

   706  */

   707 static void noop_conv (struct st_sample *dst, const void *src,

   708                        int samples, struct mixeng_volume *vol)

   709 {

   710     (void) src;

   711     (void) dst;

   712     (void) samples;

   713     (void) vol;

   714 }

   715 

   716 static CaptureVoiceOut *audio_pcm_capture_find_specific (

   717     AudioState *s,

   718     struct audsettings *as

   719     )

   720 {

   721     CaptureVoiceOut *cap;

   722 

   723     for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {

   724         if (audio_pcm_info_eq (&cap->hw.info, as)) {

   725             return cap;

   726         }

   727     }

   728     return NULL;

   729 }

   730 

   731 static void audio_notify_capture (CaptureVoiceOut *cap, audcnotification_e cmd)

   732 {

   733     struct capture_callback *cb;

   734 

   735 #ifdef DEBUG_CAPTURE

   736     dolog ("notification %d sent\n", cmd);

   737 #endif

   738     for (cb = cap->cb_head.lh_first; cb; cb = cb->entries.le_next) {

   739         cb->ops.notify (cb->opaque, cmd);

   740     }

   741 }

   742 

   743 static void audio_capture_maybe_changed (CaptureVoiceOut *cap, int enabled)

   744 {

   745     if (cap->hw.enabled != enabled) {

   746         audcnotification_e cmd;

   747         cap->hw.enabled = enabled;

   748         cmd = enabled ? AUD_CNOTIFY_ENABLE : AUD_CNOTIFY_DISABLE;

   749         audio_notify_capture (cap, cmd);

   750     }

   751 }

   752 

   753 static void audio_recalc_and_notify_capture (CaptureVoiceOut *cap)

   754 {

   755     HWVoiceOut *hw = &cap->hw;

   756     SWVoiceOut *sw;

   757     int enabled = 0;

   758 

   759     for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {

   760         if (sw->active) {

   761             enabled = 1;

   762             break;

   763         }

   764     }

   765     audio_capture_maybe_changed (cap, enabled);

   766 }

   767 

   768 static void audio_detach_capture (HWVoiceOut *hw)

   769 {

   770     SWVoiceCap *sc = hw->cap_head.lh_first;

   771 

   772     while (sc) {

   773         SWVoiceCap *sc1 = sc->entries.le_next;

   774         SWVoiceOut *sw = &sc->sw;

   775         CaptureVoiceOut *cap = sc->cap;

   776         int was_active = sw->active;

   777 

   778         if (sw->rate) {

   779             st_rate_stop (sw->rate);

   780             sw->rate = NULL;

   781         }

   782 

   783         LIST_REMOVE (sw, entries);

   784         LIST_REMOVE (sc, entries);

   785         qemu_free (sc);

   786         if (was_active) {

   787             /* We have removed soft voice from the capture:

   788                this might have changed the overall status of the capture

   789                since this might have been the only active voice */

   790             audio_recalc_and_notify_capture (cap);

   791         }

   792         sc = sc1;

   793     }

   794 }

   795 

   796 static int audio_attach_capture (AudioState *s, HWVoiceOut *hw)

   797 {

   798     CaptureVoiceOut *cap;

   799 

   800     audio_detach_capture (hw);

   801     for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {

   802         SWVoiceCap *sc;

   803         SWVoiceOut *sw;

   804         HWVoiceOut *hw_cap = &cap->hw;

   805 

   806         sc = audio_calloc (AUDIO_FUNC, 1, sizeof (*sc));

   807         if (!sc) {

   808             dolog ("Could not allocate soft capture voice (%zu bytes)\n",

   809                    sizeof (*sc));

   810             return -1;

   811         }

   812 

   813         sc->cap = cap;

   814         sw = &sc->sw;

   815         sw->hw = hw_cap;

   816         sw->info = hw->info;

   817         sw->empty = 1;

   818         sw->active = hw->enabled;

   819         sw->conv = noop_conv;

   820         sw->ratio = ((int64_t) hw_cap->info.freq << 32) / sw->info.freq;

   821         sw->rate = st_rate_start (sw->info.freq, hw_cap->info.freq);

   822         if (!sw->rate) {

   823             dolog ("Could not start rate conversion for `%s'\n", SW_NAME (sw));

   824             qemu_free (sw);

   825             return -1;

   826         }

   827         LIST_INSERT_HEAD (&hw_cap->sw_head, sw, entries);

   828         LIST_INSERT_HEAD (&hw->cap_head, sc, entries);

   829 #ifdef DEBUG_CAPTURE

   830         asprintf (&sw->name, "for %p %d,%d,%d",

   831                   hw, sw->info.freq, sw->info.bits, sw->info.nchannels);

   832         dolog ("Added %s active = %d\n", sw->name, sw->active);

   833 #endif

   834         if (sw->active) {

   835             audio_capture_maybe_changed (cap, 1);

   836         }

   837     }

   838     return 0;

   839 }

   840 

   841 /*

   842  * Hard voice (capture)

   843  */

   844 static int audio_pcm_hw_find_min_in (HWVoiceIn *hw)

   845 {

   846     SWVoiceIn *sw;

   847     int m = hw->total_samples_captured;

   848 

   849     for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {

   850         if (sw->active) {

   851             m = audio_MIN (m, sw->total_hw_samples_acquired);

   852         }

   853     }

   854     return m;

   855 }

   856 

   857 int audio_pcm_hw_get_live_in (HWVoiceIn *hw)

   858 {

   859     int live = hw->total_samples_captured - audio_pcm_hw_find_min_in (hw);

   860     if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {

   861         dolog ("live=%d hw->samples=%d\n", live, hw->samples);

   862         return 0;

   863     }

   864     return live;

   865 }

   866 

   867 /*

   868  * Soft voice (capture)

   869  */

   870 static int audio_pcm_sw_get_rpos_in (SWVoiceIn *sw)

   871 {

   872     HWVoiceIn *hw = sw->hw;

   873     int live = hw->total_samples_captured - sw->total_hw_samples_acquired;

   874     int rpos;

   875 

   876     if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {

   877         dolog ("live=%d hw->samples=%d\n", live, hw->samples);

   878         return 0;

   879     }

   880 

   881     rpos = hw->wpos - live;

   882     if (rpos >= 0) {

   883         return rpos;

   884     }

   885     else {

   886         return hw->samples + rpos;

   887     }

   888 }

   889 

   890 int audio_pcm_sw_read (SWVoiceIn *sw, void *buf, int size)

   891 {

   892     HWVoiceIn *hw = sw->hw;

   893     int samples, live, ret = 0, swlim, isamp, osamp, rpos, total = 0;

   894     struct st_sample *src, *dst = sw->buf;

   895 

   896     rpos = audio_pcm_sw_get_rpos_in (sw) % hw->samples;

   897 

   898     live = hw->total_samples_captured - sw->total_hw_samples_acquired;

   899     if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {

   900         dolog ("live_in=%d hw->samples=%d\n", live, hw->samples);

   901         return 0;

   902     }

   903 

   904     samples = size >> sw->info.shift;

   905     if (!live) {

   906         return 0;

   907     }

   908 

   909     swlim = (live * sw->ratio) >> 32;

   910     swlim = audio_MIN (swlim, samples);

   911 

   912     while (swlim) {

   913         src = hw->conv_buf + rpos;

   914         isamp = hw->wpos - rpos;

   915         /* XXX: <= ? */

   916         if (isamp <= 0) {

   917             isamp = hw->samples - rpos;

   918         }

   919 

   920         if (!isamp) {

   921             break;

   922         }

   923         osamp = swlim;

   924 

   925         if (audio_bug (AUDIO_FUNC, osamp < 0)) {

   926             dolog ("osamp=%d\n", osamp);

   927             return 0;

   928         }

   929 

   930         st_rate_flow (sw->rate, src, dst, &isamp, &osamp);

   931         swlim -= osamp;

   932         rpos = (rpos + isamp) % hw->samples;

   933         dst += osamp;

   934         ret += osamp;

   935         total += isamp;

   936     }

   937 

   938     sw->clip (buf, sw->buf, ret);

   939     sw->total_hw_samples_acquired += total;

   940     return ret << sw->info.shift;

   941 }

   942 

   943 /*

   944  * Hard voice (playback)

   945  */

   946 static int audio_pcm_hw_find_min_out (HWVoiceOut *hw, int *nb_livep)

   947 {

   948     SWVoiceOut *sw;

   949     int m = INT_MAX;

   950     int nb_live = 0;

   951 

   952     for (sw = hw->sw_head.lh_first; sw; sw = sw->entries.le_next) {

   953         if (sw->active || !sw->empty) {

   954             m = audio_MIN (m, sw->total_hw_samples_mixed);

   955             nb_live += 1;

   956         }

   957     }

   958 

   959     *nb_livep = nb_live;

   960     return m;

   961 }

   962 

   963 int audio_pcm_hw_get_live_out2 (HWVoiceOut *hw, int *nb_live)

   964 {

   965     int smin;

   966 

   967     smin = audio_pcm_hw_find_min_out (hw, nb_live);

   968 

   969     if (!*nb_live) {

   970         return 0;

   971     }

   972     else {

   973         int live = smin;

   974 

   975         if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {

   976             dolog ("live=%d hw->samples=%d\n", live, hw->samples);

   977             return 0;

   978         }

   979         return live;

   980     }

   981 }

   982 

   983 int audio_pcm_hw_get_live_out (HWVoiceOut *hw)

   984 {

   985     int nb_live;

   986     int live;

   987 

   988     live = audio_pcm_hw_get_live_out2 (hw, &nb_live);

   989     if (audio_bug (AUDIO_FUNC, live < 0 || live > hw->samples)) {

   990         dolog ("live=%d hw->samples=%d\n", live, hw->samples);

   991         return 0;

   992     }

   993     return live;

   994 }

   995 

   996 /*

   997  * Soft voice (playback)

   998  */

   999 int audio_pcm_sw_write (SWVoiceOut *sw, void *buf, int size)

  1000 {

  1001     int hwsamples, samples, isamp, osamp, wpos, live, dead, left, swlim, blck;

  1002     int ret = 0, pos = 0, total = 0;

  1003 

  1004     if (!sw) {

  1005         return size;

  1006     }

  1007 

  1008     hwsamples = sw->hw->samples;

  1009 

  1010     live = sw->total_hw_samples_mixed;

  1011     if (audio_bug (AUDIO_FUNC, live < 0 || live > hwsamples)){

  1012         dolog ("live=%d hw->samples=%d\n", live, hwsamples);

  1013         return 0;

  1014     }

  1015 

  1016     if (live == hwsamples) {

  1017 #ifdef DEBUG_OUT

  1018         dolog ("%s is full %d\n", sw->name, live);

  1019 #endif

  1020         return 0;

  1021     }

  1022 

  1023     wpos = (sw->hw->rpos + live) % hwsamples;

  1024     samples = size >> sw->info.shift;

  1025 

  1026     dead = hwsamples - live;

  1027     swlim = ((int64_t) dead << 32) / sw->ratio;

  1028     swlim = audio_MIN (swlim, samples);

  1029     if (swlim) {

  1030         sw->conv (sw->buf, buf, swlim, &sw->vol);

  1031     }

  1032 

  1033     while (swlim) {

  1034         dead = hwsamples - live;

  1035         left = hwsamples - wpos;

  1036         blck = audio_MIN (dead, left);

  1037         if (!blck) {

  1038             break;

  1039         }

  1040         isamp = swlim;

  1041         osamp = blck;

  1042         st_rate_flow_mix (

  1043             sw->rate,

  1044             sw->buf + pos,

  1045             sw->hw->mix_buf + wpos,

  1046             &isamp,

  1047             &osamp

  1048             );

  1049         ret += isamp;

  1050         swlim -= isamp;

  1051         pos += isamp;

  1052         live += osamp;

  1053         wpos = (wpos + osamp) % hwsamples;

  1054         total += osamp;

  1055     }

  1056 

  1057     sw->total_hw_samples_mixed += total;

  1058     sw->empty = sw->total_hw_samples_mixed == 0;

  1059 

  1060 #ifdef DEBUG_OUT

  1061     dolog (

  1062         "%s: write size %d ret %d total sw %d\n",

  1063         SW_NAME (sw),

  1064         size >> sw->info.shift,

  1065         ret,

  1066         sw->total_hw_samples_mixed

  1067         );

  1068 #endif

  1069 

  1070     return ret << sw->info.shift;

  1071 }

  1072 

  1073 #ifdef DEBUG_AUDIO

  1074 static void audio_pcm_print_info (const char *cap, struct audio_pcm_info *info)

  1075 {

  1076     dolog ("%s: bits %d, sign %d, freq %d, nchan %d\n",

  1077            cap, info->bits, info->sign, info->freq, info->nchannels);

  1078 }

  1079 #endif

  1080 

  1081 #define DAC

  1082 #include "audio_template.h"

  1083 #undef DAC

  1084 #include "audio_template.h"

  1085 

  1086 int AUD_write (SWVoiceOut *sw, void *buf, int size)

  1087 {

  1088     int bytes;

  1089 

  1090     if (!sw) {

  1091         /* XXX: Consider options */

  1092         return size;

  1093     }

  1094 

  1095     if (!sw->hw->enabled) {

  1096         dolog ("Writing to disabled voice %s\n", SW_NAME (sw));

  1097         return 0;

  1098     }

  1099 

  1100     bytes = sw->hw->pcm_ops->write (sw, buf, size);

  1101     return bytes;

  1102 }

  1103 

  1104 int AUD_read (SWVoiceIn *sw, void *buf, int size)

  1105 {

  1106     int bytes;

  1107 

  1108     if (!sw) {

  1109         /* XXX: Consider options */

  1110         return size;

  1111     }

  1112 

  1113     if (!sw->hw->enabled) {

  1114         dolog ("Reading from disabled voice %s\n", SW_NAME (sw));

  1115         return 0;

  1116     }

  1117 

  1118     bytes = sw->hw->pcm_ops->read (sw, buf, size);

  1119     return bytes;

  1120 }

  1121 

  1122 int AUD_get_buffer_size_out (SWVoiceOut *sw)

  1123 {

  1124     return sw->hw->samples << sw->hw->info.shift;

  1125 }

  1126 

  1127 void AUD_set_active_out (SWVoiceOut *sw, int on)

  1128 {

  1129     HWVoiceOut *hw;

  1130 

  1131     if (!sw) {

  1132         return;

  1133     }

  1134 

  1135     hw = sw->hw;