ntt_vq_coder.c

MPEG2/MPEG4编解码参考程序(实现了MPEG4的部分功能)

	  index->group_code =0x7f;
          index->last_max_sfb[0] =0;
	  index->restore_flag_tns=0;

	  ntt_maxsfb( index, sfb_width_table, nr_of_sfb, -1);

	  ntt_select_ms( spectral_line_vector,
		        index, sfb_width_table, nr_of_sfb, -1);

	  /* Backup original spectrum */
	  for(i_sup=0;i_sup<index->numChannel;i_sup++)
	    for(ismp=0;ismp<index->block_size_samples;ismp++)
	      spectrum_orig[i_sup][ismp]=spectral_line_vector[i_sup][ismp];
	  
	  if(index->restore_flag_tns==1) {
	     if(tvq_debug_level > 5)
		fprintf(stderr,"Restore spectrum.\n");
	     for(i_sup=0;i_sup<index->numChannel;i_sup++)
	     for(ismp=0;ismp<index->block_size_samples;ismp++)
	     spectral_line_vector[i_sup][ismp]=spectrum_orig[i_sup][ismp];
	  }		  
	  
	  tvq_target_spectrum[0] = spectral_line_vector[0];
	  tvq_target_spectrum[1] = spectral_line_vector[1];
	   if(debugLevel>1) 
	   fprintf(stderr,"ntt_tns_enc END pred_type = %2d %2d\n",
	   pred_type, NOK_LTP);
#if 1 /***TM9902*/
         if(pred_type == NOK_LTP)
           for(i_sup = 0; i_sup < index->numChannel; i_sup++)
           {
             tvq_target_spectrum[i_sup] = baselayer_spectral_line_vector[i_sup];

              for(ismp = 0; ismp < block_size_samples; ismp++){
	       baselayer_spectral_line_vector[i_sup][ismp] = 
	       spectral_line_vector[i_sup][ismp];
	      }
        if(tvq_debug_level >2){
	   fprintf(stderr, "HHHH %12.3f %12.3f \n",
           spectral_line_vector[i_sup][0], spectral_line_vector[i_sup][1]);
            fprintf(stderr, "HHHH %12.3f %12.3f \n",
           nok_tmp_DTimeSigBuf[i_sup][0], nok_tmp_DTimeSigBuf[i_sup][1]);
            fprintf(stderr, "HHHH %5d \n", windowSequence[i_sup]);
            fprintf(stderr, "HHHH %5d \n", windowShape[MONO_CHAN]);
            fprintf(stderr, "HHHH %5d \n", block_size_samples);
            fprintf(stderr, "HHHH %5d \n", sfb_offset[i_sup][0]);
            fprintf(stderr, "HHHH %5d \n", nr_of_sfb[i_sup]);
	 }
	   nok_ltp_enc(spectral_line_vector[i_sup],
                         nok_tmp_DTimeSigBuf[i_sup],
                         windowSequence[i_sup],
                         windowShape[MONO_CHAN], windowShape[MONO_CHAN],
                         block_size_samples,
                         block_size_samples/2,
                         block_size_samples/8,
                         &sfb_offset[i_sup][0], nr_of_sfb[i_sup],
                         &nok_lt_status[i_sup],
                         tnsInfo[i_sup],
                         NTT_VQ_SYS);
           }
#endif
	if(debugLevel>5) 
           fprintf(stderr, "MSMSMS %5d \n", index->ms_mask);
	ntt_headerenc( -1, mat_layerStream, index, &used_bits,
			 nr_of_sfb, tnsInfo, nok_lt_status, pred_type);
	if(debugLevel>2)  fprintf(stderr,"headerenc %d\n",used_bits);
	  ntt_available_bits = index->nttDataBase->ntt_NBITS_FR - used_bits;
	  
	  ntt_vq_coder(DTimeSigBuf,
                       DTimeSigLookAheadBuf,
                       spectral_line_vector,
                       lpc_spectrum /*ntt_external_pw[MONO_CHAN]*/,
                       NTT_PW_INTERNAL /*ntt_pw_select*/,
                       windowSequence[MONO_CHAN],
                       index,
                       param_ntt,
                       sfb_width_table,
		       nr_of_sfb,
		       ntt_available_bits,
                       lpc_spectrum,
                       reconstructed_spectrum);
	  
          /* Bit packing */

	if(tvq_debug_level>5){
	   fprintf(stderr," before pack%5ld\n",BsCurrentBit(mat_layerStream));
	   fprintf(stderr," before pack%5ld\n",BsCurrentBit(fixed_stream));
	}
	tomo_tmp=used_bits;
          used_bits += ntt_BitPack(index, mat_layerStream);
	  if (debugLevel>2) 
	  fprintf(stderr,"____ ntt_BaseLayer bit %d %d\n",used_bits-tomo_tmp,used_bits);
		  
          if(tvq_debug_level >5 )
		fprintf(stderr,"  after pack%5ld\n",BsCurrentBit(mat_layerStream));
		  BsClose(mat_layerStream);
		  tomo_tmp=BsCurrentBit(fixed_stream);
		  writeFlexMuxPDU( 0 , fixed_stream , mat_dynpartBuf);
	   if (debugLevel>2)
	   fprintf(stderr,"< Base %d >\n",BsCurrentBit(fixed_stream)-tomo_tmp);

          /* 
	   * Restore the spectrum of the base layer and update LTP buffer. 
	   */
	   if(pred_type == NOK_LTP)
	   {
	     
	     for(i_sup = 0; i_sup < index->numChannel; i_sup++)
	     {   
	       for(ismp = 0; ismp < block_size_samples; ismp++)
		 baselayer_rec_spectrum[ismp] = 
		 reconstructed_spectrum[i_sup][ismp];
	       
	       /* Add the LTP contribution to the reconstructed spectrum. */
	       nok_ltp_reconstruct(baselayer_rec_spectrum, 
				   windowSequence[i_sup], 
				   &sfb_offset[i_sup][0], nr_of_sfb[i_sup],
				   block_size_samples/8,
				   &nok_lt_status[i_sup]);
	       
	       /* This is passed to the scaleable encoder. */
	       for(ismp = 0; ismp < block_size_samples; ismp++)
		 reconstructed_spectrum[i_sup][ismp] = 
		 baselayer_rec_spectrum[ismp];
#if 1	       
	       /* TNS synthesis filtering. */
	       if(tnsInfo[i_sup] != NULL && (index->restore_flag_tns==0))
		 TnsEncode2(nr_of_sfb[i_sup], nr_of_sfb[i_sup], 
			    windowSequence[i_sup], &sfb_offset[i_sup][0], 
			    baselayer_rec_spectrum, tnsInfo[i_sup] , 1);
#endif
	       /* Update the time buffer of LTP. */
	       nok_ltp_update(baselayer_rec_spectrum, windowSequence[i_sup], 
			      windowShape[MONO_CHAN], windowShape[MONO_CHAN], block_size_samples, 
			      block_size_samples/2, 
			      block_size_samples/8,
			      &nok_lt_status[i_sup]);
	     }
	  }
	  
	  /* Scalable encoder */
          {
            int ntt_available_bits;
	    int iscl,tomo_tmp2;
	    int  iii, jjj;
	    for(iii=0; iii<8; iii++){
	       for(jjj=0; jjj<index->max_sfb[0]; jjj++){
	         index_scl->msMask[iii][jjj]=index->msMask[iii][jjj];
	       }
	    }
	    index_scl->max_sfb[0] = index->max_sfb[0];
            index_scl->w_type = index->w_type;
            index_scl->group_code = index->group_code;
	    index_scl->pf = index->pf;
            if(tvq_debug_level >5)
	      fprintf(stderr, "LLL %5d ntt_NSclLay \n", index->nttDataScl->ntt_NSclLay); 
	   for (iscl=0; iscl<index->nttDataScl->ntt_NSclLay; iscl++){
#if 1 /*new*/
             tvqScalEnc(
                 tvq_target_spectrum,
                 index,
                 index_scl,
                 param_ntt,
                 fixed_stream,
                 tnsInfo,
                 sfb_width_table,
                 nr_of_sfb,
                 reconstructed_spectrum,
		 pred_type,
		 iscl);

#endif
	      }
          }
          return(used_bits);	 
}

void tvqScalEnc(
  double      *tvq_target_spectrum[MAX_TIME_CHANNELS],
  ntt_INDEX   *index,
  ntt_INDEX   *index_scl,
  ntt_PARAM   *param_ntt,
  BsBitStream *fixed_stream,
  TNS_INFO    *tnsInfo[MAX_TIME_CHANNELS],
  int         sfb_width_table[MAX_TIME_CHANNELS][MAX_SCFAC_BANDS],
  int         nr_of_sfb[MAX_TIME_CHANNELS],
  double      *reconstructed_spectrum[MAX_TIME_CHANNELS],
  PRED_TYPE   pred_type,
  int         iscl)

{
          double  lpc_spectrum[ntt_T_FR_MAX]; /*dummy*/
          BsBitStream *mat_layerStream;
          BsBitBuffer *mat_dynpartBuf;
          NOK_LT_PRED_STATUS /* dummy for enhance */
	       nok_lt_status[MAX_TIME_CHANNELS] = {NULL, NULL};
         int ismp, tomo_tmp, tomo_tmp2, used_bits;
         int     ntt_available_bits;
	 int     debugLevel, i_ch;
         double  *ntt_ms_buf[MAX_TIME_CHANNELS];
         double  buffer[MAX_TIME_CHANNELS][1024];

	 

	   debugLevel=tvq_debug_level;
	    index_scl->last_max_sfb[iscl+1] = index_scl->max_sfb[iscl];
				mat_dynpartBuf = BsAllocBuffer(10000); /* Adhoc Size */
				mat_layerStream = BsOpenBufferWrite(mat_dynpartBuf);

	      used_bits=0;
	      index_scl->ms_mask =0;
	      if(index->numChannel > 1){
	        for(ismp=0; ismp<index->block_size_samples; ismp++){
		  ntt_ms_buf[0] = &(buffer[0][0]);
		  ntt_ms_buf[1] = &(buffer[1][0]);
		  ntt_ms_buf[0][ismp] = 
		    tvq_target_spectrum[0][ismp] - reconstructed_spectrum[0][ismp];
		  
		  ntt_ms_buf[1][ismp] = 
		    tvq_target_spectrum[1][ismp] - reconstructed_spectrum[1][ismp];
		}
	      }
              ntt_maxsfb( index_scl, sfb_width_table, nr_of_sfb, iscl);
              ntt_select_ms( ntt_ms_buf,
		        index_scl, sfb_width_table, nr_of_sfb, iscl);
	      
	      ntt_headerenc( iscl, 
			     mat_layerStream, index_scl, &used_bits,
			     nr_of_sfb, tnsInfo, nok_lt_status, 
			     pred_type);
	      ntt_available_bits = 
		 index_scl->nttDataScl->ntt_NBITS_FR_SCL[iscl]-used_bits;
              ntt_scale_vq_coder(tvq_target_spectrum, /*spectral_line_vector,*/
                                 lpc_spectrum,
                                 index,
                                 index_scl,
                                 param_ntt,
                                 sfb_width_table,
		                 nr_of_sfb,
                                 ntt_available_bits,
				 reconstructed_spectrum, iscl);

              /* Scalable bit packing */
				tomo_tmp=used_bits;
				tomo_tmp2=BsCurrentBit(mat_layerStream);
              used_bits += ntt_SclBitPack(index_scl, mat_layerStream , iscl);
		if(debugLevel>2)
		fprintf(stderr,"____ ntt_SclLayer bit %d %d [%d]\n",used_bits-tomo_tmp,used_bits,iscl);
		if(debugLevel>2)
		fprintf(stderr,"<<< mat_Stream[%d] %ld\n",iscl,BsCurrentBit(mat_layerStream)-tomo_tmp2);
				
				BsClose(mat_layerStream);
				tomo_tmp=BsCurrentBit(fixed_stream);
				writeFlexMuxPDU( iscl+1 , fixed_stream , mat_dynpartBuf);
}


void ntt_maxsfb(    ntt_INDEX   *index,
		    int     sfb_width_table[MAX_TIME_CHANNELS][MAX_SCFAC_BANDS],
                    int     nr_of_sfb[MAX_TIME_CHANNELS],
                    int     iscl
		    )
{
 int max_line, sb, sb_ind, k, i;
 int sfb_offset[60];
 float ftmp;
        if(iscl <0){ /*base*/
           if(tvq_debug_level>5)
	      fprintf(stderr, "%12.2f %5d DDDD base \n",
	      index->nttDataBase->bandUpper, iscl);
	   ftmp = (float)(index->nttDataBase->bandUpper);
	   if (index->w_type==EIGHT_SHORT_SEQUENCE){
	      ftmp *= (float)(index->block_size_samples/8);
              max_line = (int)ftmp; 
	   }
	   else{
	      ftmp *= (float)(index->block_size_samples);
	      max_line = (int)ftmp;
           }
       }
       else{
           if(tvq_debug_level>5)
           fprintf(stderr, "%12.2f %5d DDDD scl\n",
	      index->nttDataScl->ac_top[iscl][0][3], iscl);
	   ftmp = (float)(index->nttDataScl->ac_top[iscl][0][3]);
	   if (index->w_type==EIGHT_SHORT_SEQUENCE){
	      ftmp *= (float)(index->block_size_samples/8);
              max_line = (int)ftmp; 
	   }
	   else{
	      ftmp *= (float)(index->block_size_samples);
	      max_line = (int)ftmp;
           }
       }   
	   sfb_offset[0] = 0;
           k=0;
           for(i = 0; i < nr_of_sfb[MONO_CHAN]; i++ ) {
               sfb_offset[i] = k;
               k +=sfb_width_table[MONO_CHAN][i];
           }
           sfb_offset[i] = k;
           for(sb=0; (sfb_offset[sb]<max_line); sb++){
             sb_ind = sb+1;
            }
            index->max_sfb[iscl+1] = sb_ind;
}