dec_tf.c

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

      break;
    default:
      CommonWarning("mat_sampleFreq Error !!\n");
      break;
    }
  
  frameData->layer[layer].sampleRate = sampling_rate_decoded;
  frameData->layer[layer].bitRate = frameData->od->ESDescriptor[layer]->DecConfigDescr.avgBitrate.value;

  if( strstr( decPara, "-aac_sys" )   
      || ( strstr(decPara, "-mp4ff") != NULL)
      ) {
    unsigned int x;
    char * lopPara;
    AUDIO_SPECIFIC_CONFIG *audSpC = &frameData->od->ESDescriptor[frameData->od->streamCount.value-1]->DecConfigDescr.audioSpecificConfig;
    
    switch (audSpC->channelConfiguration.value) {
    case 1 :numChannel=1;       
      break;
    case 2 :numChannel=2;       
      break;
    default: CommonExit(1,"wrong channel config");
    }

    for (i_ch=0; i_ch<numChannel; i_ch++) {
      if ((tfData->sampleBuf[i_ch]=(float*)malloc(block_size_samples*sizeof(float)))
          ==NULL)
        CommonExit(1,"Decode: memory allocation error");
    }
    /* currently fix coded !!! */
    if ( mainDebugLevel ) {
      printf(" TF scaleable decoding NEW flexmux  bitstream syntax\n");
    }

    fSample= sampling_rate_decoded ;

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

    med_win_in_long = 2;
    short_win_in_long = 8;
    delay_samples_decoded = 2048;
    channel_configuration = CHC_MONO;
    if (numChannel ==2){
      channel_configuration =CHC_DUAL;
    }
    qc_select = AAC_SCALABLE;
    tf_select = MDCT_AAC;
    transport_stream = AAC_RAWDATA_TSTREAM;

    if ( ( lopPara = strstr ( decPara, "-lop"))) {
      sscanf(&lopPara[4],"%d%d%f",&lopLong,&lopShort,&normBw);
      if ((lopLong < 0 ) || (lopLong > 950)) {
        CommonExit(-1,"\n lopLong parameter out of range: %d", lopLong);
      }
      if ((lopShort < 0 ) || (lopShort > 110)) {
        CommonExit(-1,"\n lopShort parameter out of range: %d", lopShort);
      }
      if ((normBw < 0.0F) || (normBw > 1.0F)) {
        CommonExit(-1,"\n normalized bandwidth out of range: %f", lopShort);
      }
      if ( mainDebugLevel ) {
        printf("lopLong=%d, lopShort=%d, normalized bandwidth=%3.2f\n", lopLong, lopShort, normBw);
      }
    }

/*     aacScaleableDecodeInit(); */
    if( strstr(decPara, "-mp4ff") == NULL)  {      
      for ( x = 0; x < frameData->od->streamCount.value; x++ ){
        frameData->layer[x].bitBuf = BsAllocBuffer(64000);
      }
    }
    
    tfData->tnsBevCore=0;     
    if( strstr( decPara, "-tnsBevCor" ) ) {
      if ( mainDebugLevel ) {
        printf("\n DON'T calc tns on core spectrum");
      }
      tfData->tnsBevCore=1;      
    }
  }  



  /* NTT_TVQ_SYS T.Ishikawa 980525 */
  if (frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.TFSpecificConfig.TFCodingType.value==2
      && layer==0){
    int iscl,mat_block_size,mat_total_bitrate;
    
    /* Decoding Condition Setting T.Ishikawa */
    mat_block_size = 
      ( frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.TFSpecificConfig.frameLength.value ? 960:1024) ;
    if ( mainDebugLevel>2 ) {
      printf("TTTTTTTTTTTT %5d TTTTTTTTTTT\n",mat_block_size);
    }
#if 0
    tvq_flag_960=0;
    if (mat_block_size==960) tvq_flag_960=1;
#endif

    /* NTT_VQ supports both LENINFO_STREAM and NO_SYNCWORD. */
    /*BsGetBit(header_stream, &ultmp, 2);
      transport_stream = (enum TRANSPORT_STREAM)ultmp;*/
    transport_stream = (enum TRANSPORT_STREAM)0;/* adhoc */

    /* If the ntt_varbit is off, number of bits
       per frame should be in the header. */
    /*BsGetBit(header_stream, &ultmp, 1);
      ntt_varbit = (enum NTT_VARBIT)ultmp;*/
    ntt_varbit = NTT_VARBIT_OFF;
    if (ntt_varbit == NTT_VARBIT_OFF){
      /*BsGetBit(header_stream, &ultmp, 32);
        frameNumBit = ultmp;*/
      /*            CommonWarning("TwinVQ(for System) is not supported !!\n");*/
      /*      frameNumBit = (int)(frameData->od->ESDescriptor[0]->DecConfigDescr.avg
              Bitrate.value*mat_block_size/mat_sampleFreq);
              if ( mainDebugLevel>2 ) {
              printf(" ###### %d ######\n",frameNumBit);
              }*/
    }
    /* long term predictor */
    /*    BsGetBit(header_stream, &ultmp, 1);
          ntt_LTP_SW = ultmp;*/
    ntt_LTP_SW = 0;/* adhoc */

    /* header for scalable coder */
    ntt_NSclLay = frameData->od->streamCount.value-1;
#if 1 /*990531*/
    /* ntt_NSclLay = the Number of Enhanced Layer */
    {
      int iexit;
      iexit =0;
      ntt_NSclLay = -1;
      for (iscl=0; ((iscl<(int)frameData->od->streamCount.value) && (iexit ==0)); iscl++)
      {
	  if(frameData->od->ESDescriptor[iscl]->DecConfigDescr.\
          audioSpecificConfig.specConf.TFSpecificConfig.TFCodingType.value==2)
	       ntt_NSclLay ++;
	  else iexit = 1000;
      }
    }
#endif
    ntt_IBPS = 
      (int)(frameData->od->ESDescriptor[0]->DecConfigDescr.avgBitrate.value);
    ntt_BPS = 
      (float)(frameData->od->ESDescriptor[0]->DecConfigDescr.avgBitrate.value); /* T.Ishikawa 980623 */
    if ( mainDebugLevel>2 ) {
      printf(" ///// ntt_IBPS %d /////\n",ntt_IBPS);
      printf(" ///// ntt_BPS %f /////\n",ntt_BPS);
    }
    for (iscl=1; iscl<=ntt_NSclLay; iscl++){
      ntt_IBPS_SCL[iscl-1]=(int)
        (frameData->od->ESDescriptor[iscl]->DecConfigDescr.avgBitrate.value);
      ntt_BPS_SCL[iscl-1]=(float)
        (frameData->od->ESDescriptor[iscl]->DecConfigDescr.avgBitrate.value);
      if ( mainDebugLevel>2 ) {
        printf(" ///// ntt_IBPS_SCL[%d] %d /////\n",
               iscl-1,ntt_IBPS_SCL[iscl-1]);
      }
    }



    for(mat_total_bitrate=0,iscl=0;iscl<ntt_NSclLay;iscl++)
      {
        mat_total_bitrate += ntt_IBPS_SCL[iscl];
      }
    mat_total_bitrate += ntt_IBPS;

    frameNumBit = (int)floor(mat_total_bitrate*mat_block_size/mat_sampleFreq);
    if ( mainDebugLevel >2) {
      printf(" ###### %d ######\n",frameNumBit);
    }
    block_size_samples = mat_block_size;
    delay_samples_decoded=mat_block_size;


  }



  /* calc. no of audio channels */
  max_ch = numChannel;
 
  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];
  }
  if (frameData && 
      (frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.TFSpecificConfig.TFCodingType.value==2)){
    qc_select= NTT_VQ_SYS;
  } 
  
  if (frameData && 
      (frameData->od->ESDescriptor[0]->DecConfigDescr.audioSpecificConfig.specConf.TFSpecificConfig.TFCodingType.value==2)){
    /* acutally need to look at the audio object type; it  is 7 for tvq */
    qc_select= NTT_VQ_SYS;
  } 

  /*always NOK_LTP for TVQ or SCALABLE */
  if (qc_select == NTT_VQ_SYS || qc_select == NTT_VQ)
    pred_type = NOK_LTP;
#if 0
  if (qc_select == AAC_SCALEABLE )
    pred_type = NOK_LTP;
#endif

  /* initialize inverse Q&C */
  switch(qc_select){
  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;
      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_SCALABLE:
    {
      aacDebugString = aacDebugStr;
      aac_decode_init ( sampling_rate_decoded,
                        aacDebugStr, 
                        block_size_samples, 
                        &sfbInfo,
                        pred_type);
#if 0 
      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, 
                   frameData->od->ESDescriptor[0]->DecConfigDescr.audioSpecificConfig.channelConfiguration.value,
                   (frameData->od->ESDescriptor[0]->DecConfigDescr.audioSpecificConfig.specConf.TFSpecificConfig.frameLength.value ? 960:1024) ,
                   &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;

      }
#endif
      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->output_select =   frameData->scalOutSelect;
  tfData->prev_windowShape[0] = prev_windowShape[0];
  tfData->prev_windowShape[1] = prev_windowShape[1];

  StatisticsAacInitV1 ( );

  /* nok 990113 ... */
  tfData->pred_type=pred_type;
/*
tfData->pred_type = NOK_LTP;
fprintf(stderr, "LLLLLLLin INInew %5d %5d \n", 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;
  /* create time sample modulo buffer for core coder */
#define     MAX_CORE_DELAY 16384