scal_enc_frame.c

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

     case 48000:
     case 44100: 
      FssBwShort = 18; break;
     case 32000: 
      FssBwShort = 28; break;
     case 22050:
     case 24000:
      FssBwShort = 36; break;
     case 16000:
      FssBwShort = 56; break;
    }

    for( i=0; i<8; i++ ) {  /* always diff for short for now */
      if (diffContrSimu){
        FssControl[i] = DC_SIMUL;
      } else {
        FssControl[i] = DC_DIFF;
      }
    }
   } else {
    no_win        = 1;
    no_spec_coeff = blockSizeSamples;
    diffBandWidth = sfb_width_table;

    switch( samplRate ) {
     case 48000 :
     case 44100 : 
      numDiffBands = 20; break;
     case 32000 : 
      numDiffBands = 24; break;
     case 22050 :
     case 24000 :
      numDiffBands = 32; break;
     case 16000 :
      numDiffBands = 32; break;
    default :
      CommonExit(-1,"\nerror in CalcFssControl");
      break;
    }

    for( sb=0; sb<numDiffBands; sb++ ) {
      if (diffContrSimu){
        FssControl[sb] = DC_SIMUL;
      } else {
        FssControl[sb] = DC_DIFF;
      }
    }

    offset = 0;
    for( sb=0; sb<numDiffBands; sb++ ) {
      e_full[sb] = 0;
      e_diff[sb] = 0;

      for( i=0; i<sfb_width_table[sb]; i++ ) {
        e_full[sb] +=  p_full[offset] * p_full[offset];
        e_diff[sb] +=  p_diff[offset] * p_diff[offset];
        offset++;
      }
      if( e_diff[sb] >= e_full[sb] ) {
        FssControl[sb] = DC_SIMUL;
      }
#ifdef DEL_ADJ
      if( log10(e_full[sb] + FLT_MIN) > 0 ) {
        avg_gain[sb] += log10(e_full[sb] + FLT_MIN) - log10(e_diff[sb] + FLT_MIN);
      }
#endif
    }
    
#ifdef DEL_ADJ
    printf( "\nE_full :  " );
    for( sb=0; sb<numDiffBands; sb++ ) {
      printf( "%8.3f", 10*log10(e_full[sb] + FLT_MIN) );
    }
    printf( "\nE_diff :  " );
    for( sb=0; sb<numDiffBands; sb++ ) {
      printf( "%8.3f", 10*log10(e_diff[sb] + FLT_MIN) );
    }
    printf( "\nA_gain :  " );
    for( sb=0; sb<numDiffBands; sb++ ) {
      printf( "%8.3f", 10*avg_gain[sb]/_cnt );
    }
    _cnt++;
    printf( "\n" );
#endif
  }
 
  for( win=0; win<no_win; win++ ) {
    int offset   = win*no_spec_coeff;
    int dcf_offs = win;
    int sum      = 0;
    for( sb=0; sb<numDiffBands; sb++ ) {
      if( FssControl[dcf_offs+sb] == DC_SIMUL ) {
        for( i=0; i<diffBandWidth[sb]; i++ ) {
          p_diff[offset+i] = p_full[offset+i];
        }
      }
      offset += diffBandWidth[sb];
      sum    += diffBandWidth[sb];
    }
    for( i=0; i<(no_spec_coeff-sum); i++ ) {
      p_diff[offset+i] = p_full[offset+i];
    }
  }
}

/********************************************************************************/

/********************************************************************************/

static void aacEncodeScalHeader(
  BsBitStream  *fixed_stream,
  BsBitBuffer  *gcBitBufCh,   /* bit buffer for gain_control_data() */
  WINDOW_SEQUENCE  windowSequence,
  int          max_sfb,
  int          ch_no_layer,   /* no of channels in the current layer */
  int          ch_no_max,     /* no of channels of the last layer */
  int          ch_no_core,
  long         samplRate,
  enum DC_FLAG FssControl[MAX_TIME_CHANNELS][SFB_NUM_MAX],
  enum JS_MASK ms_mask[],
  int          num_window_groups,
  int          window_group_length[],
  TNS_INFO     *tnsInfo,
  ENC_FRAME_DATA* frameData,
  QC_MOD_SELECT qc_select,
  NOK_LT_PRED_STATUS* nok_lt_status)
{
  int ch;
  int reducedInfo=0;
  int tvq_tns_present = 0; /* <- to be implemented */
 
  if ( frameData && (frameData->od->streamCount.value > 1) 
       && (frameData->od->ESDescriptor[0]->DecConfigDescr.audioSpecificConfig.audioDecoderType.value==0) 
       && (frameData->od->ESDescriptor[0]->DecConfigDescr.audioSpecificConfig.specConf.TFSpecificConfig.TFCodingType.value==2) ) {
    /* core is a TwinVQ */
    reducedInfo=1;
  }
  write_ics_info( max_sfb, windowSequence, 
                  fixed_stream, WS_FHG, 
                  num_window_groups, 
                  window_group_length,
                  reducedInfo,
                  qc_select,
                  pred_type, 
                  &nok_bwp_status[MONO_CHAN],
                  (nok_lt_status) ? nok_lt_status : NULL,
		  (nok_lt_status) ? nok_lt_status + 1 : NULL,
		  (ch_no_layer == 2));

  if( ch_no_layer > 1 ) {
    BsPutBit( fixed_stream, 2, 2 ); /*all bands MS */
  }

  
  /* tns_channel_mono_layer data */
  if(tvq_tns_present)
    BsPutBit(fixed_stream, 0, 1);
    

  for( ch=0; ch<ch_no_max; ch++ ) {

    /* TNS data */
    if (tnsInfo) {              /* TNS active */
      write_tns_data( tnsInfo, windowSequence, fixed_stream, 1 );
    } else {                    /* switch it off */
      BsPutBit(fixed_stream,0,1);
    }
    
    /* FSS data */
    if( (ch_no_core > 0) && (ch < ch_no_layer) ) { 
      int fss_bands;
      if( windowSequence == EIGHT_SHORT_SEQUENCE) {
        fss_bands = 8;
      } else {
        switch (samplRate) {
        case 48000: fss_bands = 20; break;
        case 32000: fss_bands = 24; break;
        case 24000: fss_bands = 32; break;
        case 16000: fss_bands = 32; break;
        default: CommonExit( 1, "scalable encoder doesn't support this sampling rate currently" );
        }
      }
      aacEncodeFssData( fixed_stream, windowSequence, fss_bands, FssControl[ch], NULL );
    } else { /* if (ch_no_core >0) */

      /* LTP data */
      if(pred_type==NOK_LTP)
        {fprintf(stderr, "NNNN LTP active \n");
	nok_ltp_encode(fixed_stream, windowSequence, max_sfb,
                       nok_lt_status + ch, qc_select, NO_CORE, -1);
      }
      else
        BsPutBit( fixed_stream, 0, 1); /* no LTP in use */
    } 
  }
}


/********************************************************************************/

/********************************************************************************/

static void aacEncodeLayerHeader(
  BsBitStream  *fixed_stream,
  WINDOW_SEQUENCE  windowSequence,
  int          max_sfb,
  int          max_sfb_prev_layer,
  enum DC_FLAG msFssControl[MAX_TIME_CHANNELS][SFB_NUM_MAX],
  enum JS_MASK ms_mask[],
  int          mono_stereo_flag,
  int          ch_no_layer,    /* no of channels in the current layer */
  ENC_FRAME_DATA* frameData
)
{
  if( windowSequence == EIGHT_SHORT_SEQUENCE ){
    BsPutBit( fixed_stream, max_sfb, 4 ) ;/* max_sfb*/
  } else {
    BsPutBit( fixed_stream, max_sfb, 6 ) ;/* max_sfb */
  }

  /* ms mask */
  if( ch_no_layer > 1 ) {
    BsPutBit( fixed_stream, 2, 2 ); /*all bands MS */
  }

  if( mono_stereo_flag ) {
    int ch;
    for( ch=0; ch<2; ch++ ) {
      aacEncodeFssData( fixed_stream, windowSequence, max_sfb_prev_layer, msFssControl[ch], ms_mask );
    }
  }

}


/********************************************************************************/

/********************************************************************************/

int aacScaleableEncode(
  double      *p_spectrum[MAX_TIME_CHANNELS],
  double      energy[MAX_TIME_CHANNELS][MAX_SCFAC_BANDS],
  double      allowed_dist[MAX_TIME_CHANNELS][MAX_SCFAC_BANDS],
  WINDOW_SEQUENCE  blockType[MAX_TIME_CHANNELS],
  int         sfb_width_table[MAX_TIME_CHANNELS][MAX_SCFAC_BANDS],
  int         nr_of_sfb[MAX_TIME_CHANNELS],
  int         average_block_bits,			
  int         available_bitreservoir_bits,
  int         padding_limit,
  BsBitStream *mainStream,
  BsBitStream *var_stream,
  int         nr_of_chan,
  double      *p_reconstructed_spectrum[MAX_TIME_CHANNELS],
  int         useShortWindows,
  WINDOW_SHAPE     windowShape[MAX_TIME_CHANNELS],      /* offers the possibility to select different window functions */
  int         aacAllowScalefacs,
  int         blockSizeSamples,
  int         frameMaxNumBit,
  float       **timeSig,
  long        bitRate,
  long        samplRate,
  QC_MOD_SELECT qc_select,
  TNS_INFO *tnsInfo[MAX_TIME_CHANNELS],
  ENC_FRAME_DATA* frameData,
  enum CORE_CODEC coreCodecIdx
) 
{
  static int codedFixedBits;
  static BsBitStream *dynpartStream;
  int dynpartBits;
  int i, lay, ch;
  int frameBits, rem_bits;
  OP_MODE_INFO omi;
  enum DC_FLAG FssControl[MAX_TIME_CHANNELS][SFB_NUM_MAX];
  enum DC_FLAG msFssControl[MAX_TIME_CHANNELS][SFB_NUM_MAX];
  BsBitStream *fixedStream;
  enum JS_MASK ms_mask[SFB_NUM_MAX];
  int num_window_groups, window_group_length[8];


  if(pred_type == NOK_LTP)
    pred_type = PRED_NONE;
  
  memcpy( &omi, &opm_info[op_mode], sizeof(OP_MODE_INFO) );
  /* intermediate_layers = (op_mode >= 7) ? 1 : 0; */
  omi.tf_layers += intermediate_layers;

  /* start of bitstream composition */
  frameBits = bitRate * blockSizeSamples /samplRate;
  fixedStream = BsOpenBufferWrite(fixedPartBuf[granule]);

  if( granule == 0 ) {
    codedFixedBits = 0;

    dynpartStream = BsOpenBufferWrite( dynpartBuf );
    if (frameData==NULL){
      aacEncodeScalFrameHeader( fixedStream, op_mode, coreCodecIdx, samplRate, bitRate, intermediate_layers, 0 ,frameData);
    }
  }
  
  /* ms matrix */
  if( omi.ch_no_max == 2 ) {  /* always MS for now */
    for( i=0; i<blockSizeSamples; i++ ) {
      double dtmp = p_spectrum[0][i] + p_spectrum[1][i];
      p_spectrum[0][i] = (p_spectrum[0][i] - p_spectrum[1][i]) * 0.5;
      p_spectrum[1][i] = dtmp * 0.5;
    }
    for( i=0; i<SFB_NUM_MAX; i++ ) {
      ms_mask[i] = JS_MASK_MS;
    }
  }

  /* Core Coder */
  if( omi.ch_no_core > 0 ) {
    double coreSpectrum[MAX_TIME_CHANNELS][2048];

    if( omi.ch_no_max > omi.ch_no_core ) {
      for( i=0; i<blockSizeSamples; i++ ) {
        for( ch=1; ch<omi.ch_no_max; ch++ ) {
          timeSig[MONO_CHAN][i] += timeSig[ch][i];
        }
        timeSig[MONO_CHAN][i] *= 0.5;
      }
      for( ch=1; ch<omi.ch_no_max; ch++ ) {   /* copy S-spectrum */
        for( i=0; i<blockSizeSamples; i++ ) {
          diffSpectrum[ch][i] = p_spectrum[ch][i];
        }
      }
    }
    EncodeCore( fixedStream, timeSig[MONO_CHAN], 
                coreDecodedSampleBuf[MONO_CHAN], 
                blockSizeSamples, downsamplFac,
                coreCodecIdx);

    mdct_core(NULL,
              coreDecodedSampleBuf[MONO_CHAN], 
              coreSpectrum[MONO_CHAN],
              0, 
/*               samplRate,  */
              blockSizeSamples );

    if (tnsInfo) {

      int sfb, k, sfb_offset[ 100 ];
      
      /* calc. sfb offset table */
      for (sfb=k=0; sfb<nr_of_sfb[MONO_CHAN]; sfb++) {
        sfb_offset[sfb] = k;
        k += sfb_width_table[MONO_CHAN][sfb];
      }
      sfb_offset[sfb] = k;
      
      TnsEncode2(nr_of_sfb[MONO_CHAN],                  /* Number of bands per window */
                 nr_of_sfb[MONO_CHAN],                  /* max_sfb */ 
                 blockType[MONO_CHAN],                  /* block type */
                 sfb_offset,                            /* Scalefactor band offset table */
                 coreSpectrum[MONO_CHAN],               /* Spectral data array */
                 tnsInfo[MONO_CHAN],                    /* TNS info */
		 0);                                    /* Analysis filter. */