[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 "qemu-common.h"
#include "audio.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 = {
    .nb_samples  = 2048 * 2,
    .freq        = 44100,
    .nb_channels = 2,
};

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;
    struct st_sample *src1 = hw->mix_buf + hw->rpos;
    struct st_sample *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, struct audsettings *as)
{
    int bits16, mode, channel;
    FMODVoiceOut *fmd = (FMODVoiceOut *) hw;
    struct audsettings 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, struct audsettings *as)
{
    int bits16, mode;
    FMODVoiceIn *fmd = (FMODVoiceIn *) hw;
    struct audsettings 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[] = {
    { .name = "none",   .type = FSOUND_OUTPUT_NOSOUND },
#ifdef _WIN32
    { .name = "winmm",  .type = FSOUND_OUTPUT_WINMM   },
    { .name = "dsound", .type = FSOUND_OUTPUT_DSOUND  },
    { .name = "a3d",    .type = FSOUND_OUTPUT_A3D     },
    { .name = "asio",   .type = FSOUND_OUTPUT_ASIO    },
#endif
#ifdef __linux__
    { .name = "oss",    .type = FSOUND_OUTPUT_OSS     },
    { .name = "alsa",   .type = FSOUND_OUTPUT_ALSA    },
    { .name = "esd",    .type = FSOUND_OUTPUT_ESD     },
#endif
#ifdef __APPLE__
    { .name = "mac",    .type = FSOUND_OUTPUT_MAC     },
#endif
#if 0
    { .name = "xbox",   .type = FSOUND_OUTPUT_XBOX    },
    { .name = "ps2",    .type = FSOUND_OUTPUT_PS2     },
    { .name = "gcube",  .type = FSOUND_OUTPUT_GC      },
#endif
    { .name = "none-realtime", .type = 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 < ARRAY_SIZE (drvtab); 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 < ARRAY_SIZE (drvtab); 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[] = {
    {
        .name  = "DRV",
        .tag   = AUD_OPT_STR,
        .valp  = &conf.drvname,
        .descr = "FMOD driver"
    },
    {
        .name  = "FREQ",
        .tag   = AUD_OPT_INT,
        .valp  = &conf.freq,
        .descr = "Default frequency"
    },
    {
        .name  = "SAMPLES",
        .tag   = AUD_OPT_INT,
        .valp  = &conf.nb_samples,
        .descr = "Buffer size in samples"
    },
    {
        .name  = "CHANNELS",
        .tag   = AUD_OPT_INT,
        .valp  = &conf.nb_channels,
        .descr = "Number of default channels (1 - mono, 2 - stereo)"
    },
    {
        .name  = "BUFSIZE",
        .tag   = AUD_OPT_INT,
        .valp  = &conf.bufsize,
        .descr = "(undocumented)"
    }
#if 0
    {
        .name  = "THRESHOLD",
        .tag   = AUD_OPT_INT,
        .valp  = &conf.threshold,
        .descr = "(undocumented)"
    }
#endif
    { /* End of list */ }
};

static struct audio_pcm_ops fmod_pcm_ops = {
    .init_out = fmod_init_out,
    .fini_out = fmod_fini_out,
    .run_out  = fmod_run_out,
    .write    = fmod_write,
    .ctl_out  = fmod_ctl_out,

    .init_in  = fmod_init_in,
    .fini_in  = fmod_fini_in,
    .run_in   = fmod_run_in,
    .read     = fmod_read,
    .ctl_in   = fmod_ctl_in
};

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