数据压缩第十一次作业：MPEG音频编码实验

一、MPEG-1 Audio Layer2 编码器原理

从框架图中我们可以看出，MPEG-1的音频编码器是由两条线所构成的：
一是码流读入之后经过滤波器组将PCM样本变换为32个子带的频域信号，而后再进行相关计算的子带编码的这一条线。二则是下面的一条线，其利用心理声学模型及动态比特分配等相关操作计算了其使用中量化的比特数，起到了去除冗余信息的作用。
在MPEG音频编码的过程中，我们主要采用的思想主要是对原有的信号进行分析，筛选处原有的音频中不能被感知的部分。其中，这就包括了两大部分，一是根据原有的音频信号中的相关性出发，根据其原有信号中所存在的冗余度进行压缩编码；二则是根据人耳本身的听觉特性出发，来对人耳感知较为敏感的部分进行筛选，从而来实现压缩编码。而同时，也正是因为音频中所存在的这两大特性，也才使得我们的音频压缩编码变为了可能。
二、多相滤波器组

对于多相滤波器组而言，其主要作用是将输入的PCM样本变换为32个子带的频域信号。但同时，它也存在着自身的缺点：
（1）等带宽的滤波器组与人类听觉系统的临界频带不对应:在低频区域，单个子带会覆盖多个临界频带。
在这种情况下,量化比特数不能兼每个临界频带

(2)滤波器组与其逆过程不是无失真的,但滤波器组引入的误差很小，且听不到
(3)子带间频率有混叠,滤波后的相邻子带有频率混叠现象，一个子带中的 信号可以影响相邻子带的输出

三、心理声学模型
首先：心理声学模型包括：
生理(Physiological )感知极限（传感极限）
心理 (Psychological )感知极限 （信号处理极限）
1.听觉阈值

人耳听觉系统中存在一个听觉阈值电平，低于这个电平的声音信号就听不到
听觉阈值的大小随声音频率的改变而改变。 如图所示，一个人是否听到声音取决于声音的频率，以及声音的幅度是否高于这种频率下的听觉阈值。在本图中，我们所看见的最下方的这条蓝色的曲线，所代表的就是人耳在不同频率下所能听到的最小声音，也就是说，在蓝色曲线以下的部分，就没有编码的必要了（因为就算编了也没意义，人耳又听不见）。
2.频域掩蔽
听觉掩蔽特性。即听觉阈值电平是自适应的，会随听到的不同频率声音而发生变化。

如图所示，在掩蔽声的存在下，我们原本的绝对听力阀的曲线就不再使用率，人耳所能听到的最小声音的这条曲线发生了变化，也正是这一变化的存在，导致了我们在实际的编码过程中，对于图中由于掩蔽音导致的我们所听不到的那部分声音信息，就也可以不用编码了。
3.临界频带
临界频带是指当某个纯音被以它为中心频率、且具有一定带宽的连续噪声所掩蔽时，如果该纯音刚好被听到时的功率等于这一频带内的噪声功率，这个带宽为临界频带宽度。
通常认为从20Hz到16kHz有25个临界频带，单位为bark，其中1 Bark = 一个临界频带的宽度
4.人耳听觉系统
人类听觉系统大致等效于一个信号通过一组并联的不同中心频率的带通滤波器
听音者在噪声中听某一纯音信号时，只启用中心频率与信号频率相同的那个听觉滤波器，纯音信号通过该滤波器，而噪声信号只有通带范 围内的部分信号能通过，通带以外的频率成分则被抑制，只有通过该滤波器的噪声才对掩蔽起作用。
聆听复音时启动多个听觉滤波器。听觉能够计算各滤波器输出端的信噪比。当信噪比达到或者超过听阈因子时，即可听到该频率成分。

5.掩蔽效果的加和
当两个信号重叠并落在一个临界频带中时，二者的掩蔽分量可以线性相加。对于复杂音频信号可将其频谱分割成一系列离散段，每段就是一个 掩蔽信号。各掩蔽音互不重叠，即以一个临界带为单位。各掩蔽音的声压级则通过将对应的临界频带上的短时功率谱密度线性相加得到 。
6.MPEG1中心理声学模型的应用
MPEG-I 标准定义了两个模型
◼ 心理声学模型1: 
计算复杂度低 
但对假设用户听不到的部分压缩太严重
◼ 心理声学模型2 : 
提供了适合Layer III编码的更多特征
实际实现的模型复杂度取决所需要的压缩因子
如大的压缩因子不重要，则可以完全不用心理 声学模型。此时位分配算法不使用SMR （ Signal Mask Ratio ），而是使用SNR
四、量化和编码
1.比例因子的取值和编码
对各个子带每12个样点进行一次比例因子计算。先定出12个样点中绝对值的最大值。查比例因子表中比这个最大值大的 最小值作为比例因子。用6比特表示。
第2层的一帧对应36个子带样值，是第1层的三倍，原则上要传三个比例因子。为了降低比例因子的传输码率，采用了利用人耳时域掩蔽特性的编码策略。
每帧中每个子带的三个比例因子被一起考虑，划分成特定的几种模式。根据这些模式，1个、2个或3个比例因 子和比例因子选择信息（每子带2比特）一起被传送。如果一个比例因子和下一个只有很小的差别，就只传送大的一个，这种情况对于稳态信号经常出现。
2.比特分配及编码
对每个子带计算掩蔽-噪声比MNR，信噪比SNR–信掩比SMR， 即：MNR = SNR–SMR

使整个一帧和每个子带的总噪声-掩蔽比最小。这是一个循环过程，每一次循环使获益 最大的子带的量化级别增加一级，当然所用比特数不能超过一帧所能提供的最大数目
第1层一帧用4比特给每个子带的比特分配信 息编码；而第2层只在低频段用4比特，高频段则用2比特
3.子带样值的量化和编码
输入以12个样本为一组，每组样本经过时间-频率变换 之后进行一次比特分配并记录一个比例因子(scale factor)
比特分配信息告诉解码器每个样本由几位表示，比例 因子用6比特表示，解码器使用这个6比特的比例因子乘逆量化器的每个输出样本值，以恢复被量化的子带值。比例因子的作用是充分利用量化器的量化范围，通过比特分配和比例因子相配合，可以表示动态范围 超过120dB的样本 。
4.数据帧包装

（1）帧头(Header)：每帧开始的头32个比特，包含有同步和状 态比特流信息，在所有层都相同,同步码字为12bit全1码 （1111，1111，1111）。
（2）误码检测CRC：使用一种16bit奇偶校验字，可供在比特流 中作检测误码用。在所有层都相同
（3）声音数据：由比特分配表、比例因子选择信息、比例因子 和子带样值组成，其中子带样值是声音数据的最大部分。 每层声音数据不同。
（4）辅助数据：用作辅助数据比特流。
五、MPEG-1 Audio Layer2编码器调试
1.理解程序
首先是我们本次实验用到的主函数，其中包含了部分注释辅助理解，程序的主要思路在所给处的注释中已经给出，简化而说主要分8个步骤：
1.对滑动窗口内的音频信号进行32子带的滤波
2.如果是立体声模式，就要结合左右两声道
3.计算这一帧的比例因子，并计算这一帧的比例因子选择信息
4.使用相应的心理声学模型计算心理声学掩蔽水平
5.使用步骤4中的掩蔽电平对具有低掩蔽的子带进行迭代位分配
6.有需要的话添加CRC纠错
7.将比特分配，比例因子和比例因子信息打包到比特流中
8.对子带量化并将其打包为比特流
下面，我则根据所给出的程序的思路，对程序进行了注释

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_info包括头信息等相关内容
  frame_header header;//转到定义可见frame_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];//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));
  //初始化比例因子、比特分配表等会用到的buffer
  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);//读出从文件头中所获得的信息
  nch = frame.nch;
  error_protection = header.error_protection;



  while (get_audio (musicin, buffer, num_samples, nch, &header) > 0) {//获取音频信息
    if (glopts.verbosity > 1)//从文件里面读信息进入buffer
      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++ )//分三次观察
	for ( bl = 0; bl < 12; bl++ )//每个子带前后分12个样本
	  for ( ch = 0; ch < nch; ch++ )
	    WindowFilterSubband( &buffer[ch][gr * 12 * 32 + 32 * bl], ch,//32个子带分解
				 &(*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 //可以走newencode也可以走oldencode
    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);	
	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);//使用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.调试程序
首先在命令行中，按如下格式输入文件名：

而后，运行代码，可以得到如下结果：

同时，也可以在文件夹中得到我们生成的test1.mp2文件：

可见，生成的mp2文件相比原本的wav文件，有了明显的压缩。
3.输出特定帧所分配的比特数、比例因子和该帧的比特分配结果
本步骤需要添加以下代码进行实验：
part1：新建一个记事本文件：

  //添加代码：
  FILE* OUTPUT = NULL;
  if (fopen_s(&OUTPUT, "output.txt", "w") != 0)
  {
      printf("Failed to write the txt file!");
  }
  else
  {
      printf("Successfullly write the txt file!");
  }
  //int frameselected = 1;//选取指定的帧 //写在最开头的define了
  if (frameNum == frameselected)
  {
      fprintf(stderr, "[%4u]\r", frameNum);
  }

part2：输出特定帧所分配的比特数：

   //添加代码：输出可用比特数
    if (frameNum == frameselected)
    {
        decideout = 1;
    }
    else
    {
        decideout = 0;
    }
    if (decideout)
    {
        fprintf(OUTPUT, "可用比特数：%d\n", adb);
    }

part3：输出比例因子：

 //添加代码：//输出比例因子
    if (frameNum == frameselected)
    {
        fprintf(OUTPUT, "比例因子：\n");
        for (int i = 0; i < nch; i++)//声道
        {
            fprintf(OUTPUT, "声道%d\n", i + 1);
            for (int j = 0; j < SBLIMIT; j++)//子带
            {
                fprintf(OUTPUT, "子带%d:\t", j);
                for (int k = 0; k < 3; k++)
                {
                    fprintf(OUTPUT, "%d\t", scalar[i][k][j]);//需要注意scalar的定义顺序
                }
                fprintf(OUTPUT, "\n");
            }
        }
    }

part4：输出比特分配结果：

//添加代码：//比特分配
    if (frameselected == frameNum)
    {
        fprintf(OUTPUT, "比特分配:\n");
        for (int i = 0; i < nch; i++)//声道
        {
            fprintf(OUTPUT, "声道%d\n",i+1);
            for (int j = 0; j < SBLIMIT; j++)//子带
            {
                fprintf(OUTPUT, "子带%d:\t", j);
                fprintf(OUTPUT, "%d\n", bit_alloc[i][j]);
            }
        }
    }

part5：运行程序，得到txt文件并打开查看结果：