SDL Audio support and SB16 fixes (malc)

[qemu.git] / oss.c

/*
 * QEMU OSS Audio output driver
 * 
 * Copyright (c) 2003 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 "vl.h"

#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>

/* TODO: Graceful error handling */

#if defined(_WIN32)
#define USE_SDL_AUDIO
#endif

#define MIN(a, b) ((a)>(b)?(b):(a))
#define MAX(a, b) ((a)<(b)?(b):(a))

#define DEREF(x) (void)x
#define dolog(...) fprintf (stderr, "audio: " __VA_ARGS__)
#define ERRFail(...) do {                                               \
    int _errno = errno;                                                 \
    fprintf (stderr, "audio: " __VA_ARGS__);                            \
    fprintf (stderr, "\nsystem error: %s\n", strerror (_errno));        \
    abort ();                                                           \
} while (0)
#define Fail(...) do {                          \
    fprintf (stderr, "audio: " __VA_ARGS__);    \
    fprintf (stderr, "\n");                     \
    abort ();                                   \
} while (0)

#ifdef DEBUG_AUDIO
#define lwarn(...) fprintf (stderr, "audio: " __VA_ARGS__)
#define linfo(...) fprintf (stderr, "audio: " __VA_ARGS__)
#define ldebug(...) fprintf (stderr, "audio: " __VA_ARGS__)
#else
#define lwarn(...)
#define linfo(...)
#define ldebug(...)
#endif

static int get_conf_val (const char *key, int defval)
{
    int val = defval;
    char *strval;

    strval = getenv (key);
    if (strval) {
        val = atoi (strval);
    }

    return val;
}

static void copy_no_conversion (void *dst, void *src, int size)
{
    memcpy (dst, src, size);
}

static void copy_u16_to_s16 (void *dst, void *src, int size)
{
    int i;
    uint16_t *out, *in;

    out = dst;
    in = src;

    for (i = 0; i < size / 2; i++) {
        out[i] = in[i] + 0x8000;
    }
}

#ifdef USE_SDL_AUDIO
#include <SDL/SDL.h>
#include <SDL/SDL_thread.h>

static struct {
    int samples;
} conf = {
    .samples = 4096
};

typedef struct AudioState {
    int freq;
    int bits16;
    int nchannels;
    int rpos;
    int wpos;
    volatile int live;
    volatile int exit;
    int bytes_per_second;
    Uint8 *buf;
    int bufsize;
    int leftover;
    uint64_t old_ticks;
    SDL_AudioSpec spec;
    SDL_mutex *mutex;
    SDL_sem *sem;
    void (*copy_fn)(void *, void *, int);
} AudioState;

static AudioState sdl_audio;

void AUD_run (void)
{
}

static void own (AudioState *s)
{
    /* SDL_LockAudio (); */
    if (SDL_mutexP (s->mutex))
        dolog ("SDL_mutexP: %s\n", SDL_GetError ());
}

static void disown (AudioState *s)
{
    /* SDL_UnlockAudio (); */
    if (SDL_mutexV (s->mutex))
        dolog ("SDL_mutexV: %s\n", SDL_GetError ());
}

static void sem_wait (AudioState *s)
{
    if (SDL_SemWait (s->sem))
        dolog ("SDL_SemWait: %s\n", SDL_GetError ());
}

static void sem_post (AudioState *s)
{
    if (SDL_SemPost (s->sem))
        dolog ("SDL_SemPost: %s\n", SDL_GetError ());
}

static void audio_callback (void *data, Uint8 *stream, int len)
{
    int to_mix;
    AudioState *s = data;

    if (s->exit) return;
    while (len) {
        sem_wait (s);
        if (s->exit) return;
        own (s);
        to_mix = MIN (len, s->live);
        len -= to_mix;
        /* printf ("to_mix=%d len=%d live=%d\n", to_mix, len, s->live); */
        while (to_mix) {
            int chunk = MIN (to_mix, s->bufsize - s->rpos);
            /* SDL_MixAudio (stream, buf, chunk, SDL_MIX_MAXVOLUME); */
            memcpy (stream, s->buf + s->rpos, chunk);

            s->rpos += chunk;
            s->live -= chunk;

            stream += chunk;
            to_mix -= chunk;

            if (s->rpos == s->bufsize) s->rpos = 0;
        }
        disown (s);
    }
}

static void sem_zero (AudioState *s)
{
    int res;

    do {
        res = SDL_SemTryWait (s->sem);
        if (res < 0) {
            dolog ("SDL_SemTryWait: %s\n", SDL_GetError ());
            return;
        }
    } while (res != SDL_MUTEX_TIMEDOUT);
}

static void do_open (AudioState *s)
{
    int status;
    SDL_AudioSpec obtained;

    SDL_PauseAudio (1);
    if (s->buf) {
        s->exit = 1;
        sem_post (s);
        SDL_CloseAudio ();
        s->exit = 0;
        qemu_free (s->buf);
        s->buf = NULL;
        sem_zero (s);
    }

    s->bytes_per_second = (s->spec.freq << (s->spec.channels >> 1)) << s->bits16;
    s->spec.samples = conf.samples;
    s->spec.userdata = s;
    s->spec.callback = audio_callback;

    status = SDL_OpenAudio (&s->spec, &obtained);
    if (status < 0) {
        dolog ("SDL_OpenAudio: %s\n", SDL_GetError ());
        goto exit;
    }

    if (obtained.freq != s->spec.freq ||
        obtained.channels != s->spec.channels ||
        obtained.format != s->spec.format) {
        dolog ("Audio spec mismatch requested obtained\n"
               "freq                %5d    %5d\n"
               "channels            %5d    %5d\n"
               "fmt                 %5d    %5d\n",
               s->spec.freq, obtained.freq,
               s->spec.channels, obtained.channels,
               s->spec.format, obtained.format
            );
    }

    s->bufsize = obtained.size;
    s->buf = qemu_mallocz (s->bufsize);
    if (!s->buf) {
        dolog ("qemu_mallocz(%d)\n", s->bufsize);
        goto exit;
    }
    SDL_PauseAudio (0);

exit:
    s->rpos = 0;
    s->wpos = 0;
    s->live = 0;
}

int AUD_write (void *in_buf, int size)
{
    AudioState *s = &sdl_audio;
    int to_copy, temp;
    uint8_t *in, *out;

    own (s);
    to_copy = MIN (s->bufsize - s->live, size);

    temp = to_copy;

    in = in_buf;
    out = s->buf;

    while (temp) {
        int copy;

        copy = MIN (temp, s->bufsize - s->wpos);
        s->copy_fn (out + s->wpos, in, copy);

        s->wpos += copy;
        if (s->wpos == s->bufsize) {
            s->wpos = 0;
        }

        temp -= copy;
        in += copy;
        s->live += copy;
    }

    disown (s);
    sem_post (s);
    return to_copy;
}

static void maybe_open (AudioState *s, int req_freq, int req_nchannels,
                        audfmt_e req_fmt, int force_open)
{
    int sdl_fmt, bits16;

    switch (req_fmt) {
    case AUD_FMT_U8:
        bits16 = 0;
        sdl_fmt = AUDIO_U8;
        s->copy_fn = copy_no_conversion;
        break;

    case AUD_FMT_S8:
        fprintf (stderr, "audio: can not play 8bit signed\n");
        return;

    case AUD_FMT_S16:
        bits16 = 1;
        sdl_fmt = AUDIO_S16;
        s->copy_fn = copy_no_conversion;
        break;

    case AUD_FMT_U16:
        bits16 = 1;
        sdl_fmt = AUDIO_S16;
        s->copy_fn = copy_u16_to_s16;
        break;

    default:
        abort ();
    }

    if (force_open
        || (NULL == s->buf)
        || (sdl_fmt != s->spec.format)
        || (req_nchannels != s->spec.channels)
        || (req_freq != s->spec.freq)
        || (bits16 != s->bits16)) {

        s->spec.format = sdl_fmt;
        s->spec.channels = req_nchannels;
        s->spec.freq = req_freq;
        s->bits16 = bits16;
        do_open (s);
    }
}

void AUD_reset (int req_freq, int req_nchannels, audfmt_e req_fmt)
{
    AudioState *s = &sdl_audio;
    own (s);
    maybe_open (s, req_freq, req_nchannels, req_fmt, 0);
    disown (s);
}

void AUD_open (int req_freq, int req_nchannels, audfmt_e req_fmt)
{
    AudioState *s = &sdl_audio;
    own (s);
    maybe_open (s, req_freq, req_nchannels, req_fmt, 1);
    disown (s);
}

void AUD_adjust_estimate (int leftover)
{
    AudioState *s = &sdl_audio;
    own (s);
    s->leftover = leftover;
    disown (s);
}

int AUD_get_free (void)
{
    int free, elapsed;
    uint64_t ticks, delta;
    uint64_t ua_elapsed;
    uint64_t al_elapsed;
    AudioState *s = &sdl_audio;

    own (s);
    free = s->bufsize - s->live;

    if (0 == free) {
        disown (s);
        return 0;
    }

    elapsed = free;
    ticks = qemu_get_clock(rt_clock);
    delta = ticks - s->old_ticks;
    s->old_ticks = ticks;

    ua_elapsed = (delta * s->bytes_per_second) / 1000;
    al_elapsed = ua_elapsed & ~3ULL;

    ldebug ("tid elapsed %llu bytes\n", ua_elapsed);

    if (al_elapsed > (uint64_t) INT_MAX)
        elapsed = INT_MAX;
    else
        elapsed = al_elapsed;

    elapsed += s->leftover;
    disown (s);

    if (elapsed > free) {
        lwarn ("audio can not keep up elapsed %d free %d\n", elapsed, free);
        return free;
    }
    else {
        return elapsed;
    }
}

int AUD_get_live (void)
{
    int live;
    AudioState *s = &sdl_audio;

    own (s);
    live = s->live;
    disown (s);
    return live;
}

int AUD_get_buffer_size (void)
{
    int bufsize;
    AudioState *s = &sdl_audio;

    own (s);
    bufsize = s->bufsize;
    disown (s);
    return bufsize;
}

#define QC_SDL_NSAMPLES "QEMU_SDL_NSAMPLES"

static void cleanup (void)
{
    AudioState *s = &sdl_audio;
    own (s);
    s->exit = 1;
    sem_post (s);
    disown (s);
}

void AUD_init (void)
{
    AudioState *s = &sdl_audio;

    atexit (cleanup);
    SDL_InitSubSystem (SDL_INIT_AUDIO);
    s->mutex = SDL_CreateMutex ();
    if (!s->mutex) {
        dolog ("SDL_CreateMutex: %s\n", SDL_GetError ());
        return;
    }

    s->sem = SDL_CreateSemaphore (0);
    if (!s->sem) {
        dolog ("SDL_CreateSemaphore: %s\n", SDL_GetError ());
        return;
    }

    conf.samples = get_conf_val (QC_SDL_NSAMPLES, conf.samples);
}

#elif !defined(_WIN32) && !defined(__APPLE__)

#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/soundcard.h>

/* http://www.df.lth.se/~john_e/gems/gem002d.html */
/* http://www.multi-platforms.com/Tips/PopCount.htm */
static inline uint32_t popcount (uint32_t u)
{
  u = ((u&0x55555555) + ((u>>1)&0x55555555));
  u = ((u&0x33333333) + ((u>>2)&0x33333333));
  u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f));
  u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff));
  u = ( u&0x0000ffff) + (u>>16);
  return u;
}

static inline uint32_t lsbindex (uint32_t u)
{
  return popcount ((u&-u)-1);
}

#define IOCTL(args) do {                        \
  int ret = ioctl args;                         \
  if (-1 == ret) {                              \
    ERRFail (#args);                            \
  }                                             \
  ldebug ("ioctl " #args " = %d\n", ret);       \
} while (0)

typedef struct AudioState {
    int fd;
    int freq;
    int bits16;
    int nchannels;
    int rpos;
    int wpos;
    int live;
    int oss_fmt;
    int bytes_per_second;
    int is_mapped;
    void *buf;
    int bufsize;
    int nfrags;
    int fragsize;
    int old_optr;
    int leftover;
    uint64_t old_ticks;
    void (*copy_fn)(void *, void *, int);
} AudioState;

static AudioState oss_audio = { .fd = -1 };

static struct {
    int try_mmap;
    int nfrags;
    int fragsize;
} conf = {
    .try_mmap = 0,
    .nfrags = 4,
    .fragsize = 4096
};

static enum {DONT, DSP, TID} est = DONT;

static void pab (AudioState *s, struct audio_buf_info *abinfo)
{
    DEREF (abinfo);

    ldebug ("fragments %d, fragstotal %d, fragsize %d, bytes %d\n"
            "rpos %d, wpos %d, live %d\n",
            abinfo->fragments,
            abinfo->fragstotal,
            abinfo->fragsize,
            abinfo->bytes,
            s->rpos, s->wpos, s->live);
}

static void do_open (AudioState *s)
{
    int mmmmssss;
    audio_buf_info abinfo;
    int fmt, freq, nchannels;

    if (s->buf) {
        if (s->is_mapped) {
            if (-1 == munmap (s->buf, s->bufsize)) {
            ERRFail ("failed to unmap audio buffer %p %d",
                         s->buf, s->bufsize);
        }
        }
        else {
            qemu_free (s->buf);
        }
        s->buf = NULL;
    }

    if (-1 != s->fd)
        close (s->fd);

    s->fd = open ("/dev/dsp", O_RDWR | O_NONBLOCK);
    if (-1 == s->fd) {
        ERRFail ("can not open /dev/dsp");
    }

    fmt = s->oss_fmt;
    freq = s->freq;
    nchannels = s->nchannels;

    IOCTL ((s->fd, SNDCTL_DSP_RESET, 1));
    IOCTL ((s->fd, SNDCTL_DSP_SAMPLESIZE, &fmt));
    IOCTL ((s->fd, SNDCTL_DSP_CHANNELS, &nchannels));
    IOCTL ((s->fd, SNDCTL_DSP_SPEED, &freq));
    IOCTL ((s->fd, SNDCTL_DSP_NONBLOCK));

    mmmmssss = (conf.nfrags << 16) | conf.fragsize;
    IOCTL ((s->fd, SNDCTL_DSP_SETFRAGMENT, &mmmmssss));

    if ((s->oss_fmt != fmt)
        || (s->nchannels != nchannels)
        || (s->freq != freq)) {
        Fail ("failed to set audio parameters\n"
              "parameter | requested value | obtained value\n"
              "format    |      %10d |     %10d\n"
              "channels  |      %10d |     %10d\n"
              "frequency |      %10d |     %10d\n",
              s->oss_fmt, fmt,
              s->nchannels, nchannels,
              s->freq, freq);
    }

    IOCTL ((s->fd, SNDCTL_DSP_GETOSPACE, &abinfo));

    s->nfrags = abinfo.fragstotal;
    s->fragsize = abinfo.fragsize;
    s->bufsize = s->nfrags * s->fragsize;
    s->old_optr = 0;

    s->bytes_per_second = (freq << (nchannels >> 1)) << s->bits16;

    linfo ("bytes per second %d\n", s->bytes_per_second);

    linfo ("fragments %d, fragstotal %d, fragsize %d, bytes %d, bufsize %d\n",
           abinfo.fragments,
           abinfo.fragstotal,
           abinfo.fragsize,
           abinfo.bytes,
           s->bufsize);

    s->buf = MAP_FAILED;
    s->is_mapped = 0;

    if (conf.try_mmap) {
        s->buf = mmap (NULL, s->bufsize, PROT_WRITE, MAP_SHARED, s->fd, 0);
        if (MAP_FAILED == s->buf) {
            int err;

            err = errno;
            dolog ("failed to mmap audio, size %d, fd %d\n"
                 "syserr: %s\n",
                   s->bufsize, s->fd, strerror (err));
        }
    else {
            est = TID;
            s->is_mapped = 1;
        }
    }

    if (MAP_FAILED == s->buf) {
        est = TID;
        s->buf = qemu_mallocz (s->bufsize);
        if (!s->buf) {
            ERRFail ("audio buf malloc failed, size %d", s->bufsize);
        }
    }

    s->rpos = 0;
    s->wpos = 0;
    s->live = 0;

    if (s->is_mapped) {
        int trig;

        trig = 0;
        IOCTL ((s->fd, SNDCTL_DSP_SETTRIGGER, &trig));
        trig = PCM_ENABLE_OUTPUT;
        IOCTL ((s->fd, SNDCTL_DSP_SETTRIGGER, &trig));
    }
}

static void maybe_open (AudioState *s, int req_freq, int req_nchannels,
                        audfmt_e req_fmt, int force_open)
{
    int oss_fmt, bits16;

    switch (req_fmt) {
    case AUD_FMT_U8:
        bits16 = 0;
        oss_fmt = AFMT_U8;
        s->copy_fn = copy_no_conversion;
        break;

    case AUD_FMT_S8:
        Fail ("can not play 8bit signed");

    case AUD_FMT_S16:
        bits16 = 1;
        oss_fmt = AFMT_S16_LE;
        s->copy_fn = copy_no_conversion;
        break;

    case AUD_FMT_U16:
        bits16 = 1;
        oss_fmt = AFMT_S16_LE;
        s->copy_fn = copy_u16_to_s16;
        break;

    default:
        abort ();
    }

    if (force_open
        || (-1 == s->fd)
        || (oss_fmt != s->oss_fmt)
        || (req_nchannels != s->nchannels)
        || (req_freq != s->freq)
        || (bits16 != s->bits16)) {
        s->oss_fmt = oss_fmt;
        s->nchannels = req_nchannels;
        s->freq = req_freq;
        s->bits16 = bits16;
        do_open (s);
    }
}

void AUD_reset (int req_freq, int req_nchannels, audfmt_e req_fmt)
{
    AudioState *s = &oss_audio;
    maybe_open (s, req_freq, req_nchannels, req_fmt, 0);
}

void AUD_open (int req_freq, int req_nchannels, audfmt_e req_fmt)
{
    AudioState *s = &oss_audio;
    maybe_open (s, req_freq, req_nchannels, req_fmt, 1);
}

int AUD_write (void *in_buf, int size)
{
    AudioState *s = &oss_audio;
    int to_copy, temp;
    uint8_t *in, *out;

    to_copy = MIN (s->bufsize - s->live, size);

    temp = to_copy;

    in = in_buf;
    out = s->buf;

    while (temp) {
        int copy;

        copy = MIN (temp, s->bufsize - s->wpos);
        s->copy_fn (out + s->wpos, in, copy);

        s->wpos += copy;
        if (s->wpos == s->bufsize) {
            s->wpos = 0;
        }

        temp -= copy;
        in += copy;
        s->live += copy;
    }

    return to_copy;
}

void AUD_run (void)
{
    int res;
    int bytes;
    struct audio_buf_info abinfo;
    AudioState *s = &oss_audio;

    if (0 == s->live)
        return;

    if (s->is_mapped) {
        count_info info;

        res = ioctl (s->fd, SNDCTL_DSP_GETOPTR, &info);
        if (res < 0) {
            int err;

            err = errno;
            lwarn ("SNDCTL_DSP_GETOPTR failed with %s\n", strerror (err));
            return;
        }

        if (info.ptr > s->old_optr) {
            bytes = info.ptr - s->old_optr;
        }
        else {
            bytes = s->bufsize + info.ptr - s->old_optr;
        }

        s->old_optr = info.ptr;
        s->live -= bytes;
        return;
    }

    res = ioctl (s->fd, SNDCTL_DSP_GETOSPACE, &abinfo);

    if (res < 0) {
        int err;

        err = errno;
        lwarn ("SNDCTL_DSP_GETOSPACE failed with %s\n", strerror (err));
        return;
    }

    bytes = abinfo.bytes;
    bytes = MIN (s->live, bytes);
#if 0
    bytes = (bytes / fragsize) * fragsize;
#endif

    while (bytes) {
        int left, play, written;

        left = s->bufsize - s->rpos;
        play = MIN (left, bytes);
        written = write (s->fd, (uint8_t *)s->buf + s->rpos, play);

        if (-1 == written) {
            if (EAGAIN == errno || EINTR == errno) {
                return;
            }
            else {
                ERRFail ("write audio");
            }
        }

        play = written;
        s->live -= play;
        s->rpos += play;
        bytes -= play;

        if (s->rpos == s->bufsize) {
            s->rpos = 0;
        }
    }
}

static int get_dsp_bytes (void)
{
    int res;
    struct count_info info;
    AudioState *s = &oss_audio;

    res = ioctl (s->fd, SNDCTL_DSP_GETOPTR, &info);
    if (-1 == res) {
        int err;

        err = errno;
        lwarn ("SNDCTL_DSP_GETOPTR failed with %s\n", strerror (err));
        return -1;
    }
    else {
        ldebug ("bytes %d\n", info.bytes);
        return info.bytes;
    }
}

void AUD_adjust_estimate (int leftover)
{
    AudioState *s = &oss_audio;
    s->leftover = leftover;
}

int AUD_get_free (void)
{
    int free, elapsed;
    AudioState *s = &oss_audio;

    free = s->bufsize - s->live;

    if (free <= 0)
        return 0;

    elapsed = free;
    switch (est) {
    case DONT:
        break;

    case DSP:
        {
            static int old_bytes;
            int bytes;

            bytes = get_dsp_bytes ();
            if (bytes <= 0)
                return free;

            elapsed = bytes - old_bytes;
            old_bytes = bytes;
            ldebug ("dsp elapsed %d bytes\n", elapsed);
            break;
        }

    case TID:
        {
            uint64_t ticks, delta;
            uint64_t ua_elapsed;
            uint64_t al_elapsed;

            ticks = qemu_get_clock(rt_clock);
            delta = ticks - s->old_ticks;
            s->old_ticks = ticks;

            ua_elapsed = (delta * s->bytes_per_second) / 1000;
            al_elapsed = ua_elapsed & ~3ULL;

            ldebug ("tid elapsed %llu bytes\n", ua_elapsed);

            if (al_elapsed > (uint64_t) INT_MAX)
                elapsed = INT_MAX;
            else
                elapsed = al_elapsed;

            elapsed += s->leftover;
        }
    }

    if (elapsed > free) {
        lwarn ("audio can not keep up elapsed %d free %d\n", elapsed, free);
        return free;
    }
    else {
        return elapsed;
    }
}

int AUD_get_live (void)
{
    AudioState *s = &oss_audio;
    return s->live;
}

int AUD_get_buffer_size (void)
{
    AudioState *s = &oss_audio;
    return s->bufsize;
}

#define QC_OSS_FRAGSIZE "QEMU_OSS_FRAGSIZE"
#define QC_OSS_NFRAGS "QEMU_OSS_NFRAGS"
#define QC_OSS_MMAP "QEMU_OSS_MMAP"

void AUD_init (void)
{
    int fsp;

    DEREF (pab);

    conf.fragsize = get_conf_val (QC_OSS_FRAGSIZE, conf.fragsize);
    conf.nfrags = get_conf_val (QC_OSS_NFRAGS, conf.nfrags);
    conf.try_mmap = get_conf_val (QC_OSS_MMAP, conf.try_mmap);

    fsp = conf.fragsize;
    if (0 != (fsp & (fsp - 1))) {
        Fail ("fragment size %d is not power of 2", fsp);
    }

    conf.fragsize = lsbindex (fsp);
}

#else

void AUD_run (void)
{
}

int AUD_write (void *in_buf, int size)
{
    return 0;
}

void AUD_reset (int rfreq, int rnchannels, audfmt_e rfmt)
{
}

void AUD_adjust_estimate (int _leftover)
{
}

int AUD_get_free (void)
{
    return 0;
}

int AUD_get_live (void)
{
    return 0;
}

int AUD_get_buffer_size (void)
{
    return 0;
}

void AUD_init (void)
{
}

#endif