MyMinimad ── Linux下用libmad写的mp3解码播放程序

首先这里有篇介绍libmad的技术文章：http://www.ibm.com/developerworks/cn/linux/l-cn-libmadmp3player/index.html,介绍了大部分libmad技术。

/*****************************************************************/

平台：ubuntu-8.04.1-amd64-desktop

声卡驱动：oss

安装依赖软件包： sudo apt-get install libmad0 libmad0-dev libid3tag0 libid3tag0-dev

libmad的官网上没有文档，有两个例子：minimad(high-level api),madlld(low-level api)。low-level api用起来太复杂，所以选择minimad为本程序的蓝本。

打开音频设备：

static int sfd;

if((sfd=open("/dev/dsp",O_WRONLY))<0)

{

printf("can not open device!!!/n");

return 5;

}

在output函数中设置音频设备。在mp3字节流解码后得到pcm音频的采样率，声道和音频格式。

一般mp3文件都是立体声（有2个声道），由于要把pcm采样后并处理的数据放入一个char型的数组，而并行的左右声道的每个采样要在字符数组中处理成2个，所以字符数组中的数据的个数应该是pcm音频采样数的4倍。又因为把左右声道的数据合在一个字符数组里串行处理，所以播放的速度应该是pcm音频采样率的两倍。代码如下：

unsigned char Output[6912],*OutputPtr;

int fmt,wrote,speed;

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;

/* output sample(s) in 16-bit signed little-endian PCM */

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;

然后，就是把数据写入/dev/dsp中播放了：

OutputPtr=Output;

while(n)

{

wrote=write(sfd,OutputPtr,n);

if(wrote==-1) printf("wrote ==== -1");

OutputPtr+=wrote;

n-=wrote;

}

minimad是用的从标准输入得到mp3文件字节流，感觉不爽，改了下，用mmap把文件映射到内存

struct stat stat;

void *fdm;

char const *file;

int fd;

file=argv[1];

fd=open(file,O_RDONLY);

if (fstat(fd, &stat) == -1 ||

stat.st_size == 0)

return 2;

fdm = mmap(0, stat.st_size, PROT_READ, MAP_SHARED, fd, 0);

/************************ end *************************************/

完整源代码

/*
* 本程序是从 minimad 改进而来，如要更详细的说明请参看 minimad.c
*
* MyMinimad.c , 2008/09/17 , SiChuan University , China
*
* 编译： gcc MyMinimad.c -o MyMinimad -lmad -g -Wall
* 运行： ./MyMinimad filename.mp3
*/
# 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) {
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;
}