Android : 基于alsa库的音乐播放

继上篇：Android : alsa-lib 移植 ，这篇随笔实现一个demo基于移植好的alsa库在Android平台上播放wav文件：

一、利用ffmeg将一个mp3文件转换成wav文件：

(1)ubuntu安装ffmeg工具：

sudo add-apt-repository ppa:djcj/hybrid

sudo apt-get update

sudo apt-get install ffmpeg

(2)mp3转wav:

　  ffmpeg -i duandian.mp3 -f wav duandian.wav

二、demo代码：

/*
 *  This small demo sends a wave to your speakers.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sched.h>
#include <errno.h>
#include <getopt.h>
#include "../include/asoundlib.h"
#include <sys/time.h>
#include <math.h>

static char *device = "hw:0,0";                     /* playback device */
int blockMode = ;                  /* block mode */

/*
 * RIFF WAVE file struct.
 * For details see WAVE file format documentation
 * (for example at http://www.wotsit.org).
 */
struct WAV_HEADER_S
{
    char            riffType[];    //4byte,资源交换文件标志:RIFF
    unsigned int    riffSize;       //4byte,从下个地址到文件结尾的总字节数
    char            waveType[];    //4byte,wav文件标志:WAVE
    char            formatType[];  //4byte,波形文件标志:FMT(最后一位空格符)
    unsigned int    formatSize;     //4byte,音频属性(compressionCode,numChannels,sampleRate,bytesPerSecond,blockAlign,bitsPerSample)所占字节数
    unsigned short  compressionCode;//2byte,编码格式种类(1-线性pcm-WAVE_FORMAT_PCM,WAVEFORMAT_ADPCM)
    unsigned short  numChannels;    //2byte,通道数
    unsigned int    sampleRate;     //4byte,采样率
    unsigned int    bytesPerSecond; //4byte,传输速率
    unsigned short  blockAlign;     //2byte,数据块的对齐，即DATA数据块长度
    unsigned short  bitsPerSample;  //2byte,采样精度-PCM位宽
    char            dataType[];    //4byte,数据标志:data
    unsigned int    dataSize;       //4byte,从下个地址到文件结尾的总字节数，即除了wav header以外的pcm data length
} wav_header;  

/*
 *   Underrun and suspend recovery
 */
static int xrun_recovery(snd_pcm_t *handle, int err)
{
        int wait_cnt=;
        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));
        else
            printf("underrun occurred\n");
                return ;
        } else if (err == -ESTRPIPE) {
                while ((err = snd_pcm_resume(handle)) == -EAGAIN){
             sleep();       /* wait until the suspend flag is released */
             wait_cnt++;
             if(wait_cnt >= ){
                 printf("suspend flag  released fail after retry %d times!\n", wait_cnt);
                break;
             }
        }

                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;
}

int set_pcm_play(FILE *fp)
{
        int    rc;
        int    ret;
        int    size;
        snd_pcm_t*       handle;        //PCI设备句柄
        snd_pcm_hw_params_t*      params;//硬件信息和PCM流配置
        unsigned int    val;
        int    dir=;
        snd_pcm_uframes_t  frames;
        char   *buffer;
        int channels=wav_header.numChannels;
        int frequency=wav_header.sampleRate;
        int bit=wav_header.bitsPerSample;
        int datablock=wav_header.blockAlign;  

        rc=snd_pcm_open(&handle, device, SND_PCM_STREAM_PLAYBACK, blockMode ?  : SND_PCM_NONBLOCK);
        if(rc<)
        {
                perror("\open PCM device failed:");
                exit();
        }  

        snd_pcm_hw_params_alloca(&params); //分配params结构体
        if(rc<)
        {
                perror("\snd_pcm_hw_params_alloca:");
                exit();
        }  

        rc=snd_pcm_hw_params_any(handle, params);//初始化params
        if(rc<)
        {
                perror("\snd_pcm_hw_params_any:");
                exit();
        }  

        rc=snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);                                 //初始化访问权限
        if(rc<)
        {
                perror("\sed_pcm_hw_set_access:");
                exit();
        }  

        //采样位数
        switch(bit/)  {
            case :snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_U8);
                    break ;
            case :snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);
                    break ;
            case :snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S24_LE);
                    break ;
    }  

        rc=snd_pcm_hw_params_set_channels(handle, params, channels);  //设置声道,1表示单声>道，2表示立体声
        if(rc<)
        {
                perror("\nsnd_pcm_hw_params_set_channels:");
                exit();
        }  

        val = frequency;
        rc=snd_pcm_hw_params_set_rate_near(handle, params, &val, &dir);  //设置>频率
        if(rc<)
        {
                perror("\nsnd_pcm_hw_params_set_rate_near:");
                exit();
        }  

        rc = snd_pcm_hw_params(handle, params);
        if(rc<)
        {
            perror("\nsnd_pcm_hw_params: ");
            exit();
        }  

        rc=snd_pcm_hw_params_get_period_size(params, &frames, &dir);  /*获取周期长度*/
        if(rc<)
        {
                perror("\nsnd_pcm_hw_params_get_period_size:");
                exit();
        }  

        size = frames * datablock;   /*4 : 代表数据块长度*/  

        buffer =(char*)malloc(size);
        fseek(fp,sizeof(wav_header),SEEK_SET);  //定位歌曲到数据区  

        while ()
        {
             memset(buffer,,sizeof(buffer));
             ret = fread(buffer, , size, fp);
             if(ret == )
             {
                     printf("music write done!\n");
                     break;
             }  else if (ret != size)  {
                      printf("music read out of size !\n");
             }  

/* use poll to wait for next event */
write_data:

               if(snd_pcm_wait(handle, )){
            ret = snd_pcm_writei(handle,buffer,frames);   // 写音频数据到PCM设备
            if(ret == -EAGAIN){
                printf("write EAGAIN\n");
                goto write_data;
            }
            else if(ret < ){
                    if (xrun_recovery(handle, ret) < ) {
                                        printf("Write error: %s\n", snd_strerror(ret));
                        break;
                            }
            }
               }
       }  

        snd_pcm_drain(handle);
        snd_pcm_close(handle);
        free(buffer);
        return ;
}  

int pcm_main(int argc,char *argv[])
{  

    if(argc!=)
    {
        printf("Usage : ./nanosic_apps  file_name.wav\n");
        exit();
    }  

    int nread;
    FILE *fp;
    fp=fopen(argv[],"rb");
    if(fp==NULL)
    {
        perror("open file failed:\n");
        exit();
    }  

    nread=fread(&wav_header,,sizeof(wav_header),fp);
    /*example:
    Read wav_header size = 44
    RIFF flag = RIFF?à?WAVEfmt
    riffSize = 47308956
    waveType = WAVEfmt
    formatType = fmt
    formatSize = 16
    compressionCode = 1
    channels = 2
    Sample rate = 44100
    bytesPerSecond = 176400
    blockAlign = 4
    bitsPerSample = 16
    data = LISTp
    dataSize = 112
    */
    printf("Read wav_header size = %d\n",nread);
    printf("RIFF flag = %s\n",wav_header.riffType);
    printf("riffSize = %d\n",wav_header.riffSize);
    printf("waveType = %s\n",wav_header.waveType);
    printf("formatType = %s\n",wav_header.formatType);
    printf("formatSize = %d\n",wav_header.formatSize);
    printf("compressionCode = %d\n",wav_header.compressionCode);
    printf("channels = %d\n",wav_header.numChannels);
    printf("Sample rate = %d\n",wav_header.sampleRate);
    printf("bytesPerSecond = %d\n",wav_header.bytesPerSecond);
    printf("blockAlign = %d\n",wav_header.blockAlign);
    printf("bitsPerSample = %d\n",wav_header.bitsPerSample);
    printf("data = %s\n",wav_header.dataType);
    printf("dataSize = %d\n",wav_header.dataSize);  

    set_pcm_play(fp);  //向PCM设备写入数据

    return ;
}