dec_tf.c

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

  }

  for (x=0;x<MAX_TF_LAYER;x++){
    for (i_ch=0; i_ch<max_ch; i_ch++){
      spectral_line_vector[x][i_ch] = (double*)calloc(block_size_samples,
                                                      sizeof(double));
      tfData->spectral_line_vector[x][i_ch]=spectral_line_vector[x][i_ch];
    }
  }
  for (i_ch=0; i_ch<max_ch; i_ch++){
    time_sample_vector[i_ch] = (double*)calloc(block_size_samples,
                                               sizeof(double));
    tfData->time_sample_vector[i_ch]=time_sample_vector[i_ch];
  }
  /* son_NBCpp */
  {
    int i_ch; /* added 971010 YT*/
    int band;
    for (i_ch=0; i_ch<max_ch; i_ch++){ /* added 971010 YT*/
      
      spectral_line_vector_for_gc[i_ch] = (double *)calloc(block_size_samples, sizeof(double));
      imdctBufForGC[i_ch] = (double *)calloc(block_size_samples*2, sizeof(double));
      DBandSigBufForOverlapping[i_ch] = (double **)calloc(NBANDS, sizeof(double *));
      DBandSigBuf[i_ch] = (double **)calloc(NBANDS, sizeof(double *));
      gainInfo[i_ch] = (GAINC **)calloc(NBANDS, sizeof(GAINC *));
      for (band = 0; band < NBANDS; band++) {
        DBandSigBufForOverlapping[i_ch][band] =
          (double *)calloc(block_size_samples/NBANDS*2, sizeof(double));
        DBandSigBuf[i_ch][band] =
          (double *)calloc(block_size_samples/NBANDS, sizeof(double));
        gainInfo[i_ch][band] = (GAINC *)calloc(short_win_in_long, sizeof(GAINC));
      }
    } /* end of for(i_ch...)*/
  }
  
  /* initialize inverse Q&C */
  switch(qc_select){
  case NTT_VQ:
    {
      int iscl;
      float t_bit_rate_scl;
      char *p_ctmp;
      
      /* bitrate control */
      t_bit_rate_scl = 0.;
      for (iscl=0; iscl<ntt_NSclLay; iscl++){
        t_bit_rate_scl += (float)ntt_IBPS_SCL[iscl];
      }
      /* initalization of base decoder */
      if ( mainDebugLevel>2 )  fprintf(stderr,"TTTTTT : bitRate %f ntt_BPS %d\n",bitRate,ntt_IBPS);
	  
      ntt_TfInit((float)fSample, (float)ntt_IBPS+t_bit_rate_scl/*(float)(ntt_IBPS+t_bit_rate_scl)*//*(float)bitRate*/, t_bit_rate_scl, max_ch,
                 block_size_samples, &ntt_index, &ntt_index_scl);
      /**TM9002
         ntt_nok_lt_pred_dec_init(&ntt_info);
      */
      aac_decode_init(sampling_rate_decoded,
                      aacDebugStr, block_size_samples, &sfbInfo, pred_type);

      /* initialization of scalable coders */
      /*NNNN
        ntt_TBITS_FR_SCL = 0;
        i*/
      /* set number of scalable layers to be decoded */
      ntt_NSclLayDec = ntt_NSclLay;
      if( ( p_ctmp=strstr( decPara, "-nttDecLyr " ) ) ) {
        if(sscanf(p_ctmp+11, "%d", &ntt_NSclLayDec) == 0){
          CommonExit(1, "Encode: parameter of -nttDecLyr switch not found");
        }
      }
      if (ntt_NSclLayDec > ntt_NSclLay) ntt_NSclLayDec = ntt_NSclLay;
      for (iscl=0; iscl<ntt_NSclLay; iscl++){
        ntt_scale_init ( iscl, 
                         ntt_NSclLayDec, 
                         ntt_IBPS_SCL[iscl], 
                         (float)fSample, 
                         &ntt_index, 
                         &ntt_index_scl);
	nttData->nttDataScl = ntt_index_scl.nttDataScl;
        if( strstr( decPara, "-nttSclMsg" ) ) {
          ntt_scale_message(iscl, ntt_IBPS, ntt_IBPS_SCL);
        }
      }
      ntt_index.nttDataScl->ntt_NSclLay = ntt_NSclLay;
      ntt_index_scl.nttDataScl->ntt_NSclLay = ntt_NSclLay;
      ntt_index.nttDataScl->ntt_NSclLayDec = ntt_NSclLayDec;
      ntt_index_scl.nttDataScl->ntt_NSclLayDec = ntt_NSclLayDec;
      nttData->nttDataBase = ntt_index.nttDataBase;
      nttData->nttDataScl = ntt_index_scl.nttDataScl;

      /* T.Ishikawa 981014 */
      if ( mainDebugLevel>2 ) {
        printf("<<OLD>> BAND %f BPS %d\n",ntt_index.nttDataBase->bandUpper,
               ntt_IBPS);
        for(iscl=0;iscl<ntt_NSclLay;iscl++)
          printf("<<OLD>> BPS_SCL[%d] %d\n",iscl,ntt_IBPS_SCL[iscl]);
        printf("<<OLD>> CH %d\n",numChannel);
        for(iscl=0;iscl<4;iscl++)
          printf("<<OLD>> AC_TOP[%d] %f , AC_BTM[%d] %f\n",iscl,
                 ntt_index_scl.nttDataScl->ac_top[0][0][iscl],iscl,
                 ntt_index_scl.nttDataScl->ac_btm[0][0][iscl]);

        if (ntt_NSclLay > 0){
          printf( "<<>><<>> NUMBER OF LAYERS TO BE DECODED: %d\n",
                  ntt_NSclLayDec);
        }
      }
      break;
    }

  case NTT_VQ_SYS: /* T.Ishikawa 980525 */
    {
      int iscl;
      float t_bit_rate_scl,tomo_ftmp;
      char *p_ctmp;

      if ( mainDebugLevel ) {
        printf(" ####### TwinVQ(FlexMux) Init %x\n",qc_select);
      }
      /* bitrate control */
      t_bit_rate_scl = 0.;
      for (iscl=0; iscl<ntt_NSclLay; iscl++){
        t_bit_rate_scl += (float)ntt_IBPS_SCL[iscl];
      }

      tomo_ftmp=(float)ntt_IBPS+t_bit_rate_scl;
      /*      bitRate -= (float)((int)( ((31.0*sampling_rate_decoded/1024.0)*(float)
              (ntt_NSclLay+1) + 25.0*sampling_rate_decoded/1024.0)));*/
      /*      bitRate -= (float)((int)( ((31.0*24000.0/1024.0)*(float)(ntt_NSclLay+1
              ) + 25.0*24000.0/1024.0)));*/
      if ( mainDebugLevel>2 ) {
        printf(" <<<< DecTfInit : tomo_ftmp %f >>> \n",tomo_ftmp);
      }
      /* initalization of base decoder */
      ntt_TfInit((float)fSample, (float)tomo_ftmp, t_bit_rate_scl, 
                 max_ch, block_size_samples, &ntt_index, &ntt_index_scl);
      /*TM9902*
        ntt_nok_lt_pred_dec_init(&ntt_info);
      */
      sampling_rate_decoded = (long int)fSample;
      fprintf(stderr,"sampling_rate_decoded %ld\n",sampling_rate_decoded);
      aac_decode_init(sampling_rate_decoded,
                      aacDebugStr, block_size_samples, &sfbInfo, pred_type);

      /* initialization of scalable coders */
      /*NN
        ntt_TBITS_FR_SCL = 0;
        i*/
      /* set number of scalable layers to be decoded */
      ntt_NSclLayDec = ntt_NSclLay;
      if( ( p_ctmp=strstr( decPara, "-nttDecLyr " ) ) ) {
        if(sscanf(p_ctmp+11, "%d", &ntt_NSclLayDec) == 0){
          CommonExit(1, "Encode: parameter of -nttDecLyr switch not found");
        }
      }
     
      if (ntt_NSclLayDec > ntt_NSclLay) ntt_NSclLayDec = ntt_NSclLay;
      for (iscl=0; iscl<ntt_NSclLay; iscl++){
        ntt_scale_init ( iscl, 
                         ntt_NSclLayDec, 
                         ntt_IBPS_SCL[iscl], 
                         (float)fSample, 
                         &ntt_index, 
                         &ntt_index_scl);
	nttData->nttDataScl = ntt_index_scl.nttDataScl;
	
	if( strstr( decPara, "-nttSclMsg" ) ) {
          ntt_scale_message(iscl, ntt_IBPS, ntt_IBPS_SCL);
        }
      }
      ntt_index.nttDataScl->ntt_NSclLayDec = ntt_NSclLayDec;
      ntt_index_scl.nttDataScl->ntt_NSclLayDec = ntt_NSclLayDec;
      ntt_index.nttDataScl->ntt_NSclLay = ntt_NSclLay; 
      ntt_index_scl.nttDataScl->ntt_NSclLay = ntt_NSclLay; 
      tfData->output_select = ntt_NSclLayDec;
      scalOutSelect = ntt_NSclLayDec;
      nttData->nttDataBase = ntt_index.nttDataBase;
      nttData->nttDataScl = ntt_index_scl.nttDataScl;
      
      /* T.Ishikawa 980623 */
      t_bit_rate_scl=0;
      for(iscl=0;iscl<ntt_NSclLay;iscl++)
        {
          /* T.Ishikawa 980703 */
          t_bit_rate_scl += (float)ntt_IBPS_SCL[iscl]*numChannel;
        }


      if ( mainDebugLevel>2 ) {
        printf("BAND %f BPS %d\n",ntt_index.nttDataBase->bandUpper,
               ntt_IBPS);
        for(iscl=0;iscl<ntt_NSclLay;iscl++)
          printf("BPS_SCL[%d] %d\n",iscl,ntt_IBPS_SCL[iscl]);
        printf("CH %d\n",numChannel);
        for(iscl=0;iscl<4;iscl++)
          printf("AC_TOP[%d] %f , AC_BTM[%d] %f\n",iscl,
                 ntt_index_scl.nttDataScl->ac_top[0][0][iscl],iscl,
                 ntt_index_scl.nttDataScl->ac_btm[0][0][iscl]);
        if (ntt_NSclLay > 0){
          printf( "<<>><<>> NUMBER OF LAYERS TO BE DECODED: %d\n",
                  ntt_NSclLayDec);
        }
      }
      break;
    }

  case AAC_QC:
    {
      aacDebugString = aacDebugStr;
      aac_decode_init ( sampling_rate_decoded,
                        aacDebugStr,
                        block_size_samples,
                        &sfbInfo,
                        pred_type);
      break;    /* HP 970407 */
    }

  case AAC_SCALABLE:
    {

      aacDebugString = aacDebugStr;
      aac_decode_init ( sampling_rate_decoded,
                        aacDebugStr, 
                        block_size_samples, 
                        &sfbInfo,
                        pred_type);
      if (frameData && 
          (frameData->od->ESDescriptor[0]->DecConfigDescr.audioSpecificConfig.specConf.TFSpecificConfig.TFCodingType.value==2)){
        ntt_TfInit((float)fSample, 
		   (float)(frameData->od->ESDescriptor[0]->DecConfigDescr.avgBitrate.value), 
		   0.0, numChannel, block_size_samples, &ntt_index, &ntt_index_scl);
        ntt_index.nttDataScl->ntt_NSclLayDec = ntt_NSclLayDec;
        ntt_index_scl.nttDataScl->ntt_NSclLayDec = ntt_NSclLayDec;
        ntt_index.nttDataScl->ntt_NSclLay = ntt_NSclLay; 
        ntt_index_scl.nttDataScl->ntt_NSclLay = ntt_NSclLay; 
	nttData->nttDataBase = ntt_index.nttDataBase;
	nttData->nttDataScl = ntt_index_scl.nttDataScl;
      }
      break;
    }


  default:
    CommonExit(-1,"\nerror in switch");
  }
  for (i_ch=0; i_ch<max_ch; i_ch++){
    overlap_buffer[i_ch] = (double*)calloc(block_size_samples,
                                           sizeof(double));
    tfData->overlap_buffer[i_ch]=    overlap_buffer[i_ch];
  }
  tfData->sfbInfo = sfbInfo;
  tfData->block_size_samples = block_size_samples;
  tfData->prev_windowShape[0] = prev_windowShape[0];
  tfData->prev_windowShape[1] = prev_windowShape[1];
  StatisticsAacInitV1 ( );

  /* nok 990113 ... */
  tfData->pred_type=pred_type;
  if(pred_type == NOK_LTP)
    for(i_ch = 0; i_ch < numChannel; i_ch++)
      {
        nok_lt_status[i_ch] = (NOK_LT_PRED_STATUS *)mal1(sizeof(*nok_lt_status[0]));
      
        nok_init_lt_pred(nok_lt_status[i_ch]);
        tfData->nok_lt_status[i_ch]=nok_lt_status[i_ch];
      }
  /* ... nok */
  tvq_debug_level = mainDebugLevel;

}

void DecTfInitNew (
                   char*               decPara,          /* in: decoder parameter string */    
                   char*               aacDebugStr,
                   HANDLE_BUFFER*      hVm,
                   HANDLE_BUFFER*      hHcrSpecData,
                   FRAME_DATA*         frameData,
                   TF_DATA*            tfData,
                   LPC_DATA*           lpcData,
                   ntt_DATA*           nttData,
                   int                 mainDebugLevel,
                   int                 layer
                   )
{

  int                 numChannel;       /* in: num audio channels */
  float               fSample;          /* in: sampling frequancy [Hz] */
  int                 profile;          /* in: bitstream profile as indicated in the ADIF header */
    
  int           delay_samples_decoded = 0;
  int           x; 
  int           i_ch;
  WINDOW_SHAPE prev_windowShape[2] = {WS_FHG, WS_FHG}; 
  float mat_sampleFreq = 0;
  int block_size_samples  ;
  /* +++++++++++++++++++++++++++++++++++++++++ */
  int ntt_NSclLay;
  int ntt_NSclLayDec;
  int ntt_LTP_SW; /*dh990414*/
  int ntt_IBPS, ntt_IBPS_SCL[8];
  float ntt_BPS, ntt_BPS_SCL[8];
  ntt_INDEX           ntt_index;
  ntt_INDEX           ntt_index_scl;
  /* +++++++++++++++++++++++++++++++++++++++++ */
  *hVm          = CreateBuffer(VIRTUELL);
  *hHcrSpecData = CreateBuffer(AAC_MAX_INPUT_BUF_BITS);


  if( strstr( decPara, "-aac_sys" )
      || ( strstr(decPara, "-mp4ff") != NULL)
      ) { profile = LC_Profile; }

  /* set profile */
  mc_info.profile = profile;

  block_size_samples 
    = ( frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.TFSpecificConfig.frameLength.value ? 960:1024);

  switch
    (frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.samplingFreqencyIndex.value)
    {
    case 0:
      mat_sampleFreq=96000.0;
      sampling_rate_decoded=96000;
      break;
    case 1:
      mat_sampleFreq=88200.0;
      sampling_rate_decoded=88200;
      break;
    case 2:
      mat_sampleFreq=64000.0;
      sampling_rate_decoded=64000;
      break;
    case 3:
      mat_sampleFreq=48000.0;
      sampling_rate_decoded=48000;
      break;
    case 4:
      mat_sampleFreq=44100.0;
      sampling_rate_decoded=44100;
      break;
    case 5:
      mat_sampleFreq=32000.0;
      sampling_rate_decoded=32000;
      break;
    case 6:
      mat_sampleFreq=24000.0;
      sampling_rate_decoded=24000;
      break;
    case 7:
      mat_sampleFreq=22050.0;
      sampling_rate_decoded=22050;
      break;
    case 8:
      mat_sampleFreq=16000.0;
      sampling_rate_decoded=16000;
      break;
    case 9:
      mat_sampleFreq=12000.0;
      sampling_rate_decoded=12000;
      break;
    case 10:
      mat_sampleFreq=11025.0;
      sampling_rate_decoded=11025;
      break;
    case 11:
      mat_sampleFreq=8000.0;
      sampling_rate_decoded=8000;
      break;
    case 12:
    case 13:
    case 14:
    case 15:
      CommonWarning("reserved \n");