Archipelago » qemu

/*

 * QEMU ALSA audio driver

 *

 * Copyright (c) 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 <alsa/asoundlib.h>

#include "qemu-common.h"

#include "qemu-char.h"

#include "audio.h"

#if QEMU_GNUC_PREREQ(4, 3)

#pragma GCC diagnostic ignored "-Waddress"

#endif

#define AUDIO_CAP "alsa"

#include "audio_int.h"

struct pollhlp {

    snd_pcm_t *handle;

    struct pollfd *pfds;

    int count;

    int mask;

};

typedef struct ALSAVoiceOut {

    HWVoiceOut hw;

    int wpos;

    int pending;

    void *pcm_buf;

    snd_pcm_t *handle;

    struct pollhlp pollhlp;

} ALSAVoiceOut;

typedef struct ALSAVoiceIn {

    HWVoiceIn hw;

    snd_pcm_t *handle;

    void *pcm_buf;

    struct pollhlp pollhlp;

} ALSAVoiceIn;

static struct {

    int size_in_usec_in;

    int size_in_usec_out;

    const char *pcm_name_in;

    const char *pcm_name_out;

    unsigned int buffer_size_in;

    unsigned int period_size_in;

    unsigned int buffer_size_out;

    unsigned int period_size_out;

    unsigned int threshold;

    int buffer_size_in_overridden;

    int period_size_in_overridden;

    int buffer_size_out_overridden;

    int period_size_out_overridden;

    int verbose;

} conf = {

    .buffer_size_out = 4096,

    .period_size_out = 1024,

    .pcm_name_out = "default",

    .pcm_name_in = "default",

};

struct alsa_params_req {

    int freq;

    snd_pcm_format_t fmt;

    int nchannels;

    int size_in_usec;

    int override_mask;

    unsigned int buffer_size;

    unsigned int period_size;

};

struct alsa_params_obt {

    int freq;

    audfmt_e fmt;

    int endianness;

    int nchannels;

    snd_pcm_uframes_t samples;

};

static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, 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", snd_strerror (err));

}

static void GCC_FMT_ATTR (3, 4) alsa_logerr2 (

    int err,

    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", snd_strerror (err));

}

static void alsa_fini_poll (struct pollhlp *hlp)

{

    int i;

    struct pollfd *pfds = hlp->pfds;

    if (pfds) {

        for (i = 0; i < hlp->count; ++i) {

            qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);

        }

        qemu_free (pfds);

    }

    hlp->pfds = NULL;

    hlp->count = 0;

    hlp->handle = NULL;

}

static void alsa_anal_close1 (snd_pcm_t **handlep)

{

    int err = snd_pcm_close (*handlep);

    if (err) {

        alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep);

    }

    *handlep = NULL;

}

static void alsa_anal_close (snd_pcm_t **handlep, struct pollhlp *hlp)

{

    alsa_fini_poll (hlp);

    alsa_anal_close1 (handlep);

}

static int alsa_recover (snd_pcm_t *handle)

{

    int err = snd_pcm_prepare (handle);

    if (err < 0) {

        alsa_logerr (err, "Failed to prepare handle %p\n", handle);

        return -1;

    }

    return 0;

}

static int alsa_resume (snd_pcm_t *handle)

{

    int err = snd_pcm_resume (handle);

    if (err < 0) {

        alsa_logerr (err, "Failed to resume handle %p\n", handle);

        return -1;

    }

    return 0;

}

static void alsa_poll_handler (void *opaque)

{

    int err, count;

    snd_pcm_state_t state;

    struct pollhlp *hlp = opaque;

    unsigned short revents;

    count = poll (hlp->pfds, hlp->count, 0);

    if (count < 0) {

        dolog ("alsa_poll_handler: poll %s\n", strerror (errno));

        return;

    }

    if (!count) {

        return;

    }

    /* XXX: ALSA example uses initial count, not the one returned by

       poll, correct? */

    err = snd_pcm_poll_descriptors_revents (hlp->handle, hlp->pfds,

                                            hlp->count, &revents);

    if (err < 0) {

        alsa_logerr (err, "snd_pcm_poll_descriptors_revents");

        return;

    }

    if (!(revents & hlp->mask)) {

        if (conf.verbose) {

            dolog ("revents = %d\n", revents);

        }

        return;

    }

    state = snd_pcm_state (hlp->handle);

    switch (state) {

    case SND_PCM_STATE_SETUP:

        alsa_recover (hlp->handle);

        break;

    case SND_PCM_STATE_XRUN:

        alsa_recover (hlp->handle);

        break;

    case SND_PCM_STATE_SUSPENDED:

        alsa_resume (hlp->handle);

        break;

    case SND_PCM_STATE_PREPARED:

        audio_run ("alsa run (prepared)");

        break;

    case SND_PCM_STATE_RUNNING:

        audio_run ("alsa run (running)");

        break;

    default:

        dolog ("Unexpected state %d\n", state);

    }

}

static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask)

{

    int i, count, err;

    struct pollfd *pfds;

    count = snd_pcm_poll_descriptors_count (handle);

    if (count <= 0) {

        dolog ("Could not initialize poll mode\n"

               "Invalid number of poll descriptors %d\n", count);

        return -1;

    }

    pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds));

    if (!pfds) {

        dolog ("Could not initialize poll mode\n");

        return -1;

    }

    err = snd_pcm_poll_descriptors (handle, pfds, count);

    if (err < 0) {

        alsa_logerr (err, "Could not initialize poll mode\n"

                     "Could not obtain poll descriptors\n");

        qemu_free (pfds);

        return -1;

    }

    for (i = 0; i < count; ++i) {

        if (pfds[i].events & POLLIN) {

            err = qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler,

                                       NULL, hlp);

        }

        if (pfds[i].events & POLLOUT) {

            if (conf.verbose) {

                dolog ("POLLOUT %d %d\n", i, pfds[i].fd);

            }

            err = qemu_set_fd_handler (pfds[i].fd, NULL,

                                       alsa_poll_handler, hlp);

        }

        if (conf.verbose) {

            dolog ("Set handler events=%#x index=%d fd=%d err=%d\n",

                   pfds[i].events, i, pfds[i].fd, err);

        }

        if (err) {

            dolog ("Failed to set handler events=%#x index=%d fd=%d err=%d\n",

                   pfds[i].events, i, pfds[i].fd, err);

            while (i--) {

                qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);

            }

            qemu_free (pfds);

            return -1;

        }

    }

    hlp->pfds = pfds;

    hlp->count = count;

    hlp->handle = handle;

    hlp->mask = mask;

    return 0;

}

static int alsa_poll_out (HWVoiceOut *hw)

{

    ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;

    return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLOUT);

}

static int alsa_poll_in (HWVoiceIn *hw)

{

    ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;

    return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLIN);

}

static int alsa_write (SWVoiceOut *sw, void *buf, int len)

{

    return audio_pcm_sw_write (sw, buf, len);

}

static snd_pcm_format_t aud_to_alsafmt (audfmt_e fmt, int endianness)

{

    switch (fmt) {

    case AUD_FMT_S8:

        return SND_PCM_FORMAT_S8;

    case AUD_FMT_U8:

        return SND_PCM_FORMAT_U8;

    case AUD_FMT_S16:

        if (endianness) {

            return SND_PCM_FORMAT_S16_BE;

        }

        else {

            return SND_PCM_FORMAT_S16_LE;

        }

    case AUD_FMT_U16:

        if (endianness) {

            return SND_PCM_FORMAT_U16_BE;

        }

        else {

            return SND_PCM_FORMAT_U16_LE;

        }

    case AUD_FMT_S32:

        if (endianness) {

            return SND_PCM_FORMAT_S32_BE;

        }

        else {

            return SND_PCM_FORMAT_S32_LE;

        }

    case AUD_FMT_U32:

        if (endianness) {

            return SND_PCM_FORMAT_U32_BE;

        }

        else {

            return SND_PCM_FORMAT_U32_LE;

        }

    default:

        dolog ("Internal logic error: Bad audio format %d\n", fmt);

#ifdef DEBUG_AUDIO

        abort ();

#endif

        return SND_PCM_FORMAT_U8;

    }

}

static int alsa_to_audfmt (snd_pcm_format_t alsafmt, audfmt_e *fmt,

                           int *endianness)

{

    switch (alsafmt) {

    case SND_PCM_FORMAT_S8:

        *endianness = 0;

        *fmt = AUD_FMT_S8;

        break;

    case SND_PCM_FORMAT_U8:

        *endianness = 0;

        *fmt = AUD_FMT_U8;

        break;

    case SND_PCM_FORMAT_S16_LE:

        *endianness = 0;

        *fmt = AUD_FMT_S16;

        break;

    case SND_PCM_FORMAT_U16_LE:

        *endianness = 0;

        *fmt = AUD_FMT_U16;

        break;

    case SND_PCM_FORMAT_S16_BE:

        *endianness = 1;

        *fmt = AUD_FMT_S16;

        break;

    case SND_PCM_FORMAT_U16_BE:

        *endianness = 1;

        *fmt = AUD_FMT_U16;

        break;

    case SND_PCM_FORMAT_S32_LE:

        *endianness = 0;

        *fmt = AUD_FMT_S32;

        break;

    case SND_PCM_FORMAT_U32_LE:

        *endianness = 0;

        *fmt = AUD_FMT_U32;

        break;

    case SND_PCM_FORMAT_S32_BE:

        *endianness = 1;

        *fmt = AUD_FMT_S32;

        break;

    case SND_PCM_FORMAT_U32_BE:

        *endianness = 1;

        *fmt = AUD_FMT_U32;

        break;

    default:

        dolog ("Unrecognized audio format %d\n", alsafmt);

        return -1;

    }

    return 0;

}

static void alsa_dump_info (struct alsa_params_req *req,

                            struct alsa_params_obt *obt,

                            snd_pcm_format_t obtfmt)

{

    dolog ("parameter | requested value | obtained value\n");

    dolog ("format    |      %10d |     %10d\n", req->fmt, obtfmt);

    dolog ("channels  |      %10d |     %10d\n",

           req->nchannels, obt->nchannels);

    dolog ("frequency |      %10d |     %10d\n", req->freq, obt->freq);

    dolog ("============================================\n");

    dolog ("requested: buffer size %d period size %d\n",

           req->buffer_size, req->period_size);

    dolog ("obtained: samples %ld\n", obt->samples);

}

static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold)

{

    int err;

    snd_pcm_sw_params_t *sw_params;

    snd_pcm_sw_params_alloca (&sw_params);

    err = snd_pcm_sw_params_current (handle, sw_params);

    if (err < 0) {

        dolog ("Could not fully initialize DAC\n");

        alsa_logerr (err, "Failed to get current software parameters\n");

        return;

    }

    err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold);

    if (err < 0) {

        dolog ("Could not fully initialize DAC\n");

        alsa_logerr (err, "Failed to set software threshold to %ld\n",

                     threshold);

        return;

    }

    err = snd_pcm_sw_params (handle, sw_params);

    if (err < 0) {

        dolog ("Could not fully initialize DAC\n");

        alsa_logerr (err, "Failed to set software parameters\n");

        return;

    }

}

static int alsa_open (int in, struct alsa_params_req *req,

                      struct alsa_params_obt *obt, snd_pcm_t **handlep)

{

    snd_pcm_t *handle;

    snd_pcm_hw_params_t *hw_params;

    int err;

    int size_in_usec;

    unsigned int freq, nchannels;

    const char *pcm_name = in ? conf.pcm_name_in : conf.pcm_name_out;

    snd_pcm_uframes_t obt_buffer_size;

    const char *typ = in ? "ADC" : "DAC";

    snd_pcm_format_t obtfmt;

    freq = req->freq;

    nchannels = req->nchannels;

    size_in_usec = req->size_in_usec;

    snd_pcm_hw_params_alloca (&hw_params);

    err = snd_pcm_open (

        &handle,

        pcm_name,

        in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,

        SND_PCM_NONBLOCK

        );

    if (err < 0) {

        alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name);

        return -1;

    }

    err = snd_pcm_hw_params_any (handle, hw_params);

    if (err < 0) {

        alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n");

        goto err;

    }

    err = snd_pcm_hw_params_set_access (

        handle,

        hw_params,

        SND_PCM_ACCESS_RW_INTERLEAVED

        );

    if (err < 0) {

        alsa_logerr2 (err, typ, "Failed to set access type\n");

        goto err;

    }

    err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt);

    if (err < 0 && conf.verbose) {

        alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt);

    }

    err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0);

    if (err < 0) {

        alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq);

        goto err;

    }

    err = snd_pcm_hw_params_set_channels_near (

        handle,

        hw_params,

        &nchannels

        );

    if (err < 0) {

        alsa_logerr2 (err, typ, "Failed to set number of channels %d\n",

                      req->nchannels);

        goto err;

    }

    if (nchannels != 1 && nchannels != 2) {

        alsa_logerr2 (err, typ,

                      "Can not handle obtained number of channels %d\n",

                      nchannels);

        goto err;

    }

    if (req->buffer_size) {

        unsigned long obt;

        if (size_in_usec) {

            int dir = 0;

            unsigned int btime = req->buffer_size;

            err = snd_pcm_hw_params_set_buffer_time_near (

                handle,

                hw_params,

                &btime,

                &dir

                );

            obt = btime;

        }

        else {

            snd_pcm_uframes_t bsize = req->buffer_size;

            err = snd_pcm_hw_params_set_buffer_size_near (

                handle,

                hw_params,

                &bsize

                );

            obt = bsize;

        }

        if (err < 0) {

            alsa_logerr2 (err, typ, "Failed to set buffer %s to %d\n",

                          size_in_usec ? "time" : "size", req->buffer_size);

            goto err;

        }

        if ((req->override_mask & 2) && (obt - req->buffer_size))

            dolog ("Requested buffer %s %u was rejected, using %lu\n",

                   size_in_usec ? "time" : "size", req->buffer_size, obt);

    }

    if (req->period_size) {

        unsigned long obt;

        if (size_in_usec) {

            int dir = 0;

            unsigned int ptime = req->period_size;

            err = snd_pcm_hw_params_set_period_time_near (

                handle,

                hw_params,

                &ptime,

                &dir

                );

            obt = ptime;

        }

        else {

            int dir = 0;

            snd_pcm_uframes_t psize = req->period_size;

            err = snd_pcm_hw_params_set_period_size_near (

                handle,

                hw_params,

                &psize,

                &dir

                );

            obt = psize;

        }

        if (err < 0) {

            alsa_logerr2 (err, typ, "Failed to set period %s to %d\n",

                          size_in_usec ? "time" : "size", req->period_size);

            goto err;

        }

        if (((req->override_mask & 1) && (obt - req->period_size)))

            dolog ("Requested period %s %u was rejected, using %lu\n",

                   size_in_usec ? "time" : "size", req->period_size, obt);

    }

    err = snd_pcm_hw_params (handle, hw_params);

    if (err < 0) {

        alsa_logerr2 (err, typ, "Failed to apply audio parameters\n");

        goto err;

    }

    err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size);

    if (err < 0) {

        alsa_logerr2 (err, typ, "Failed to get buffer size\n");

        goto err;

    }

    err = snd_pcm_hw_params_get_format (hw_params, &obtfmt);

    if (err < 0) {

        alsa_logerr2 (err, typ, "Failed to get format\n");

        goto err;

    }

    if (alsa_to_audfmt (obtfmt, &obt->fmt, &obt->endianness)) {

        dolog ("Invalid format was returned %d\n", obtfmt);

        goto err;

    }

    err = snd_pcm_prepare (handle);

    if (err < 0) {

        alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle);

        goto err;

    }

    if (!in && conf.threshold) {

        snd_pcm_uframes_t threshold;

        int bytes_per_sec;

        bytes_per_sec = freq << (nchannels == 2);

        switch (obt->fmt) {

        case AUD_FMT_S8:

        case AUD_FMT_U8:

            break;

        case AUD_FMT_S16:

        case AUD_FMT_U16:

            bytes_per_sec <<= 1;

            break;

        case AUD_FMT_S32:

        case AUD_FMT_U32:

            bytes_per_sec <<= 2;

            break;

        }

        threshold = (conf.threshold * bytes_per_sec) / 1000;

        alsa_set_threshold (handle, threshold);

    }

    obt->nchannels = nchannels;

    obt->freq = freq;

    obt->samples = obt_buffer_size;

    *handlep = handle;

    if (conf.verbose &&

        (obtfmt != req->fmt ||

         obt->nchannels != req->nchannels ||

         obt->freq != req->freq)) {

        dolog ("Audio parameters for %s\n", typ);

        alsa_dump_info (req, obt, obtfmt);

    }

#ifdef DEBUG

    alsa_dump_info (req, obt, obtfmt);

#endif

    return 0;

 err:

    alsa_anal_close1 (&handle);

    return -1;

}

static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)

{

    snd_pcm_sframes_t avail;

    avail = snd_pcm_avail_update (handle);

    if (avail < 0) {

        if (avail == -EPIPE) {

            if (!alsa_recover (handle)) {

                avail = snd_pcm_avail_update (handle);

            }

        }

        if (avail < 0) {

            alsa_logerr (avail,

                         "Could not obtain number of available frames\n");

            return -1;

        }

    }

    return avail;

}

static void alsa_write_pending (ALSAVoiceOut *alsa)

{

    HWVoiceOut *hw = &alsa->hw;

    while (alsa->pending) {

        int left_till_end_samples = hw->samples - alsa->wpos;

        int len = audio_MIN (alsa->pending, left_till_end_samples);

        char *src = advance (alsa->pcm_buf, alsa->wpos << hw->info.shift);

        while (len) {

            snd_pcm_sframes_t written;

            written = snd_pcm_writei (alsa->handle, src, len);

            if (written <= 0) {

                switch (written) {

                case 0:

                    if (conf.verbose) {

                        dolog ("Failed to write %d frames (wrote zero)\n", len);

                    }

                    return;

                case -EPIPE:

                    if (alsa_recover (alsa->handle)) {

                        alsa_logerr (written, "Failed to write %d frames\n",

                                     len);

                        return;

                    }

                    if (conf.verbose) {

                        dolog ("Recovering from playback xrun\n");

                    }

                    continue;

                case -ESTRPIPE:

                    /* stream is suspended and waiting for an

                       application recovery */

                    if (alsa_resume (alsa->handle)) {

                        alsa_logerr (written, "Failed to write %d frames\n",

                                     len);

                        return;

                    }

                    if (conf.verbose) {

                        dolog ("Resuming suspended output stream\n");

                    }

                    continue;

                case -EAGAIN:

                    return;

                default:

                    alsa_logerr (written, "Failed to write %d frames from %p\n",

                                 len, src);

                    return;

                }

            }

            alsa->wpos = (alsa->wpos + written) % hw->samples;

            alsa->pending -= written;

            len -= written;

        }

    }

}

static int alsa_run_out (HWVoiceOut *hw, int live)

{

    ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;

    int decr;

    snd_pcm_sframes_t avail;

    avail = alsa_get_avail (alsa->handle);

    if (avail < 0) {

        dolog ("Could not get number of available playback frames\n");

        return 0;

    }

    decr = audio_MIN (live, avail);

    decr = audio_pcm_hw_clip_out (hw, alsa->pcm_buf, decr, alsa->pending);

    alsa->pending += decr;

    alsa_write_pending (alsa);

    return decr;

}

static void alsa_fini_out (HWVoiceOut *hw)

{

    ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;

    ldebug ("alsa_fini\n");

    alsa_anal_close (&alsa->handle, &alsa->pollhlp);

    if (alsa->pcm_buf) {

        qemu_free (alsa->pcm_buf);

        alsa->pcm_buf = NULL;

    }

}

static int alsa_init_out (HWVoiceOut *hw, struct audsettings *as)

{

    ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;

    struct alsa_params_req req;

    struct alsa_params_obt obt;

    snd_pcm_t *handle;

    struct audsettings obt_as;

    req.fmt = aud_to_alsafmt (as->fmt, as->endianness);

    req.freq = as->freq;

    req.nchannels = as->nchannels;

    req.period_size = conf.period_size_out;

    req.buffer_size = conf.buffer_size_out;

    req.size_in_usec = conf.size_in_usec_out;

    req.override_mask =

        (conf.period_size_out_overridden ? 1 : 0) |

        (conf.buffer_size_out_overridden ? 2 : 0);

    if (alsa_open (0, &req, &obt, &handle)) {

        return -1;

    }

    obt_as.freq = obt.freq;

    obt_as.nchannels = obt.nchannels;

    obt_as.fmt = obt.fmt;

    obt_as.endianness = obt.endianness;

    audio_pcm_init_info (&hw->info, &obt_as);

    hw->samples = obt.samples;

    alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift);

    if (!alsa->pcm_buf) {

        dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",

               hw->samples, 1 << hw->info.shift);

        alsa_anal_close1 (&handle);

        return -1;

    }

    alsa->handle = handle;

    return 0;

}

#define VOICE_CTL_PAUSE 0

#define VOICE_CTL_PREPARE 1

#define VOICE_CTL_START 2

static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int ctl)

{

    int err;

    if (ctl == VOICE_CTL_PAUSE) {

        err = snd_pcm_drop (handle);

        if (err < 0) {

            alsa_logerr (err, "Could not stop %s\n", typ);

            return -1;

        }

    }

    else {