audio/fmodaudio.c

   1 /*
   2  * QEMU FMOD audio driver
   3  *
   4  * Copyright (c) 2004-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 <fmod.h>
  25 #include <fmod_errors.h>
  26 #include "vl.h"
  27
  28 #define AUDIO_CAP "fmod"
  29 #include "audio_int.h"
  30
  31 typedef struct FMODVoiceOut {
  32     HWVoiceOut hw;
  33     unsigned int old_pos;
  34     FSOUND_SAMPLE *fmod_sample;
  35     int channel;
  36 } FMODVoiceOut;
  37
  38 typedef struct FMODVoiceIn {
  39     HWVoiceIn hw;
  40     FSOUND_SAMPLE *fmod_sample;
  41 } FMODVoiceIn;
  42
  43 static struct {
  44     const char *drvname;
  45     int nb_samples;
  46     int freq;
  47     int nb_channels;
  48     int bufsize;
  49     int threshold;
  50     int broken_adc;
  51 } conf = {
  52     NULL,
  53     2048 * 2,
  54     44100,
  55     2,
  56     0,
  57     0,
  58     0
  59 };
  60
  61 static void GCC_FMT_ATTR (1, 2) fmod_logerr (const char *fmt, ...)
  62 {
  63     va_list ap;
  64
  65     va_start (ap, fmt);
  66     AUD_vlog (AUDIO_CAP, fmt, ap);
  67     va_end (ap);
  68
  69     AUD_log (AUDIO_CAP, "Reason: %s\n",
  70              FMOD_ErrorString (FSOUND_GetError ()));
  71 }
  72
  73 static void GCC_FMT_ATTR (2, 3) fmod_logerr2 (
  74     const char *typ,
  75     const char *fmt,
  76     ...
  77     )
  78 {
  79     va_list ap;
  80
  81     AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
  82
  83     va_start (ap, fmt);
  84     AUD_vlog (AUDIO_CAP, fmt, ap);
  85     va_end (ap);
  86
  87     AUD_log (AUDIO_CAP, "Reason: %s\n",
  88              FMOD_ErrorString (FSOUND_GetError ()));
  89 }
  90
  91 static int fmod_write (SWVoiceOut *sw, void *buf, int len)
  92 {
  93     return audio_pcm_sw_write (sw, buf, len);
  94 }
  95
  96 static void fmod_clear_sample (FMODVoiceOut *fmd)
  97 {
  98     HWVoiceOut *hw = &fmd->hw;
  99     int status;
 100     void *p1 = 0, *p2 = 0;
 101     unsigned int len1 = 0, len2 = 0;
 102
 103     status = FSOUND_Sample_Lock (
 104         fmd->fmod_sample,
 105         0,
 106         hw->samples << hw->info.shift,
 107         &p1,
 108         &p2,
 109         &len1,
 110         &len2
 111         );
 112
 113     if (!status) {
 114         fmod_logerr ("Failed to lock sample\n");
 115         return;
 116     }
 117
 118     if ((len1 & hw->info.align) || (len2 & hw->info.align)) {
 119         dolog ("Lock returned misaligned length %d, %d, alignment %d\n",
 120                len1, len2, hw->info.align + 1);
 121         goto fail;
 122     }
 123
 124     if ((len1 + len2) - (hw->samples << hw->info.shift)) {
 125         dolog ("Lock returned incomplete length %d, %d\n",
 126                len1 + len2, hw->samples << hw->info.shift);
 127         goto fail;
 128     }
 129
 130     audio_pcm_info_clear_buf (&hw->info, p1, hw->samples);
 131
 132  fail:
 133     status = FSOUND_Sample_Unlock (fmd->fmod_sample, p1, p2, len1, len2);
 134     if (!status) {
 135         fmod_logerr ("Failed to unlock sample\n");
 136     }
 137 }
 138
 139 static void fmod_write_sample (HWVoiceOut *hw, uint8_t *dst, int dst_len)
 140 {
 141     int src_len1 = dst_len;
 142     int src_len2 = 0;
 143     int pos = hw->rpos + dst_len;
 144     st_sample_t *src1 = hw->mix_buf + hw->rpos;
 145     st_sample_t *src2 = NULL;
 146
 147     if (pos > hw->samples) {
 148         src_len1 = hw->samples - hw->rpos;
 149         src2 = hw->mix_buf;
 150         src_len2 = dst_len - src_len1;
 151         pos = src_len2;
 152     }
 153
 154     if (src_len1) {
 155         hw->clip (dst, src1, src_len1);
 156     }
 157
 158     if (src_len2) {
 159         dst = advance (dst, src_len1 << hw->info.shift);
 160         hw->clip (dst, src2, src_len2);
 161     }
 162
 163     hw->rpos = pos % hw->samples;
 164 }
 165
 166 static int fmod_unlock_sample (FSOUND_SAMPLE *sample, void *p1, void *p2,
 167                                unsigned int blen1, unsigned int blen2)
 168 {
 169     int status = FSOUND_Sample_Unlock (sample, p1, p2, blen1, blen2);
 170     if (!status) {
 171         fmod_logerr ("Failed to unlock sample\n");
 172         return -1;
 173     }
 174     return 0;
 175 }
 176
 177 static int fmod_lock_sample (
 178     FSOUND_SAMPLE *sample,
 179     struct audio_pcm_info *info,
 180     int pos,
 181     int len,
 182     void **p1,
 183     void **p2,
 184     unsigned int *blen1,
 185     unsigned int *blen2
 186     )
 187 {
 188     int status;
 189
 190     status = FSOUND_Sample_Lock (
 191         sample,
 192         pos << info->shift,
 193         len << info->shift,
 194         p1,
 195         p2,
 196         blen1,
 197         blen2
 198         );
 199
 200     if (!status) {
 201         fmod_logerr ("Failed to lock sample\n");
 202         return -1;
 203     }
 204
 205     if ((*blen1 & info->align) || (*blen2 & info->align)) {
 206         dolog ("Lock returned misaligned length %d, %d, alignment %d\n",
 207                *blen1, *blen2, info->align + 1);
 208
 209         fmod_unlock_sample (sample, *p1, *p2, *blen1, *blen2);
 210
 211         *p1 = NULL - 1;
 212         *p2 = NULL - 1;
 213         *blen1 = ~0U;
 214         *blen2 = ~0U;
 215         return -1;
 216     }
 217
 218     if (!*p1 && *blen1) {
 219         dolog ("warning: !p1 && blen1=%d\n", *blen1);
 220         *blen1 = 0;
 221     }
 222
 223     if (!p2 && *blen2) {
 224         dolog ("warning: !p2 && blen2=%d\n", *blen2);
 225         *blen2 = 0;
 226     }
 227
 228     return 0;
 229 }
 230
 231 static int fmod_run_out (HWVoiceOut *hw)
 232 {
 233     FMODVoiceOut *fmd = (FMODVoiceOut *) hw;
 234     int live, decr;
 235     void *p1 = 0, *p2 = 0;
 236     unsigned int blen1 = 0, blen2 = 0;
 237     unsigned int len1 = 0, len2 = 0;
 238     int nb_live;
 239
 240     live = audio_pcm_hw_get_live_out2 (hw, &nb_live);
 241     if (!live) {
 242         return 0;
 243     }
 244
 245     if (!hw->pending_disable
 246         && nb_live
 247         && (conf.threshold && live <= conf.threshold)) {
 248         ldebug ("live=%d nb_live=%d\n", live, nb_live);
 249         return 0;
 250     }
 251
 252     decr = live;
 253
 254     if (fmd->channel >= 0) {
 255         int len = decr;
 256         int old_pos = fmd->old_pos;
 257         int ppos = FSOUND_GetCurrentPosition (fmd->channel);
 258
 259         if (ppos == old_pos || !ppos) {
 260             return 0;
 261         }
 262
 263         if ((old_pos < ppos) && ((old_pos + len) > ppos)) {
 264             len = ppos - old_pos;
 265         }
 266         else {
 267             if ((old_pos > ppos) && ((old_pos + len) > (ppos + hw->samples))) {
 268                 len = hw->samples - old_pos + ppos;
 269             }
 270         }
 271         decr = len;
 272
 273         if (audio_bug (AUDIO_FUNC, decr < 0)) {
 274             dolog ("decr=%d live=%d ppos=%d old_pos=%d len=%d\n",
 275                    decr, live, ppos, old_pos, len);
 276             return 0;
 277         }
 278     }
 279
 280
 281     if (!decr) {
 282         return 0;
 283     }
 284
 285     if (fmod_lock_sample (fmd->fmod_sample, &fmd->hw.info,
 286                           fmd->old_pos, decr,
 287                           &p1, &p2,
 288                           &blen1, &blen2)) {
 289         return 0;
 290     }
 291
 292     len1 = blen1 >> hw->info.shift;
 293     len2 = blen2 >> hw->info.shift;
 294     ldebug ("%p %p %d %d %d %d\n", p1, p2, len1, len2, blen1, blen2);
 295     decr = len1 + len2;
 296
 297     if (p1 && len1) {
 298         fmod_write_sample (hw, p1, len1);
 299     }
 300
 301     if (p2 && len2) {
 302         fmod_write_sample (hw, p2, len2);
 303     }
 304
 305     fmod_unlock_sample (fmd->fmod_sample, p1, p2, blen1, blen2);
 306
 307     fmd->old_pos = (fmd->old_pos + decr) % hw->samples;
 308     return decr;
 309 }
 310
 311 static int aud_to_fmodfmt (audfmt_e fmt, int stereo)
 312 {
 313     int mode = FSOUND_LOOP_NORMAL;
 314
 315     switch (fmt) {
 316     case AUD_FMT_S8:
 317         mode |= FSOUND_SIGNED | FSOUND_8BITS;
 318         break;
 319
 320     case AUD_FMT_U8:
 321         mode |= FSOUND_UNSIGNED | FSOUND_8BITS;
 322         break;
 323
 324     case AUD_FMT_S16:
 325         mode |= FSOUND_SIGNED | FSOUND_16BITS;
 326         break;
 327
 328     case AUD_FMT_U16:
 329         mode |= FSOUND_UNSIGNED | FSOUND_16BITS;
 330         break;
 331
 332     default:
 333         dolog ("Internal logic error: Bad audio format %d\n", fmt);
 334 #ifdef DEBUG_FMOD
 335         abort ();
 336 #endif
 337         mode |= FSOUND_8BITS;
 338     }
 339     mode |= stereo ? FSOUND_STEREO : FSOUND_MONO;
 340     return mode;
 341 }
 342
 343 static void fmod_fini_out (HWVoiceOut *hw)
 344 {
 345     FMODVoiceOut *fmd = (FMODVoiceOut *) hw;
 346
 347     if (fmd->fmod_sample) {
 348         FSOUND_Sample_Free (fmd->fmod_sample);
 349         fmd->fmod_sample = 0;
 350
 351         if (fmd->channel >= 0) {
 352             FSOUND_StopSound (fmd->channel);
 353         }
 354     }
 355 }
 356
 357 static int fmod_init_out (HWVoiceOut *hw, audsettings_t *as)
 358 {
 359     int bits16, mode, channel;
 360     FMODVoiceOut *fmd = (FMODVoiceOut *) hw;
 361     audsettings_t obt_as = *as;
 362
 363     mode = aud_to_fmodfmt (as->fmt, as->nchannels == 2 ? 1 : 0);
 364     fmd->fmod_sample = FSOUND_Sample_Alloc (
 365         FSOUND_FREE,            /* index */
 366         conf.nb_samples,        /* length */
 367         mode,                   /* mode */
 368         as->freq,               /* freq */
 369         255,                    /* volume */
 370         128,                    /* pan */
 371         255                     /* priority */
 372         );
 373
 374     if (!fmd->fmod_sample) {
 375         fmod_logerr2 ("DAC", "Failed to allocate FMOD sample\n");
 376         return -1;
 377     }
 378
 379     channel = FSOUND_PlaySoundEx (FSOUND_FREE, fmd->fmod_sample, 0, 1);
 380     if (channel < 0) {
 381         fmod_logerr2 ("DAC", "Failed to start playing sound\n");
 382         FSOUND_Sample_Free (fmd->fmod_sample);
 383         return -1;
 384     }
 385     fmd->channel = channel;
 386
 387     /* FMOD always operates on little endian frames? */
 388     obt_as.endianness = 0;
 389     audio_pcm_init_info (&hw->info, &obt_as);
 390     bits16 = (mode & FSOUND_16BITS) != 0;
 391     hw->samples = conf.nb_samples;
 392     return 0;
 393 }
 394
 395 static int fmod_ctl_out (HWVoiceOut *hw, int cmd, ...)
 396 {
 397     int status;
 398     FMODVoiceOut *fmd = (FMODVoiceOut *) hw;
 399
 400     switch (cmd) {
 401     case VOICE_ENABLE:
 402         fmod_clear_sample (fmd);
 403         status = FSOUND_SetPaused (fmd->channel, 0);
 404         if (!status) {
 405             fmod_logerr ("Failed to resume channel %d\n", fmd->channel);
 406         }
 407         break;
 408
 409     case VOICE_DISABLE:
 410         status = FSOUND_SetPaused (fmd->channel, 1);
 411         if (!status) {
 412             fmod_logerr ("Failed to pause channel %d\n", fmd->channel);
 413         }
 414         break;
 415     }
 416     return 0;
 417 }
 418
 419 static int fmod_init_in (HWVoiceIn *hw, audsettings_t *as)
 420 {
 421     int bits16, mode;
 422     FMODVoiceIn *fmd = (FMODVoiceIn *) hw;
 423     audsettings_t obt_as = *as;
 424
 425     if (conf.broken_adc) {
 426         return -1;
 427     }
 428
 429     mode = aud_to_fmodfmt (as->fmt, as->nchannels == 2 ? 1 : 0);
 430     fmd->fmod_sample = FSOUND_Sample_Alloc (
 431         FSOUND_FREE,            /* index */
 432         conf.nb_samples,        /* length */
 433         mode,                   /* mode */
 434         as->freq,               /* freq */
 435         255,                    /* volume */
 436         128,                    /* pan */
 437         255                     /* priority */
 438         );
 439
 440     if (!fmd->fmod_sample) {
 441         fmod_logerr2 ("ADC", "Failed to allocate FMOD sample\n");
 442         return -1;
 443     }
 444
 445     /* FMOD always operates on little endian frames? */
 446     obt_as.endianness = 0;
 447     audio_pcm_init_info (&hw->info, &obt_as);
 448     bits16 = (mode & FSOUND_16BITS) != 0;
 449     hw->samples = conf.nb_samples;
 450     return 0;
 451 }
 452
 453 static void fmod_fini_in (HWVoiceIn *hw)
 454 {
 455     FMODVoiceIn *fmd = (FMODVoiceIn *) hw;
 456
 457     if (fmd->fmod_sample) {
 458         FSOUND_Record_Stop ();
 459         FSOUND_Sample_Free (fmd->fmod_sample);
 460         fmd->fmod_sample = 0;
 461     }
 462 }
 463
 464 static int fmod_run_in (HWVoiceIn *hw)
 465 {
 466     FMODVoiceIn *fmd = (FMODVoiceIn *) hw;
 467     int hwshift = hw->info.shift;
 468     int live, dead, new_pos, len;
 469     unsigned int blen1 = 0, blen2 = 0;
 470     unsigned int len1, len2;
 471     unsigned int decr;
 472     void *p1, *p2;
 473
 474     live = audio_pcm_hw_get_live_in (hw);
 475     dead = hw->samples - live;
 476     if (!dead) {
 477         return 0;
 478     }
 479
 480     new_pos = FSOUND_Record_GetPosition ();
 481     if (new_pos < 0) {
 482         fmod_logerr ("Could not get recording position\n");
 483         return 0;
 484     }
 485
 486     len = audio_ring_dist (new_pos,  hw->wpos, hw->samples);
 487     if (!len) {
 488         return 0;
 489     }
 490     len = audio_MIN (len, dead);
 491
 492     if (fmod_lock_sample (fmd->fmod_sample, &fmd->hw.info,
 493                           hw->wpos, len,
 494                           &p1, &p2,
 495                           &blen1, &blen2)) {
 496         return 0;
 497     }
 498
 499     len1 = blen1 >> hwshift;
 500     len2 = blen2 >> hwshift;
 501     decr = len1 + len2;
 502
 503     if (p1 && blen1) {
 504         hw->conv (hw->conv_buf + hw->wpos, p1, len1, &nominal_volume);
 505     }
 506     if (p2 && len2) {
 507         hw->conv (hw->conv_buf, p2, len2, &nominal_volume);
 508     }
 509
 510     fmod_unlock_sample (fmd->fmod_sample, p1, p2, blen1, blen2);
 511     hw->wpos = (hw->wpos + decr) % hw->samples;
 512     return decr;
 513 }
 514
 515 static struct {
 516     const char *name;
 517     int type;
 518 } drvtab[] = {
 519     {"none", FSOUND_OUTPUT_NOSOUND},
 520 #ifdef _WIN32
 521     {"winmm", FSOUND_OUTPUT_WINMM},
 522     {"dsound", FSOUND_OUTPUT_DSOUND},
 523     {"a3d", FSOUND_OUTPUT_A3D},
 524     {"asio", FSOUND_OUTPUT_ASIO},
 525 #endif
 526 #ifdef __linux__
 527     {"oss", FSOUND_OUTPUT_OSS},
 528     {"alsa", FSOUND_OUTPUT_ALSA},
 529     {"esd", FSOUND_OUTPUT_ESD},
 530 #endif
 531 #ifdef __APPLE__
 532     {"mac", FSOUND_OUTPUT_MAC},
 533 #endif
 534 #if 0
 535     {"xbox", FSOUND_OUTPUT_XBOX},
 536     {"ps2", FSOUND_OUTPUT_PS2},
 537     {"gcube", FSOUND_OUTPUT_GC},
 538 #endif
 539     {"none-realtime", FSOUND_OUTPUT_NOSOUND_NONREALTIME}
 540 };
 541
 542 static void *fmod_audio_init (void)
 543 {
 544     size_t i;
 545     double ver;
 546     int status;
 547     int output_type = -1;
 548     const char *drv = conf.drvname;
 549
 550     ver = FSOUND_GetVersion ();
 551     if (ver < FMOD_VERSION) {
 552         dolog ("Wrong FMOD version %f, need at least %f\n", ver, FMOD_VERSION);
 553         return NULL;
 554     }
 555
 556 #ifdef __linux__
 557     if (ver < 3.75) {
 558         dolog ("FMOD before 3.75 has bug preventing ADC from working\n"
 559                "ADC will be disabled.\n");
 560         conf.broken_adc = 1;
 561     }
 562 #endif
 563
 564     if (drv) {
 565         int found = 0;
 566         for (i = 0; i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {
 567             if (!strcmp (drv, drvtab[i].name)) {
 568                 output_type = drvtab[i].type;
 569                 found = 1;
 570                 break;
 571             }
 572         }
 573         if (!found) {
 574             dolog ("Unknown FMOD driver `%s'\n", drv);
 575             dolog ("Valid drivers:\n");
 576             for (i = 0; i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {
 577                 dolog ("  %s\n", drvtab[i].name);
 578             }
 579         }
 580     }
 581
 582     if (output_type != -1) {
 583         status = FSOUND_SetOutput (output_type);
 584         if (!status) {
 585             fmod_logerr ("FSOUND_SetOutput(%d) failed\n", output_type);
 586             return NULL;
 587         }
 588     }
 589
 590     if (conf.bufsize) {
 591         status = FSOUND_SetBufferSize (conf.bufsize);
 592         if (!status) {
 593             fmod_logerr ("FSOUND_SetBufferSize (%d) failed\n", conf.bufsize);
 594         }
 595     }
 596
 597     status = FSOUND_Init (conf.freq, conf.nb_channels, 0);
 598     if (!status) {
 599         fmod_logerr ("FSOUND_Init failed\n");
 600         return NULL;
 601     }
 602
 603     return &conf;
 604 }
 605
 606 static int fmod_read (SWVoiceIn *sw, void *buf, int size)
 607 {
 608     return audio_pcm_sw_read (sw, buf, size);
 609 }
 610
 611 static int fmod_ctl_in (HWVoiceIn *hw, int cmd, ...)
 612 {
 613     int status;
 614     FMODVoiceIn *fmd = (FMODVoiceIn *) hw;
 615
 616     switch (cmd) {
 617     case VOICE_ENABLE:
 618         status = FSOUND_Record_StartSample (fmd->fmod_sample, 1);
 619         if (!status) {
 620             fmod_logerr ("Failed to start recording\n");
 621         }
 622         break;
 623
 624     case VOICE_DISABLE:
 625         status = FSOUND_Record_Stop ();
 626         if (!status) {
 627             fmod_logerr ("Failed to stop recording\n");
 628         }
 629         break;
 630     }
 631     return 0;
 632 }
 633
 634 static void fmod_audio_fini (void *opaque)
 635 {
 636     (void) opaque;
 637     FSOUND_Close ();
 638 }
 639
 640 static struct audio_option fmod_options[] = {
 641     {"DRV", AUD_OPT_STR, &conf.drvname,
 642      "FMOD driver", NULL, 0},
 643     {"FREQ", AUD_OPT_INT, &conf.freq,
 644      "Default frequency", NULL, 0},
 645     {"SAMPLES", AUD_OPT_INT, &conf.nb_samples,
 646      "Buffer size in samples", NULL, 0},
 647     {"CHANNELS", AUD_OPT_INT, &conf.nb_channels,
 648      "Number of default channels (1 - mono, 2 - stereo)", NULL, 0},
 649     {"BUFSIZE", AUD_OPT_INT, &conf.bufsize,
 650      "(undocumented)", NULL, 0},
 651 #if 0
 652     {"THRESHOLD", AUD_OPT_INT, &conf.threshold,
 653      "(undocumented)"},
 654 #endif
 655
 656     {NULL, 0, NULL, NULL, NULL, 0}
 657 };
 658
 659 static struct audio_pcm_ops fmod_pcm_ops = {
 660     fmod_init_out,
 661     fmod_fini_out,
 662     fmod_run_out,
 663     fmod_write,
 664     fmod_ctl_out,
 665
 666     fmod_init_in,
 667     fmod_fini_in,
 668     fmod_run_in,
 669     fmod_read,
 670     fmod_ctl_in
 671 };
 672
 673 struct audio_driver fmod_audio_driver = {
 674     INIT_FIELD (name           = ) "fmod",
 675     INIT_FIELD (descr          = ) "FMOD 3.xx http://www.fmod.org",
 676     INIT_FIELD (options        = ) fmod_options,
 677     INIT_FIELD (init           = ) fmod_audio_init,
 678     INIT_FIELD (fini           = ) fmod_audio_fini,
 679     INIT_FIELD (pcm_ops        = ) &fmod_pcm_ops,
 680     INIT_FIELD (can_be_default = ) 1,
 681     INIT_FIELD (max_voices_out = ) INT_MAX,
 682     INIT_FIELD (max_voices_in  = ) INT_MAX,
 683     INIT_FIELD (voice_size_out = ) sizeof (FMODVoiceOut),
 684     INIT_FIELD (voice_size_in  = ) sizeof (FMODVoiceIn)
 685 };