MPEG-1 Audio Layer II编码原理及编码器调试

最新推荐文章于 2022-06-05 17:07:30 发布

S.Z.Zheng

最新推荐文章于 2022-06-05 17:07:30 发布

阅读量2.1k

点赞数

分类专栏： C++ 数据压缩原理与应用文章标签：音频编码解码编码器信息压缩

本文链接：https://blog.csdn.net/szzheng/article/details/106692435

版权

C++ 同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

数据压缩原理与应用

14 篇文章 3 订阅

订阅专栏

MPEG-1 Audio Layer II编码原理及编码器调试

模拟音频信号数字化后通常具有极高的码率，例如对于取样频率为44.1 kHz的双声道CD数字音频而言，采用16 bit量化，无压缩码率可达1.41 Mbps，非常不利于存储和传输。因此，为了节省存储空间、提高传输效率，必须要对数字音频信号进行压缩编码。

一. 数字音频信号压缩的可能性

无压缩的数字音频信号中主要存在两方面的冗余信息：

一是声音信号中本身存在的冗余：信号幅度分布是非均匀的（小幅度的样值比大幅度样值出现的概率高），且样本之间存在相关性（时域冗余）；

二是根据人耳的听觉特性，可不对与听觉无关的部分编码（具体内容见后）。

二. 人类听觉系统的感知特性

1. 等响度曲线

等响度曲线

图中每条曲线代表的（人耳感受的）响度相同，最下方一条曲线代表最小可听阈，其下方区域的声音人耳无法察觉，因此可以不编码。

2. 频域掩蔽效应

一个高强度纯音会使得该频率附近的最小可听阈曲线提升，掩蔽掉在其下的（原本能听到的）声音。这个纯音称为掩蔽声，掩蔽声存在时，音调音刚刚能被听到时的阈值称为掩蔽阈值。

频域掩蔽示意图

因此在编码时，可以去除掩蔽阈值以下的信号分量，并忽略可能会被掩蔽的量化噪声。

掩蔽曲线具有以下特点：

不对称，高频一端的斜率绝对值更小；
低频音易对高频音产生掩蔽；
掩蔽声强度越高、频率越高，掩蔽的频率范围越宽。

3. 临界频带（Critical Band）

临界频带具有两种等价的定义：

定义一：当某个纯音被以它为中心频率、且具有一定带宽的连续噪声所掩蔽时，如果该纯音刚好被听到时的功率等于这一频带内的噪声功率，这个带宽为临界频带宽度；
定义二：如果增大掩蔽信号覆盖的频率范围，超过到某个值后掩蔽效应不再随着带宽的增大而增强，这个临界的带宽就称为临界频带。

其单位为Bark，代表一个临界频带的宽度。

通常认为，在20 Hz—16 kHz的范围内有25个临界频带（500 Hz以下每个临界频带的带宽大约是100 Hz，500 Hz以上的临界频带带宽逐渐增加）。

4. 人类听觉系统

人类听觉系统可以大致等效为在0 Hz—20 kHz范围内的25个重叠的带通滤波器组。

人耳在噪声中听某一纯音信号时，只启用中心频率与信号频率相同的那个听觉滤波器，且只有纯音信号和在通带范围内的部分信号可通过该滤波器。只有通过该滤波器的噪声才对掩蔽起作用；
聆听复音时启动多个听觉滤波器。听觉能够计算各滤波器输出端的信噪比。当信噪比达到或者超过听阈因子时，即可听到该频率成分。

人耳听觉系统

5. 时域掩蔽效应

由于在时间上相邻的声音之间存在超前掩蔽（5—20 ms）和滞后掩蔽（50—200 ms），因此在编码时，可将时间上相继的一些样值归并成块，并计算每块内最大样值的比例因子。

三. MPEG-1音频压缩编码

MPEG-1中采用了感知音频编码，Layer II的编码器框图如下。

MPEG-1 Audio Layer II编码器框图

可以看到，编码器具有两条脉络：一是上方蓝色框内的子带编码部分，这也是编码的主线；二是下方的部分，是MPEG音频编码的亮点。

下面以Layer II为基准，简要说明编码器的组成和编码过程。

1. 多相滤波器

数字音频信号通过一个多相滤波器组，变换成32个等宽频带子带，使得信号具有较高的时间分辨率，确保在短暂冲击信号的情况下，编码的声音信号具有足够高的质量。

但需要说明的是，高时域分辨率和高频域分辨率是不可兼得的，我们需要做出权衡。

滤波器组的输出是临界频带经过量化的系数样值。若一个子带覆盖多个临界频带，则选择具有最小NMR的临界频带来计算分配给子带的比特数。

2. 心理声学模型

心理声学模型决定了各个子带中允许的最大量化噪声，小于它的量化噪声都会被掩蔽。若子带内的信号功率小于掩蔽阈值，则不进行编码；否则，确定要编码的系数所需的比特数，使量化引起的噪声低于掩蔽效应；

使用FFT将音频样值变换到频域。这里Layer II采用1024点FFT（Layer I中采用512点），提高了频率分辨率，可以得到更准确的频谱特性；
将得到的频率组成临界频带；
由于乐音和非乐音（噪声）信号的掩蔽能力不同，因此在临界频带的谱值中，将两种信号分离：可将局部峰值视为乐音，然后将本临界频带内的剩余频谱组成一个代表噪声频率（无调成份）；

乐音和非乐音（噪声）的掩蔽能力不同
计算每个子带的全局掩蔽阈值（以频率为自变量）；

全局掩蔽阈值的计算公式
计算每个子带的SMR（每8 ms计算一个）；

3. 量化编码

(1) 比特分配

比特分配：对每个子带计算**掩噪比MNR (dB) = 信噪比SNR - 信掩比SMR，然后找出其中具有最低MNR的子带，并给该子带多分配一些比特，然后重新计算MNR，继续分配，重复该步骤，直至没有比特可以分配。这样可以使得在满足比特率和掩蔽要求的前提下，使MNR最小**；

掩噪比MNR = 信噪比SNR - 信掩比SMR

(2) 计算比例因子

对各个子带每36个样点（Layer I为12个样点）进行一次比例因子的计算，先确定12个连续样值中的最大值，查Layer II、Layer I比例因子表中比这它大的最小值作为量化比例因子；
每12个样值计算出一个比例因子，Layer II中将每个子带分为3组，每组各有12个取样值，因此36个样值具有3个比例因子；
比例因子可以使得比较准确地计算出子带的声压级；
一般比例因子从低频子带到高频子带连续下降；

(3) 子带样值量化

将子带样值除以比例因子（结果为 $X$ ），根据所分配的比特数查表得 $A$ 、 $B$ ，量化结果为 $A X + B$ 。

(4) 颗粒形成

对量化级别在3、5、9级时，采用“颗粒” 优化。例如：

采用颗粒量化：3个样本 @ 3个量化水平 = 27种可能的值 → 5 bit
不采用颗粒量化：1个样本 @ 3个量化水平 = 2bit → 3个样本6 bit
经过大量实验，使用颗粒量化可将压缩比从4:1增加到6:1乃至8:1

4. 帧比特流形成

其中每个子带中前后相邻的连续36个样值（3组12个样值）共用在这个子带比特分配值，36个样值中的同一组样值共用该组的比例因子；
同一时刻的32个子带样值放在一起；
Layer II每帧包含1152个PCM样值（为Layer I的三倍）；
若取样频率为48 kHz，一帧相当于1152 / 48k = 24 ms的声音样值，因此Layer II的精确度为24 ms（为Layer I的三倍，因而更精确）。

MPEG-1 Audio Layer II的帧结构

四. 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. 命令行设置

最基本的命令行参数如下：

输入文件名 输出文件名

此时使用默认的输出比特率（192 kbps）。

此外，我们还可以参考usage()函数来自定额外的输出参数，如：

-b 48 -a 输入文件名 输出文件名

可将输出比特率设为48 kbps，并输出单声道音频。

3. 输出一帧的比例因子和比特分配表

定义文件指针：FILE* infoFp;

为了保证程序的简明与运行流畅，将需要观测的内容输出到TRACE文件，因此在文件开头位置定义宏：#define FRAME_TRACE 1，这样设为1时就打开数据帧的TRACE文件。

先在print_config()函数中输出一些输入、输出文件的主要参数（参考函数中的写法即可）：

#if FRAME_TRACE
	fprintf(infoFp, "========== 基本信息 ==========\n");
	fprintf(infoFp, "输入文件：%s\n", inPath);
	fprintf(infoFp, "输出文件：%s\n", outPath);
	fprintf(infoFp, "采样频率：%.1f kHz\n", s_freq[header->version][header->sampling_frequency]);
	fprintf(infoFp, "输出文件码率：%d kbps\n", bitrate[header->version][header->bitrate_index]);
#endif // FRAME_TRACE

然后输出比例因子和比特分配表，在main()中添加：

		/* 打开文件等步骤略 */
		...
#else
		scale_factor_calc(*sb_sample, scalar, nch, frame.sblimit); // 计算比例因子
		pick_scale(scalar, &frame, max_sc);    // pick比例因子

				/********** Added by S.Z.Zheng **********/
#if FRAME_TRACE
		if (frameNum == 2) {
			fprintf(infoFp, "声道数：%d\n", nch);
			fprintf(infoFp, "目前观测第 %d 帧\n", frameNum);
			fprintf(infoFp, "本帧比特预算：%d bits\n", adb);
			fprintf(infoFp, "\n");

			/* 比例因子 */
			fprintf(infoFp, "========== 比例因子 ==========\n");
			for (ch = 0; ch < nch; ch++)	// 每个声道单独输出
			{
				fprintf(infoFp, "------ 声道%2d ------\n", ch + 1);
				for (sb = 0; sb < frame.sblimit; sb++)	// 每个子带
				{
					fprintf(infoFp, "子带[%2d]:\t", sb + 1);
					for (int gr = 0; gr < 3; gr++) {
						fprintf(infoFp, "%2d\t", scalar[ch][gr][sb]);
					}
					fprintf(infoFp, "\n");
				}
			}
			fprintf(infoFp, "\n");

			/* 比特分配表 */
			fprintf(infoFp, "========== 比特分配表 ==========\n");  //输出比特分配结果
			for (ch = 0; ch < nch; ch++) {
				fprintf(infoFp, "------ 声道%2d ------\n", ch + 1); //按声道分配
				for (sb = 0; sb < frame.sblimit; sb++) {
					fprintf(infoFp, "子带[%2d]:\t%2d\n", sb + 1, bit_alloc[ch][sb]);
				}
				fprintf(infoFp, "\n");
			}
		}
#endif // FRAME_TRACE
		/********** Addition ended **********/
		...

五. 测试结果

1. 乐音

========== 基本信息 ==========
输入文件：music.wav
输出文件：music_192k.mp2
采样频率：44.1 kHz
输出文件码率：192 kbps
声道数：2
目前观测第 2 帧
本帧比特预算：5016 bits

========== 比例因子 ==========
------ 声道 1 ------
子带[ 1]:	33	35	35	
子带[ 2]:	44	41	41	
子带[ 3]:	47	46	46	
子带[ 4]:	47	46	45	
子带[ 5]:	46	44	47	
子带[ 6]:	50	47	48	
子带[ 7]:	46	49	49	
子带[ 8]:	47	48	48	
子带[ 9]:	49	48	48	
子带[10]:	49	46	47	
子带[11]:	48	47	48	
子带[12]:	46	48	48	
子带[13]:	49	48	48	
子带[14]:	47	51	50	
子带[15]:	49	49	48	
子带[16]:	50	46	49	
子带[17]:	51	50	48	
子带[18]:	51	50	51	
子带[19]:	52	49	51	
子带[20]:	51	49	49	
子带[21]:	49	51	50	
子带[22]:	51	49	52	
子带[23]:	48	49	50	
子带[24]:	54	52	55	
子带[25]:	54	56	54	
子带[26]:	55	54	54	
子带[27]:	53	54	53	
子带[28]:	54	54	54	
子带[29]:	54	56	53	
子带[30]:	55	56	55	
------ 声道 2 ------
子带[ 1]:	34	34	36	
子带[ 2]:	43	43	44	
子带[ 3]:	44	46	45	
子带[ 4]:	45	47	47	
子带[ 5]:	46	48	47	
子带[ 6]:	47	49	51	
子带[ 7]:	47	49	49	
子带[ 8]:	49	48	48	
子带[ 9]:	51	50	46	
子带[10]:	49	49	49	
子带[11]:	48	50	48	
子带[12]:	50	48	48	
子带[13]:	48	48	50	
子带[14]:	47	49	50	
子带[15]:	50	50	49	
子带[16]:	48	49	49	
子带[17]:	49	50	49	
子带[18]:	50	50	50	
子带[19]:	51	51	50	
子带[20]:	51	49	50	
子带[21]:	53	53	51	
子带[22]:	53	50	50	
子带[23]:	49	49	48	
子带[24]:	51	51	53	
子带[25]:	53	57	53	
子带[26]:	57	53	56	
子带[27]:	53	53	55	
子带[28]:	54	53	54	
子带[29]:	55	54	55	
子带[30]:	56	57	54	

========== 比特分配表 ==========
------ 声道 1 ------
子带[ 1]:	 4
子带[ 2]:	 4
子带[ 3]:	 3
子带[ 4]:	 5
子带[ 5]:	 5
子带[ 6]:	 5
子带[ 7]:	 4
子带[ 8]:	 5
子带[ 9]:	 4
子带[10]:	 5
子带[11]:	 3
子带[12]:	 6
子带[13]:	 5
子带[14]:	 3
子带[15]:	 2
子带[16]:	 2
子带[17]:	 4
子带[18]:	 4
子带[19]:	 3
子带[20]:	 3
子带[21]:	 3
子带[22]:	 3
子带[23]:	 1
子带[24]:	 1
子带[25]:	 0
子带[26]:	 1
子带[27]:	 0
子带[28]:	 1
子带[29]:	 1
子带[30]:	 0

------ 声道 2 ------
子带[ 1]:	 3
子带[ 2]:	 4
子带[ 3]:	 4
子带[ 4]:	 5
子带[ 5]:	 5
子带[ 6]:	 5
子带[ 7]:	 4
子带[ 8]:	 5
子带[ 9]:	 4
子带[10]:	 5
子带[11]:	 3
子带[12]:	 6
子带[13]:	 5
子带[14]:	 3
子带[15]:	 2
子带[16]:	 2
子带[17]:	 4
子带[18]:	 4
子带[19]:	 3
子带[20]:	 3
子带[21]:	 3
子带[22]:	 3
子带[23]:	 1
子带[24]:	 1
子带[25]:	 0
子带[26]:	 1
子带[27]:	 0
子带[28]:	 1
子带[29]:	 1
子带[30]:	 0

输出比特率为48 kbps时：

========== 基本信息 ==========
输入文件：music.wav
输出文件：music_48k.mp2
采样频率：44.1 kHz
输出文件码率：48 kbps
声道数：2
目前观测第 2 帧
本帧比特预算：1256 bits

========== 比例因子 ==========
------ 声道 1 ------
子带[ 1]:	33	35	35	
子带[ 2]:	44	41	41	
子带[ 3]:	47	46	46	
子带[ 4]:	47	46	45	
子带[ 5]:	46	44	47	
子带[ 6]:	50	47	48	
子带[ 7]:	46	49	49	
子带[ 8]:	47	48	48	
------ 声道 2 ------
子带[ 1]:	34	34	36	
子带[ 2]:	43	43	44	
子带[ 3]:	44	46	45	
子带[ 4]:	45	47	47	
子带[ 5]:	46	48	47	
子带[ 6]:	47	49	51	
子带[ 7]:	47	49	49	
子带[ 8]:	49	48	48	

========== 比特分配表 ==========
------ 声道 1 ------
子带[ 1]:	 3
子带[ 2]:	 2
子带[ 3]:	 1
子带[ 4]:	 1
子带[ 5]:	 1
子带[ 6]:	 1
子带[ 7]:	 1
子带[ 8]:	 1

------ 声道 2 ------
子带[ 1]:	 1
子带[ 2]:	 2
子带[ 3]:	 2
子带[ 4]:	 1
子带[ 5]:	 1
子带[ 6]:	 1
子带[ 7]:	 1
子带[ 8]:	 1

2. 噪声

噪声为使用MATLAB产生的高斯白噪声。

========== 基本信息 ==========
输入文件：agwn.wav
输出文件：agwn_192k.mp2
采样频率：44.1 kHz
输出文件码率：192 kbps
声道数：1
目前观测第 2 帧
本帧比特预算：5016 bits

========== 比例因子 ==========
------ 声道 1 ------
子带[ 1]:	24	23	22	
子带[ 2]:	25	23	25	
子带[ 3]:	24	27	24	
子带[ 4]:	24	26	25	
子带[ 5]:	24	25	24	
子带[ 6]:	27	25	25	
子带[ 7]:	25	24	24	
子带[ 8]:	25	24	24	
子带[ 9]:	25	22	25	
子带[10]:	25	25	25	
子带[11]:	23	26	27	
子带[12]:	25	24	24	
子带[13]:	24	23	24	
子带[14]:	23	24	24	
子带[15]:	26	24	25	
子带[16]:	24	25	23	
子带[17]:	23	25	24	
子带[18]:	25	23	23	
子带[19]:	24	25	25	
子带[20]:	23	26	24	
子带[21]:	24	25	23	
子带[22]:	24	25	23	
子带[23]:	23	23	24	
子带[24]:	26	25	24	
子带[25]:	23	25	24	
子带[26]:	24	23	26	
子带[27]:	25	24	25	
子带[28]:	24	26	23	
子带[29]:	23	25	23	
子带[30]:	26	24	22	

========== 比特分配表 ==========
------ 声道 1 ------
子带[ 1]:	 6
子带[ 2]:	 5
子带[ 3]:	 5
子带[ 4]:	 7
子带[ 5]:	 7
子带[ 6]:	 7
子带[ 7]:	 7
子带[ 8]:	 7
子带[ 9]:	 6
子带[10]:	 7
子带[11]:	 6
子带[12]:	 6
子带[13]:	 6
子带[14]:	 6
子带[15]:	 6
子带[16]:	 4
子带[17]:	 6
子带[18]:	 6
子带[19]:	 5
子带[20]:	 5
子带[21]:	 5
子带[22]:	 5
子带[23]:	 4
子带[24]:	 1
子带[25]:	 1
子带[26]:	 1
子带[27]:	 1
子带[28]:	 1
子带[29]:	 1
子带[30]:	 0

3. 乐音叠加噪声

使用MATLAB在乐音波形上叠加高斯白噪声。

========== 基本信息 ==========
输入文件：music+agwn.wav
输出文件：music+agwn_192k.mp2
采样频率：44.1 kHz
输出文件码率：192 kbps
声道数：2
目前观测第 2 帧
本帧比特预算：5016 bits

========== 比例因子 ==========
------ 声道 1 ------
子带[ 1]:	25	24	25	
子带[ 2]:	26	25	24	
子带[ 3]:	25	24	23	
子带[ 4]:	23	24	24	
子带[ 5]:	24	25	24	
子带[ 6]:	25	24	26	
子带[ 7]:	25	24	26	
子带[ 8]:	24	23	24	
子带[ 9]:	24	24	23	
子带[10]:	23	26	22	
子带[11]:	26	23	24	
子带[12]:	23	25	26	
子带[13]:	24	23	23	
子带[14]:	25	25	24	
子带[15]:	24	27	25	
子带[16]:	27	23	26	
子带[17]:	24	26	23	
子带[18]:	26	23	23	
子带[19]:	25	25	24	
子带[20]:	25	26	23	
子带[21]:	24	24	26	
子带[22]:	23	26	24	
子带[23]:	26	25	24	
子带[24]:	24	23	27	
子带[25]:	24	25	23	
子带[26]:	25	24	23	
子带[27]:	24	25	27	
子带[28]:	22	23	23	
子带[29]:	24	24	23	
子带[30]:	23	23	24	
------ 声道 2 ------
子带[ 1]:	25	24	25	
子带[ 2]:	26	25	24	
子带[ 3]:	25	24	23	
子带[ 4]:	23	24	24	
子带[ 5]:	24	25	24	
子带[ 6]:	25	24	26	
子带[ 7]:	25	24	26	
子带[ 8]:	24	23	24	
子带[ 9]:	24	24	23	
子带[10]:	23	26	22	
子带[11]:	26	23	24	
子带[12]:	23	25	26	
子带[13]:	24	23	23	
子带[14]:	25	25	24	
子带[15]:	24	27	25	
子带[16]:	27	23	26	
子带[17]:	24	26	23	
子带[18]:	26	23	23	
子带[19]:	25	25	24	
子带[20]:	25	26	23	
子带[21]:	24	24	26	
子带[22]:	23	26	24	
子带[23]:	26	25	24	
子带[24]:	24	23	27	
子带[25]:	24	25	23	
子带[26]:	25	24	23	
子带[27]:	24	25	27	
子带[28]:	22	23	23	
子带[29]:	24	24	23	
子带[30]:	23	23	24	

========== 比特分配表 ==========
------ 声道 1 ------
子带[ 1]:	 3
子带[ 2]:	 3
子带[ 3]:	 3
子带[ 4]:	 4
子带[ 5]:	 4
子带[ 6]:	 3
子带[ 7]:	 3
子带[ 8]:	 4
子带[ 9]:	 3
子带[10]:	 3
子带[11]:	 2
子带[12]:	 3
子带[13]:	 1
子带[14]:	 3
子带[15]:	 1
子带[16]:	 1
子带[17]:	 1
子带[18]:	 2
子带[19]:	 2
子带[20]:	 1
子带[21]:	 1
子带[22]:	 1
子带[23]:	 1
子带[24]:	 0
子带[25]:	 0
子带[26]:	 0
子带[27]:	 0
子带[28]:	 0
子带[29]:	 0
子带[30]:	 0

------ 声道 2 ------
子带[ 1]:	 3
子带[ 2]:	 3
子带[ 3]:	 3
子带[ 4]:	 3
子带[ 5]:	 4
子带[ 6]:	 3
子带[ 7]:	 3
子带[ 8]:	 4
子带[ 9]:	 3
子带[10]:	 3
子带[11]:	 2
子带[12]:	 3
子带[13]:	 1
子带[14]:	 3
子带[15]:	 1
子带[16]:	 1
子带[17]:	 1
子带[18]:	 2
子带[19]:	 2
子带[20]:	 1
子带[21]:	 1
子带[22]:	 1
子带[23]:	 0
子带[24]:	 0
子带[25]:	 0
子带[26]:	 0
子带[27]:	 0
子带[28]:	 0
子带[29]:	 0
子带[30]:	 0