enc_tf.c

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

      qc_select = NTT_VQ_SYS;
    }
  
  if( strstr( encPara, "-pp_aac" ) ) {
    pp_select = AAC_PP;
  }
  if( strstr( encPara, "-qc_aac" ) ) {
    qc_select = AAC_QC;
    tf_select = MDCT_AAC;
  }
  
  if( strstr( encPara, "-qc_aac_960" ) ) {
    qc_select = AAC_QC;
    tf_select = MDCT_AAC;
    useShortWindows=1;
    block_size_samples=960;
  }

  /* case aac_sys: allows the use of TVQ as core */
  if( strstr( encPara, "-aac_sys" ) 
  || ( strstr(encPara, "-mp4ff") != NULL)
    ) {
    qc_select = AAC_SYS;
    tf_select = MDCT_AAC;
    useShortWindows=1;
    win_switch_mode = STATIC_LONG;
    
    frameData->opMode = 2;
    if( (p_ctmp = strstr( encPara, "-mode" )) ) {
      sscanf( p_ctmp+5, "%d", &frameData->opMode );
    }
    frameData->layer[0].sampleRate=sampling_rate ;
    coreCodecIdx=NO_CORE;

    switch (frameData->opMode) {
    case 0 : 
      coreCodecIdx=NTT_TVQ;
      if ((p_ctmp=strstr(encPara, "-core_coder"))) {
        int utmp;
        sscanf(p_ctmp+11,"%d", &utmp);
        coreCodecIdx = (enum CORE_CODEC) utmp;
      } 
      if( (p_ctmp=strstr( encPara, "-core_br" )) ) {
        sscanf( p_ctmp+8, "%d", &frameData->layer[0].bitRate  );
      }

      switch(coreCodecIdx) {
      case NTT_TVQ:  
        block_size_samples=1024;
        break;
      default:
         CommonExit(-1,"core coder not yet supported for this mode"); 
      }
      break;
    case 1 :
      coreCodecIdx=NTT_TVQ;
      if ((p_ctmp=strstr(encPara, "-core_coder"))) {
        int utmp;
        sscanf(p_ctmp+11,"%d", &utmp);
        coreCodecIdx = (enum CORE_CODEC) utmp;
      } 
      if( (p_ctmp=strstr( encPara, "-core_br" )) ) {
        sscanf( p_ctmp+8, "%d", &frameData->layer[0].bitRate  );
      }

      switch(coreCodecIdx) {
      case NTT_TVQ:  
        block_size_samples=1024;
#if 0
        frameData->layer[0].sampleRate=sampling_rate ;
#endif
        break;
      default:
         CommonExit(-1,"core coder not yet supported for this mode"); 
      }
      break;
    
    case 2 : 
      block_size_samples = 1024; /* AAC sys mode without core codec */
      frameData->layer[0].bitRate=bit_rate ; /* bitrate for AAC */
      frameData->layer[0].sampleRate=sampling_rate ;
      break;
    case 3 : CommonExit(-1,"this mode is not supported for aac_sys"); 
      break;
    case 4 :
    case 5 :
    case 6 :
      block_size_samples = 1024; /* AAC sys mode with core codec */
      coreCodecIdx=NTT_TVQ;
      if ( ( p_ctmp=strstr(encPara, "-core_coder" ) ) ) {
        int utmp;
        sscanf(p_ctmp+11,"%d", &utmp);
        coreCodecIdx = (enum CORE_CODEC) utmp;
      }       
      if( (p_ctmp=strstr( encPara, "-core_br" )) ) {
        sscanf( p_ctmp+8, "%d", &frameData->layer[0].bitRate  );
      }

      switch(coreCodecIdx) {
      case NTT_TVQ:  
        block_size_samples=1024;
#if 0 /*NN*/
        frameData->layer[0].sampleRate=sampling_rate ;
        frameData->layer[1].bitRate=bit_rate - frameData->layer[0].bitRate ; /* bitrate for AAC */
        frameData->layer[1].sampleRate=sampling_rate ;
        frameData->layer[2].sampleRate=sampling_rate ;
        frameData->layer[3].sampleRate=sampling_rate ;
        frameData->layer[4].sampleRate=sampling_rate ;
#endif
        break;
      default:
         CommonExit(-1,"core coder not yet supported for this mode"); 
      }
      break;
    
    case 7 :
      block_size_samples = 1024; /* AAC sys mode without core codec */
      coreCodecIdx=NTT_TVQ;
      if ( ( p_ctmp=strstr(encPara, "-core_coder" ) ) ) {
        int utmp;
        sscanf(p_ctmp+11,"%d", &utmp);
        coreCodecIdx = (enum CORE_CODEC) utmp;
      }             
      if( (p_ctmp=strstr( encPara, "-core_br" )) ) {
        sscanf( p_ctmp+8, "%d", &frameData->layer[0].bitRate  );
      }

      switch(coreCodecIdx) {
      case NTT_TVQ:  
        block_size_samples=1024;
        frameData->layer[0].sampleRate=sampling_rate ;
        frameData->layer[1].bitRate= (bit_rate - frameData->layer[0].bitRate)/2 ; /* bitrate for AAC */
        frameData->layer[1].sampleRate=sampling_rate ;
        frameData->layer[2].bitRate=bit_rate 
          -  frameData->layer[1].bitRate - frameData->layer[0].bitRate; /* bitrate for AAC */
        frameData->layer[2].sampleRate=sampling_rate ;
        break;
      default:
         CommonExit(-1,"core coder not yet supported for this mode"); 
      }
      break;
    case 11 : 
      block_size_samples = 1024; /* AAC sys mode without core codec */
      frameData->layer[0].bitRate=bit_rate/2 ; /* bitrate for AAC */
      frameData->layer[0].sampleRate=sampling_rate ;
      frameData->layer[1].bitRate=bit_rate - frameData->layer[0].bitRate ; /* bitrate for AAC */
      frameData->layer[1].sampleRate=sampling_rate ;
      break;

    default: CommonExit(-1,"this mode is not yet supported for aac_sys"); 
      break;
    }
    /* check if core coder is TVQ */
    if(coreCodecIdx==NTT_TVQ){
       double tvq_br;
       int iscl;
       initTvqSys( numChannel,	   /* in: num audio channels */
                sampling_rate_f,   /* in: sampling frequancy [Hz] */         
                bit_rate_f,        /* in: bit rate [bit/sec] */
                encPara,	   /* in: encoder parameter string */
                quantDebugLevel,   /* in : quantDebugLevel */
                frameNumSample,	   /* out: num samples per frame */
                delayNumSample,	   /* out: encoder delay (num samples) */
                frameData,
		&ntt_index,
		&ntt_index_scl,
		nttData); 
        ntt_NSclLay=ntt_index.nttDataScl->ntt_NSclLay; 
	
        tvq_br = frameData->layer[0].bitRate;
	for(iscl=0;iscl<ntt_NSclLay;iscl++) {
	    frameData->layer[iscl+1].sampleRate
		 =frameData->layer[0].sampleRate;
	    tvq_br += frameData->layer[iscl+1].bitRate;
        }
     if(frameData->opMode > 1){	
	  frameData->layer[ntt_NSclLay+1].bitRate= 
	           floor(bit_rate_f) - tvq_br;
          frameData->layer[ntt_NSclLay+1].sampleRate=sampling_rate ;
	ntt_NSclLay_aac = 0;
	if(( p_ctmp=strstr( encPara, "-aacScl " ) )){
	if((ntt_NSclLay_aac=sscanf( p_ctmp+8, "%d %d %d %d %d %d %d %d",
		   &aac_BPS_SCL[0],
	           &aac_BPS_SCL[1],
		   &aac_BPS_SCL[2],
		   &aac_BPS_SCL[3],
		   &aac_BPS_SCL[4],
		   &aac_BPS_SCL[5],
		   &aac_BPS_SCL[6],
		   &aac_BPS_SCL[7])) == 0) {
	CommonExit(1, "Encode: parameter of -aacScl switch not found");
	}
	for(iscl=0;iscl<ntt_NSclLay_aac;iscl++) {
	  frameData->layer[iscl+ntt_NSclLay+1].bitRate= aac_BPS_SCL[iscl];
          frameData->layer[iscl+ntt_NSclLay+1].sampleRate=sampling_rate ;
        }
      }
    }
    }
    transport_stream = NO_TSTREAM;    
    win_switch_mode = FFT_PE_WINDOW_SWITCHING ;
  }
  /* case aac_sca: supports only speech codecs as core */
  if( strstr( encPara, "-aac_sca" ) ) {
    qc_select = AAC_SCALABLE;
    tf_select = MDCT_AAC;
    useShortWindows=1;
    block_size_samples=960;
    transport_stream = NO_TSTREAM;    
    win_switch_mode = STATIC_LONG;

    if ( (p_ctmp = strstr( encPara, "-mode" ) ) ) {
      sscanf( p_ctmp+6, "%d", &op_mode );
    }

    if ( ( p_ctmp=strstr(encPara, "-core " ) ) ) {
        int utmp;
        sscanf(p_ctmp+6,"%d", &utmp);
        coreCodecIdx = (enum CORE_CODEC) utmp;
      if (coreCodecIdx==NTT_TVQ)
        CommonExit(1,"NTT TVQ core not supported in this mode");
    }
  }

  if( strstr( encPara, "-aac_raw" ) ) {
    qc_select = AAC_QC;
    tf_select = MDCT_AAC;
    win_switch_mode = STATIC_LONG;
    transport_stream = AAC_RAWDATA_TSTREAM;
  }


  if( (p_ctmp=strstr( encPara, "-aac_pns " )) ) {
    if( sscanf( p_ctmp+9, "%d",&pns_sfb_start ) == 0 ) {
      CommonExit( 1, "Encode: parameter of -aac_pns switch not found" );
    }
    tf_select = MDCT_AAC;
    win_switch_mode = STATIC_LONG;
    transport_stream = AAC_RAWDATA_TSTREAM;
  }

  if( strstr( encPara, "-aac_tns" ) ) {
    int n_ch, i_ch;
    n_ch = numChannel;
    for (i_ch=0; i_ch<n_ch; i_ch++) {
      tnsInfo[i_ch] = (TNS_INFO*)calloc(1, sizeof(TNS_INFO));
      TnsInit( (long)sampling_rate_f, MAIN, tnsInfo[i_ch], qc_select, block_size_samples);
    }
    tns_enable = 1;
  }
  if( strstr( encPara, "-aac_nosfacs" ) ) {
    aacAllowScalefacs=0;
  }
  if( strstr( encPara, "-no_tstream" ) ) {
    transport_stream = NO_TSTREAM;
  }
  if( strstr( encPara, "-len_tstream" ) ) {
    transport_stream = LENINFO_TSTREAM;
  }
  if ((qc_select == NTT_VQ) || (qc_select == NTT_VQ_SYS)){ /* T.Ishikawa 980525 */
    transport_stream = NO_SYNCWORD;
    win_switch_mode = FFT_PE_WINDOW_SWITCHING;
  }
  if ( strstr( encPara, "-no_syncword") ){ /* supported by NTT_VQ only */
    transport_stream = NO_SYNCWORD;
  }
  if( (p_ctmp=strstr( encPara, "-wsm " )) ) {  /* window length switching parameters */
    if( sscanf( p_ctmp+5, "%d",(int*)&win_switch_mode ) == 0 ) {
      CommonExit( 1, "Encode: parameter of -wsm switch not found" );
    }
  }
  if( (p_ctmp=strstr( encPara, "-wlp " )) ) {  /* window length parameters */
    if( sscanf( p_ctmp+5, "%i %i %i", &block_size_samples, &med_win_in_long, &short_win_in_long) == 0 ) {
      CommonExit( 1, "Encode: parameters of -wlp switch not found" );
    }
  }
  if( (p_ctmp=strstr( encPara, "-cde " )) ) {  /* window length switching parameters */
    if( sscanf( p_ctmp+5, "%d",(int*)&coreDelay ) == 0 ) {
      CommonExit( 1, "Encode: parameter of -cde switch not found (coreDelay)" );
    }
    if (coreDelay>block_size_samples)
      CommonExit( 1, "\nillegal core delay: greater than blocksize" );      
  }
  if( strstr( encPara, "-pred_ltp" ) )
    pred_type = NOK_LTP;
  if(strstr( encPara, "-pred_nok_bwp" ))
    pred_type = NOK_BWP;
  /* set the return values (including NTT_VQ global initialization) */
  /* number of channels */
  max_ch = numChannel;
  {
    if ((qc_select != NTT_VQ) && (qc_select != NTT_VQ_SYS) ){ /* set the return values for non NTT_VQ coders */ /* T.Ishikawa 980525 */
      *frameNumSample = block_size_samples;
      *delayNumSample = 2*block_size_samples; 
    }
    else if( qc_select==NTT_VQ_SYS ){ 
    /* global init. of the NTT_VQ_SYS coder T.Ishikawa 980526 */
#if 1
    initTvqSys( numChannel,	   /* in: num audio channels */
                sampling_rate_f,   /* in: sampling frequancy [Hz] */         
                bit_rate_f,        /* in: bit rate [bit/sec] */
                encPara,	   /* in: encoder parameter string */
                quantDebugLevel,   /* in : quantDebugLevel */
                frameNumSample,	   /* out: num samples per frame */
                delayNumSample,	   /* out: encoder delay (num samples) */
                frameData,
		&ntt_index,
		&ntt_index_scl,
		nttData); 
        ntt_NSclLay=ntt_index.nttDataScl->ntt_NSclLay; 
#endif
    }
    else if( qc_select==NTT_VQ ){
      /* global init. of the NTT_VQ coder T.Ishikawa 980526 */
      int    iscl;
      float  t_bit_rate_scl;
	  int ntt_core_br;
	  int mat_total_tvq_bits,total_frame_bits;
	  
	  if(debugLevel >= 1)
	  fprintf(stderr,"#### TwinVQ(Conventional) Global Init %x \n",qc_select);

	  mat_total_tvq_bits=0;
	  
      /* bitrate control */
      ntt_NSclLay = 0;

      block_size_samples = 1024;
	  tvq_flag_960=0;
      if ((p_ctmp=strstr( encPara, "-tvq_960" ))) { 
          block_size_samples = 960;
	  tvq_flag_960=1;
      } 

      /* TNS handling for TWIN VQ codec E. Allamache 981117 Added by T.Ishikawa 981211 */
      if ((p_ctmp=strstr( encPara, "-tvq_tns" ))) {
        int i_ch;
        for (i_ch=0; i_ch<max_ch; i_ch++) {
          tnsInfo[i_ch] = (TNS_INFO*)calloc(1, sizeof(TNS_INFO));
          TnsInit( (long)sampling_rate_f, LOW /*MAIN*/, tnsInfo[i_ch], qc_select, block_size_samples);
        }
        tvq_tns_enable = 1;
      }

      /* T.Ishikawa 981118 */
      if( (p_ctmp=strstr( encPara, "-core_br" )) ) {
        sscanf( p_ctmp+8, "%d", &ntt_core_br  );
		ntt_IBPS=(int)floor(ntt_core_br/(long)max_ch);
      }	  
      else
        {
          ntt_core_br = 8000;
          fprintf(stderr,"Warning!! : TwinVQ(System) BaseLayer_Br is set %d bps(Default)\n",ntt_core_br);
        }


      if(( p_ctmp=strstr( encPara, "-nttScl " ) )) {
	/* HP 970509   added an 8th "%d" */
	if((ntt_NSclLay=sscanf( p_ctmp+8, "%d %d %d %d %d %d %d %d",
                                &ntt_IBPS_SCL[0],