ALSA Lib-简单的播放例子

参考：https://www.alsa-project.org/alsa-doc/alsa-lib/_2test_2pcm_8c-example.html

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <alsa/asoundlib.h>
#include <unistd.h>

typedef struct {
    char *file_name;
    char *device;
    int ch;
    int bit;
    int rate;
    snd_pcm_format_t format;
    unsigned int buffer_time;
    unsigned int period_time;
    snd_pcm_uframes_t buffer;
    snd_pcm_uframes_t period;
}CONFIG_T;

typedef struct {
    char id[];
    int size;
}RIFF_HEADER_T;

typedef struct {
    char format[];
    char sub_id_1[];
    int sub_size_1;
    short fmt;
    short ch;
    int sample_rate;
    int byte_rate;
    short block_align;
    short bits_per_sample;
}WAVE_HEADER_T;

typedef struct {
    char sub_id_2[];
    int sub_size_2;
}DATA_HEADER_T;

RIFF_HEADER_T riff_header;
WAVE_HEADER_T wave_header;
DATA_HEADER_T data_header;
CONFIG_T config;

static void help(void)
{
    printf(
"Usage: pcm [OPTION]... [FILE]...\n"
"-h,--help  help\n"
"-D,--device    playback device\n"
"-i,--input_file only support wav file\n"
"\n");
}

static void parse_cmd(int argc, char **argv)
{
    struct option long_option[] =
    {
        {"help", , NULL, 'h'},
        {"device", , NULL, 'D'},
        {"input_file", , NULL, 'i'},
        {NULL, , NULL, },
    };
    while () {
        int c;
        if ((c = getopt_long(argc, argv, "hD:i:", long_option, NULL)) < )
            break;
        switch (c) {
        case 'h':
            help();
            break;
        case 'D':
            config.device = strdup(optarg);
            break;
        case 'i':
            config.file_name = strdup(optarg);
            break;
        }
    }
}

static snd_pcm_format_t get_format(int bits_per_sample)
{
    snd_pcm_format_t format = SND_PCM_FORMAT_S8;
    switch(bits_per_sample) {
        case :
           format =  SND_PCM_FORMAT_S8;
           break;
        case :
           format =  SND_PCM_FORMAT_S16_LE;
           break;
       case :
           format =  SND_PCM_FORMAT_S24_LE;
           break;
       case :
           format =  SND_PCM_FORMAT_S32_LE;
           break;
    }
    return format;
}

static int config_init(CONFIG_T *pConfig)
{
    FILE *fp = NULL;
    if (NULL == pConfig) {
        return -;
    }
    fp = fopen(pConfig->file_name, "rb");
    if (NULL == fp) {
        return -;
    }

    fread((void *)&riff_header, sizeof(RIFF_HEADER_T), , fp);
    fread((void *)&wave_header, sizeof(WAVE_HEADER_T), , fp);
     if (wave_header.sub_size_1 > sizeof (WAVE_HEADER_T) -)
        fseek(fp, wave_header.sub_size_1 - (sizeof (WAVE_HEADER_T) - ), SEEK_CUR);
    fread((void *)&data_header, sizeof(DATA_HEADER_T), , fp);
    pConfig->ch = wave_header.ch;
    pConfig->rate= wave_header.sample_rate;
    pConfig->bit= wave_header.bits_per_sample;
    pConfig->format = get_format(wave_header.bits_per_sample);
    fclose(fp);
    return ;
}

static int set_hwparams(snd_pcm_t *handle)
{
    snd_pcm_hw_params_t *params;
    unsigned int rrate;
    snd_pcm_uframes_t size;
    int err, dir;
    snd_pcm_hw_params_alloca(&params);
    /* choose all parameters */
    err = snd_pcm_hw_params_any(handle, params);
    if (err < ) {
        printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));
        return err;
    }
      /* set the interleaved read/write format */
    err = snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
    if (err < ) {
        printf("Access type not available for playback: %s\n", snd_strerror(err));
        return err;
    }
    /* set the sample format */
    err = snd_pcm_hw_params_set_format(handle, params, config.format);
    if (err < ) {
        printf("Sample format not available for playback: %s\n", snd_strerror(err));
        return err;
    }
    /* set the count of channels */
    err = snd_pcm_hw_params_set_channels(handle, params, config.ch);
    if (err < ) {
        printf("Channels count (%u) not available for playbacks: %s\n", config.ch, snd_strerror(err));
        return err;
    }
    /* set the stream rate */
    rrate = config.rate;
    err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, );
    if (err < ) {
        printf("Rate %uHz not available for playback: %s\n", config.rate, snd_strerror(err));
        return err;
    }
    if (rrate != config.rate) {
        printf("Rate doesn't match (requested %uHz, get %iHz)\n", config.rate, err);
        return -EINVAL;
    }
    /* set the buffer time */
    err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &config.buffer_time, &dir);
    if (err < ) {
        printf("Unable to set buffer time %u for playback: %s\n", config.buffer_time, snd_strerror(err));
        return err;
    }
    err = snd_pcm_hw_params_get_buffer_size(params, &size);
    if (err < ) {
        printf("Unable to get buffer size for playback: %s\n", snd_strerror(err));
        return err;
    }
    config.buffer = size;
    /* set the period time */
    err = snd_pcm_hw_params_set_period_time_near(handle, params, &config.period_time, &dir);
    if (err < ) {
        printf("Unable to set period time %u for playback: %s\n", config.period_time, snd_strerror(err));
        return err;
    }
    err = snd_pcm_hw_params_get_period_size(params, &size, &dir);
    if (err < ) {
        printf("Unable to get period size for playback: %s\n", snd_strerror(err));
        return err;
    }
    config.period = size;
    /* write the parameters to device */
    err = snd_pcm_hw_params(handle, params);
    if (err < ) {
        printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
        return err;
    }
    return ;
}
static int set_swparams(snd_pcm_t *handle)
{
    int err;
    snd_pcm_sw_params_t *swparams;
    snd_pcm_sw_params_alloca(&swparams);
    /* get the current swparams */
    err = snd_pcm_sw_params_current(handle, swparams);
    if (err < ) {
        printf("Unable to determine current swparams for playback: %s\n", snd_strerror(err));
        return err;
    }
    /* start the transfer when the buffer is almost full: */
    /* (buffer_size / avail_min) * avail_min */
    err = snd_pcm_sw_params_set_start_threshold(handle, swparams, (config.buffer / config.period) * config.period);
    if (err < ) {
        printf("Unable to set start threshold mode for playback: %s\n", snd_strerror(err));
        return err;
    }

    /* write the parameters to the playback device */
    err = snd_pcm_sw_params(handle, swparams);
    if (err < ) {
        printf("Unable to set sw params for playback: %s\n", snd_strerror(err));
        return err;
    }
    return ;
}

/*
 *   Underrun and suspend recovery
 */

static int xrun_recovery(snd_pcm_t *handle, int err)
{
    printf("stream recovery\n");
    if (err == -EPIPE) {    /* under-run */
        err = snd_pcm_prepare(handle);
        if (err < )
            printf("Can't recovery from underrun, prepare failed: %s\n", snd_strerror(err));
        return ;
    } else if (err == -ESTRPIPE) {
        while ((err = snd_pcm_resume(handle)) == -EAGAIN)
            sleep();   /* wait until the suspend flag is released */
        if (err < ) {
            err = snd_pcm_prepare(handle);
            if (err < )
                printf("Can't recovery from suspend, prepare failed: %s\n", snd_strerror(err));
        }
        return ;
    }
    return err;
}

static int write_loop(snd_pcm_t *handle)
{
    int err;
    size_t remain, read_size;
    FILE *fp = NULL;
    char *read_buffer = NULL, *offset = NULL;
    int bytes_per_frame = config.ch * (config.bit >> );
    read_size = config.period * bytes_per_frame;
    fp = fopen(config.file_name, "rb");
    if (NULL == fp) {
        return -;
    }
    read_buffer = (char * )malloc(read_size);
    fseek(fp, , SEEK_CUR);

    while () {
        memset(read_buffer ,, read_size);
        err = fread(read_buffer ,, read_size, fp);
        if (err <= )
            break;
        offset = read_buffer;
        remain = err / bytes_per_frame;
        while (remain> ) {
            err = snd_pcm_writei(handle, offset, remain);
            if (err == -EAGAIN)
                continue;
            if (err < ) {
                if (xrun_recovery(handle, err) < ) {
                    printf("Write error: %s\n", snd_strerror(err));
                    exit(EXIT_FAILURE);
                }
                continue;
            }
            offset += err * bytes_per_frame;
            remain -= err;
        }
    }
    free(read_buffer);
    fclose(fp);
    return ;
}

int main(int argc, char **argv)
{
    int err = ;
    snd_pcm_t *handle;
    memset (&config, , sizeof(CONFIG_T));
    config.buffer_time = ;//us
    config.period_time = ;
    parse_cmd(argc, argv);
    config_init(&config);
    if ((err = snd_pcm_open(&handle, config.device, SND_PCM_STREAM_PLAYBACK, )) < ) {
        printf("Playback open error: %s\n", snd_strerror(err));
        return ;
    }

    if ((err = set_hwparams(handle)) < ) {
        printf("Setting of hwparams failed: %s\n", snd_strerror(err));
        exit(EXIT_FAILURE);
    }
    if ((err = set_swparams(handle)) < ) {
        printf("Setting of swparams failed: %s\n", snd_strerror(err));
        exit(EXIT_FAILURE);
    }
    write_loop(handle);
    snd_pcm_close(handle);
    return 0;
}

Makefile:

ALSA_INC_PATH=/home/fellow/alsa-lib-1.2./output/usr/include
ALSA_LIB_PATH=/usr/lib/i386-linux-gnu
ALSA_PLUG_PATH=/usr/lib/i386-linux-gnu/alsa-lib

export LD_LIBRARY_PATH=${ALSA_LIB_PATH}:${ALSA_PLUG_PATH}:$LD_LIBRARY_PATH
export CC=gcc
export CFLAGS=-I${ALSA_INC_PATH}
export LDFLAGS=-L{ALSA_LIB_PATH} -lasound
SOURCE=alsa_test.c
TARGET=alsa_test
all:
    ${CC} ${SOURCE} ${CFLAGS} ${LDFLAGS} -o ${TARGET}

./alsa_test -D default -i xx.wav