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