MPEG作业

MPEG介绍
MPEG标准主要有以下五个，MPEG-1、MPEG-2、MPEG-4、MPEG-7及MPEG-21等。该专家组建于1988年，专门负责为CD建立视频和音频标准，而成员都是视频、音频及系统领域的技术专家。及后，他们成功将声音和影像的记录脱离了传统的模拟方式，建立了ISO/IEC11172压缩编码标准，并制定出MPEG-格式，令视听传播方面进入了数字化时代。因此，大家现在泛指的MPEG-X版本，就是由ISO (InternationalOrganization for Standardization) 所制定而发布的视频、音频、数据的压缩标准。

MPEG-1声音的主要性能
输入为PCM信号，采样率为32、44.1或48kHz，输出为32kbps~384kbps

具有三个独立的压缩层次：layerⅠ（编码器最简单）、layerⅡ（编码器复杂度中等）、layerⅢ（编码器最复杂）

心理声学模型
心理声学模型用来计算信号中不可被听觉感知的部分

人耳听觉特性
人耳听觉系统大致等效于一个信号通过一组并联的不同中心频率的带通滤波器，中心频率与信号频率相同的滤波器具有最大响应，中心频率偏离信号频率较多的滤波器不会产生响应。在0Hz到20kHz频率范围内由25个重叠的带通滤波器组成滤波器组。

听觉系统中存在一个听觉阈值电平，低于这个电平的声音信号就听不到。

听觉阈值电平是自适应的，也就是说听觉阈值的大小随声音频率的改变而改变。
一个人能否听到这种声音取决于声音的频率以及声音的幅度是否高于这种频率下的听觉阈值
掩蔽效应： 一个较弱的声音的听觉感受被另一个较强的声音影响的现象称为人耳的听觉掩蔽效应。掩蔽作用与信号频率和强度有关。掩蔽效应在一定频率范围内不随带宽增大而改变，直至超过某个频率值。
如果有多个频率成分的复杂信号存在，那么频谱的总掩蔽阈值与频率的关系取决于各掩蔽音的强度、频率和它们之间的距离。

临界频带

临界频带是指当某个纯音被以它为中心频率，且具有一定带宽的连续噪声所掩蔽时，如果该纯音刚好被听到时的功率等于这一频带内的噪声功率，这个带宽为临界频带宽度

通常认为从20Hz到16kHz有25个临界频带，单位为bark，1bark=一个临界频带的宽度

掩蔽值

掩蔽音与被掩蔽音的组合方式有四种，即它们分别可以是乐音信号或窄带噪声。
音乐与语音信号大都由一系列复杂的频谱分量构成，相应的这些多个掩蔽分量也会相互影响并最终获得一个整体的掩蔽阈值。
多个掩蔽音同时存在时的综合掩蔽效果可以理解为每个掩蔽音的掩蔽效果先独立变化然后再线性相加
当两个信号重叠并落在一个临界频带中时，二者的掩蔽分量可以线性相加
对于复杂音频信号，可以将其频谱分割成一系列离散段，每段就是一个掩蔽信号，各掩蔽音互不重叠，即以一个临界带为单位。各掩蔽音的声压级则通过将对应的临界频带上的短时功率谱密度线性相加得到。
将输入信号变换到频域，再将结果分解成一些尽量与临界频带尽可能相似的子带，然后对每个子带进行量化，量化方式应当使得量化噪声听不见
心理声学模型Ⅰ
该模型的计算复杂度低，但对假设用户听不到的部分压缩太严重。

实际实现的模型复杂度取决于所需要的压缩因子，如大的压缩因子不重要，则可以不用心理声学模型，此时位分配算法不使用SMR而使用SNR

将样本变换到频域
32个等分的子带信号并不能精确地反映人耳的听觉特性，因此引入FFT补偿频率分辨率不足的问题。
layer1每帧有384个样本点，因此采用512点的样本窗口；layer2和layer3每帧有1152个样本点，采用1024点的样本窗口，每帧两次计算，选择两个信掩比（SMR）中较小的一个
确定声压级别

考虑安静时阈值
即绝对阈值，在标准中有根据输入PCM信号的采样率编制的“频率、临界频带率和绝对阈值”表
将音频信号分解为“乐音”和“非乐音/噪声”部分，因为这两种信号的掩蔽能力不同
根据音频频谱的局部功率最大值确定乐音成分，局部峰值为乐音，之后将本临界频带内的剩余频谱合在一起，组成一个代表噪声频率
音调和非音调掩蔽成分的消除
利用标准中给出的绝对阈值消除被掩蔽成分，考虑在每个临界频带内，小于0.5bark的距离中只保留最高功率的成分
单个掩蔽阈值的计算
音调成分和非音调成分单个掩蔽阈值根据标准中的算法求得
全局掩蔽阈值的计算
还要考虑其他临界频带的影响，因为一个掩蔽信号会对其他频带上的信号产生掩蔽效应，称为掩蔽扩散
每个子带的掩蔽阈值
选择出本子带中最小的阈值作为子带阈值
计算每个子带信号掩蔽比SMR
SMR=信号能量/掩蔽阈值
将SMR传递给编码单元
MPEG-1 编码原理

基本思想
分析信号，去掉不能被感知的部分

整体框架

输入声音信号经过一个多相滤波器组，变换到多个子带。同时，经过“心理声学模型”计算以频率为自变量的噪声掩蔽阈值、量化和编码部分用信掩比SMR决定分配给子带信号的量化位数，使量化噪声<掩蔽阈值。最后通过数据帧包装将量化的子带样本和其他数据按照规定的帧格式组装成比特数据流

两条线

MPEG音频压缩编码框架主体分为两条线，一条是红框中的内容，一条是绿框中的内容

红框部分：PCM码流经多相滤波器组变换为32个子带的频域信号，在实际中可以理解为每32个样点做一次子带分解，连续做12次，此时得到的每个子带中都有12个样点，这样的过程再连续做3次，所以最终每个子带上会有12 × 3 = 36 12\times 3=3612×3=36个样本点。之后利用第二条线的结果对数据进行量化。

绿框部分：对PCM信号进行FFT，输入到心理声学模型中，同时，红框中子带分解后，根据各个子带的样本点计算提取相应子带的比例因子，也将其输入到心理声学模型中，由心理声学模型计算以频率为自变量的噪声掩蔽阈值，通过信号掩蔽比SMR确定比例因子选择信息，另外，与目标码率结合确定动态比特分配，决定给子带分配多少量化比特数。

将量化后的子带样本和边信息编码数据以及辅助数据按照规定的帧格式组装成帧比特流输出。

时-频分析的矛盾
之所以要分成上下两条线进行压缩编码，是因为时-频之间存在矛盾。

对于傅里叶变换过程中，窗的长度决定频谱图的时间分辨率和频率分辨率，窗长越长，截取的信号越长，傅里叶变换后频率分辨率越高，时间分辨率越低；相反，窗长越短，截取的信号就越短，频率分辨率越低，时间分辨率越高

因此，MPEG音频压缩编码的第一条线，利用子带分析滤波器组使信号具有高的时间分辨率，确保在短暂冲击信号情况下，编码的声音信号仍具有足够高的质量。第二条线利用FFT运算，使信号具有高的频率分辨率，因为掩蔽阈值是从功率谱密度推出来的

重要模块分析
多相滤波器组
子带编码：将原始信号分解为若干个子频带，对其分别进行编码处理后再合成为全频带信号

多相滤波器组用来分割子带，将PCM样本变换到32个子带的频域信号

缺点：

等带宽的滤波器组与人类听觉系统的临界频带不对应，在低频区域，单个子带会覆盖多个临界频带，在这种情况下，量化比特数不能兼顾每个临界频带
滤波器组与其逆过程不是无失真的，但是滤波器组引入的误差很小，且听不到
子带间频率有混叠，滤波后的相邻子带有频率混叠现象，一个子带中的信号可以影响相邻子带的输出
比例因子选择
比例因子：对各个子带每12个样点进行一次比例因子计算，先定出12个样点中绝对值的最大值，查比例因子表中比这个最大值大的最小值作为比例因子。用6bit表示。
比例因子选择：每帧中每个子带的三个比例因子被一起考虑，划分成特定的几种模式，根据这些模式，1个、2个或3个比例因子和比例因子选择信息（每子带2bit）一起被传送。如果一个比例因子和下一个只有很小的差别，就只传送大的一个，这种情况对于稳态信号经常出现。
心理声学模型
输入为比例因子和FFT变换的结果，输出为信掩比，用于动态比特分配

动态比特分配
layer Ⅰ

输入为（目标）码率和信掩比，输出为量化比特数

在调整到固定的码率之前，要先确定可用于样值编码的有效比特数，这个数值取决于比例因子、比例因子选择信息、比特分配信息以及辅助数据所需比特数
目标：使整帧和每个子带的总噪声-掩蔽比最小
比特分配的过程
计算噪声-掩蔽比NMR=信掩比SMR-信噪比SNR
其中SNR由MPEG-1标准给定，NMR表示波形误差与感知测量之间的误差
比特分配时的最好情况：信噪比=信掩比
码率分配的实现思路：
初始还未分配bit时，信噪比为0，噪掩比等于信掩比。
根据（目标）码率计算预估比特数
优先对噪掩比高的子带分配比特（如果噪掩比是负数则不考虑），使获益最大的子带的量化级别增加一级
量化比特数每增加1bit，信噪比会上升6db，噪掩比会下降6db
分配比特后重新计算该子带的噪掩比，之后重复上述过程，直到没有比特可用或每个子带的噪掩比都为0

装帧
layer Ⅰ

layerⅡ
与layer Ⅰ类似但有所增强

帧：3组/帧×12个样本/子带×32个子带/帧=1152个样本/帧

缩放因子：每个子带的3个组尽量使用共同的缩放因子

1/2/3个缩放因子和缩放因子选择信息（每子带2bit）一起传送
如果缩放因子和下一个只有很小的差别，就只传送大的一个，这种情况对于稳态信号经常出现
如果要给瞬态信号编码，则要在瞬态的前、后沿传送两个或所有三个比例因子
量化：每子带12个连续的样值都除以比例因子进行归一化，得到的值为X XX，进行量化计算：A × X + B A\times X+BA×X+B，其中A AA和B BB是量化系数，根据bit分配信息得到量化级数，根据量化级数查量化表得到A AA和B BB

根据采样和码率量化，不同子带可以从不同的量化器集合中选择
对量化级别在3,5,9级，采用“颗粒”优化
装帧：

关键代码分析
代码注释
 

/************************************************************************
*
* main
*
* PURPOSE:  MPEG II Encoder with
* psychoacoustic models 1 (MUSICAM) and 2 (AT&T)    //mpeg2编码+心理声学模型1和2
*
* SEMANTICS:  One overlapping frame of audio of up to 2 channels are
* processed at a time in the following order:     //每次处理最多两个信道的音频帧，顺序如下
* (associated routines are in parentheses)
*
* 1.  Filter sliding window of data to get 32 subband
* samples per channel.            //滑动窗一次获得32个子带的样本
* (window_subband,filter_subband)
*
* 2.  If joint stereo mode, combine left and right channels
* for subbands above #jsbound#.    //如果是联合立体声模式，则将以上子带的左右通道合并
* (combine_LR)
*
* 3.  Calculate scalefactors for the frame, and 
* also calculate scalefactor select information.    //计算每帧的比例因子和比例因子选择信息
* (*_scale_factor_calc)
*
* 4.  Calculate psychoacoustic masking levels using selected
* psychoacoustic model.       //利用选择的心理声学模型计算心理声学掩蔽水平
* (psycho_i, psycho_ii)
*
* 5.  Perform iterative bit allocation for subbands with low
* mask_to_noise ratios using masking levels from step 4.        //迭代分配bit
* (*_main_bit_allocation)
*
* 6.  If error protection flag is active, add redundancy for
* error protection.          //可以添加冗余校验
* (*_CRC_calc)
*
* 7.  Pack bit allocation, scalefactors, and scalefactor select
* headerrmation onto bitstream.       //将bit分配、比例因子和比例因子选择信息进行打包
* (*_encode_bit_alloc,*_encode_scale,transmission_pattern)
*
* 8.  Quantize subbands and pack them into bitstream     //对子带进行量化并打包
* (*_subband_quantization, *_sample_encoding)
*
************************************************************************/
int frameNum = 0;

int main (int argc, char **argv)
{
  typedef double SBS[2][3][SCALE_BLOCK][SBLIMIT];   // SCALE_BLOCK=12，SBLIMIT=32
  SBS *sb_sample;
  typedef double JSBS[3][SCALE_BLOCK][SBLIMIT];
  JSBS *j_sample;
  typedef double IN[2][HAN_SIZE];   //HAN_SIZE=512
  IN *win_que;
  typedef unsigned int SUB[2][3][SCALE_BLOCK][SBLIMIT];
  SUB *subband;

  frame_info frame;      //音频帧信息结构体变量，包含头信息、bit分配表、声道数、子带数等音频帧信息
  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];    //心理声学模型得到smr
  // FLOAT snr32[32];
  short sam[2][1344];		/* was [1056]; */
  int model, nch, error_protection;    //nch指声道数
  static unsigned int crc;
  int sb, ch, adb;      //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 */     //MPEG_AUDIO_ID=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)
      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);   //bit预算
    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 totalbit = adb;

    {
      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++ )     //每组做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



    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++) {    //nch表示通道数
	for (sb = 0; sb < SBLIMIT; sb++)    //SBLIMIT=32
	  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);    //送入buffer和最大比例因子，返回smr
	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);    //对于给定的子带，决定是否发送1、2或全部3个比例因子，并相应地填写比例因子选择信息,scfsi是比例因子选择信息
    main_bit_allocation (smr, scfsi, bit_alloc, &adb, &frame, &glopts);    //比特分配
    if (error_protection)   //如果需要就添加CRC
      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);     //剩余未分配比特数写入stack
    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);
}

实验结果：