MPEG音频编码
模拟音频信号数字化后通常具有极高的码率，例如对于取样频率为44.1 kHz的双声道CD数字音频而言，采用16 bit量化，无压缩码率可达1.41 Mbps，非常不利于存储和传输。因此，为了节省存储空间、提高传输效率，必须要对数字音频信号进行压缩编码。
一、 人类听觉系统的感知特性
许多科学工作者一直在研究听觉系统对声音的感知特性，下面介绍已经用在MPEG Audio压缩编码算法中的三个特性：响度、音高和掩蔽效应。
.1.1. 对响度的感知
声音的响度就是声音的强弱。在物理上，声音的响度使用客观测量单位来度量，即dyn/cm2(达因/平方厘米)(声压)或W/cm2(瓦特/平方厘米)(声强)。在心理上，主观感觉的声音强弱使用响度级“方(phon)”或者“宋(sone)”来度量。这两种感知声音强弱的计量单位是完全不同的两种概念，但是它们之间又有一定的联系。
当声音弱到人的耳朵刚刚可以听见时，我们称此时的声音强度为“听阈”。例如，1 kHz纯音的声强达到10-16w/cm2(定义成零dB声强级)时，人耳刚能听到，此时的主观响度级定为零方。实验表明，听阈是随频率变化的。测出的“听阈—频率”曲线如图9-01所示。图中最靠下面的一根曲线叫做“零方等响度级”曲线，也称“绝对听阈”曲线，即在安静环境中，能被人耳听到的纯音的最小值。
另一种极端的情况是声音强到使人耳感到疼痛。实验表明，如果频率为1 kHz的纯音的声强级达到120 dB左右时，人的耳朵就感到疼痛，这个阈值称为“痛阈”。对不同的频率进行测量，可以得到“痛阈—频率”曲线，如图9-01中最靠上面所示的一根曲线。这条曲线也就是120方等响度级曲线。
在“听阈—频率”曲线和“痛阈—频率”曲线之间的区域就是人耳的听觉范围。这个范围内的等响度级曲线也是用同样的方法测量出来的。由图9-01可以看出，1 kHz的10 dB的声音和200 Hz的30 dB的声音，在人耳听起来具有相同的响度。
图9-01 “听阈—频率”曲线
图9-01说明人耳对不同频率的敏感程度差别很大，其中对2 kHz～4 kHz范围的信号最为敏感，幅度很低的信号都能被人耳听到。而在低频区和高频区，能被人耳听到的信号幅度要高得多。
.1.2. 对音高的感知
客观上用频率来表示声音的音高，其单位是Hz。而主观感觉的音高单位则是“美(Mel)”,主观音高与客观音高的关系是
其中的单位为Hz，这也是两个既不相同又有联系的单位。
人耳对响度的感觉有一个范围，即从听阈到痛阈。同样，人耳对频率的感觉也有一个范围。人耳可以听到的最低频率约20 Hz，最高频率约18000 Hz。正如测量响度时是以1 kHz纯音为基准一样，在测量音高时则以40 dB声强为基准，并且同样由主观感觉来确定。
测量主观音高时，让实验者听两个声强级为40 dB的纯音，固定其中一个纯音的频率，调节另一个纯音的频率，直到他感到后者的音高为前者的两倍，就标定这两个声音的音高差为两倍。实验表明，音高与频率之间也不是线性关系。测出的“音高—频率”曲线如图9-02所示。
图9-02 “音高—频率”曲线
.1.3. 掩蔽效应
一种频率的声音阻碍听觉系统感受另一种频率的声音的现象称为掩蔽效应。前者称为掩蔽声音(masking tone)，后者称为被掩蔽声音(masked tone)。掩蔽可分成频域掩蔽和时域掩蔽。
1. 频域掩蔽
一个强纯音会掩蔽在其附近同时发声的弱纯音，这种特性称为频域掩蔽，也称同时掩蔽(simultaneous masking)。如图9-03所示，一个声强为60 dB、频率为1000 Hz的纯音，另外还有一个1100 Hz的纯音，前者比后者高18 dB，在这种情况下我们的耳朵就只能听到那个1000 Hz的强音。如果有一个1000 Hz的纯音和一个声强比它低18 dB的2000 Hz的纯音，那么我们的耳朵将会同时听到这两个声音。要想让2000 Hz的纯音也听不到，则需要把它降到比1000 Hz的纯音低45 dB。一般来说，弱纯音离强纯音越近就越容易被掩蔽。
图9-03 声强为60 dB、频率为1000 Hz纯音的掩蔽效应
在图9-04中的一组曲线分别表示频率为250 Hz、1 kHz、4 kHz和8 kHz纯音的掩蔽效应，它们的声强均为60 dB。从图中可以看到：①在250 Hz、1 kHz、4 kHz和8 kHz纯音附近，对其他纯音的掩蔽效果最明显，②低频纯音可以有效地掩蔽高频纯音，但高频纯音对低频纯音的掩蔽作用则不明显。
图9-04 不同纯音的掩蔽效应曲线
由于声音频率与掩蔽曲线不是线性关系，为从感知上来统一度量声音频率，引入了“临界频带(critical band)”的概念。通常认为，在20 Hz到16 kHz范围内有24个临界频带，如表9-01所示。临界频带的单位叫Bark(巴克)，
1 Bark = 一个临界频带的宽度
(频率)< 500 Hz的情况下, 1 Bark » /100
(频率) > 500 Hz的情况下, 1Bark » 9 + 4log(
/1000)
以上我们讨论了响度、音高和掩蔽效应，尤其是人的主观感觉。其中掩蔽效应尤为重要，它是心理声学模型的基础。
表9-01 临界频带[16]
2. 时域掩蔽
除了同时发出的声音之间有掩蔽现象之外，在时间上相邻的声音之间也有掩蔽现象，并且称为时域掩蔽。时域掩蔽又分为超前掩蔽(pre-masking)和滞后掩蔽(post-masking)，如图9-05所示。产生时域掩蔽的主要原因是人的大脑处理信息需要花费一定的时间。一般来说，超前掩蔽很短，只有大约5～20 ms，而滞后掩蔽可以持续50～200 ms。这个区别也是很容易理解的。
二、MPEG-I 心理声学模型
MPEG-1中采用了感知音频编码，Layer II的编码器框图如下
可以看到，编码器具有两条脉络：一是上方蓝色框内的子带编码部分，这也是编码的主线；二是下方的部分，是MPEG音频编码的亮点。
下面以Layer II为基准，简要说明编码器的组成和编码过程。
1、多相滤波器
数字音频信号通过一个多相滤波器组，变换成32个等宽频带子带，使得信号具有较高的时间分辨率，确保在短暂冲击信号的情况下，编码的声音信号具有足够高的质量。
但需要说明的是，高时域分辨率和高频域分辨率是不可兼得的，我们需要做出权衡。
滤波器组的输出是临界频带经过量化的系数样值。若一个子带覆盖多个临界频带，则选择具有最小NMR的临界频带来计算分配给子带的比特数。
2、心理声学模型
MPEG-I 标准定义了两个模型：
心理声学模型1:
计算复杂度低，但对假设用户听不到的部分压缩太严重；
心理声学模型2 :
提供了适合Layer III编码的更多特征，实际实现的模型复杂度取决所需要的压缩因子。如大的压缩因子不重要，则可以完全不用心理声学模型。此时位分配算法不使用SMR（ Signal Mask Ratio ），而是使用SNR。
1、将样本变换到频域
32个等分的子带信号并不能精确地反映人耳的听觉特性。
引入FFT补偿频率分辨率不足的问题。
◼采用Hann加权和DFT；
◼ Hann加权减少频域中的边界效应；
◼ 此变换不同于多相滤波器组，因为模型需要更精细的频率分辨率，而且计算掩蔽阈值也需要每个频率的幅值。
模型1：采用512 (Layer I) 或1024 (Layers II and III)样本窗口
◼ Layer I：每帧384个样本点，512个样本点足够覆盖；
◼ Layer II 和Layer III：每帧1152个样本点，每帧两次计算，模型1选择 两个信号掩蔽比（SMR）中较小的一个。
2、确定声压级别
3、考虑安静时阈值
也即绝对阈值。在标准中有根据输入PCM信号的采
样率编制的“频率、临界频带率和绝对阈值”表。
此表为多位科学家经多次心理声学实验所得。
5、音调和非音调掩蔽成分的消除
利用标准中给出的绝对阈值消除被掩蔽成分；
考虑在每个临界频带内，小于0.5Bark的距离
中只保留最高功率的成分
6、单个掩蔽阈值的计算
音调成分和非音调成分单个掩蔽阈值根据标
准中给出的算法求得。
7、全局掩蔽阈值的计算
还要考虑别的临界频带的影响。一个掩蔽信号会对其它频带上的信号产生掩蔽效应。这种掩蔽效应称为掩蔽扩散。
8、每个子带的掩蔽阈值
◼选择出本子带中最小的阈值作为子带阈值
◼对高频不正确——高频区的临界频带很宽，可能跨越多个子带，从而导致模型1将临界带宽内所有的非音调部分集中为一个代表频率，当一个子带在很宽的频带内却远离代表频率时，无法得到准确的非音调掩蔽值。但计算量低。
9、计算每个子带信号掩蔽比(signal-to-mask ratio, SMR)
SMR = 信号能量 / 掩蔽阈值，并将SMR传递给编码单元
3、 量化编码
(1) 码率分配
在调整到固定的码率之前:
◼先确定可用于样值编码的有效比特数
◼这个数值取决于比例因子、比例因子选择信息、比特分配信息以及辅助数据所需比特数
◼ 比特分配的过程
对每个子带计算掩蔽-噪声比MNR，是信噪比SNR–信掩比 SMR，即：MNR = SNR–SMR，NMR=SMR-SNR
◼ 算法：使整帧和每个子带的总噪声—掩蔽比最小
计算噪声-掩蔽比(noise-to-mask ratio, NMR)： NMR = SMR – SNR (dB)
其中SNR 由MPEG-I标准给定 (为量化水平的函数)
NMR：表示波形误差与感知测量之间的误差
◼ 算法：循环，直到没有比特可用：
◼ NMR = SMR– SNR (dB)
◼ 对最高NMR的子带分配比特，使获益最大的子带的
量化级别增加一级
◼ 重新计算分配了更多比特子带的NMR
(2) 计算比例因子
缩放因子(比例因子)一般从低频子带到高频子带出现连续下降，每个子带的3个组尽可能共用缩放因子
Layer I: 1个/12个样本
Layer II： 1个/（24/36）个样本
◼ 1/2/3个缩放因子和缩放因子选择信息(scale factor
selection information, SCFSI) （每子带2比特）一起传送
如果缩放因子和下一个只有很小的差别，就只传送大的一个，这种情况对于稳态信号经常出现
如果要给瞬态信号编码，则要在瞬态的前、后沿传送两个或所有三个比例因子
(3) 子带样值量化
(4) 颗粒形成
对量化级别在3、5、9级时，采用“颗粒” 优化
◼ 颗粒= 3 个样本，根据颗粒选择量化水平
◼ 例：3个样本 @ 3个量化水平 = 27种可能的值 → 5 比特
不采用颗粒量化：1个样本 @ 3个量化水平 = 2比特x 3 个样本 → 6 比特
4、帧比特流形成
三、 MPEG-1 Audio Layer II编码器调试
1、main函数及理解
int main(int argc, char** argv) {
typedef double SBS[2][3][SCALE_BLOCK][SBLIMIT];
SBS* sb_sample;
typedef double JSBS[3][SCALE_BLOCK][SBLIMIT];
JSBS* j_sample;
typedef double IN[2][HAN_SIZE];
IN* win_que;
typedef unsigned int SUB[2][3][SCALE_BLOCK][SBLIMIT];
SUB* subband;
frame_info frame; // 包含头信息、比特分配表、声道数、子带数等内容
frame_header header; // 包含采样频率等信息
char original_file_name[MAX_NAME_SIZE]; // 输入文件名
char encoded_file_name[MAX_NAME_SIZE]; // 输出文件名
short** win_buf;
static short buffer[2][1152];
static unsigned int bit_alloc[2][SBLIMIT]; // 存放双声道各个子带的比特分配表
static unsigned int scfsi[2][SBLIMIT];
static unsigned int scalar[2][3][SBLIMIT]; // 存放双声道3组12个样值的各个子带的比例因子
static unsigned int j_scale[3][SBLIMIT];
static double smr[2][SBLIMIT], lgmin[2][SBLIMIT], max_sc[2][SBLIMIT];
// FLOAT snr32[32];
short sam[2][1344]; /* was [1056]; */
int model;
int nch; // 声道数
int error_protection;
static unsigned int crc;
int sb, ch;
int adb; // 比特预算 (i.e., number of bits available)
unsigned long frameBits, sentBits = 0;
unsigned long num_samples;
int lg_frame;
int i;
/* Used to keep the SNR values for the fast/quick psy models */
static FLOAT smrdef[2][32];
static int psycount = 0;
extern int minimum;
time_t start_time, end_time;
int total_time;
sb_sample = (SBS*)mem_alloc(sizeof(SBS), "sb_sample");
j_sample = (JSBS*)mem_alloc(sizeof(JSBS), "j_sample");
win_que = (IN*)mem_alloc(sizeof(IN), "Win_que");
subband = (SUB*)mem_alloc(sizeof(SUB), "subband");
win_buf = (short**)mem_alloc(sizeof(short*) * 2, "win_buf");
/* clear buffers */
memset((char*)buffer, 0, sizeof(buffer));
memset((char*)bit_alloc, 0, sizeof(bit_alloc));
memset((char*)scalar, 0, sizeof(scalar));
memset((char*)j_scale, 0, sizeof(j_scale));
memset((char*)scfsi, 0, sizeof(scfsi));
memset((char*)smr, 0, sizeof(smr));
memset((char*)lgmin, 0, sizeof(lgmin));
memset((char*)max_sc, 0, sizeof(max_sc));
//memset ((char *) snr32, 0, sizeof (snr32));
memset((char*)sam, 0, sizeof(sam));
global_init();
header.extension = 0;
frame.header = &header;
frame.tab_num = -1; /* no table loaded */
frame.alloc = NULL;
header.version = MPEG_AUDIO_ID; /* Default: MPEG-1 */
total_time = 0;
time(&start_time);
programName = argv[0]; // exe文件名称
if (argc == 1) /* no command-line args */
short_usage();
else
parse_args(argc, argv, &frame, &model, &num_samples, original_file_name, encoded_file_name); // 解析命令行参数
print_config(&frame, &model, original_file_name, encoded_file_name); // print文件参数到窗口
/* this will load the alloc tables and do some other stuff */
hdr_to_frps(&frame);
nch = frame.nch;
error_protection = header.error_protection;
/* 从数据流获取音频 */
while (get_audio(musicin, buffer, num_samples, nch, &header) > 0) {
/* 从输入的文件读取数据到buffer */
if (glopts.verbosity > 1)
if (++frameNum % 10 == 0) /* 出错 */
fprintf(stderr, "[%4u]\r", frameNum);
fflush(stderr);
win_buf[0] = &buffer[0][0];
win_buf[1] = &buffer[1][0];
adb = available_bits(&header, &glopts); // 计算比特预算
lg_frame = adb / 8;
if (header.dab_extension) {
/* in 24 kHz we always have 4 bytes */
if (header.sampling_frequency == 1)
header.dab_extension = 4;
/* You must have one frame in memory if you are in DAB mode */
/* in conformity of the norme ETS 300 401 http://www.etsi.org */
/* see bitstream.c */
if (frameNum == 1)
minimum = lg_frame + MINIMUM;
adb -= header.dab_extension * 8 + header.dab_length * 8 + 16;
}
{
int gr, bl, ch;
/* New polyphase filter
Combines windowing and filtering. Ricardo Feb'03 */
for (gr = 0; gr < 3; gr++) /* 36个样值分为3组 */
for (bl = 0; bl < 12; bl++) /* 每组做12次子带分解 */
for (ch = 0; ch < nch; ch++)
WindowFilterSubband(&buffer[ch][gr * 12 * 32 + 32 * bl], ch, &(*sb_sample)[ch][gr][bl][0]); /* 多相滤波器组 */
}
#ifdef REFERENCECODE
{
/* Old code. left here for reference */
int gr, bl, ch;
for (gr = 0; gr < 3; gr++)
for (bl = 0; bl < SCALE_BLOCK; bl++)
for (ch = 0; ch < nch; ch++) {
window_subband(&win_buf[ch], &(*win_que)[ch][0], ch);
filter_subband(&(*win_que)[ch][0], &(*sb_sample)[ch][gr][bl][0]);
}
}
#endif
#ifdef NEWENCODE
scalefactor_calc_new(*sb_sample, scalar, nch, frame.sblimit);
find_sf_max(scalar, &frame, max_sc);
if (frame.actual_mode == MPG_MD_JOINT_STEREO) {
/* this way we calculate more mono than we need */
/* but it is cheap */
combine_LR_new(*sb_sample, *j_sample, frame.sblimit);
scalefactor_calc_new(j_sample, &j_scale, 1, frame.sblimit);
}
#else
scale_factor_calc(*sb_sample, scalar, nch, frame.sblimit); // 计算比例因子
pick_scale(scalar, &frame, max_sc); // 选择比例因子
if (frame.actual_mode == MPG_MD_JOINT_STEREO) { /* 先忽略 */
/* this way we calculate more mono than we need */
/* but it is cheap */
combine_LR(*sb_sample, *j_sample, frame.sblimit);
scale_factor_calc(j_sample, &j_scale, 1, frame.sblimit);
}
#endif
/* 选择心理声学模型，计算SMR */
if ((glopts.quickmode == TRUE) && (++psycount % glopts.quickcount != 0)) {
/* We're using quick mode, so we're only calculating the model every
'quickcount' frames. Otherwise, just copy the old ones across */
for (ch = 0; ch < nch; ch++) {
for (sb = 0; sb < SBLIMIT; sb++)
smr[ch][sb] = smrdef[ch][sb];
}
} else {
/* calculate the psymodel */
switch (model) {
case -1:
psycho_n1(smr, nch);
break;
case 0: /* Psy Model A */
psycho_0(smr, nch, scalar, (FLOAT)s_freq[header.version][header.sampling_frequency] * 1000); // smr为输出
break;
case 1:
psycho_1(buffer, max_sc, smr, &frame);
break;
case 2:
for (ch = 0; ch < nch; ch++) {
psycho_2(&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
(FLOAT)s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
}
break;
case 3:
/* Modified psy model 1 */
psycho_3(buffer, max_sc, smr, &frame, &glopts);
break;
case 4:
/* Modified Psycho Model 2 */
for (ch = 0; ch < nch; ch++) {
psycho_4(&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT)s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
}
break;
case 5:
/* Model 5 comparse model 1 and 3 */
psycho_1(buffer, max_sc, smr, &frame);
fprintf(stdout, "1 ");
smr_dump(smr, nch);
psycho_3(buffer, max_sc, smr, &frame, &glopts);
fprintf(stdout, "3 ");
smr_dump(smr, nch);
break;
case 6:
/* Model 6 compares model 2 and 4 */
for (ch = 0; ch < nch; ch++)
psycho_2(&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
(FLOAT)s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout, "2 ");
smr_dump(smr, nch);
for (ch = 0; ch < nch; ch++)
psycho_4(&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT)s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout, "4 ");
smr_dump(smr, nch);
break;
case 7:
fprintf(stdout, "Frame: %i\n", frameNum);
/* Dump the SMRs for all models */
psycho_1(buffer, max_sc, smr, &frame);
fprintf(stdout, "1");
smr_dump(smr, nch);
psycho_3(buffer, max_sc, smr, &frame, &glopts);
fprintf(stdout, "3");
smr_dump(smr, nch);
for (ch = 0; ch < nch; ch++)
psycho_2(&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], //snr32,
(FLOAT)s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout, "2");
smr_dump(smr, nch);
for (ch = 0; ch < nch; ch++)
psycho_4(&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT)s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout, "4");
smr_dump(smr, nch);
break;
case 8:
/* Compare 0 and 4 */
psycho_n1(smr, nch);
fprintf(stdout, "0");
smr_dump(smr, nch);
for (ch = 0; ch < nch; ch++)
psycho_4(&buffer[ch][0], &sam[ch][0], ch, &smr[ch][0], // snr32,
(FLOAT)s_freq[header.version][header.sampling_frequency] *
1000, &glopts);
fprintf(stdout, "4");
smr_dump(smr, nch);
break;
default:
fprintf(stderr, "Invalid psy model specification: %i\n", model);
exit(0);
}
if (glopts.quickmode == TRUE)
/* copy the smr values and reuse them later */
for (ch = 0; ch < nch; ch++) {
for (sb = 0; sb < SBLIMIT; sb++)
smrdef[ch][sb] = smr[ch][sb];
}
if (glopts.verbosity > 4)
smr_dump(smr, nch);
}
#ifdef NEWENCODE
sf_transmission_pattern(scalar, scfsi, &frame);
main_bit_allocation_new(smr, scfsi, bit_alloc, &adb, &frame, &glopts);
//main_bit_allocation (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
if (error_protection)
CRC_calc(&frame, bit_alloc, scfsi, &crc);
write_header(&frame, &bs);
//encode_info (&frame, &bs);
if (error_protection)
putbits(&bs, crc, 16);
write_bit_alloc(bit_alloc, &frame, &bs);
//encode_bit_alloc (bit_alloc, &frame, &bs);
write_scalefactors(bit_alloc, scfsi, scalar, &frame, &bs);
//encode_scale (bit_alloc, scfsi, scalar, &frame, &bs);
subband_quantization_new(scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
*subband, &frame);
//subband_quantization (scalar, *sb_sample, j_scale, *j_sample, bit_alloc,
// *subband, &frame);
write_samples_new(*subband, bit_alloc, &frame, &bs);
//sample_encoding (*subband, bit_alloc, &frame, &bs);
#else
transmission_pattern(scalar, scfsi, &frame);
main_bit_allocation(smr, scfsi, bit_alloc, &adb, &frame, &glopts); // 比特分配
if (error_protection)
CRC_calc(&frame, bit_alloc, scfsi, &crc);
encode_info(&frame, &bs); // 编码
if (error_protection)
encode_CRC(crc, &bs);
encode_bit_alloc(bit_alloc, &frame, &bs);
encode_scale(bit_alloc, scfsi, scalar, &frame, &bs);
subband_quantization(scalar, *sb_sample, j_scale, *j_sample, bit_alloc, *subband, &frame); // 量化
sample_encoding(*subband, bit_alloc, &frame, &bs);
#endif
/* If not all the bits were used, write out a stack of zeros */
for (i = 0; i < adb; i++)
put1bit(&bs, 0);
if (header.dab_extension) {
/* Reserve some bytes for X-PAD in DAB mode */
putbits(&bs, 0, header.dab_length * 8);
for (i = header.dab_extension - 1; i >= 0; i--) {
CRC_calcDAB(&frame, bit_alloc, scfsi, scalar, &crc, i);
/* this crc is for the previous frame in DAB mode */
if (bs.buf_byte_idx + lg_frame < bs.buf_size)
bs.buf[bs.buf_byte_idx + lg_frame] = crc;
/* reserved 2 bytes for F-PAD in DAB mode */
putbits(&bs, crc, 8);
}
putbits(&bs, 0, 16);
}
frameBits = sstell(&bs) - sentBits;
if (frameBits % 8) { /* a program failure */
fprintf(stderr, "Sent %ld bits = %ld slots plus %ld\n", frameBits,
frameBits / 8, frameBits % 8);
fprintf(stderr, "If you are reading this, the program is broken\n");
fprintf(stderr, "email [mfc at NOTplanckenerg.com] without the NOT\n");
fprintf(stderr, "with the command line arguments and other info\n");
exit(0);
}
sentBits += frameBits;
}
close_bit_stream_w(&bs);
if ((glopts.verbosity > 1) && (glopts.vbr == TRUE)) {
int i;
#ifdef NEWENCODE
extern int vbrstats_new[15];
#else
extern int vbrstats[15];
#endif
fprintf(stdout, "VBR stats:\n");
for (i = 1; i < 15; i++)
fprintf(stdout, "%4i ", bitrate[header.version][i]);
fprintf(stdout, "\n");
for (i = 1; i < 15; i++)
#ifdef NEWENCODE
fprintf(stdout, "%4i ", vbrstats_new[i]);
#else
fprintf(stdout, "%4i ", vbrstats[i]);
#endif
fprintf(stdout, "\n");
}
fprintf(stderr,
"Avg slots/frame = %.3f; b/smp = %.2f; bitrate = %.3f kbps\n",
(FLOAT)sentBits / (frameNum * 8),
(FLOAT)sentBits / (frameNum * 1152),
(FLOAT)sentBits / (frameNum * 1152) *
s_freq[header.version][header.sampling_frequency]);
if (fclose(musicin) != 0) {
fprintf(stderr, "Could not close \"%s\".\n", original_file_name);
exit(2);
}
fprintf(stderr, "\nDone\n");
time(&end_time);
total_time = end_time - start_time;
printf("total time is %d\n", total_time);
exit(0);
}
2、输出一帧的比例因子和比特分配表
定义文件指针：FILE* infoFp;
为了保证程序的简明与运行流畅，将需要观测的内容输出到TRACE文件，因此在文件开头位置定义宏：#define FRAME_TRACE 1，这样设为1时就打开数据帧的TRACE文件。
先在print_config()函数中输出一些输入、输出文件的主要参数（参考函数中的写法即可）：
#if FRAME_TRACE
fprintf(output_txt, "========== 基本信息 ==========\n");
fprintf(output_txt, "输入文件：%s\n", inPath);
fprintf(output_txt, "输出文件：%s\n", outPath);
fprintf(output_txt, "采样频率：%.1f kHz\n", s_freq[header->version][header->sampling_frequency]);
fprintf(output_txt, "输出文件码率：%d kbps\n", bitrate[header->version][header->bitrate_index]);
#endif
然后输出比例因子和比特分配表，在main()中添加：
...
#else
scale_factor_calc (*sb_sample, scalar, nch, frame.sblimit);//计算比例因子
pick_scale (scalar, &frame, max_sc);//拾取比例因子
{int sb,gr,ch;
if (frameNum == 200)
{
fprintf(output_txt, "声道数：%d\n", nch);
fprintf(output_txt, "目前观测第 %d 帧\n", frameNum);
fprintf(output_txt, "本帧比特预算：%d bits\n", adb);
fprintf(output_txt, "\n");
fprintf(output_txt, "========== 比例因子 ==========\n");
for (ch = 0; ch < nch; ch++)
{
fprintf(output_txt, "------ 声道%2d ------\n", ch + 1);
for (sb = 0; sb < frame.sblimit; sb++)
{
fprintf(output_txt, "子带[%2d]:\t", sb + 1);
for (gr = 0; gr < 3; gr++)
{
fprintf(output_txt, "%2d\t", scalar[ch][gr][sb]);
}
fprintf(output_txt, "\n");
}
}
fprintf(output_txt, "\n");
}
}
...
#else
transmission_pattern (scalar, scfsi, &frame);
main_bit_allocation (smr, scfsi, bit_alloc, &adb, &frame, &glopts);
if (frameNum == 200)
{
fprintf(output_txt, "========== 比特分配表 ==========\n");
{int ch, sb;
for (ch = 0; ch < nch; ch++)
{
fprintf(output_txt, "------ 声道%2d ------\n", ch + 1);
for (sb = 0; sb < frame.sblimit; sb++)
{
fprintf(output_txt, "子带[%2d]:\t%2d\n", sb, bit_alloc[ch][sb]);
}
fprintf(output_txt, "\n");
}
}
四、 测试结果
1、乐音
========== 基本信息 ==========
输入文件：match2.wav
输出文件：output.mp2
采样频率：48.0 kHz
输出文件码率：192 kbps
声道数：2
目前观测第 200 帧
本帧比特预算：4608 bits
========== 比例因子 ==========
------ 声道 1 ------
子带[ 1]: 16 15 14
子带[ 2]: 15 15 17
子带[ 3]: 20 22 19
子带[ 4]: 22 22 22
子带[ 5]: 25 28 26
子带[ 6]: 24 24 26
子带[ 7]: 27 25 27
子带[ 8]: 29 27 29
子带[ 9]: 30 31 29
子带[10]: 28 28 30
子带[11]: 32 30 30
子带[12]: 32 31 33
子带[13]: 34 35 35
子带[14]: 34 33 33
子带[15]: 36 34 34
子带[16]: 37 35 34
子带[17]: 31 31 31
子带[18]: 33 34 34
子带[19]: 33 33 33
子带[20]: 34 35 35
子带[21]: 39 39 39
子带[22]: 42 39 41
子带[23]: 38 37 38
子带[24]: 35 36 37
子带[25]: 36 35 36
子带[26]: 35 35 36
子带[27]: 40 38 39
------ 声道 2 ------
子带[ 1]: 16 15 13
子带[ 2]: 14 15 17
子带[ 3]: 22 22 18
子带[ 4]: 22 22 22
子带[ 5]: 25 27 26
子带[ 6]: 25 24 26
子带[ 7]: 27 25 26
子带[ 8]: 29 28 27
子带[ 9]: 32 31 29
子带[10]: 28 28 30
子带[11]: 31 31 29
子带[12]: 33 33 32
子带[13]: 37 34 38
子带[14]: 34 33 34
子带[15]: 36 34 34
子带[16]: 37 37 33
子带[17]: 30 31 31
子带[18]: 32 35 33
子带[19]: 34 32 36
子带[20]: 35 35 36
子带[21]: 39 38 40
子带[22]: 40 41 41
子带[23]: 38 37 39
子带[24]: 36 37 37
子带[25]: 37 36 36
子带[26]: 34 34 36
子带[27]: 38 38 38
========== 比特分配表 ==========
------ 声道 1 ------
子带[ 0]: 4
子带[ 1]: 3
子带[ 2]: 3
子带[ 3]: 5
子带[ 4]: 4
子带[ 5]: 4
子带[ 6]: 4
子带[ 7]: 3
子带[ 8]: 3
子带[ 9]: 3
子带[10]: 2
子带[11]: 2
子带[12]: 2
子带[13]: 2
子带[14]: 1
子带[15]: 2
子带[16]: 4
子带[17]: 1
子带[18]: 0
子带[19]: 0
子带[20]: 0
子带[21]: 0
子带[22]: 0
子带[23]: 0
子带[24]: 0
子带[25]: 0
子带[26]: 0
------ 声道 2 ------
子带[ 0]: 4
子带[ 1]: 4
子带[ 2]: 4
子带[ 3]: 5
子带[ 4]: 4
子带[ 5]: 4
子带[ 6]: 3
子带[ 7]: 3
子带[ 8]: 3
子带[ 9]: 3
子带[10]: 2
子带[11]: 2
子带[12]: 2
子带[13]: 2
子带[14]: 1
子带[15]: 2
子带[16]: 4
子带[17]: 2
子带[18]: 1
子带[19]: 0
子带[20]: 0
子带[21]: 0
子带[22]: 0
子带[23]: 0
子带[24]: 0
子带[25]: 0
子带[26]: 0
2、噪音
使用Audacity产生的白噪音
========== 基本信息 ==========
输入文件：noise.wav
输出文件：output_noise.mp2
采样频率：44.1 kHz
输出文件码率：192 kbps
声道数：1
目前观测第 300 帧
本帧比特预算：5016 bits
========== 比例因子 ==========
------ 声道 1 ------
子带[ 1]: 10 10 11
子带[ 2]: 12 11 13
子带[ 3]: 10 12 9
子带[ 4]: 10 9 10
子带[ 5]: 8 9 10
子带[ 6]: 10 11 9
子带[ 7]: 11 11 11
子带[ 8]: 13 13 12
子带[ 9]: 12 11 13
子带[10]: 11 9 10
子带[11]: 11 12 11
子带[12]: 9 9 10
子带[13]: 12 11 10
子带[14]: 8 8 9
子带[15]: 10 11 12
子带[16]: 13 12 11
子带[17]: 10 11 11
子带[18]: 12 10 11
子带[19]: 10 10 10
子带[20]: 10 12 12
子带[21]: 11 10 11
子带[22]: 11 10 10
子带[23]: 10 10 10
子带[24]: 10 12 12
子带[25]: 10 11 10
子带[26]: 11 12 10
子带[27]: 12 10 11
子带[28]: 11 10 10
子带[29]: 11 10 13
子带[30]: 12 9 8
========== 比特分配表 ==========
------ 声道 1 ------
子带[ 0]: 5
子带[ 1]: 5
子带[ 2]: 6
子带[ 3]: 7
子带[ 4]: 6
子带[ 5]: 6
子带[ 6]: 5
子带[ 7]: 5
子带[ 8]: 6
子带[ 9]: 6
子带[10]: 4
子带[11]: 6
子带[12]: 4
子带[13]: 5
子带[14]: 4
子带[15]: 3
子带[16]: 5
子带[17]: 5
子带[18]: 4
子带[19]: 3
子带[20]: 3
子带[21]: 3
子带[22]: 4
子带[23]: 3
子带[24]: 2
子带[25]: 2
子带[26]: 2
子带[27]: 2
子带[28]: 2
子带[29]: 2
3、混合
使用Audacity将乐音与噪音合并
========== 基本信息 ==========
输入文件：mix.wav
输出文件：output_mix.mp2
采样频率：48.0 kHz
输出文件码率：192 kbps
声道数：2
目前观测第 300 帧
本帧比特预算：4608 bits
========== 比例因子 ==========
------ 声道 1 ------
子带[ 1]: 9 6 7
子带[ 2]: 9 9 13
子带[ 3]: 11 10 10
子带[ 4]: 11 11 11
子带[ 5]: 12 10 9
子带[ 6]: 11 11 9
子带[ 7]: 11 11 9
子带[ 8]: 11 11 12
子带[ 9]: 10 10 10
子带[10]: 11 11 12
子带[11]: 10 9 10
子带[12]: 12 11 9
子带[13]: 11 11 10
子带[14]: 9 10 11
子带[15]: 9 11 9
子带[16]: 12 12 10
子带[17]: 10 10 13
子带[18]: 11 12 11
子带[19]: 10 11 11
子带[20]: 12 10 9
子带[21]: 10 11 10
子带[22]: 9 10 12
子带[23]: 11 10 11
子带[24]: 10 10 9
子带[25]: 10 9 10
子带[26]: 9 9 13
子带[27]: 10 11 10
------ 声道 2 ------
子带[ 1]: 9 6 7
子带[ 2]: 9 9 13
子带[ 3]: 11 10 10
子带[ 4]: 11 11 11
子带[ 5]: 12 10 9
子带[ 6]: 11 11 9
子带[ 7]: 11 11 9
子带[ 8]: 11 11 12
子带[ 9]: 10 10 10
子带[10]: 11 11 12
子带[11]: 10 9 10
子带[12]: 12 11 9
子带[13]: 11 11 10
子带[14]: 9 10 11
子带[15]: 9 11 9
子带[16]: 12 12 10
子带[17]: 10 10 13
子带[18]: 11 12 11
子带[19]: 10 11 11
子带[20]: 12 10 9
子带[21]: 10 11 10
子带[22]: 9 10 12
子带[23]: 11 10 11
子带[24]: 10 10 9
子带[25]: 10 9 10
子带[26]: 9 9 13
子带[27]: 10 11 10
========== 比特分配表 ==========
------ 声道 1 ------
子带[ 0]: 4
子带[ 1]: 3
子带[ 2]: 3
子带[ 3]: 4
子带[ 4]: 4
子带[ 5]: 4
子带[ 6]: 4
子带[ 7]: 3
子带[ 8]: 3
子带[ 9]: 3
子带[10]: 3
子带[11]: 2
子带[12]: 3
子带[13]: 3
子带[14]: 2
子带[15]: 2
子带[16]: 2
子带[17]: 1
子带[18]: 1
子带[19]: 1
子带[20]: 1
子带[21]: 1
子带[22]: 1
子带[23]: 1
子带[24]: 1
子带[25]: 1
子带[26]: 1
------ 声道 2 ------
子带[ 0]: 4
子带[ 1]: 3
子带[ 2]: 3
子带[ 3]: 4
子带[ 4]: 4
子带[ 5]: 4
子带[ 6]: 4
子带[ 7]: 3
子带[ 8]: 3
子带[ 9]: 3
子带[10]: 3
子带[11]: 2
子带[12]: 3
子带[13]: 3
子带[14]: 2
子带[15]: 2
子带[16]: 2
子带[17]: 1
子带[18]: 1
子带[19]: 1
子带[20]: 1
子带[21]: 1
子带[22]: 1
子带[23]: 1
子带[24]: 1
子带[25]: 1
子带[26]: 1
118
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
