/*modify by hfl 20140216*/
#define ALSA_PCM_NEW_HW_PARAMS_API
# include <stdio.h>
# include <unistd.h>
# include <sys/stat.h>
# include <sys/mman.h>


# include "mad.h"
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>




#include <sys/ioctl.h>
#include <sys/soundcard.h>
#include <alsa/asoundlib.h>
/*
 * This is perhaps the simplest example use of the MAD high-level API.
 * Standard input is mapped into memory via mmap(), then the high-level API
 * is invoked with three callbacks: input, output, and error. The output
 * callback converts MAD's high-resolution PCM samples to 16 bits, then
 * writes them to standard output in little-endian, stereo-interleaved
 * format.
 */
 //#define printf    
static Get_file_length(char *PATH);
static int init_dsp();
static int Uninit_dsp();
static int decode(unsigned char const *, unsigned long);
static enum mad_flow outputplay(void *data,
    struct mad_header const *header,
    struct mad_pcm *pcm);
int main(int argc, char *argv[])
{
printf("The main is start!\n");
  struct stat stat;
  void *fdm;


  int  fd;
  //char buffer1[80000];
  printf("###The input file is %s  ! the arc=%d###\n",argv[1],argc);
  if (argc == 1)
   {
   printf("The argc is wrong!\n");
    return 1;
 }
  
#if 0
  if (fstat(STDIN_FILENO, &stat) == -1 ||
      stat.st_size == 0)
    return 2;
#endif


 fd =open(argv[1],O_RDWR);
if(-1==fd)
{
   printf("sorry,The file open is faild!\n");
}
else
{
 printf("The file open is sucessed!\n");
}
//read(fd,buffer1,sizeof(buffer1));
//printf("%s", buffer1);
stat.st_size = Get_file_length(argv[1]);
printf("The file size is %d\n",stat.st_size );
printf("The Map is begin ok!\n");


fdm = mmap(0, stat.st_size, PROT_READ, MAP_SHARED, fd, 0);
  if (fdm == MAP_FAILED)
  {
  printf("mmap is failed\n");
    return 3;
  }


  decode(fdm, stat.st_size);


  if (munmap(fdm, stat.st_size) == -1)
    return 4;
   
  return 0;
}


/*
 * This is a private message structure. A generic pointer to this structure
 * is passed to each of the callback functions. Put here any data you need
 * to access from within the callbacks.
 */


struct buffer {
  unsigned char const *start;
  unsigned long length;
};
int id;
int flag=0;
snd_pcm_t *handle;
 snd_pcm_uframes_t frames =1024;
 int fd=0;
/*初始化音频设备*/
int init_dsp(int rate,int channels)
{


  int rc;
 
  snd_pcm_hw_params_t *params;
  int dir;
 


   /* Open PCM device for playback. */
  rc = snd_pcm_open(&handle, "default",
                    SND_PCM_STREAM_PLAYBACK, 0);
  if (rc < 0) {
    fprintf(stderr,
            "unable to open pcm device: %s\n",
            snd_strerror(rc));
    exit(1);
  }




  /* Allocate a hardware parameters object. */
  snd_pcm_hw_params_alloca(&params);


  /* Fill it in with default values. */
  snd_pcm_hw_params_any(handle, params);


  /* Set the desired hardware parameters. */


  /* Interleaved mode */
  snd_pcm_hw_params_set_access(handle, params,
                      SND_PCM_ACCESS_RW_INTERLEAVED);


  /* Signed 16-bit little-endian format */
  snd_pcm_hw_params_set_format(handle, params,
                              SND_PCM_FORMAT_S16_LE);


  /* Two channels (stereo) */
  printf("channel=%d\n", channels);
  snd_pcm_hw_params_set_channels(handle, params, channels);


  /* 44100 bits/second sampling rate (CD quality) */
 // val = 16000;
  snd_pcm_hw_params_set_rate_near(handle, params,
                                  & rate, &dir);
printf("rate=%d\n",rate);
  /* Set period size to 32 frames. */
  /*一次送人的帧太少，会下溢冲（至少15帧)*/
 // snd_pcm_hw_params_set_period_size_near(handle,  params, &frames, &dir);


  /* Write the parameters to the driver */
  rc = snd_pcm_hw_params(handle, params);
  if (rc < 0) {
    fprintf(stderr,
            "unable to set hw parameters: %s\n",
            snd_strerror(rc));
    exit(1);
  }


printf( "The Dsp init is atlas ok!\n");
return 0;


}
static int Uninit_dsp()
{
   //fclose(fdout);
   snd_pcm_drain(handle);
   snd_pcm_close(handle);
   printf("play end \n");
   
}
/*
 * This is the input callback. The purpose of this callback is to (re)fill
 * the stream buffer which is to be decoded. In this example, an entire file
 * has been mapped into memory, so we just call mad_stream_buffer() with the
 * address and length of the mapping. When this callback is called a second
 * time, we are finished decoding.
 */


static
enum mad_flow input(void *data,
   struct mad_stream *stream)
{
  struct buffer *buffer = data;


  if (!buffer->length)
    return MAD_FLOW_STOP;


  mad_stream_buffer(stream, buffer->start, buffer->length);


  buffer->length = 0;
printf("1111");
  return MAD_FLOW_CONTINUE;
}


/*
 * The following utility routine performs simple rounding, clipping, and
 * scaling of MAD's high-resolution samples down to 16 bits. It does not
 * perform any dithering or noise shaping, which would be recommended to
 * obtain any exceptional audio quality. It is therefore not recommended to
 * use this routine if high-quality output is desired.
 */


static inline
signed int scale(mad_fixed_t sample)
{
  /* round */
  sample += (1L << (MAD_F_FRACBITS - 16));


  /* clip */
  if (sample >= MAD_F_ONE)
    sample = MAD_F_ONE - 1;
  else if (sample < -MAD_F_ONE)
    sample = -MAD_F_ONE;


  /* quantize */
  return sample >> (MAD_F_FRACBITS + 1 - 16);
}


static int Get_file_length(char *PATH)
{  
     FILE *fp;
     fp=fopen(PATH,"r");
    if(!fp)
   {
   printf("sorry,The file open is faild!\n");
   }
   else
    {
    printf("The file open is sucessed!\n");
   }
   fseek(fp, 0L,SEEK_END);
   return (ftell(fp));
}
/*
 * This is the output callback function. It is called after each frame of
 * MPEG audio data has been completely decoded. The purpose of this callback
 * is to output (or play) the decoded PCM audio.
 */


static
enum mad_flow output(void *data,
    struct mad_header const *header,
    struct mad_pcm *pcm)
{
  unsigned int nchannels, nsamples;
  mad_fixed_t const *left_ch, *right_ch;
  static FILE *fdout;
  char buf[1];
  
  /* pcm->samplerate contains the sampling frequency */
 fdout= fopen("mypcm.pcm","ab+");
  if(!fdout)
  {
   printf("open is failed\n");
  }
  else
  printf("out open is ok\n");
  nchannels = pcm->channels;
  nsamples  = pcm->length;
  left_ch   = pcm->samples[0];
  right_ch  = pcm->samples[1];


  while (nsamples--) {
    signed int sample;


    /* output sample(s) in 16-bit signed little-endian PCM */
 
    sample = scale(*left_ch++);
   
    buf[0]=(sample >> 0) & 0xff;
    printf("%d\t",buf[0]);
    fwrite(buf,1,1,fdout);
    
    buf[0]=(sample >> 8) & 0xff;
  printf("%d\t",buf[0]);
    fwrite(buf,1,1,fdout);
    if (nchannels == 2) {
     sample = scale(*right_ch++);

     buf[0]=(sample >> 0) & 0xff;
fwrite(buf,1,1,fdout);
 
     buf[0]=(sample >> 8) & 0xff;
fwrite(buf,1,1,fdout);
    }
  }
fclose(fdout);
  return MAD_FLOW_CONTINUE;
}
static
enum mad_flow outputplay(void *data,
    struct mad_header const *header,
    struct mad_pcm *pcm)
{
  unsigned int nchannels;
  long int nsamples,samplerate;
  mad_fixed_t const *left_ch, *right_ch;
   static int i=0;
  char buf[1];
  static char buffer[1024*2*2];
  /* pcm->samplerate contains the sampling frequency */


  nchannels = pcm->channels;
  nsamples  = pcm->length;/* 这个不是采样位，而一帧的数据长度12*3(采样)*32(子带)=1152*/
  left_ch   = pcm->samples[0];
  right_ch  = pcm->samples[1];
  samplerate=pcm->samplerate;
  


  if(!flag)
  {
  printf("channels=%d, samples2=%ld,flag=%d\n", nchannels,samplerate,flag);
printf("init dsp is begin\n");
  init_dsp(samplerate,nchannels);
  memset(buffer,0,sizeof(buffer));
   flag++;
  }




 
#if 1
  while (nsamples--) {
    signed int sample;
   
    /* output sample(s) in 16-bit signed little-endian PCM */
 
    sample = scale(*left_ch++);
   
    buf[0]=(sample >> 0) & 0xff;
    
    memcpy(buffer+i,buf,1);
    i++;
   // printf("i=%d,%d,%d\t",i,buf[i-1],buf[0]);
    buf[0]=(sample >> 8) & 0xff;
  memcpy(buffer+i,buf,1);
  i++;

    if (nchannels == 2) {
     sample = scale(*right_ch++);

     buf[0]=(sample >> 0) & 0xff;
 memcpy(buffer+i,buf,1);
            i++;
 
     buf[0]=(sample >> 8) & 0xff;
memcpy(buffer+i,buf,1);
          i++;
 
    }
if(i==frames*2*nchannels)
{ i=0;
snd_pcm_writei(handle, buffer, frames);
}


  }
  #endif
   
  //snd_pcm_writei(handle, buffer, frames);
   


  return MAD_FLOW_CONTINUE;
}




/*
 * This is the error callback function. It is called whenever a decoding
 * error occurs. The error is indicated by stream->error; the list of
 * possible MAD_ERROR_* errors can be found in the mad.h (or stream.h)
 * header file.
 */


static
enum mad_flow error(void *data,
   struct mad_stream *stream,
   struct mad_frame *frame)
{
  struct buffer *buffer = data;


  fprintf(stderr, "decoding error 0x%04x (%s) at byte offset %u\n",
 stream->error, mad_stream_errorstr(stream),
 stream->this_frame - buffer->start);
    Uninit_dsp();
  /* return MAD_FLOW_BREAK here to stop decoding (and propagate an error) */


  return MAD_FLOW_CONTINUE;
}


/*
 * This is the function called by main() above to perform all the decoding.
 * It instantiates a decoder object and configures it with the input,
 * output, and error callback functions above. A single call to
 * mad_decoder_run() continues until a callback function returns
 * MAD_FLOW_STOP (to stop decoding) or MAD_FLOW_BREAK (to stop decoding and
 * signal an error).
 */


static
int decode(unsigned char const *start, unsigned long length)
{
  struct buffer buffer;
  struct mad_decoder decoder;
  int result;


  /* initialize our private message structure */


  buffer.start  = start;
  buffer.length = length;


  /* configure input, output, and error functions */


  mad_decoder_init(&decoder, &buffer,
  input, 0 /* header */, 0 /* filter */, outputplay,
  error, 0 /* message */);


  /* start decoding */


  result = mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);


  /* release the decoder */


  mad_decoder_finish(&decoder);


  return result;

}

以上是基于alas音频驱动的mp3播放器。这里要注意alas送数据是以帧为单位送数据。而oss是以字节为单位，所以先要攒包到frame,再送数据。snd_pcm_writei(handle, buffer, frames); 要注意frames和字节的换算关系:size=frame*(每个采样率所占字节数）*声道数。同时frames不能太小，太小会解码器数据不够f而下溢出。frames只是32。本代码为1M，为的防止概率性同步不上问题

注意alsa架构要链接到alsa库，注意修改makefile编译选项。

CFLAGS = -Wall -march=i486 -g -O  -fforce-addr -fthread-jumps -fcse-follow-jumps -fcse-skip-blocks -fexpensive-optimizations -fregmove -fschedule-insns2 -fstrength-reduce -I/usr/include/alsa -lasound

编译命令：sudo make minimad

即可