数据压缩_实验六_Mp2编码

Mp2音频编码实验

一、实验原理

1、Mp2编码

（1）设计思想

Mp2音频编码框图分为上下两条线。

上半部分利用多相滤波器组，将输入的PCM样本变换到32个子带的频域信号。依据动态比特分配信息对32个分别进行量化。下半部分对输入的PCM样点做1024点FFT，利用心理声学模型，为上半部分的每个子带动态分配比特。

时频分析的矛盾

短时傅里叶变换是最常用的一种时频分析方法，它通过时间窗内的一段信号来表示某一时刻的信号特征。在短时傅里叶变换过程中，窗的长度决定频谱图的时间分辨率和频率分辨率，窗长越长，截取的信号越长，信号越长，傅里叶变换后频率分辨率越高，时间分辨率越差；相反，窗长越短，截取的信号就越短，频率分辨率越差，时间分辨率越好。

框图上支路时间分辨率高，频率分辨率低；框图下支路频率分辨率高，时间分辨率低。

通过子带分析滤波器组使信号具有高的时间分辨率， 确保在短暂冲击信号情况下，编码的声音信号具有足够高的质量。下支路又可以使信号通过FFT运算具有高的频率分辨率， 因为掩蔽阈值是从功率谱密度推出来的。

32个等分的子带信号并不能精确地反映人耳的听觉特性，引入FFT补偿频率分辨率不足的问题。为使上下两支路互补，上支路向下提供比例因子信息，下支路向上提供基于心理声学模型的动态比特分配信息。

（2）多相滤波器组

人类听觉系统大致等效于一个信号通过一组并联的不同中心频率的带通滤波器。听音者在噪声中听某一纯音信号时，只启用中心频率与信号频率相同的那个听觉滤波器，纯音信号通过该滤波器，而噪声信号只有通带范 围内的部分信号能通过，通带以外的频率成分则被抑制，只有通过该滤波器的噪声才对掩蔽起作用。

为利用这一听觉特性进行压缩，输入端采用一组多相滤波器组将PCM信号变换为32个子带的频域信号，便于后续利用心理声学模型动态分配比特。

（3）比例因子的取值

比例因子：对各个子带每12个样点进行一次比例因子计算。先定出12个 样点中绝对值的最大值。查比例因子表中比这个最大值大的 最小值作为比例因子。用6比特表示。

比例因子选择信息：每帧中每个子带的三个比例因子被一起考虑，划分成特定的几种模式。根据这些模式，1个、2个或3个比例因 子和比例因子选择信息（每子带2比特）一起被传送。如果一个比例因子和下一个只有很小的差别，就只传送大的一个，这种情况对于稳态信号经常出现。

使用这一算法后，和第1层相比，第2层传输的比例因子平均减少了2个，即传输码率由22.5Kb/s降低到了7.5Kb/s。

（4）心理声学模型

1. 听觉系统中存在一个听觉阈值电平，低于这个电平的声音 信号就听不到
2. 听觉掩蔽特性。即听觉阈值电平是自适应的，会随听到的 不同频率声音而发生变化

临界频带

临界频带是指当某个纯音被以它为中心频率、且具有一定带宽的连续噪声所掩蔽时，如果该纯音刚好被听到时的功率等于这一频带内的噪声功率，这个带宽为临界频带宽度。通常认为从20Hz到16kHz有25个临界频带，单位为bark，1 Bark = 一个临界频带的宽度。

时域/频域掩蔽

频域掩蔽域随声压级变化曲线如下

如果有多个频率成分的复杂信号存在，那么频谱的总掩蔽阈值与频率的关系取决于各掩蔽音的强度、频率和它们之间的距离。

掩蔽值的计算

Lutfi 对多个掩蔽音同时存在时的综合掩蔽效果进行了研究： 每个掩蔽音的掩蔽效果先独立变换然后再线性相加。

当两个信号重叠并落在一个临界频带中时，二者的掩蔽分量可以线性相加。

对于复杂音频信号可将其频谱分割成一系列离散段，每段就是一个 掩蔽信号。各掩蔽音互不重叠，即以一个临界带为单位。各掩蔽音 的声压级则通过将对应的临界频带上的短时功率谱密度线性相加得到。

具体计算步骤

1、将样本变换到频域

2、确定声压级别

子带n中的声压级别L_sb计算如下：

其中X(k)是在子带n中频谱线的声压级别，scf_max(n)是在一帧中子带n的三个比例缩放因子最大的一个。

3、考虑安静时阈值

在标准中有根据输入PCM信号的采 样率编制的“频率、临界频带率和绝对阈值”表。 此表为多位科学家经多次心理声学实验所得。

4、将音频信号分解为“乐音”和“非乐音”

两种信号的掩蔽能力不同

模型1：根据音频频谱的局部功率最大值确定乐音成分。局部峰值为乐音，然后将本临界频带内的剩余频谱合在一 起，组成一个代表噪声频率（无调成份）。

5、音调和非音调掩蔽成分的消除

利用标准中给出的绝对阈值消除被掩蔽成分； 考虑在每个临界频带内，小于0.5Bark的距离 中只保留最高功率的成分。

6、单个掩蔽阈值的计算

音调成分和非音调成分单个掩蔽阈值根据标准中给出的算法求得。

7、全局掩蔽阈值的计算

还要考虑别的临界频带的影响。一个掩蔽信号会对其 它频带上的信号产生掩蔽效应。这种掩蔽效应称为掩蔽扩散。

8、每个子带的掩蔽阈值

选择出本子带中最小的阈值作为子带阈值。

（5）量化和编码

将输入信号变换到频域，再将结果分解成一些尽量与临界频带尽可能相似的子带，然后对每个子带进行量化，量化方式应当使得量化噪声听不见。量化时注意只需发送掩蔽水平以上的能量。

量化和编码部分用信掩比SMR决定分配给子带信号 的量化位数，使量化噪声＜掩蔽域值。

比特分配及编码

在调整到固定的码率之前，先确定可用于样值编码的有效比特数，这个数值取决于比例因子、比例因子选择信息、比特分配信息 以及辅助数据所需比特数。

比特分配的过程：对每个子带计算掩蔽-噪声比MNR，信噪比SNR–信掩比SMR， 即：MNR = SNR–SMR。使整个一帧和每个子带的总噪声-掩蔽比最小。这是一个循环过程，每一次循环使获益最大的子带的量化级别增加一级，最终所用比特数不能超过一帧所能提供的最大数目。

2、.wav文件格式

实验中的采用的输入文件为.wav格式，下面给出文件基本格式说明。

WAVE文件有很多不同的压缩格式，最基本的WAVE文件是PCM（脉冲编码调制）格式的，这种文件直接存储采样的声音数据没有经过任何的压缩。

（1）文件组织形式

WAVE文件是以RIFF格式来组织内部结构的。RIFF文件结构可以看作是树状结构，其基本构成是称为"块"（Chunk）的单元，最顶端是一个“RIFF”块，下面的每个块有“类型块标识(可选)”、“标志符”、“数据大小”及“数据”等项所组成。“类型块标识”只在部分chunk中用到，如 “WAVE” chunk中，这时表示下面嵌套有别的chunk。

块的结构如表所示

名称	Size	备注
块标志符	4	４个小写字符(如 "fmt ", “fact”, “data” 等)
数据大小	4	DWORD类型,表示后接数据的大小(N Bytes)
数据	4	本块中正式数据部分

WAVE文件是由若干个Chunk组成的。按照在文件中的出现位置包括：RIFF WAVE Chunk, Format Chunk, Fact Chunk(可选), Data Chunk。每个文件最前端写入的是RIFF块，每个文件只有一个RIFF块。非PCM格式的文件会至少多加入一个 “fact” 块，它用来记录数据(注意是数据而不是文件)解压缩后的大小。这个 “fact” 块一般加在 “data” 块的前面。具体见下图

（2）PCM数据格式

PCM(Pulse Code Modulation)也被称为 脉码编码调制。PCM中的声音数据没有被压缩，如果是单声道的文件，采样数据按时间的先后顺序依次存入。如果是双声道的文件，采样数据按时间先后顺序交叉地存入。

如图所示

二、程序分析

1、程序框架

1. 将输入的PCM样本变换到32个子带的频域信号
2. 计算比例因子和比例因子选择信息
3. 基于选择的心理声学模型计算每个子带的SMR
4. 基于计算出的SMR进行动态比特分配
5. 进行边信息编码，打包进输出比特流中
6. 基于动态分配的比特数对32个子带进行编码输出

2、部分代码说明

主程序

FILE* fp;
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], scfsi[2][SBLIMIT];
	static unsigned int scalar[2][3][SBLIMIT], 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, nch, error_protection;
	static unsigned int crc;
	int sb, ch, adb;
	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];
	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);	/* 命令行打印相关信息 */

	/* this will load the alloc tables and do some other stuff */

	hdr_to_frps(&frame);	/* 对帧结构体frame的其他参数取出头信息进行初始化，方便后续解码 */
	nch = frame.nch;
	error_protection = header.error_protection;

	while (get_audio(musicin, buffer, num_samples, nch, &header) > 0) {	/* 读入一帧样点 */
		if (glopts.verbosity > 1)  /* glopts.verbosity : 2 by default. 0 is no output at all */
			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++)					/* 一个子带内3个快 */
				for (bl = 0; bl < 12; bl++)				/* 1个块内12个样点 */
					for (ch = 0; ch < nch; ch++)		/* 声道数 */
						WindowFilterSubband(&buffer[ch][gr * 12 * 32 + 32 * bl], ch,
							&(*sb_sample)[ch][gr][bl][0]);	/* 变换至32个子带 */
		}

#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



		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);
				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
		/* 对于给定的子带，确定是否发送1、2或所有3个比例因子，并填写比例因子选择信息 */
		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 */
		// 比特未用尽，补0
			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);

计算可用比特

/* function returns the number of available bits */
int available_bits (frame_header *header, options * glopts)
{
  int adb;

  slots.extra = 0;		/* be default, no extra slots */

  slots.average =
    (1152.0 / s_freq[header->version][header->sampling_frequency]) *
    ((double) bitrate[header->version][header->bitrate_index] / 8.0);   /* 计算平均字节数 */

  slots.whole = (int) slots.average;    /* 先令总字节数 = 平均字节数 */
  slots.frac = slots.average - (double) slots.whole;

  /* never allow padding for a VBR frame. 
     Don't ask me why, I've forgotten why I set this */
  if (slots.frac != 0 && glopts->usepadbit && glopts->vbr == FALSE) {
    if (slots.lag > (slots.frac - 1.0)) {	/* no padding for this frame */
      slots.lag -= slots.frac;
      slots.extra = 0;
      header->padding = 0;
    } else {			/* padding */

      slots.extra = 1;
      header->padding = 1;
      slots.lag += (1 - slots.frac);
    }
  }

  adb = (slots.whole + slots.extra) * 8;    /* 总字节数x8 = 总的可分配比特数 */ 
  return adb;
}

三、实验要求

• 输出音频的采样率和目标码率
• 输出某个帧的所分配比特数、比例因子、比特分配结果

1、实现代码

在主程序中添加

#if TRACE
	int Init_Trace = 0;
	fp = fopen("Trace_file.txt", "w");
	if (fp == NULL) {
		printf("trace file open error!");
	}
#endif // TRACE

#if TRACE
		if (Init_Trace==0) {
			/* 输出音频的采样率和目标码率 */
			fprintf(fp, "\n>---------- frequency ----------\n");
			fprintf(fp, "采样频率:%lf kHz\n",s_freq[frame.header->version][frame.header->sampling_frequency]);

			fprintf(fp, "\n> ---------- bitrate ----------\n");
			fprintf(fp, "目标码率:%d kbps\n", bitrate[frame.header->version][frame.header->bitrate_index]);
			fflush(fp);
			/* 输出该帧所分配的比特数 */
			fprintf(fp, "\n>---------- available_bits ----------\n");
			fprintf(fp, "该帧所分配的比特数:%d bit\n", lg_frame*8);
			fflush(fp);
			/* 输出该帧的比例因子 */
			fprintf(fp, "\n> ---------- scalar factor information ----------\n");
			fflush(fp);
			for (int i = 0; i < 2; i++) {
				fprintf(fp, "> ----- 声道%d -----\n", i);
				fflush(fp);
				for (int j = 0; j < SBLIMIT; j++) {
					fprintf(fp, "> 子带%d\t比例因子选择信息:%d\t", j, scfsi[i][j]);
					fflush(fp);
					switch (scfsi[i][j]) {
					case 0:
						fprintf(fp, "比例因子:");
						fflush(fp);
						for (int k = 0; k < 3; k++) {
							fprintf(fp, "%d ", scalar[i][k][j]);
							fflush(fp);
						}
						fprintf(fp, "\n");
						break;
					case 1:
						fprintf(fp, "比例因子:");
						fprintf(fp, "%d ", scalar[i][0][j]);
						fprintf(fp, "%d ", scalar[i][0][j]);
						fprintf(fp, "%d ", scalar[i][2][j]);
						fprintf(fp, "\n");
						fflush(fp);
						break;
					case 3:
						fprintf(fp, "比例因子:");
						fprintf(fp, "%d ", scalar[i][0][j]);
						fprintf(fp, "%d ", scalar[i][2][j]);
						fprintf(fp, "%d ", scalar[i][2][j]);
						fprintf(fp, "\n");
						fflush(fp);
						break;
					case 2:
						fprintf(fp, "比例因子:");
						fprintf(fp, "%d ", scalar[i][0][j]);
						fprintf(fp, "%d ", scalar[i][0][j]);
						fprintf(fp, "%d ", scalar[i][0][j]);
						fprintf(fp, "\n");
						fflush(fp);
						break;
					}
				}
			}
			/* 输出该帧的比特分配结果 */
			fprintf(fp, "\n> ---------- bit_alloc information ----------\n");
			fflush(fp);
			for (int i = 0; i < 2; i++) {
				fprintf(fp, "> ----- 声道%d -----\n", i);
				fflush(fp);
				for (int j = 0; j < SBLIMIT; j++) {
					fprintf(fp, "> 子带%d\t比例分配:%d\n", j, bit_alloc[i][j]);
					fflush(fp);
				}
			}
		}
		Init_Trace = 1;
		fclose(fp);
#endif // TRACE

2、输出结果

3、不同特性的音频文件比较

音乐	噪音	音乐+噪音

比较三类音频发现，音乐的声音信号平稳，多个子带内都只传送1个比例因子。噪声信号变化剧烈，往往每个子带内需要传送3个比例因子。