MAD(libmad)是一个开源的高精度MPEG音频解码库，支持MPEG-1标准。libmad提供24-bit的PCM输出，完全定点计算，非常适合在没有浮点支持的嵌入式硬件平台上使用。使用libmad提供的一系列API可以实现MP3文件的解码。

“mad.h”头文件定义了libmad的数据结构及API函数，libmad中的主要数据结构：

image

MAD通过回调函数机制来实现解码，每个回调函数会返回一个枚举类型mad_flow,通过mad_flow可以控制解码的过程。在未经处理的情况下，MAD一般输出32bit，以little endian格式存放在mad_fixed_t中的数据。但是大多数的声卡并不能支持输出高达32bit精度的数据，因而还必须对mad_fixed_t进行量化，圆滑处理以及抖动，使到采样信号降到16bit精度。MAD负责的只是解码的过程，它工作过程是：从外部获取输入，逐帧解码，在解码的过程中返回信息，然后得到解码结果。开发人员要手动设置输入输出。

编程实现解码的方法为：初始化mad_decoder,里面包含了指向输入、输出、滤波、错误和消息回调函数的指针。通过mad_decoder_init()实现初始化。

struct mad_decoder decoder;
struct my_playbuf playbuf;                            //设置数据缓冲区
mad_decoder_init(&decoder, &playbuf, input_func, header_func, 
/*filter*/0, output_func, /*error*/ 0, /* message */ 0);

在这个初始化函数里面，回调输入函数指向了input_func，处理帧头信息的函数指向了header_func，而输出函数则为output_func。其它的滤波，错误和信息函数没有设置，置0。接着，MAD进入了一个解码的循环过程：当解码函数里面的数据解码完毕时，调用input_func函数；当input_func函数告知解码函数全部数据已经解码完毕，则MAD处理退出；对帧头进行解码，调用header_func函数；对帧中的主数据进行解码；调用filter_func函数；将解码数据输出，调用output_func函数；重复上述步骤。

MAD在每进行一帧的解码结束后都会询问mad_flow的状态，以决定是否进行下一帧的解码。enum mad_flow的数据结构定义如下：

enum mad_flow{
MAD_FLOW_CONTINUE = 0x0000,             /*继续进行下一帧的解码*/
MAD_FLOW_STOP = 0x0010,        /*停止对该比特流的解码并正常退出*/
MAD_FLOW_BREAK = 0x0010,       /*停止对该比特流的解码并返回错误*/
MAD_FLOW_IGNORE = 0x0020              /*不解码该帧，跳入下一帧*/
}；

大多数情况下回调函数会返回MAD_FLOW_CONTINUE。要自定义实现的回调函数的声明格式为：

enum mad_flow (*input_func)(void *, struct mad_stream *);
enum mad_flow (*header_func)(void *, struct mad_header const *);
enum mad_flow (*filter_func)(void *, struct mad_stream const *, struct mad_frame *);
enum mad_flow (*output_func)(void *, struct mad_header const *, struct mad_pcm *);
enum mad_flow (*error_func)(void *, struct mad_stream *, struct mad_frame *);
enum mad_flow (*message_func)(void *, void *, unsigned int *);

其中void *指针将缓冲数据传递给这些回调函数，由回调函数对数据进行处理。Input_func函数一般会执行以下操作：

if (more_data_available)
buffer = refill_buffer();
mad_stream_buffer(stream, buffer, length_of_buffer);
return MAD_FLOW_CONTINUE;
else return MAD_FLOW_STOP;

header_func函数会根据mad_header指向的帧头从中读取重要的帧信息，如将读取到的帧长度赋值给mad_timer_t，可以从mad.h中得知存放这些信息的数据结构。

在output_func函数中，利用指向PCM数据的指针mad_pcm,执行类似以下操作：

mad_fixed_t *left_ch = pcm->samples[0], *right_ch =pcm->samples[1];    
//将采样数据分别输出到左右声道
int nsamples = pcm->length;
signed int sample;
unsigned char * buffer = some_buffer;
unsigned char * ptr = buffer;
while (nsamples--){
    sample = (signed int) do_downsample(*left_ch++)
    *ptr++ = (unsigned char) (sample >> 0);
   *ptr++ = (unsigned char) (sample >> 8);
    sample = (signed int) do_downsample(*right_ch++)
   *ptr++ = (unsigned char) (sample >> 0);
    *ptr++ = (unsigned char) (sample >> 8);
    //处理左右声道采样数据，输出16bit little endian格式PCM
}

定义好各回调函数之后，便可以开始解码：
mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);
解码完毕后，调用mad_decoder_finish(&decoder);

1、libmad主要数据结构：

struct mad_stream {
  unsigned char const *buffer;    /* input bitstream buffer */
  unsigned char const *bufend;    /* end of buffer */
  unsigned long skiplen;          /* bytes to skip before next frame */
  int sync;                    /* stream sync found */
  unsigned long freerate;          /* free bitrate (fixed) */
  unsigned char const *this_frame; /* start of current frame */
  unsigned char const *next_frame; /* start of next frame */
  struct mad_bitptr ptr;          /* current processing bit pointer */
  struct mad_bitptr anc_ptr;      /* ancillary bits pointer */
  unsigned int anc_bitlen;        /* number of ancillary bits */
  unsigned char (*main_data)[MAD_BUFFER_MDLEN];    /* Layer III main_data() */
  unsigned int md_len;          /* bytes in main_data */
  int options;                  /* decoding options (see below) */
  enum mad_error error;          /* error code (see above) */
};

如果缓冲区最后一个 MPEG 数据帧只有部分数据包括在缓冲区中，那么struct mad_stream中的next_frame域指到不完整数据的开始地址。由于缓冲区的 MPEG 数据帧不一定完整，所以不完整的 MPEG 帧的数据必须拷贝到下一次解码操作的缓冲区中，进行再次解码。这里我们还看到bufend指向缓冲区数据的最后地址，也就是最后一字节的地址加 1 的位置。mad_stream.bufend – mad_stream.next_frame就是剩余的未被解码的 MPEG 帧的数据的字节数量（假设此帧在缓冲区中不完整）。mad_stream的error域用来记录操作mad_stream得到的错误代码。错误代码在 mad.h 中有很详细的定义。

2、错误代码在mad.h中详细定义

struct mad_synth {
  mad_fixed_t filter[2][2][2][16][8]; /* polyphase filterbank outputs */
                                                      /* [ch][eo][peo][s][v] */
  unsigned int phase;            /* current processing phase */
  struct mad_pcm pcm;          /* PCM output */
};

mad_synth中的关键域pcm保存解码和合成后得到的 PCM 数据。

3、mad_synth中的关键域

struct mad_pcm {
  unsigned int samplerate;        /* sampling frequency (Hz) */
  unsigned short channels;        /* number of channels */
  unsigned short length;          /* number of samples per channel */
  mad_fixed_t samples[2][1152];  /* PCM output samples [ch][sample] */
};

struct mad_pcm定义了音频的采样率、每个声道个数以及最后的 PCM 采样数据。这些参数可用来初始化音频设备。

4、struct mad_pcm

struct mad_frame {
  struct mad_header header;              /* MPEG audio header */
  int options;                          /* decoding options (from stream) */
  mad_fixed_t sbsample[2][36][32];      /* synthesis subband filter samples */
  mad_fixed_t (*overlap)[2][32][18];      /* Layer III block overlap data */
};

mad_frame是记录 MPEG 帧解码后的数据的数据结构，其中的mad_header尤其重要，其用来记录 MPEG 帧的一些基本信息，比如 MPEG 层数、声道模式、流比特率、采样比特率等等。声道模式包括单声道、双声道、联合立体混音声以及一般立体声。

5、mad_frame

enum mad_mode {  
    MAD_MODE_SINGLE_CHANNEL = 0,          /* single channel */  
    MAD_MODE_DUAL_CHANNEL  = 1,    /* dual channel */  
    MAD_MODE_JOINT_STEREO  = 2,          /* joint (MS/intensity) stereo */  
    MAD_MODE_STEREO  = 3                  /* normal LR stereo */
};
struct mad_header {  
    enum mad_layer layer;        /* audio layer (1, 2, or 3) */  
    enum mad_mode mode;        /* channel mode  */  
    int mode_extension;          /* additional mode info */  
    enum mad_emphasis emphasis;  /* de-emphasis to use  */  
    unsigned long bitrate;          /* stream bitrate */  
    unsigned int samplerate;        /* sampling frequency (Hz) */  
    unsigned short crc_check;      /* frame CRC accumulator */  
    unsigned short crc_target;      /* final target CRC checksum */  
    int flags;                    /* flags  */ 
    int private_bits;  /* private bits  */  
    mad_timer_t duration;  /* audio playing time of frame */};

使用的 API 功能简单介绍：

用到的 API 包括：

void mad_stream_init(struct mad_stream *)
void mad_synth_init(struct mad_synth *);
void mad_frame_init(struct mad_frame *);

以上3个 API 初始化解码需要的数据结构。

void mad_stream_buffer(struct mad_stream *, unsigned char const *, unsigned long);

此函数把原始的未解码的 MPEG 数据和mad_stream数据结构关联，以便使用mad_frame_decode( )来解码 MPEG 帧数据。

int mad_frame_decode(struct mad_frame *, struct mad_stream *);

把mad_stream中的 MPEG 帧数据解码。

void mad_synth_frame(struct mad_synth *, struct mad_frame const *);

把解码后的音频数据合成 PCM 采样。

void mad_stream_finish(struct mad_stream *);
void mad_frame_finish(struct mad_frame *);
mad_synth_finish(struct mad_synth);

以上 3 个 API 在解码完毕后使用，释放 libmad 占用的资源等

音频解码播放测试Demo（音质可能不是很好，没有细致调节）

# include <stdio.h>
# include <stdlib.h>   
# include <unistd.h>   
# include <sys/stat.h>   
# include <sys/mman.h>   
# include <sys/soundcard.h>   
# include <sys/ioctl.h>   
# include <sys/fcntl.h>   
# include <sys/types.h>   
# include "mad.h"   

struct buffer {   
    unsigned char const *start;   
    unsigned long length;   
};   

static int sfd;        /*声音设备的描述符 */
static int decode(unsigned char const *, unsigned long);   
int main(int argc, char *argv[])   
{   

    struct stat stat;   
    void *fdm;   
    char const *file;   
    int fd;   
    file = argv[1];   
    fd = open(file, O_RDONLY);   

    if ((sfd = open("/dev/dsp", O_WRONLY)) < 0) {   //我用的是linux，注意路径与声卡设备对应好
    printf("can not open device!!!/n");   
    return 5;   
    }   

    ioctl(sfd, SNDCTL_DSP_SYNC, 0); /*此句可以不要 */
    if (fstat(fd, &stat) == -1 || stat.st_size == 0)
    return 2;   

    fdm = mmap(0, stat.st_size, PROT_READ, MAP_SHARED, fd, 0); 
    if (fdm == MAP_FAILED)   
    return 3;   

    decode(fdm, stat.st_size);   

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

    ioctl(sfd, SNDCTL_DSP_RESET, 0);   

    close(sfd);   
    return 0;   

}   

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

/*这一段是处理采样后的pcm音频 */
static inline signed int scale(mad_fixed_t sample)   
{   
    sample += (1L << (MAD_F_FRACBITS - 16));   
    if (sample >= MAD_F_ONE)   
          sample = MAD_F_ONE - 1;   
    else if (sample < -MAD_F_ONE)   
          sample = -MAD_F_ONE;   
    return sample >> (MAD_F_FRACBITS + 1 - 16);   
}   

static
enum mad_flow output(void *data,   
            struct mad_header const *header, struct mad_pcm *pcm)   
{   
    unsigned int nchannels, nsamples, n;   
    mad_fixed_t const *left_ch, *right_ch;   
    unsigned char Output[6912], *OutputPtr;   
    int fmt, wrote, speed;   

    nchannels = pcm->channels;   
    n = nsamples = pcm->length;   
    left_ch = pcm->samples[0];   
    right_ch = pcm->samples[1];   
    fmt = AFMT_S16_LE;   
    speed = pcm->samplerate * 2;    /*播放速度是采样率的两倍 */
    ioctl(sfd, SNDCTL_DSP_SPEED, &(speed));   
    ioctl(sfd, SNDCTL_DSP_SETFMT, &fmt);   
    ioctl(sfd, SNDCTL_DSP_CHANNELS, &(pcm->channels));   
    OutputPtr = Output;   

    while (nsamples--) {   
        signed int sample;   
        sample = scale(*left_ch++);   
        *(OutputPtr++) = sample >> 0;   
        *(OutputPtr++) = sample >> 8;   
        if (nchannels == 2) {   
              sample = scale(*right_ch++);   
              *(OutputPtr++) = sample >> 0;   
              *(OutputPtr++) = sample >> 8;   
          }   
    }   

    n *= 4;        /*数据长度为pcm音频采样的4倍 */
    OutputPtr = Output;   

    while (n) {   
    wrote = write(sfd, OutputPtr, n);   
    OutputPtr += wrote;   
    n -= wrote;   
    }   
    OutputPtr = Output;   
    return MAD_FLOW_CONTINUE;   
}   

static
enum mad_flow error(void *data,   
            struct mad_stream *stream, struct mad_frame *frame)   
{   
    return MAD_FLOW_CONTINUE;   
}   

static
int decode(unsigned char const *start, unsigned long length)   
{   
    struct buffer buffer;   
    struct mad_decoder decoder;   
    int result;   
    buffer.start = start;   
    buffer.length = length;   
    mad_decoder_init(&decoder, &buffer, input, 0, 0, output, error, 0);   
    mad_decoder_options(&decoder, 0);   
    result = mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);   
    mad_decoder_finish(&decoder);   
    return result;   
}