enc_tf.c

C写的MPEG4音频源代码(G.723/G.729)

        int ismp, med_sw, i_ch, top;
        /* initialize */
        if (ntt_InitFlag){
          sig_tmptmp = (double *)calloc((size_t)(max_ch*block_size_samples*3),
                                        sizeof(double));
          sig_tmp = sig_tmptmp + block_size_samples * max_ch;
          for (i_ch=0; i_ch<max_ch; i_ch++){
            top = i_ch * block_size_samples;
            for (ismp=0; ismp<block_size_samples; ismp++){
              sig_tmp[ismp+top] = DTimeSigBuf[i_ch][ismp];
            }
          }
        }
        for (i_ch=0; i_ch<max_ch; i_ch++){
          top = i_ch * block_size_samples;
          for (ismp=0; ismp<block_size_samples; ismp++){
            sig_tmp[ismp+block_size_samples*max_ch+top] =
              DTimeSigLookAheadBuf[i_ch][ismp];
          }
        }
	
        /* automatic switching module */ /* T.Ishikawa 980525 */
        if ((qc_select == NTT_VQ)||(qc_select ==NTT_VQ_SYS)) med_sw = 1; /* if med_sw == 1            */
        else                    med_sw = 0; /* medium block is activated */
        
	
	ntt_tf_pre_process(sig_tmp, &ntt_index, &param_ntt, med_sw,
                           ntt_InitFlag);
        windowSequence[MONO_CHAN] = (WINDOW_SEQUENCE)ntt_index.w_type;
/*         windowSequence[MONO_CHAN] =     ntt_index.w_type =    EIGHT_SHORT_SEQUENCE; */
        /* prepare for the next frame */
        for (ismp=0; ismp<block_size_samples*2*max_ch; ismp++){
          sig_tmp[ismp-block_size_samples*max_ch] = sig_tmp[ismp];
        }
        param_ntt.ntt_param_set_flag = 1;

      }
      break;

    default:
      CommonExit( 1, "Encode: unsupported window switching mode %d", win_switch_mode );
    }

                    
    if (debugLevel>1)
      printf("Blocktype   %d \n",windowSequence[MONO_CHAN] );

    switch( windowSequence[MONO_CHAN] ) {
    case EIGHT_SHORT_SEQUENCE  :
      no_sub_win   = short_win_in_long;
      sub_win_size = block_size_samples/short_win_in_long;
      bw_lines     = bw_lines_short;
      break;
      
    default:
      no_sub_win   = 1;
      sub_win_size = block_size_samples;
      bw_lines     = bw_lines_long;
      break;
    }
   
    /* son_AACpp */
    if (pp_select == AAC_PP)
      {
        int i_ch; /* 971010 added YT*/
        int band;
	for(i_ch=0;i_ch<max_ch;i_ch++){ /* 971010 added YT*/

          /* polyphase quadrature filter */
          son_pqf_main(DTimeSigLookAheadBufForGC[i_ch], block_size_samples,
                       i_ch, DBandSigLookAheadBuf[i_ch]);
          /* set analysis buffer for gain control */
          for (band = 0; band < NBANDS; band++) {
            memcpy((char *)&DBandSigBufForGCAnalysis[i_ch][band][block_size_samples/NBANDS*2],
                   (char *)DBandSigLookAheadBuf[i_ch][band],
                   block_size_samples/NBANDS*sizeof(double)
                   );
          }

		if(gc_switch == GC_PRESENT){

          /* gain detector */
          son_gc_detect(DBandSigBufForGCAnalysis[i_ch], block_size_samples,
                        windowSequence[MONO_CHAN],
                        i_ch, gainInfo[i_ch]
                        );
		}
		else { /* if GC_NON_PRESENT */
		son_gc_detect_reset(DBandSigBufForGCAnalysis[i_ch], block_size_samples, windowSequence[i_ch], i_ch, gainInfo[i_ch]);
		}

          /* gain modifier */
          son_gc_modifier(DBandSigBufForGCAnalysis[i_ch],
                          gainInfo[i_ch],
                          block_size_samples,
                          windowSequence[MONO_CHAN], i_ch,
                          DBandSigWithGCBuf[i_ch]
                          );
          /* shift analysis buffer */
          for (band = 0; band < NBANDS; band++) {
            memcpy((char *)DBandSigBufForGCAnalysis[i_ch][band],
                   (char *)&DBandSigBufForGCAnalysis[i_ch][band][block_size_samples/NBANDS],
                   block_size_samples/NBANDS*2*sizeof(double)
                   );
          }

		if(gc_switch == GC_PRESENT){
          /* packing gain data into the gc_stream */
          son_gc_pack(gc_stream[i_ch], windowSequence[MONO_CHAN],
                      max_band[i_ch], gainInfo[i_ch]);
		}

        } /* for i_ch...*/
      } /* if (pp_select == AAC_PP).. */
   
  } /* pre processing */


  /******************************************************************************************************************************
  *
  * psychoacoustic
  *
  ******************************************************************************************************************************/
   /*
   if((qc_select != NTT_VQ) && (qc_select != NTT_VQ_SYS))*/
   {
    EncTf_psycho_acoustic( fSampleLong,
                           1,
                           qc_select,
                           block_size_samples,
                           chpo_long, chpo_short );
   }
   if (debugLevel>2) fprintf(stderr,"NNNNN %d \n",chpo_long[0].no_of_cb);
  
  /******************************************************************************************************************************
  *
  * T/F mapping
  *
  ******************************************************************************************************************************/

  {
    /* son_AACpp */
    if (pp_select == AAC_PP)
      {
	int band;
	/* added 971010 YT*/
        int i_ch, n_ch;
        n_ch = max_ch;
        for (i_ch=0; i_ch<n_ch; i_ch++){

          for (band = 0; band < NBANDS; band++) {
            buffer2freq(
                        DBandSigWithGCBuf[i_ch][band],
                        &spectral_line_vector_for_gc[i_ch][block_size_samples/NBANDS*band],
                        overlap_buffer[i_ch],	/* dummy */
                        windowSequence[MONO_CHAN],
                        windowShape[i_ch],
                        windowShapePrev[i_ch],
                        block_size_samples/NBANDS, 
                        block_size_samples/NBANDS/med_win_in_long,
                        block_size_samples/NBANDS/short_win_in_long,
                        NON_OVERLAPPED_MODE,
                        short_win_in_long
                        );
          }
          son_gc_arrangeSpecEnc(
                                spectral_line_vector_for_gc[i_ch],
                                block_size_samples,
                                windowSequence[MONO_CHAN],
                                spectral_line_vector[i_ch]
                                );
        } /* for(i_ch...*/
      }
    else /* if (pp_select != AAC_PP) */{
      int i_ch, n_ch;
      n_ch = max_ch;
      for (i_ch=0; i_ch<n_ch; i_ch++){
	buffer2freq(
		    DTimeSigBuf[i_ch],
		    spectral_line_vector[i_ch],
		    overlap_buffer[i_ch],
		    windowSequence[MONO_CHAN],
                    windowShape[i_ch],
                    windowShapePrev[i_ch],
		    block_size_samples, 
		    block_size_samples/med_win_in_long,
		    block_size_samples/short_win_in_long,
		    OVERLAPPED_MODE,
		    short_win_in_long		/* HP 971023 */
		    );
      }
    }
    
  
    /* used_bits += missing if tf_buffer2freq adds something to the fixed stream */

#if 0
    {
      int i, k;
      for( k=0; k<8; k++ ) {
        printf( "\n" );
        for( i=0; i<128; i++ ) {
          printf( "%12.6f ",  spectral_line_vector[MONO_CHAN][(k*128)+i] );
          if( (i%8) ==0 ) printf( "\n" );
        }
      }
    }
#endif
  }



  /******************************************************************************************************************************
  *
  * adapt ratios of psychoacoustic module to codec scale factor bands
  *
  ******************************************************************************************************************************/
    {
      int    par_set;

      par_set = 0;

      switch( windowSequence[MONO_CHAN] ) {
      case ONLY_LONG_SEQUENCE :
        memcpy( (char*)sfb_width_table[MONO_CHAN], (char*)chpo_long[MONO_CHAN].cb_width, (NSFB_LONG+1)*sizeof(int) );
        nr_of_sfb[MONO_CHAN] = chpo_long[MONO_CHAN].no_of_cb;
        p_ratio[MONO_CHAN]   = chpo_long[MONO_CHAN].p_ratio;
        par_set = 1;
        break;
      case LONG_START_SEQUENCE :
        memcpy( (char*)sfb_width_table[MONO_CHAN], (char*)chpo_long[MONO_CHAN].cb_width, (NSFB_LONG+1)*sizeof(int) );
        nr_of_sfb[MONO_CHAN] = chpo_long[MONO_CHAN].no_of_cb;
        p_ratio[MONO_CHAN]   = chpo_long[MONO_CHAN].p_ratio;
        par_set = 1;
        break;
      case EIGHT_SHORT_SEQUENCE :
        memcpy( (char*)sfb_width_table[MONO_CHAN], (char*)chpo_short[MONO_CHAN][0].cb_width, (NSFB_SHORT+1)*sizeof(int) );
        nr_of_sfb[MONO_CHAN] = chpo_short[MONO_CHAN][0].no_of_cb;
        p_ratio[MONO_CHAN]   = chpo_short[MONO_CHAN][0].p_ratio;
        par_set = 1;
        break;
      case LONG_STOP_SEQUENCE :
        memcpy( (char*)sfb_width_table[MONO_CHAN], (char*)chpo_long[MONO_CHAN].cb_width, (NSFB_LONG+1)*sizeof(int) );
        nr_of_sfb[MONO_CHAN] = chpo_long[MONO_CHAN].no_of_cb;
        p_ratio[MONO_CHAN]   = chpo_long[MONO_CHAN].p_ratio;
        par_set = 1;
        break;
      default:
        break;
      
      }

      /* to prevent undefined ptr just use a meaningful value to allow for experiments with the meachanism above */
      if( !par_set) {   
        memcpy( (char*)sfb_width_table[MONO_CHAN], (char*)chpo_long[MONO_CHAN].cb_width, (NSFB_LONG+1)*sizeof(int) );
        nr_of_sfb[MONO_CHAN]  = chpo_long[MONO_CHAN].no_of_cb;
        p_ratio[MONO_CHAN] = chpo_long[MONO_CHAN].p_ratio;
      }
    }


  /* copy sfb tables */
  for(i=0; i<max_ch; i++)
    nr_of_sfb[i] = nr_of_sfb[MONO_CHAN];


  /* Set the AAC grouping information.  */
  switch( qc_select ) {
  case AAC_QC:
  case AAC_SCALABLE:
  case AAC_SYS:
    if (windowSequence[MONO_CHAN] == EIGHT_SHORT_SEQUENCE) {
#if 1
      num_window_groups=8;
      window_group_length[0] = 1;
      window_group_length[1] = 1;
      window_group_length[2] = 1;
      window_group_length[3] = 1;
      window_group_length[4] = 1;
      window_group_length[5] = 1;
      window_group_length[6] = 1;
      window_group_length[7] = 1;
#else
      num_window_groups=1;
      window_group_length[0] = 8;
      window_group_length[1] = 0;
      window_group_length[2] = 0;
      window_group_length[3] = 0;
#endif
    } else {
      num_window_groups = 1;
      window_group_length[0] = 1;
    }
    break;
  
  default:
    break;
    } /* switch qc_select */

  /* Calculate sfb-offset table. Needed by (at least) TNS and LTP. */
  if ((qc_select != AAC_QC)
      )
  ntt_maxsfb( &ntt_index, sfb_width_table, nr_of_sfb, -1);
  for(ch = 0; ch < max_ch; ch++)
  {
    sfb_offset[ch][0] = 0;
    k=0;
    for(i = 0; i < nr_of_sfb[ch]; i++ )
    {
      sfb_offset[ch][i] = k;
      k += sfb_width_table[MONO_CHAN /***TM ch **/][i];
    }
    sfb_offset[ch][i] = k;
  }

  /******************************************************************************************************************************
  *
  * carry out TNS processing
  *
  ******************************************************************************************************************************/
  if (tns_enable || tvq_tns_enable) {
    for (i_ch=0; i_ch<max_ch; i_ch++) {
      TnsEncode(nr_of_sfb[MONO_CHAN],                  /* Number of bands per window */
                nr_of_sfb[MONO_CHAN],                  /* max_sfb */ 
                windowSequence[MONO_CHAN],                 /* block type */
                sfb_offset[MONO_CHAN],                 /* Scalefactor band offset table */
                spectral_line_vector[i_ch],            /* Spectral data array */
                tnsInfo[i_ch]);                        /* TNS info */
        }
  }


  /******************************************************************************************************************************
  *
  * compute energy and allowed distortion from the original spectrum
  *
  ******************************************************************************************************************************/
  /* These have to be done before prediction (not, for example, inside
     the quantizer) since the signal going to the quantizer is changed
     by the prediction. Do not use p_ratio after this. Use
     allowed_distortion (and p_energy) instead.
     1997-11-23 Mikko Suonio  */
  switch( qc_select ) {
  case AAC_QC:
  case AAC_SCALABLE:
  case AAC_SYS:
    {
      int group, i_ch, index, i, j, sfb;
      double dtmp;

      for (i_ch = 0; i_ch < max_ch; i_ch++) {
	index = 0;
	/* calculate the scale factor band energy in window groups  */
	for (group = 0; group < num_window_groups; group++) {
	  for (sfb = 0; sfb < nr_of_sfb[i_ch]; sfb++)
	    p_energy[i_ch][sfb + group * nr_of_sfb[i_ch]] = 0.0;
	  for (i = 0; i < window_group_length[group]; i++) {
	    for (sfb = 0; sfb < nr_of_sfb[i_ch]; sfb++) {