Subversion Repositories svnkaklik

	#include <stdio.h>

	#include <stdlib.h>

	#include <errno.h>

	#include <poll.h>

	#include <alsa/asoundlib.h>

/* you allocate these in heap */

int             restarting;

int             fragments = 2;

int             channels = 1;

int             buffer_size = 512;

int             sample_rate = 48000;

int             frame_size = 1024;

int             bits = 16;

char           *snd_device_in  = "plughw:0,0";

char           *snd_device_out = "plughw:0,0";

snd_pcm_t      *playback_handle;

snd_pcm_t      *capture_handle;

int err;

int configure_alsa_audio(snd_pcm_t *device, int channels)

{

    snd_pcm_hw_params_t *hw_params;

    int                 err;

    int                 tmp;

    snd_pcm_uframes_t   frames;

    /* allocate memory for hardware parameter structure */ 

    if ((err = snd_pcm_hw_params_malloc(&hw_params)) < 0) {

        fprintf (stderr, "cannot allocate parameter structure (%s)\n",

                 snd_strerror(err));

        return 1;

    }

    /* fill structure from current audio parameters */

    if ((err = snd_pcm_hw_params_any(device, hw_params)) < 0) {

        fprintf (stderr, "cannot initialize parameter structure (%s)\n",

                 snd_strerror(err));

        return 1;

    }

    /* set access type, sample rate, sample format, channels */

    if ((err = snd_pcm_hw_params_set_access(device, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {

        fprintf (stderr, "cannot set access type: %s\n",

                 snd_strerror(err));

        return 1;

    }

    // bits = 16

    if ((err = snd_pcm_hw_params_set_format(device, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) {

        fprintf (stderr, "cannot set sample format: %s\n",

                 snd_strerror(err));

        return 1;

    }

    tmp = sample_rate;    

    if ((err = snd_pcm_hw_params_set_rate_near(device, hw_params, &tmp, 0)) < 0) {

        fprintf (stderr, "cannot set sample rate: %s\n",

                 snd_strerror(err));

        return 1;

    }

    if (tmp != sample_rate) {

        fprintf(stderr, "Could not set requested sample rate, asked for %d got %d\n", sample_rate, tmp);

        sample_rate = tmp;

    }

    if ((err = snd_pcm_hw_params_set_channels(device, hw_params, channels)) < 0) {

        fprintf (stderr, "cannot set channel count: %s\n",

                 snd_strerror(err));

        return 1;

    }

    if ((err = snd_pcm_hw_params_set_periods_near(device, hw_params, &fragments, 0)) < 0) {

        fprintf(stderr, "Error setting # fragments to %d: %s\n", fragments,

                snd_strerror(err));

        return 1;

    }

    frame_size = channels * (bits / 8);

    frames = buffer_size / frame_size * fragments;

    if ((err = snd_pcm_hw_params_set_buffer_size_near(device, hw_params, &frames)) < 0) {

        fprintf(stderr, "Error setting buffer_size %d frames: %s\n", frames,

                snd_strerror(err));

        return 1;

    }

    if (buffer_size != frames * frame_size / fragments) {

        fprintf(stderr, "Could not set requested buffer size, asked for %d got %d\n", buffer_size, frames * frame_size / fragments);

        buffer_size = frames * frame_size / fragments;

    }

    if ((err = snd_pcm_hw_params(device, hw_params)) < 0) {

        fprintf(stderr, "Error setting HW params: %s\n",

                snd_strerror(err));

        return 1;

    }

    return 0;

}

main (void)

{

int i,frames, inframes, outframes, frame_size;

if ((err = snd_pcm_open(&playback_handle, snd_device_out, SND_PCM_STREAM_PLAYBACK, 0)) < 0) {

    fprintf(stderr, "cannot open output audio device %s: %s\n", snd_device_in, snd_strerror(err));

    exit(1);

}

if ((err = snd_pcm_open(&capture_handle, snd_device_in, SND_PCM_STREAM_CAPTURE, 0)) < 0) {

    fprintf(stderr, "cannot open input audio device %s: %s\n", snd_device_out, snd_strerror(err));

    exit(1);

}

configure_alsa_audio(snd_device_in,  channels);

configure_alsa_audio(snd_device_out, channels);

restarting = 1;

while (1) {

    frame_size = channels * (bits / 8);

    frames = buffer_size / frame_size;

    if (restarting) {

        restarting = 0;

        /* drop any output we might got and stop */

        snd_pcm_drop(capture_handle);

        snd_pcm_drop(playback_handle);

        /* prepare for use */

        snd_pcm_prepare(capture_handle);

        snd_pcm_prepare(playback_handle);

    /* fill the whole output buffer */

    for (i = 0; i < fragments; i += 1)

    snd_pcm_writei(playback_handle, rdbuf, frames);

    }

    while ((inframes = snd_pcm_readi(capture_handle, rdbuf, frames)) < 0) {

        if (inframes == -EAGAIN)

            continue;

    // by the way, writing to terminal emulator is costly if you use

    // bad emulators like gnome-terminal, so don't do this.

        fprintf(stderr, "Input buffer overrun\n");

        restarting = 1;

        snd_pcm_prepare(capture_handle);

    }

    if (inframes != frames)

        fprintf(stderr, "Short read from capture device: %d, expecting %d\n", inframes, frames);

    /* now processes the frames */

    do_something(rdbuf, inframes);

    while ((outframes = snd_pcm_writei(playback_handle, rdbuf, inframes)) < 0) {

        if (outframes == -EAGAIN)

            continue;

        fprintf(stderr, "Output buffer underrun\n");

        restarting = 1;

        snd_pcm_prepare(playback_handle);

    }

    if (outframes != inframes)

        fprintf(stderr, "Short write to playback device: %d, expecting %d\n", outframes, frames);

		snd_pcm_close(snd_device_out);

		snd_pcm_close(snd_device_in);

		exit (0);

}