vtest.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/time.h>

#include <alsa/asoundlib.h>

int xrun_count;

int dsp_fd;

static int buffer_size;
static int period_size;

static void
set_hwparams(snd_pcm_t *handle)
{
        snd_pcm_uframes_t size;
        int dir;
        snd_pcm_hw_params_t *hwparams;
    unsigned int uval;

        snd_pcm_hw_params_malloc(&hwparams);

        snd_pcm_hw_params_any(handle, hwparams);

        snd_pcm_hw_params_set_rate_resample(handle, hwparams, 1);

        snd_pcm_hw_params_set_access(handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED);
        snd_pcm_hw_params_set_format(handle, hwparams, SND_PCM_FORMAT_U8);
        snd_pcm_hw_params_set_channels(handle, hwparams, 1);

    uval = 11025;
        snd_pcm_hw_params_set_rate_near(handle, hwparams, &uval, 0);

    uval = 500 * 1000; /* usecs */
        snd_pcm_hw_params_set_buffer_time_near(handle, hwparams, &uval, &dir);
        snd_pcm_hw_params_get_buffer_size(hwparams, &size);
    buffer_size = size;

    uval = 100 * 1000;
        snd_pcm_hw_params_set_period_time_near(handle, hwparams, &uval, &dir);
        snd_pcm_hw_params_get_period_size(hwparams, &size, &dir);
    period_size = size;

        snd_pcm_hw_params(handle, hwparams);

    printf ("buffer_size %d; period_size %d\n", buffer_size, period_size);
}

static void
set_swparams(snd_pcm_t *handle)
{
        snd_pcm_sw_params_t *swparams;

        snd_pcm_sw_params_malloc(&swparams);

        snd_pcm_sw_params_current(handle, swparams);

        /* start the transfer when the buffer is almost full: */
        /* (buffer_size / avail_min) * avail_min */
        snd_pcm_sw_params_set_start_threshold(handle, swparams, (buffer_size / period_size) * period_size);

        /* allow the transfer when at least period_size samples can be processed */
        snd_pcm_sw_params_set_avail_min(handle, swparams, period_size);

        /* align all transfers to 1 sample */
        snd_pcm_sw_params_set_xfer_align(handle, swparams, 1);

        snd_pcm_sw_params(handle, swparams);
}

snd_pcm_t *pcm;

void
sound_init (void)
{
    int err;
    char *device;

    device = "plughw:0,0";

    printf ("opening pcm device %s\n", device);
        if ((err = snd_pcm_open(&pcm, device, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)) < 0) {
                printf("Playback open error: %s\n", snd_strerror(err));
        exit (1);
        }

    set_hwparams(pcm);
    set_swparams(pcm);
}

int soundbuf_size;
unsigned char *soundbuf;
int soundbuf_used;
int soundbuf_off;
int soundbuf_playing;

/* return 0 when there is nothing left to play */
int
sound_step (void)
{
    int avail, n;

    if (soundbuf_playing == 0)
        return (0);

    if ((avail = soundbuf_used - soundbuf_off) == 0) {
        soundbuf_playing = 0;

        snd_pcm_drain (pcm);
        return (0);
    }

    if (avail > period_size)
        avail = period_size;

    n = snd_pcm_writei (pcm, soundbuf + soundbuf_off, avail);

    if (n < 0) {
        if (n == -EAGAIN) {
            usleep (1);
            return (1);
        }
        if (n == -EPIPE) {
            xrun_count++;
            snd_pcm_prepare (pcm);
            return (1);
        }
        
        printf ("sound write error: %s\n", 
            snd_strerror(n));
        exit (1);
    }

//  printf ("used %d (xrun %d)\n", n, xrun_count);


    soundbuf_off += n;

    return (1);
}

void
sound_play (unsigned char *buf, int size)
{
    unsigned char *start_buf;

    if (size > soundbuf_size) {
        if (soundbuf)
            free (soundbuf);
        soundbuf_size = size;
        if ((soundbuf = malloc (soundbuf_size)) == NULL) {
            fprintf (stderr, "out of memory\n");
            exit (1);
        }
    }

    memcpy (soundbuf, buf, size);

    soundbuf_used = size;
    soundbuf_off = 0;
    soundbuf_playing = 1;

    snd_pcm_start (pcm);
    snd_pcm_prepare (pcm);

    start_buf = malloc (buffer_size);
    memset (start_buf, 0x80, buffer_size);
    snd_pcm_writei (pcm, start_buf, buffer_size);
    free (start_buf);

    sound_step ();
}

double
get_time (void)
{
    struct timeval tv;
    gettimeofday (&tv, NULL);
    return (tv.tv_sec + tv.tv_usec / 1e6);
}

void
busywait (double secs)
{
    double start;
    start = get_time ();
    while (get_time () - start < secs)
        ;
}

void
usage (void)
{
    fprintf (stderr, "usage: vtest idx\n");
    exit (1);
}

int
main (int argc, char **argv)
{
    int c;
    char *filename;
    int idx;
    FILE *f;
    char *rawbuf;
    FILE *outf;
    int i;

    struct TM {
        long offset;
        long size;
    } ABSnd;

    filename = "/l/baris/gamedat/unews.cdr";

    while ((c = getopt (argc, argv, "")) != EOF) {
        switch (c) {
        default:
            usage ();
        }
    }

    if (optind >= argc)
        usage ();

    idx = atoi (argv[optind++]);

    if (optind != argc)
        usage ();

    if ((f = fopen (filename, "rb")) == NULL) {
        fprintf (stderr, "can't open %s\n", filename);
        exit (1);
    }

    fseek (f, idx * sizeof (ABSnd), SEEK_SET);
    fread (&ABSnd, sizeof ABSnd, 1, f);

    printf ("offset %ld; size %ld\n", ABSnd.offset, ABSnd.size);

    if ((rawbuf = malloc (ABSnd.size)) == NULL) {
        fprintf (stderr, "out of memory\n");
        exit (1);
    }

    fseek (f, ABSnd.offset, SEEK_SET);
    fread (rawbuf, 1, ABSnd.size, f);

    outf = fopen ("x", "wb");
    fwrite (rawbuf, 1, ABSnd.size, outf);
    fclose (outf);

    outf = fopen ("y", "wb");
    for (i = 0; i < ABSnd.size; i++)
        fprintf (outf, "%d\n", rawbuf[i] & 0xff);
    fclose (outf);

    sound_init ();

    usleep (250 * 1000);

    sound_play ((unsigned char *)rawbuf, ABSnd.size);
    while (sound_step ())
        ;

    usleep (250 * 1000);

    printf ("total xruns %d\n", xrun_count);

    return (0);
}

---