[qemu.git] / audio / fmodaudio.c

/*
 * QEMU FMOD audio driver
 *
 * Copyright (c) 2004-2005 Vassili Karpov (malc)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include <fmod.h>
#include <fmod_errors.h>
#include "vl.h"

#define AUDIO_CAP "fmod"
#include "audio_int.h"

typedef struct FMODVoiceOut {
    HWVoiceOut hw;
    unsigned int old_pos;
    FSOUND_SAMPLE *fmod_sample;
    int channel;
} FMODVoiceOut;

typedef struct FMODVoiceIn {
    HWVoiceIn hw;
    FSOUND_SAMPLE *fmod_sample;
} FMODVoiceIn;

static struct {
    const char *drvname;
    int nb_samples;
    int freq;
    int nb_channels;
    int bufsize;
    int threshold;
    int broken_adc;
} conf = {
    NULL,
    2048 * 2,
    44100,
    2,
    0,
    0,
    0
};

static void GCC_FMT_ATTR (1, 2) fmod_logerr (const char *fmt, ...)
{
    va_list ap;

    va_start (ap, fmt);
    AUD_vlog (AUDIO_CAP, fmt, ap);
    va_end (ap);

    AUD_log (AUDIO_CAP, "Reason: %s\n",
             FMOD_ErrorString (FSOUND_GetError ()));
}

static void GCC_FMT_ATTR (2, 3) fmod_logerr2 (
    const char *typ,
    const char *fmt,
    ...
    )
{
    va_list ap;

    AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);

    va_start (ap, fmt);
    AUD_vlog (AUDIO_CAP, fmt, ap);
    va_end (ap);

    AUD_log (AUDIO_CAP, "Reason: %s\n",
             FMOD_ErrorString (FSOUND_GetError ()));
}

static int fmod_write (SWVoiceOut *sw, void *buf, int len)
{
    return audio_pcm_sw_write (sw, buf, len);
}

static void fmod_clear_sample (FMODVoiceOut *fmd)
{
    HWVoiceOut *hw = &fmd->hw;
    int status;
    void *p1 = 0, *p2 = 0;
    unsigned int len1 = 0, len2 = 0;

    status = FSOUND_Sample_Lock (
        fmd->fmod_sample,
        0,
        hw->samples << hw->info.shift,
        &p1,
        &p2,
        &len1,
        &len2
        );

    if (!status) {
        fmod_logerr ("Failed to lock sample\n");
        return;
    }

    if ((len1 & hw->info.align) || (len2 & hw->info.align)) {
        dolog ("Lock returned misaligned length %d, %d, alignment %d\n",
               len1, len2, hw->info.align + 1);
        goto fail;
    }

    if ((len1 + len2) - (hw->samples << hw->info.shift)) {
        dolog ("Lock returned incomplete length %d, %d\n",
               len1 + len2, hw->samples << hw->info.shift);
        goto fail;
    }

    audio_pcm_info_clear_buf (&hw->info, p1, hw->samples);

 fail:
    status = FSOUND_Sample_Unlock (fmd->fmod_sample, p1, p2, len1, len2);
    if (!status) {
        fmod_logerr ("Failed to unlock sample\n");
    }
}

static void fmod_write_sample (HWVoiceOut *hw, uint8_t *dst, int dst_len)
{
    int src_len1 = dst_len;
    int src_len2 = 0;
    int pos = hw->rpos + dst_len;
    st_sample_t *src1 = hw->mix_buf + hw->rpos;
    st_sample_t *src2 = NULL;

    if (pos > hw->samples) {
        src_len1 = hw->samples - hw->rpos;
        src2 = hw->mix_buf;
        src_len2 = dst_len - src_len1;
        pos = src_len2;
    }

    if (src_len1) {
        hw->clip (dst, src1, src_len1);
    }

    if (src_len2) {
        dst = advance (dst, src_len1 << hw->info.shift);
        hw->clip (dst, src2, src_len2);
    }

    hw->rpos = pos % hw->samples;
}

static int fmod_unlock_sample (FSOUND_SAMPLE *sample, void *p1, void *p2,
                               unsigned int blen1, unsigned int blen2)
{
    int status = FSOUND_Sample_Unlock (sample, p1, p2, blen1, blen2);
    if (!status) {
        fmod_logerr ("Failed to unlock sample\n");
        return -1;
    }
    return 0;
}

static int fmod_lock_sample (
    FSOUND_SAMPLE *sample,
    struct audio_pcm_info *info,
    int pos,
    int len,
    void **p1,
    void **p2,
    unsigned int *blen1,
    unsigned int *blen2
    )
{
    int status;

    status = FSOUND_Sample_Lock (
        sample,
        pos << info->shift,
        len << info->shift,
        p1,
        p2,
        blen1,
        blen2
        );

    if (!status) {
        fmod_logerr ("Failed to lock sample\n");
        return -1;
    }

    if ((*blen1 & info->align) || (*blen2 & info->align)) {
        dolog ("Lock returned misaligned length %d, %d, alignment %d\n",
               *blen1, *blen2, info->align + 1);

        fmod_unlock_sample (sample, *p1, *p2, *blen1, *blen2);

        *p1 = NULL - 1;
        *p2 = NULL - 1;
        *blen1 = ~0U;
        *blen2 = ~0U;
        return -1;
    }

    if (!*p1 && *blen1) {
        dolog ("warning: !p1 && blen1=%d\n", *blen1);
        *blen1 = 0;
    }

    if (!p2 && *blen2) {
        dolog ("warning: !p2 && blen2=%d\n", *blen2);
        *blen2 = 0;
    }

    return 0;
}

static int fmod_run_out (HWVoiceOut *hw)
{
    FMODVoiceOut *fmd = (FMODVoiceOut *) hw;
    int live, decr;
    void *p1 = 0, *p2 = 0;
    unsigned int blen1 = 0, blen2 = 0;
    unsigned int len1 = 0, len2 = 0;
    int nb_live;

    live = audio_pcm_hw_get_live_out2 (hw, &nb_live);
    if (!live) {
        return 0;
    }

    if (!hw->pending_disable
        && nb_live
        && (conf.threshold && live <= conf.threshold)) {
        ldebug ("live=%d nb_live=%d\n", live, nb_live);
        return 0;
    }

    decr = live;

    if (fmd->channel >= 0) {
        int len = decr;
        int old_pos = fmd->old_pos;
        int ppos = FSOUND_GetCurrentPosition (fmd->channel);

        if (ppos == old_pos || !ppos) {
            return 0;
        }

        if ((old_pos < ppos) && ((old_pos + len) > ppos)) {
            len = ppos - old_pos;
        }
        else {
            if ((old_pos > ppos) && ((old_pos + len) > (ppos + hw->samples))) {
                len = hw->samples - old_pos + ppos;
            }
        }
        decr = len;

        if (audio_bug (AUDIO_FUNC, decr < 0)) {
            dolog ("decr=%d live=%d ppos=%d old_pos=%d len=%d\n",
                   decr, live, ppos, old_pos, len);
            return 0;
        }
    }


    if (!decr) {
        return 0;
    }

    if (fmod_lock_sample (fmd->fmod_sample, &fmd->hw.info,
                          fmd->old_pos, decr,
                          &p1, &p2,
                          &blen1, &blen2)) {
        return 0;
    }

    len1 = blen1 >> hw->info.shift;
    len2 = blen2 >> hw->info.shift;
    ldebug ("%p %p %d %d %d %d\n", p1, p2, len1, len2, blen1, blen2);
    decr = len1 + len2;

    if (p1 && len1) {
        fmod_write_sample (hw, p1, len1);
    }

    if (p2 && len2) {
        fmod_write_sample (hw, p2, len2);
    }

    fmod_unlock_sample (fmd->fmod_sample, p1, p2, blen1, blen2);

    fmd->old_pos = (fmd->old_pos + decr) % hw->samples;
    return decr;
}

static int aud_to_fmodfmt (audfmt_e fmt, int stereo)
{
    int mode = FSOUND_LOOP_NORMAL;

    switch (fmt) {
    case AUD_FMT_S8:
        mode |= FSOUND_SIGNED | FSOUND_8BITS;
        break;

    case AUD_FMT_U8:
        mode |= FSOUND_UNSIGNED | FSOUND_8BITS;
        break;

    case AUD_FMT_S16:
        mode |= FSOUND_SIGNED | FSOUND_16BITS;
        break;

    case AUD_FMT_U16:
        mode |= FSOUND_UNSIGNED | FSOUND_16BITS;
        break;

    default:
        dolog ("Internal logic error: Bad audio format %d\n", fmt);
#ifdef DEBUG_FMOD
        abort ();
#endif
        mode |= FSOUND_8BITS;
    }
    mode |= stereo ? FSOUND_STEREO : FSOUND_MONO;
    return mode;
}

static void fmod_fini_out (HWVoiceOut *hw)
{
    FMODVoiceOut *fmd = (FMODVoiceOut *) hw;

    if (fmd->fmod_sample) {
        FSOUND_Sample_Free (fmd->fmod_sample);
        fmd->fmod_sample = 0;

        if (fmd->channel >= 0) {
            FSOUND_StopSound (fmd->channel);
        }
    }
}

static int fmod_init_out (HWVoiceOut *hw, audsettings_t *as)
{
    int bits16, mode, channel;
    FMODVoiceOut *fmd = (FMODVoiceOut *) hw;
    audsettings_t obt_as = *as;

    mode = aud_to_fmodfmt (as->fmt, as->nchannels == 2 ? 1 : 0);
    fmd->fmod_sample = FSOUND_Sample_Alloc (
        FSOUND_FREE,            /* index */
        conf.nb_samples,        /* length */
        mode,                   /* mode */
        as->freq,               /* freq */
        255,                    /* volume */
        128,                    /* pan */
        255                     /* priority */
        );

    if (!fmd->fmod_sample) {
        fmod_logerr2 ("DAC", "Failed to allocate FMOD sample\n");
        return -1;
    }

    channel = FSOUND_PlaySoundEx (FSOUND_FREE, fmd->fmod_sample, 0, 1);
    if (channel < 0) {
        fmod_logerr2 ("DAC", "Failed to start playing sound\n");
        FSOUND_Sample_Free (fmd->fmod_sample);
        return -1;
    }
    fmd->channel = channel;

    /* FMOD always operates on little endian frames? */
    obt_as.endianness = 0;
    audio_pcm_init_info (&hw->info, &obt_as);
    bits16 = (mode & FSOUND_16BITS) != 0;
    hw->samples = conf.nb_samples;
    return 0;
}

static int fmod_ctl_out (HWVoiceOut *hw, int cmd, ...)
{
    int status;
    FMODVoiceOut *fmd = (FMODVoiceOut *) hw;

    switch (cmd) {
    case VOICE_ENABLE:
        fmod_clear_sample (fmd);
        status = FSOUND_SetPaused (fmd->channel, 0);
        if (!status) {
            fmod_logerr ("Failed to resume channel %d\n", fmd->channel);
        }
        break;

    case VOICE_DISABLE:
        status = FSOUND_SetPaused (fmd->channel, 1);
        if (!status) {
            fmod_logerr ("Failed to pause channel %d\n", fmd->channel);
        }
        break;
    }
    return 0;
}

static int fmod_init_in (HWVoiceIn *hw, audsettings_t *as)
{
    int bits16, mode;
    FMODVoiceIn *fmd = (FMODVoiceIn *) hw;
    audsettings_t obt_as = *as;

    if (conf.broken_adc) {
        return -1;
    }

    mode = aud_to_fmodfmt (as->fmt, as->nchannels == 2 ? 1 : 0);
    fmd->fmod_sample = FSOUND_Sample_Alloc (
        FSOUND_FREE,            /* index */
        conf.nb_samples,        /* length */
        mode,                   /* mode */
        as->freq,               /* freq */
        255,                    /* volume */
        128,                    /* pan */
        255                     /* priority */
        );

    if (!fmd->fmod_sample) {
        fmod_logerr2 ("ADC", "Failed to allocate FMOD sample\n");
        return -1;
    }

    /* FMOD always operates on little endian frames? */
    obt_as.endianness = 0;
    audio_pcm_init_info (&hw->info, &obt_as);
    bits16 = (mode & FSOUND_16BITS) != 0;
    hw->samples = conf.nb_samples;
    return 0;
}

static void fmod_fini_in (HWVoiceIn *hw)
{
    FMODVoiceIn *fmd = (FMODVoiceIn *) hw;

    if (fmd->fmod_sample) {
        FSOUND_Record_Stop ();
        FSOUND_Sample_Free (fmd->fmod_sample);
        fmd->fmod_sample = 0;
    }
}

static int fmod_run_in (HWVoiceIn *hw)
{
    FMODVoiceIn *fmd = (FMODVoiceIn *) hw;
    int hwshift = hw->info.shift;
    int live, dead, new_pos, len;
    unsigned int blen1 = 0, blen2 = 0;
    unsigned int len1, len2;
    unsigned int decr;
    void *p1, *p2;

    live = audio_pcm_hw_get_live_in (hw);
    dead = hw->samples - live;
    if (!dead) {
        return 0;
    }

    new_pos = FSOUND_Record_GetPosition ();
    if (new_pos < 0) {
        fmod_logerr ("Could not get recording position\n");
        return 0;
    }

    len = audio_ring_dist (new_pos,  hw->wpos, hw->samples);
    if (!len) {
        return 0;
    }
    len = audio_MIN (len, dead);

    if (fmod_lock_sample (fmd->fmod_sample, &fmd->hw.info,
                          hw->wpos, len,
                          &p1, &p2,
                          &blen1, &blen2)) {
        return 0;
    }

    len1 = blen1 >> hwshift;
    len2 = blen2 >> hwshift;
    decr = len1 + len2;

    if (p1 && blen1) {
        hw->conv (hw->conv_buf + hw->wpos, p1, len1, &nominal_volume);
    }
    if (p2 && len2) {
        hw->conv (hw->conv_buf, p2, len2, &nominal_volume);
    }

    fmod_unlock_sample (fmd->fmod_sample, p1, p2, blen1, blen2);
    hw->wpos = (hw->wpos + decr) % hw->samples;
    return decr;
}

static struct {
    const char *name;
    int type;
} drvtab[] = {
    {"none", FSOUND_OUTPUT_NOSOUND},
#ifdef _WIN32
    {"winmm", FSOUND_OUTPUT_WINMM},
    {"dsound", FSOUND_OUTPUT_DSOUND},
    {"a3d", FSOUND_OUTPUT_A3D},
    {"asio", FSOUND_OUTPUT_ASIO},
#endif
#ifdef __linux__
    {"oss", FSOUND_OUTPUT_OSS},
    {"alsa", FSOUND_OUTPUT_ALSA},
    {"esd", FSOUND_OUTPUT_ESD},
#endif
#ifdef __APPLE__
    {"mac", FSOUND_OUTPUT_MAC},
#endif
#if 0
    {"xbox", FSOUND_OUTPUT_XBOX},
    {"ps2", FSOUND_OUTPUT_PS2},
    {"gcube", FSOUND_OUTPUT_GC},
#endif
    {"none-realtime", FSOUND_OUTPUT_NOSOUND_NONREALTIME}
};

static void *fmod_audio_init (void)
{
    size_t i;
    double ver;
    int status;
    int output_type = -1;
    const char *drv = conf.drvname;

    ver = FSOUND_GetVersion ();
    if (ver < FMOD_VERSION) {
        dolog ("Wrong FMOD version %f, need at least %f\n", ver, FMOD_VERSION);
        return NULL;
    }

#ifdef __linux__
    if (ver < 3.75) {
        dolog ("FMOD before 3.75 has bug preventing ADC from working\n"
               "ADC will be disabled.\n");
        conf.broken_adc = 1;
    }
#endif

    if (drv) {
        int found = 0;
        for (i = 0; i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {
            if (!strcmp (drv, drvtab[i].name)) {
                output_type = drvtab[i].type;
                found = 1;
                break;
            }
        }
        if (!found) {
            dolog ("Unknown FMOD driver `%s'\n", drv);
            dolog ("Valid drivers:\n");
            for (i = 0; i < sizeof (drvtab) / sizeof (drvtab[0]); i++) {
                dolog ("  %s\n", drvtab[i].name);
            }
        }
    }

    if (output_type != -1) {
        status = FSOUND_SetOutput (output_type);
        if (!status) {
            fmod_logerr ("FSOUND_SetOutput(%d) failed\n", output_type);
            return NULL;
        }
    }

    if (conf.bufsize) {
        status = FSOUND_SetBufferSize (conf.bufsize);
        if (!status) {
            fmod_logerr ("FSOUND_SetBufferSize (%d) failed\n", conf.bufsize);
        }
    }

    status = FSOUND_Init (conf.freq, conf.nb_channels, 0);
    if (!status) {
        fmod_logerr ("FSOUND_Init failed\n");
        return NULL;
    }

    return &conf;
}

static int fmod_read (SWVoiceIn *sw, void *buf, int size)
{
    return audio_pcm_sw_read (sw, buf, size);
}

static int fmod_ctl_in (HWVoiceIn *hw, int cmd, ...)
{
    int status;
    FMODVoiceIn *fmd = (FMODVoiceIn *) hw;

    switch (cmd) {
    case VOICE_ENABLE:
        status = FSOUND_Record_StartSample (fmd->fmod_sample, 1);
        if (!status) {
            fmod_logerr ("Failed to start recording\n");
        }
        break;

    case VOICE_DISABLE:
        status = FSOUND_Record_Stop ();
        if (!status) {
            fmod_logerr ("Failed to stop recording\n");
        }
        break;
    }
    return 0;
}

static void fmod_audio_fini (void *opaque)
{
    (void) opaque;
    FSOUND_Close ();
}

static struct audio_option fmod_options[] = {
    {"DRV", AUD_OPT_STR, &conf.drvname,
     "FMOD driver", NULL, 0},
    {"FREQ", AUD_OPT_INT, &conf.freq,
     "Default frequency", NULL, 0},
    {"SAMPLES", AUD_OPT_INT, &conf.nb_samples,
     "Buffer size in samples", NULL, 0},
    {"CHANNELS", AUD_OPT_INT, &conf.nb_channels,
     "Number of default channels (1 - mono, 2 - stereo)", NULL, 0},
    {"BUFSIZE", AUD_OPT_INT, &conf.bufsize,
     "(undocumented)", NULL, 0},
#if 0
    {"THRESHOLD", AUD_OPT_INT, &conf.threshold,
     "(undocumented)"},
#endif

    {NULL, 0, NULL, NULL, NULL, 0}
};

static struct audio_pcm_ops fmod_pcm_ops = {
    fmod_init_out,
    fmod_fini_out,
    fmod_run_out,
    fmod_write,
    fmod_ctl_out,

    fmod_init_in,
    fmod_fini_in,
    fmod_run_in,
    fmod_read,
    fmod_ctl_in
};

struct audio_driver fmod_audio_driver = {
    INIT_FIELD (name           = ) "fmod",
    INIT_FIELD (descr          = ) "FMOD 3.xx http://www.fmod.org",
    INIT_FIELD (options        = ) fmod_options,
    INIT_FIELD (init           = ) fmod_audio_init,
    INIT_FIELD (fini           = ) fmod_audio_fini,
    INIT_FIELD (pcm_ops        = ) &fmod_pcm_ops,
    INIT_FIELD (can_be_default = ) 1,
    INIT_FIELD (max_voices_out = ) INT_MAX,
    INIT_FIELD (max_voices_in  = ) INT_MAX,
    INIT_FIELD (voice_size_out = ) sizeof (FMODVoiceOut),
    INIT_FIELD (voice_size_in  = ) sizeof (FMODVoiceIn)
};
Commit	Line	Data
85571bc7	1	/*
1d14ffa9 FB	2	* QEMU FMOD audio driver
	3	*
	4	* Copyright (c) 2004-2005 Vassili Karpov (malc)
	5	*
85571bc7 FB	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
1d14ffa9 FB	28	#define AUDIO_CAP "fmod"
1d14ffa9 FB	29	#include "audio_int.h"
fb065187	30
1d14ffa9 FB	31	typedef struct FMODVoiceOut {
1d14ffa9 FB	32	HWVoiceOut hw;
fb065187 FB	33	unsigned int old_pos;
	34	FSOUND_SAMPLE *fmod_sample;
	35	int channel;
1d14ffa9	36	} FMODVoiceOut;
85571bc7	37
1d14ffa9 FB	38	typedef struct FMODVoiceIn {
	39	HWVoiceIn hw;
	40	FSOUND_SAMPLE *fmod_sample;
	41	} FMODVoiceIn;
85571bc7 FB	42
85571bc7 FB	43	static struct {
1d14ffa9	44	const char *drvname;
85571bc7 FB	45	int nb_samples;
	46	int freq;
	47	int nb_channels;
	48	int bufsize;
	49	int threshold;
1d14ffa9	50	int broken_adc;
85571bc7	51	} conf = {
1d14ffa9 FB	52	NULL,
1d14ffa9 FB	53	2048 * 2,
85571bc7	54	44100,
1d14ffa9 FB	55	2,
1d14ffa9 FB	56	0,
85571bc7	57	0,
1d14ffa9	58	0
85571bc7 FB	59	};
85571bc7 FB	60
1d14ffa9 FB	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
c0fe3827	81	AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
1d14ffa9 FB	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	}
85571bc7	90
1d14ffa9	91	static int fmod_write (SWVoiceOut sw, void buf, int len)
85571bc7	92	{
1d14ffa9	93	return audio_pcm_sw_write (sw, buf, len);
85571bc7 FB	94	}
85571bc7 FB	95
1d14ffa9	96	static void fmod_clear_sample (FMODVoiceOut *fmd)
85571bc7	97	{
1d14ffa9	98	HWVoiceOut *hw = &fmd->hw;
85571bc7 FB	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,
1d14ffa9	106	hw->samples << hw->info.shift,
85571bc7 FB	107	&p1,
	108	&p2,
	109	&len1,
	110	&len2
	111	);
	112
	113	if (!status) {
1d14ffa9	114	fmod_logerr ("Failed to lock sample\n");
85571bc7 FB	115	return;
	116	}
	117
1d14ffa9 FB	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);
85571bc7 FB	121	goto fail;
	122	}
	123
1d14ffa9 FB	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);
85571bc7 FB	127	goto fail;
85571bc7 FB	128	}
1d14ffa9 FB	129
1d14ffa9 FB	130	audio_pcm_info_clear_buf (&hw->info, p1, hw->samples);
85571bc7 FB	131
	132	fail:
	133	status = FSOUND_Sample_Unlock (fmd->fmod_sample, p1, p2, len1, len2);
	134	if (!status) {
1d14ffa9	135	fmod_logerr ("Failed to unlock sample\n");
85571bc7 FB	136	}
	137	}
	138
1d14ffa9	139	static void fmod_write_sample (HWVoiceOut hw, uint8_t dst, int dst_len)
85571bc7	140	{
1d14ffa9 FB	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;
85571bc7 FB	150	src_len2 = dst_len - src_len1;
	151	pos = src_len2;
	152	}
	153
	154	if (src_len1) {
	155	hw->clip (dst, src1, src_len1);
85571bc7 FB	156	}
	157
	158	if (src_len2) {
1d14ffa9	159	dst = advance (dst, src_len1 << hw->info.shift);
85571bc7	160	hw->clip (dst, src2, src_len2);
85571bc7	161	}
1d14ffa9 FB	162
1d14ffa9 FB	163	hw->rpos = pos % hw->samples;
85571bc7 FB	164	}
85571bc7 FB	165
1d14ffa9	166	static int fmod_unlock_sample (FSOUND_SAMPLE sample, void p1, void *p2,
85571bc7 FB	167	unsigned int blen1, unsigned int blen2)
85571bc7 FB	168	{
1d14ffa9	169	int status = FSOUND_Sample_Unlock (sample, p1, p2, blen1, blen2);
85571bc7	170	if (!status) {
1d14ffa9	171	fmod_logerr ("Failed to unlock sample\n");
85571bc7 FB	172	return -1;
	173	}
	174	return 0;
	175	}
	176
1d14ffa9 FB	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	)
85571bc7	187	{
85571bc7 FB	188	int status;
	189
	190	status = FSOUND_Sample_Lock (
1d14ffa9 FB	191	sample,
	192	pos << info->shift,
	193	len << info->shift,
85571bc7 FB	194	p1,
	195	p2,
	196	blen1,
	197	blen2
	198	);
	199
	200	if (!status) {
1d14ffa9	201	fmod_logerr ("Failed to lock sample\n");
85571bc7 FB	202	return -1;
	203	}
	204
1d14ffa9 FB	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;
85571bc7 FB	215	return -1;
85571bc7 FB	216	}
1d14ffa9 FB	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
85571bc7 FB	228	return 0;
	229	}
	230
1d14ffa9	231	static int fmod_run_out (HWVoiceOut *hw)
85571bc7	232	{
1d14ffa9 FB	233	FMODVoiceOut fmd = (FMODVoiceOut ) hw;
1d14ffa9 FB	234	int live, decr;
85571bc7 FB	235	void p1 = 0, p2 = 0;
	236	unsigned int blen1 = 0, blen2 = 0;
	237	unsigned int len1 = 0, len2 = 0;
1d14ffa9	238	int nb_live;
85571bc7	239
1d14ffa9 FB	240	live = audio_pcm_hw_get_live_out2 (hw, &nb_live);
	241	if (!live) {
	242	return 0;
85571bc7 FB	243	}
	244
	245	if (!hw->pending_disable
1d14ffa9 FB	246	&& nb_live
	247	&& (conf.threshold && live <= conf.threshold)) {
	248	ldebug ("live=%d nb_live=%d\n", live, nb_live);
	249	return 0;
85571bc7 FB	250	}
	251
	252	decr = live;
	253
85571bc7	254	if (fmd->channel >= 0) {
1d14ffa9 FB	255	int len = decr;
	256	int old_pos = fmd->old_pos;
	257	int ppos = FSOUND_GetCurrentPosition (fmd->channel);
85571bc7	258
1d14ffa9 FB	259	if (ppos == old_pos \|\| !ppos) {
1d14ffa9 FB	260	return 0;
85571bc7	261	}
1d14ffa9 FB	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;
85571bc7	277	}
85571bc7	278	}
85571bc7	279
1d14ffa9 FB	280
	281	if (!decr) {
	282	return 0;
85571bc7 FB	283	}
85571bc7 FB	284
1d14ffa9 FB	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;
85571bc7 FB	290	}
85571bc7 FB	291
1d14ffa9 FB	292	len1 = blen1 >> hw->info.shift;
1d14ffa9 FB	293	len2 = blen2 >> hw->info.shift;
85571bc7 FB	294	ldebug ("%p %p %d %d %d %d\n", p1, p2, len1, len2, blen1, blen2);
85571bc7 FB	295	decr = len1 + len2;
85571bc7	296
1d14ffa9 FB	297	if (p1 && len1) {
1d14ffa9 FB	298	fmod_write_sample (hw, p1, len1);
85571bc7 FB	299	}
85571bc7 FB	300
1d14ffa9 FB	301	if (p2 && len2) {
1d14ffa9 FB	302	fmod_write_sample (hw, p2, len2);
85571bc7 FB	303	}
85571bc7 FB	304
1d14ffa9	305	fmod_unlock_sample (fmd->fmod_sample, p1, p2, blen1, blen2);
85571bc7	306
85571bc7	307	fmd->old_pos = (fmd->old_pos + decr) % hw->samples;
1d14ffa9	308	return decr;
85571bc7 FB	309	}
85571bc7 FB	310
1d14ffa9	311	static int aud_to_fmodfmt (audfmt_e fmt, int stereo)
85571bc7 FB	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:
1d14ffa9 FB	333	dolog ("Internal logic error: Bad audio format %d\n", fmt);
	334	#ifdef DEBUG_FMOD
	335	abort ();
	336	#endif
	337	mode \|= FSOUND_8BITS;
85571bc7 FB	338	}
	339	mode \|= stereo ? FSOUND_STEREO : FSOUND_MONO;
	340	return mode;
	341	}
	342
1d14ffa9	343	static void fmod_fini_out (HWVoiceOut *hw)
85571bc7	344	{
1d14ffa9	345	FMODVoiceOut fmd = (FMODVoiceOut ) hw;
85571bc7 FB	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
c0fe3827	357	static int fmod_init_out (HWVoiceOut hw, audsettings_t as)
85571bc7 FB	358	{
85571bc7 FB	359	int bits16, mode, channel;
1d14ffa9	360	FMODVoiceOut fmd = (FMODVoiceOut ) hw;
d929eba5	361	audsettings_t obt_as = *as;
85571bc7	362
c0fe3827	363	mode = aud_to_fmodfmt (as->fmt, as->nchannels == 2 ? 1 : 0);
85571bc7 FB	364	fmd->fmod_sample = FSOUND_Sample_Alloc (
	365	FSOUND_FREE, /* index */
	366	conf.nb_samples, /* length */
	367	mode, /* mode */
c0fe3827	368	as->freq, /* freq */
85571bc7 FB	369	255, /* volume */
	370	128, /* pan */
	371	255 /* priority */
	372	);
	373
	374	if (!fmd->fmod_sample) {
1d14ffa9	375	fmod_logerr2 ("DAC", "Failed to allocate FMOD sample\n");
85571bc7 FB	376	return -1;
	377	}
	378
	379	channel = FSOUND_PlaySoundEx (FSOUND_FREE, fmd->fmod_sample, 0, 1);
	380	if (channel < 0) {
1d14ffa9	381	fmod_logerr2 ("DAC", "Failed to start playing sound\n");
85571bc7 FB	382	FSOUND_Sample_Free (fmd->fmod_sample);
	383	return -1;
	384	}
	385	fmd->channel = channel;
	386
1d14ffa9	387	/* FMOD always operates on little endian frames? */
d929eba5 FB	388	obt_as.endianness = 0;
d929eba5 FB	389	audio_pcm_init_info (&hw->info, &obt_as);
1d14ffa9	390	bits16 = (mode & FSOUND_16BITS) != 0;
c0fe3827	391	hw->samples = conf.nb_samples;
85571bc7 FB	392	return 0;
	393	}
	394
1d14ffa9	395	static int fmod_ctl_out (HWVoiceOut *hw, int cmd, ...)
85571bc7 FB	396	{
85571bc7 FB	397	int status;
1d14ffa9	398	FMODVoiceOut fmd = (FMODVoiceOut ) hw;
85571bc7 FB	399
	400	switch (cmd) {
	401	case VOICE_ENABLE:
	402	fmod_clear_sample (fmd);
	403	status = FSOUND_SetPaused (fmd->channel, 0);
	404	if (!status) {
1d14ffa9	405	fmod_logerr ("Failed to resume channel %d\n", fmd->channel);
85571bc7 FB	406	}
	407	break;
	408
	409	case VOICE_DISABLE:
	410	status = FSOUND_SetPaused (fmd->channel, 1);
	411	if (!status) {
1d14ffa9	412	fmod_logerr ("Failed to pause channel %d\n", fmd->channel);
85571bc7 FB	413	}
	414	break;
	415	}
	416	return 0;
	417	}
	418
c0fe3827	419	static int fmod_init_in (HWVoiceIn hw, audsettings_t as)
1d14ffa9 FB	420	{
	421	int bits16, mode;
	422	FMODVoiceIn fmd = (FMODVoiceIn ) hw;
d929eba5	423	audsettings_t obt_as = *as;
1d14ffa9 FB	424
	425	if (conf.broken_adc) {
	426	return -1;
	427	}
	428
c0fe3827	429	mode = aud_to_fmodfmt (as->fmt, as->nchannels == 2 ? 1 : 0);
1d14ffa9 FB	430	fmd->fmod_sample = FSOUND_Sample_Alloc (
	431	FSOUND_FREE, /* index */
	432	conf.nb_samples, /* length */
	433	mode, /* mode */
c0fe3827	434	as->freq, /* freq */
1d14ffa9 FB	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? */
d929eba5 FB	446	obt_as.endianness = 0;
d929eba5 FB	447	audio_pcm_init_info (&hw->info, &obt_as);
1d14ffa9	448	bits16 = (mode & FSOUND_16BITS) != 0;
c0fe3827	449	hw->samples = conf.nb_samples;
1d14ffa9 FB	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) {
c0fe3827	482	fmod_logerr ("Could not get recording position\n");
1d14ffa9 FB	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
85571bc7 FB	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
1d14ffa9	539	{"none-realtime", FSOUND_OUTPUT_NOSOUND_NONREALTIME}
85571bc7 FB	540	};
	541
	542	static void *fmod_audio_init (void)
	543	{
1d14ffa9	544	size_t i;
85571bc7 FB	545	double ver;
	546	int status;
	547	int output_type = -1;
1d14ffa9	548	const char *drv = conf.drvname;
85571bc7 FB	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
1d14ffa9 FB	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
85571bc7 FB	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) {
1d14ffa9 FB	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	}
85571bc7 FB	579	}
	580	}
	581
	582	if (output_type != -1) {
	583	status = FSOUND_SetOutput (output_type);
	584	if (!status) {
1d14ffa9	585	fmod_logerr ("FSOUND_SetOutput(%d) failed\n", output_type);
85571bc7 FB	586	return NULL;
	587	}
	588	}
	589
85571bc7 FB	590	if (conf.bufsize) {
	591	status = FSOUND_SetBufferSize (conf.bufsize);
	592	if (!status) {
1d14ffa9	593	fmod_logerr ("FSOUND_SetBufferSize (%d) failed\n", conf.bufsize);
85571bc7 FB	594	}
	595	}
	596
	597	status = FSOUND_Init (conf.freq, conf.nb_channels, 0);
	598	if (!status) {
1d14ffa9	599	fmod_logerr ("FSOUND_Init failed\n");
85571bc7 FB	600	return NULL;
	601	}
	602
	603	return &conf;
	604	}
	605
1d14ffa9 FB	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
85571bc7 FB	634	static void fmod_audio_fini (void *opaque)
85571bc7 FB	635	{
1d14ffa9	636	(void) opaque;
85571bc7 FB	637	FSOUND_Close ();
	638	}
	639
1d14ffa9 FB	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
85571bc7 FB	671	};
85571bc7 FB	672
1d14ffa9 FB	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)
85571bc7	685	};