MP3解码算法分析

1. 读 32bit 的帧头，头处理的主处理流程
Header.read_header(Bitstream, Crc16[] crcp) [javazoom.jl.decoder]
int headerstring; // 帧头的32位对应的32位整数
int channel_bitrate; // 比特率
boolean sync = false; // 同步判断

do {
headerstring = stream.syncHeader(syncmode);// 同步并获取帧头的32位整数
_headerstring = headerstring;

if (syncmode==Bitstream.INITIAL_SYNC) { // 如果是初始化同步
h_version = ((headerstring >>> 19) & 1); // 求取第 19 位的版本号
if (((headerstring >>> 20) & 1) == 0) // 第 20 位为: MPEG2.5 detection
if (h_version == MPEG2_LSF)
h_version = MPEG25_LSF;
else
throw stream.newBitstreamException(Bitstream.UNKNOWN_ERROR);
// 第 10-11 位为采样率
if ((h_sample_frequency = ((headerstring >>> 10) & 3)) == 3)
throw stream.newBitstreamException(Bitstream.UNKNOWN_ERROR);
}

h_layer = 4 - (headerstring >>> 17) & 3; // 第 17-18 位为层号 Layer I/II/III
h_protection_bit = (headerstring >>> 16) & 1; // 第 16 位为保护位 Protect
h_bitrate_index = (headerstring >>> 12) & 0xF; // 第 12-15 位为比特率
h_padding_bit = (headerstring >>> 9) & 1; // 第 9 位为补齐位
h_mode = ((headerstring >>> 6) & 3); // 第 6-7 位为模式位
h_mode_extension = (headerstring >>> 4) & 3; // 第 4-5 位为模式扩展位
if (h_mode==JOINT_STEREO) h_intensity_stereo_bound = (h_mode_extension << 2) + 4;
else h_intensity_stereo_bound = 0; // 用不到
if (((headerstring >>> 3) & 1)==1) h_copyright = true; // 第 3 位版权等信息
if (((headerstring >>> 2) & 1)==1) h_original = true; // 第 2 位为 Home 信息

if (h_layer==1) h_number_of_subbands = 32; // 计算子带数(subbands)，Layer I 有 32 个子带
else {
channel_bitrate = h_bitrate_index; // 计算每个信道的比特率
if (h_mode != SINGLE_CHANNEL)
if (channel_bitrate == 4) channel_bitrate = 1;
else channel_bitrate -= 4;

if ((channel_bitrate == 1) || (channel_bitrate == 2))
if (h_sample_frequency == THIRTYTWO) h_number_of_subbands = 12;
else h_number_of_subbands = 8;
else
if ((h_sample_frequency == FOURTYEIGHT) || ((channel_bitrate >= 3)
&& (channel_bitrate <= 5)))
h_number_of_subbands = 27;
else
h_number_of_subbands = 30;
}
if (h_intensity_stereo_bound > h_number_of_subbands)
h_intensity_stereo_bound = h_number_of_subbands;

calculate_framesize(); // 计算帧尺寸和槽数(framesize/nSlots)
stream.read_frame_data(framesize); // 读取帧数据(framedata):

if(stream.isSyncCurrentPosition(syncmode)){// 当前位置同步
if (syncmode==Bitstream.INITIAL_SYNC) { // 如果是初始化同步
syncmode = Bitstream.STRICT_SYNC; // 设定为严格同步
stream.set_syncword(headerstring & 0xFFF80CC0); // 设定同步字，0xFFF80CC0 为同步字掩码
}
sync = true; // 目前同步
} else {
stream.unreadFrame(); // 当前不同步，把帧数据退回去缓冲区中
}
} while (!sync); // 如果未同步重读

stream.parse_frame(); // 分析帧

if (h_protection_bit == 0) { // 帧中包含 16 位的 crc 校验和
checksum = (short)stream.get_bits(16); // 取出 16 位的 crc 校验和到 checksum
if (crc == null)
crc = new Crc16();
crc.add_bits(headerstring, 16); // ？把头 16 位加入校验
crcp[0] = crc; // 把校验器返回 crcp[]
} else
crcp[0] = null; // 无校验
}

2. 帧尺寸计算，计算帧尺寸(单位为字节)，抛掉头尺寸。
public int calculate_framesize() {
if (h_layer == 1) { // 层 Layer I，公式：fs = 12 * br / sf
framesize = (12 * bitrates[h_version][0][h_bitrate_index])
/ frequencies[h_version][h_sample_frequency];
if (h_padding_bit != 0 ) framesize++;
framesize <<= 2; // 每槽 4bytes
nSlots = 0;
} else { // 层 Layer II/III，公式：fs = 144 * br / sf
framesize = (144 * bitrates[h_version][h_layer - 1][h_bitrate_index])
/ frequencies[h_version][h_sample_frequency];
if (h_version == MPEG2_LSF || h_version == MPEG25_LSF)
framesize >>= 1; // 每槽 4bits
if (h_padding_bit != 0) // 对齐位
framesize++;
if (h_layer == 3) { // 层 Layer III 槽调整
if (h_version == MPEG1) { // MPEG1
nSlots = framesize
- ((h_mode==SINGLE_CHANNEL) ? 17:32) // 减去 边(side)信息尺寸
- ((h_protection_bit!=0) ? 0 : 2) // 减去 CRC 尺寸
- 4; // 减去 头尺寸
} else { // MPEG-2 LSF, MPEG-2.5 LSF
nSlots = framesize
- ((h_mode==SINGLE_CHANNEL) ? 9:17) // 减去 边(side)信息尺寸
- ((h_protection_bit!=0) ? 0 : 2) // 减去 CRC 尺寸
- 4; // 减去 头尺寸
}
} else { // 层 Layer II 槽为 0
nSlots = 0;
}
}
framesize -= 4; // 再扣去一遍头尺寸？
return framesize; // 返回
}

3. 帧头是否同步，即检查头32位整数的合法性
public boolean isSyncMark(int headerstring, int syncmode, int syncword) {
boolean sync = false; // 同步变量

if (syncmode==INITIAL_SYNC) { // 初始化同步
sync=((headerstring&0xFFE00000)==0xFFE00000); // MPEG 2.5
} else { // 否则要检查内部合法性
sync=((headerstring&0xFFF80C00)==syncword) // 同步字相同，且：
&&(((headerstring&0x000000C0)==0x000000C0)==single_ch_mode);
}

if (sync) // 过滤掉非法采样率
sync = (((headerstring >>> 10) & 3)!=3);
if (sync) // 过滤掉非法层
sync = (((headerstring >>> 17) & 3)!=0);
if (sync) // 过滤掉非法版本
sync = (((headerstring >>> 19) & 3)!=1);

return sync; // 返回是否同步
}

4. 帧数据分析，转化读入的字节为每4个转化为一个32位整数。问题：为什么要这样做？
void parse_frame() throws BitstreamException {
int b=0;
byte[] byteread = frame_bytes; // 予处理：帧字节缓冲
int bytesize = framesize; // 帧尺寸(单位字节)

for (int k=0; k<bytesize; k+=4) { // 每4字节合成成32位的整数
byte b0=0, b1=0, b2=0, b3=0;
b0 = byteread[k];
if (k+1<bytesize) b1 = byteread[k+1]; // 避免异常需要用前判断：帧尺寸非4之倍数
if (k+2<bytesize) b2 = byteread[k+2];
if (k+3<bytesize) b3 = byteread[k+3];
framebuffer[b++] = (b0 << 24) | (b1 << 16) // 再合成32位整数：先读的 b0, b1 在高位，
| (b2 << 8) | b3; // 后读的 b2, b3 在低位
}

wordpointer = 0; // 后处理：字指针复位 0，范围：0 ~ 整数字个数-1
bitindex = 0; // 位指针复位 0，范围：0 ~ 31
}

5. 从缓冲区读入指定位数到一个无符号整数的低位部分 LSB(1~16)
public int get_bits(int number_of_bits) {
int returnvalue = 0;
int sum = bitindex + number_of_bits; // bitindex为当前字wordpointer下的当前位数指针

if (wordpointer < 0) wordpointer = 0; // 这儿有个问题，wordpointer 能是-1吗?!

if (sum <= 32) { // 所有位包含在当前字中*wordpointer，没跨32位字
returnvalue = (framebuffer[wordpointer] >>> (32 - sum))
& bitmask[number_of_bits]; // bitmask[] = {0,1,3,7,15,31,63,127,...}
if ((bitindex+=number_of_bits)==32) { // 位指针前移 number_of_bits 位
bitindex = 0; // bitindex==32, 即 bitindex = 0
wordpointer++; // 字指针前移一个字
}
} else { // 跨字处理
int Right = (framebuffer[wordpointer] & 0x0000FFFF); // 上字后半部分
wordpointer++; // 字指针前移一个字
int Left = (framebuffer[wordpointer] & 0xFFFF0000); // 下子前半部分
returnvalue = ((Right << 16) & 0xFFFF0000)
| ((Left >>> 16)& 0x0000FFFF); // 整字合并

returnvalue >>>= 48 - sum; // 截尾便于掩码操作
returnvalue &= bitmask[number_of_bits]; // 掩码出想读的位数字
bitindex = sum - 32; // 位指针前移到位结束处
}

return returnvalue; // 返回想读的位数字
}

6. 首个帧头处理初始化——Decoder.initialize(header)
private void initialize(Header header) throws DecoderException {
float scalefactor = 32700.0f; // 评论：允许客户化缩放系数(Scale Factor)
int mode = header.mode();
int layer = header.layer();
int channels = (mode==Header.SINGLE_CHANNEL ? 1 : 2);

if (output==null) // 设置创建输出缓冲区，如果客户端未设置
output = new SampleBuffer(header.frequency(), channels);

float[] factors = equalizer.getBandFactors();// 均衡器在解码器创建时已创建，获取其各波段系数
filter1 = new SynthesisFilter(0, scalefactor, factors); // 创建合成过滤器 1

if (channels==2) // 评论：允许为立体声输出单声道
filter2 = new SynthesisFilter(1, scalefactor, factors); // 创建合成过滤器 2

outputChannels = channels;
outputFrequency = header.frequency();

initialized = true; // 初始化完成标志，以后不必再初始化。405
}

随机文章：

MP3解码算法分析(2)——MP3帧头(Frame Header)数据结构描述 2005-12-19
MP3解码算法分析(6)——帧解码器接口定义与选择 2005-12-21
MP3解码算法分析(7)——L1帧解码器分析 2005-12-21
MP3解码算法分析(3)——CRC16算法 2005-12-20
MP3解码算法分析(8)——解码器概念/类框架 2005-12-21