我拿了libmad示例C文件，并播放了一个mp3，播放得很好。但是，当我尝试以块的形式读取文件时，与一次性读取文件的示例相反，我听到＆＃34;中断＆＃34;播放太快了。
这是我的输入回调和输出回调
static enum mad_flow input(void *data, struct mad_stream *stream) {
struct buffer *buffer = data;
// char* raw_data[buffer->size];
// if(fgets(*raw_data, buffer->size, buffer->file) == NULL) {
// file is finished!
// in our case we would want to move to next file here!
// when we get there, we will get data from node->file of LL, instead of file.
// with node->file, we can simply move to next song when playing the music.
// return MAD_FLOW_STOP;
// }
//printf("%s\n",*raw_data);
void *fdm;
fdm = mmap(0, BUFFER_SIZE, PROT_READ, MAP_SHARED, buffer->fd, buffer->offset);
if (fdm == MAP_FAILED) {
printf("%s\n","failed");
return MAD_FLOW_STOP;
}
if(buffer->offset >= buffer->size) {
if (munmap(fdm, BUFFER_SIZE) == -1)
return MAD_FLOW_STOP;
return MAD_FLOW_STOP;
}
mad_stream_buffer(stream, fdm, BUFFER_SIZE);
printf("size is %lu and offset is %lu\n",buffer->size, buffer->offset);
buffer->offset += BUFFER_SIZE;
printf("%s\n","read");
return MAD_FLOW_CONTINUE;
}
static enum mad_flow output(void *data, struct mad_header const *header, struct mad_pcm *pcm) {
register int nsamples = pcm->length;
mad_fixed_t const *left_ch = pcm->samples[0], *right_ch = pcm->samples[1];
static unsigned char stream[1152*4]; /* 1152 because that's what mad has as a max; *4 because
there are 4 distinct bytes per sample (in 2 channel case) */
static unsigned int rate = 0;
static int channels = 0;
//static struct audio_dither dither;
register char * ptr = stream;
register signed int sample;
register mad_fixed_t tempsample;
printf("%s\n", "playing");
/* We need to know information about the file before we can open the playdevice
in some cases. So, we do it here. */
if (pcm->channels == 2) {
while (nsamples--) {
signed int sample;
sample = scale(*left_ch++);
// sample = (signed int) audio_linear_dither(16, tempsample, &dither);
stream[(pcm->length-nsamples)*4 ] = ((sample >> 0) & 0xff);
stream[(pcm->length-nsamples)*4 +1] = ((sample >> 8) & 0xff);
sample = scale(*right_ch++);
stream[(pcm->length-nsamples)*4+2 ] = ((sample >> 0) & 0xff);
stream[(pcm->length-nsamples)*4 +3] = ((sample >> 8) & 0xff);
}
ao_play(device, stream, pcm->length * 4);
} else {
while (nsamples--) {
signed int sample;
sample = scale(*left_ch++);
stream[(pcm->length-nsamples)*2 ] = ((sample >> 0) & 0xff);
stream[(pcm->length-nsamples)*2 +1] = ((sample >> 8) & 0xff);
}
ao_play(device, stream, pcm->length * 2);
}
return MAD_FLOW_CONTINUE;
}
我使用的示例可以在这里找到：https://github.com/fasterthanlime/libmad/blob/master/minimad.c
我正在使用libao来播放生成的PCM，这在添加到示例时工作正常，因此我猜它不是libao的问题。
答案 0 :(得分：6)
这是一个老问题，但我遇到了同样的问题，目前很难找到简单的示例代码来执行此操作，甚至是在邮件列表之外的半个解释。
首先，关于你的特定代码，我知道每次与mmap（）整个文件相比，每次调用mmap（）一小部分文件都没有优势。 mmap（）并没有像你想象的那样将文件读入内存;它甚至不为整个文件分配物理内存。它只分配虚拟内存。只要程序从尚未加载的虚拟内存中读取（页面错误处理程序），操作系统就会将文件读入物理内存，并从物理内存中删除部分文件无论何时在其他地方需要物理内存。
话虽如此，如果您使用的是没有内存管理单元的嵌入式系统，您将无法获得具有这些特性的mmap（），并且您可能没有足够的物理内存来加载整个内存管理单元MP3文件也可以存入内存。因此，对于本解释的其余部分，我假设您正在使用一些通用的read（）函数来获取数据并使目标系统具有以千字节为单位指定的内存大小。
问题在于mad_stream_buffer（）没有按照你的想法做或想做它。它会让你认为它会将你给它的任何缓冲区添加到内部流中，并在该流运行不足时调用input（）。但是没有内部流。 libmad只能使用你给它的缓冲区，调用mad_stream_buffer（）只是替换缓冲区指针。
要真正理解为什么这是一个问题，您还需要了解MP3的工作原理。 MP3文件的音频部分被分解为称为＆＃34;帧＆＃34;的数据块。帧是字节对齐的，并以一串全部设置为1的位开始，称为同步字。它用于在开始播放或搜索后找到第一帧的开头。在调用input（）回调之后，libmad将始终在其当前输入缓冲区中查找第一个同步字，在它找到的第一个同步字之前跳过任何数据。然后，libmad将开始解码MP3帧，直到没有数据或遇到不完整的帧。最后的不完整帧也被忽略，并再次调用input（）。
所以最终发生的事情看起来像这样：
| read() 1 | read() 2 | read() 3 | read() 4 |
|hdr|frame1|??????|frame3|frame4|??????|frame6|??????|frame8|frame9|?
要使其发挥作用，您需要做的是：
input():
| read() 1 |
|hdr|frame1|frame|
decoded as:
| buffer 1 |
|???|frame1|?????|
|
input(): |
.----------'
v | read() 2 |
|frame2|frame3|fr|
decoded as:
| buffer 2 |
|frame2|frame3|??|
|
input(): |
.-------------'
v | read() 3 |
|frame4|frame5|fr|
decoded as:
| buffer 3 |
|frame4|frame5|??|
等等。如果libmad获得的缓冲区不包含帧或不以帧边界结束，则会将error参数中的struct mad_stream条目设置为传递给MAD_ERROR_BUFLEN的输入。如果它在帧的中间结束，则next_frame条目将被设置为先前给定的数据缓冲区内的指针，该指针标记不完整帧的开始。如果缓冲区中根本没有帧，则该指针的值将为null。在这种情况下，您还会收到＆＃34;同步丢失＆＃34;错误回调中的错误，如果有的话。
你需要一个数据缓冲区，它可以容纳至少一个最大长度的MP3帧，加上8个字节用于libmad的MAD_BUFFER_GUARD。那将是至少2881字节长（source）。但是假设缓冲区在帧的开始处开始。如果您还不知道第一帧的位置（即MP3文件的开头），那么在这种情况下，您需要逐字节移位数据缓冲区，以便在最坏的情况下找到它。因此，您可能会选择断电2。
在input（）中，您需要执行以下操作：
error不是MAD_ERROR_BUFLEN，请使用全新的数据块加载数据缓冲区并返回。next_frame，则将（前一个）缓冲区的未使用部分移动到缓冲区的开头，然后用新数据填充缓冲区的剩余部分。next_frame为空，则尚未找到有效的帧。为了确保没有跳过第一帧，这可能已部分在缓冲区中，我们需要最多移位数据缓冲区（buflen - max_frame_size），并用新数据填充缓冲区的剩余部分。 MAD_BUFFER_GUARD个零字节。最后，这里有适用于我的完整代码。
#define MP3_BUF_SIZE 4096
#define MP3_FRAME_SIZE 2881
static enum mad_flow input(void *data, struct mad_stream *stream) {
static char mp3_buf[MP3_BUF_SIZE]; /* MP3 data buffer. */
int keep; /* Number of bytes to keep from the previous buffer. */
int retval; /* Return value from read(). */
int len; /* Length of the new buffer. */
int eof; /* Whether this is the last buffer that we can provide. */
/* Figure out how much data we need to move from the end of the previous
buffer into the start of the new buffer. */
if (stream->error != MAD_ERROR_BUFLEN) {
/* All data has been consumed, or this is the first call. */
keep = 0;
} else if (stream->next_frame != NULL) {
/* The previous buffer was consumed partially. Move the unconsumed portion
into the new buffer. */
keep = stream->bufend - stream->next_frame;
} else if ((stream->bufend - stream->buffer) < MP3_BUF_SIZE) {
/* No data has been consumed at all, but our read buffer isn't full yet,
so let's just read more data first. */
keep = stream->bufend - stream->buffer;
} else {
/* No data has been consumed at all, and our read buffer is already full.
Shift the buffer to make room for more data, in such a way that any
possible frame position in the file is completely in the buffer at least
once. */
keep = MP3_BUF_SIZE - MP3_FRAME_SIZE;
}
/* Shift the end of the previous buffer to the start of the new buffer if we
want to keep any bytes. */
if (keep) {
memmove(mp3_buf, stream->bufend - keep, keep);
}
/* Append new data to the buffer. */
retval = read(in_fd, mp3_buf + keep, MP3_BUF_SIZE - keep);
if (retval < 0) {
/* Read error. */
perror("failed to read from input");
return MAD_FLOW_STOP;
} else if (retval == 0) {
/* End of file. Append MAD_BUFFER_GUARD zero bytes to make sure that the
last frame is properly decoded. */
if (keep + MAD_BUFFER_GUARD <= MP3_BUF_SIZE) {
/* Append all guard bytes and stop decoding after this buffer. */
memset(mp3_buf + keep, 0, MAD_BUFFER_GUARD);
len = keep + MAD_BUFFER_GUARD;
eof = 1;
} else {
/* The guard bytes don't all fit in our buffer, so we need to continue
decoding and write all fo teh guard bytes in the next call to input(). */
memset(mp3_buf + keep, 0, MP3_BUF_SIZE - keep);
len = MP3_BUF_SIZE;
eof = 0;
}
} else {
/* New buffer length is amount of bytes that we kept from the previous
buffer plus the bytes that we read just now. */
len = keep + retval;
eof = 0;
}
/* Pass the new buffer information to libmad. */
mad_stream_buffer(stream, mp3_buf, len);
return eof ? MAD_FLOW_STOP : MAD_FLOW_CONTINUE;
}
请注意，我没有进行大量测试，比如实际上确保它正确地解码了第一帧和最后一帧，并且我没有参与该项目，因此这里可能存在小错误。我正在听这个代码解码的MP3，因为我正在输入这些单词。
希望这可以节省某人工作的某个地方！