ntt_vq_coder.c

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

 if(iscl <0){
   WINDOW_SEQUENCE windowSequence;
   int i_ch;

   windowSequence = index->w_type;
   
   for(i_ch=0; i_ch < index->numChannel; i_ch++)
   {
     if(pred_type == NOK_LTP) /* LTP used. */
       *used_bits += nok_ltp_encode(stream, windowSequence, 
       /**TM nr_of_sfb[i_ch], */   index->max_sfb[0],
				    nok_lt_status + i_ch, NTT_VQ_SYS, 
				    NTT_TVQ, 1 /**TM i_ch***/);
     else
     {
       BsPutBit(stream, 0, 1); /* LTP not used. */
       *used_bits += 1;
     }

     /* TNS data */
      if(tnsInfo[MONO_CHAN]) {
	if (tnsInfo[MONO_CHAN]->tnsDataPresent) {     /* TNS active */
			int tns_bits,bits_tmp;
			tns_bits= write_tns_data( tnsInfo[MONO_CHAN], 
                                        windowSequence, stream, 0 );
        if(tvq_debug_level>5)
	  fprintf(stderr, "AAAAA TNS %5d %5d\n", 
	  tnsInfo[MONO_CHAN]->tnsDataPresent, tns_bits);
#if 1
			switch (index->w_type){
				case ONLY_LONG_SEQUENCE: 
				case LONG_START_SEQUENCE: case LONG_STOP_SEQUENCE:
				bits_tmp = index->nttDataBase->ntt_NBITS_FR
				   -(ntt_NMTOOL_BITSperCH*index->numChannel)-tns_bits-(*used_bits);
				break;
				case EIGHT_SHORT_SEQUENCE:
				bits_tmp = index->nttDataBase->ntt_NBITS_FR
				      -(ntt_NMTOOL_BITS_SperCH*index->numChannel)
				      -tns_bits-(*used_bits);
				break;
                                default:
	                        break;
			}

			if(bits_tmp<50) /* TNS not active T.Ishikawa 981214 */
				{
					BsPutBit(stream,0,1);
					*used_bits += 1;
					tnsInfo[MONO_CHAN]->tnsDataPresent=0;
					index->restore_flag_tns=1;
					if(tvq_debug_level>2)
					fprintf(stderr,"tnsDataNotPresent %5d ,bits_tmp %5d\n",tns_bits,bits_tmp);
				}
			else /* TNS active T.Ishikawa 981214 */
#endif
				{
					*used_bits+=write_tns_data( tnsInfo[MONO_CHAN], 
                                        windowSequence, stream, 1 );
					index->restore_flag_tns=0;
					if(tvq_debug_level>2)
					fprintf(stderr,"tnsDataPresent %5d bits_tmp %5d\n",tns_bits,bits_tmp);
				}
        } 
        else {                    /* switch it off */
         BsPutBit(stream,0,1);
         *used_bits += 1;
        }
      }
      else {                    /* switch it off */
        BsPutBit(stream,0,1);
        *used_bits += 1;
      }

	if(tvq_debug_level>2)
        fprintf(stderr, "TNS end %5d\n",  *used_bits); 
   }

 } /* only for core */

}



void ntt_select_ms( double      *spectral_line_vector[MAX_TIME_CHANNELS],
		    ntt_INDEX   *index,
		    int     sfb_width_table[MAX_TIME_CHANNELS][MAX_SCFAC_BANDS],
                    int         nr_of_sfb[MAX_TIME_CHANNELS],
		    int         iscl)
{
 int ismp;
 double bufm[1024];
 double bufs[1024];
 double lp, rp, ratio_lr, ratio_sm;
 int ii, jj;
 int sfb_offset[60];
	if(index->numChannel < 2) return;
    { int k, i;
	   k=0;
	   sfb_offset[0] = 0;
           for(i = 0; i < nr_of_sfb[MONO_CHAN]; i++ ) {
               sfb_offset[i] = k;
               k +=sfb_width_table[MONO_CHAN][i];
           }
    }
    if(index->ms_mask != 1){
        lp=rp=0.0;
        for (ismp=0; ismp<index->block_size_samples; ismp++){
	   lp += (spectral_line_vector[0][ismp]*spectral_line_vector[0][ismp]);
	   rp += (spectral_line_vector[1][ismp]*spectral_line_vector[1][ismp]);
        }
        ratio_lr = ntt_max(lp/(rp+0.1), rp/(lp+0.1));
        for (ismp=0; ismp<index->block_size_samples; ismp++){
	       bufm[ismp] =  (spectral_line_vector[0][ismp]
			     +spectral_line_vector[1][ismp]);
	       bufs[ismp] =  (spectral_line_vector[0][ismp]
			     -spectral_line_vector[1][ismp]);
        }
        lp=rp=0.0;
        for (ismp=0; ismp<index->block_size_samples; ismp++){
	   lp += (bufm[ismp]*bufm[ismp]);
	   rp += (bufs[ismp]*bufs[ismp]);
        }
        ratio_sm = ntt_max(lp/(rp+0.1), rp/(lp+0.1));
	if (ratio_lr > ratio_sm) index->ms_mask = 0;
        else                     index->ms_mask = 2;
            index->group_code =127; /*TEST*/
    }
    if(tvq_debug_level>2)
    fprintf(stderr, "MMMMMM %5d flag\n",  index->ms_mask);
if(index->ms_mask ==1){
  if(index->w_type==EIGHT_SHORT_SEQUENCE){
    int is, icounter;
    icounter =0;
    for(jj=index->last_max_sfb[iscl+1]; jj<index->max_sfb[iscl+1]; jj++){
        lp=rp=0.0;
        for(ii=0; ii<8; ii++){
	 is= index->block_size_samples/8*ii;
	 for (ismp=is+sfb_offset[jj]; ismp<is+sfb_offset[jj+1]; ismp++){
	   lp += (spectral_line_vector[0][ismp]*spectral_line_vector[0][ismp]);
	   rp += (spectral_line_vector[1][ismp]*spectral_line_vector[1][ismp]);
         }
	}
        ratio_lr = ntt_max(lp/(rp+0.1), rp/(lp+0.1));
        for(ii=0; ii<8; ii++){
	 is= index->block_size_samples/8*ii;
         for (ismp=is+sfb_offset[jj]; ismp<is+sfb_offset[jj+1]; ismp++){
	       bufm[ismp] =  (spectral_line_vector[0][ismp]
			     +spectral_line_vector[1][ismp]);
	       bufs[ismp] =  (spectral_line_vector[0][ismp]
			     -spectral_line_vector[1][ismp]);
         }
        }
        lp=rp=0.0;
        for(ii=0; ii<8; ii++){
	 is= index->block_size_samples/8*ii;
         for (ismp=is+sfb_offset[jj]; ismp<is+sfb_offset[jj+1]; ismp++){
	   lp += (bufm[ismp]*bufm[ismp]);
	   rp += (bufs[ismp]*bufs[ismp]);
         }
        }
        ratio_sm = ntt_max(lp/(rp+0.1), rp/(lp+0.1));
	if (ratio_lr > ratio_sm) index->msMask[0][jj] = 0;
	else  index->msMask[0][jj] = 1;
    if(index->msMask[0][jj] ==1) icounter++;
    }
    if(icounter < jj/4)index->ms_mask = 0; 
    if(icounter > jj-jj/4)index->ms_mask = 2; 
  }
  else{
    int icounter;
    icounter =0;
    if(tvq_debug_level >5)
     fprintf(stderr, "LLLLLLLL last_max_sfb,max_sfb,iscl,%5d %5d %5d\n",
     index->last_max_sfb[iscl+1], index->max_sfb[iscl+1], iscl);
    for(jj=index->last_max_sfb[iscl+1]; jj<index->max_sfb[iscl+1]; jj++){
        lp=rp=0.0;
        for (ismp=sfb_offset[jj]; ismp<sfb_offset[jj+1]; ismp++){
	   lp += (spectral_line_vector[0][ismp]*spectral_line_vector[0][ismp]);
	   rp += (spectral_line_vector[1][ismp]*spectral_line_vector[1][ismp]);
        }
        ratio_lr = ntt_max(lp/(rp+0.1), rp/(lp+0.1));
        for (ismp=sfb_offset[jj]; ismp<sfb_offset[jj+1]; ismp++){
	       bufm[ismp] =  (spectral_line_vector[0][ismp]
			     +spectral_line_vector[1][ismp]);
	       bufs[ismp] =  (spectral_line_vector[0][ismp]
			     -spectral_line_vector[1][ismp]);
        }
        lp=rp=0.0;
        for (ismp=sfb_offset[jj]; ismp<sfb_offset[jj+1]; ismp++){
	   lp += (bufm[ismp]*bufm[ismp]);
	   rp += (bufs[ismp]*bufs[ismp]);
        }
        ratio_sm = ntt_max(lp/(rp+0.1), rp/(lp+0.1));
	if (ratio_lr > ratio_sm) index->msMask[0][jj] = 0;
	else  index->msMask[0][jj] = 1;
    if(tvq_debug_level > 4)
    fprintf(stderr, "MMMMMM %5d %5d %5d \n", jj, sfb_offset[jj], index->msMask[0][jj]);
    
    if(index->msMask[0][jj] ==1) icounter++;
    }
    if(icounter < jj/4)index->ms_mask = 0; 
    if(icounter > jj-jj/4)index->ms_mask = 2; 
    if(tvq_debug_level > 3)
    fprintf(stderr, "MMMMMM %5d %5d \n",  index->ms_mask, jj);
  }
}
	for(ii=0; ii<8; ii++){
	  if(index->ms_mask == 2){
	    for(jj=index->last_max_sfb[iscl+1]; jj<index->max_sfb[iscl+1]; jj++){
              index->msMask[ii][jj]=1;    /* force ms_mask */
	    }
	  }
	/* for index->ms_mask =1  no optimized encoder*/
	  else if(index->ms_mask == 1){
	    for(jj=index->last_max_sfb[iscl+1]; jj<index->max_sfb[iscl+1]; jj++){
              index->msMask[ii][jj]=(jj+ii)%2;    
	    }
	  }
	  else if(index->ms_mask == 0){
	    for(jj=index->last_max_sfb[iscl+1]; jj<index->max_sfb[iscl+1]; jj++){
              index->msMask[ii][jj]=0;   
	    }
	  }
	}
}

void ntt_tns_enc(double *spectral_line_vector[MAX_TIME_CHANNELS],
		 ntt_INDEX  *index, 
	         int     sfb_width_table[MAX_TIME_CHANNELS][MAX_SCFAC_BANDS],
	         WINDOW_SEQUENCE   windowSequence,
		 int         nr_of_sfb[MAX_TIME_CHANNELS],
		 TNS_INFO	 *tnsInfo[MAX_TIME_CHANNELS]
		)
{

  if(tnsInfo[MONO_CHAN] != NULL) {
    int i_ch, n_ch;
    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;

    for (i_ch=0; i_ch<index->numChannel; i_ch++) {
      TnsEncode(nr_of_sfb[MONO_CHAN],        /* Number of bands per w indow */
                nr_of_sfb[MONO_CHAN],        /* max_sfb */
                windowSequence,              /* block type */
                sfb_offset,                  /* Scalefactor band offs t table */
                spectral_line_vector[i_ch],  /* Spectral data array */
                tnsInfo[i_ch]);             
   } 
  }
}


int  tvqScaleableFlexMuxEncode(
  double      *DTimeSigBuf[MAX_TIME_CHANNELS],
  double      *DTimeSigLookAheadBuf[MAX_TIME_CHANNELS],
  double      *spectral_line_vector[MAX_TIME_CHANNELS],
  double      *nok_tmp_DTimeSigBuf[MAX_TIME_CHANNELS],
  double      *baselayer_spectral_line_vector[MAX_TIME_CHANNELS],
  double      *ntt_ms_buf[MAX_TIME_CHANNELS],
  WINDOW_SHAPE windowShape[MAX_TIME_CHANNELS],
  WINDOW_SEQUENCE windowSequence[MAX_TIME_CHANNELS],
  ntt_INDEX   *index,
  ntt_INDEX   *index_scl,
  ntt_PARAM   *param_ntt,
  BsBitStream *fixed_stream,
  TNS_INFO    *tnsInfo[MAX_TIME_CHANNELS],
  int         sfb_width_table[MAX_TIME_CHANNELS][MAX_SCFAC_BANDS],
  int         nr_of_sfb[MAX_TIME_CHANNELS],
  double      *reconstructed_spectrum[MAX_TIME_CHANNELS],
  PRED_TYPE   pred_type,
  int         block_size_samples,
  int         sfb_offset[MAX_TIME_CHANNELS][MAX_SCFAC_BANDS+1],
  NOK_LT_PRED_STATUS nok_lt_status[MAX_TIME_CHANNELS])
{
          int     ismp, tomo_tmp;
          int     used_bits, ntt_available_bits;
	  int     debugLevel;
          double  *ntt_external_pw[MAX_TIME_CHANNELS];
          double  lpc_spectrum[ntt_T_FR_MAX];
	  double *tvq_target_spectrum[MAX_TIME_CHANNELS];
	  double spectrum_orig[MAX_TIME_CHANNELS][ntt_T_FR_MAX]; /* T.Ishikawa 981215 */
          BsBitStream *mat_layerStream;
          BsBitBuffer *mat_dynpartBuf;
	  double baselayer_rec_spectrum[BLOCK_LEN_LONG];
          
	  int i_sup;
	  windowShape[MONO_CHAN]=WS_FHG; /* <---*/
	  mat_dynpartBuf = BsAllocBuffer(10000); /* Adhoc Size */
	  mat_layerStream = BsOpenBufferWrite(mat_dynpartBuf);
          used_bits=0;
          debugLevel=tvq_debug_level;
	  
          BsPutBit(mat_layerStream, windowSequence[MONO_CHAN], 2);
          if(debugLevel>5)
	   fprintf(stderr,"windowSequence %d\n",(int)windowSequence[MONO_CHAN]);
          /*BsPutBit(fixed_stream, windowSequence[MONO_CHAN], 2);*/ /* T.Ishikawa 980727 */
          index->w_type = windowSequence[MONO_CHAN];
          windowSequence[index->numChannel-1] = windowSequence[MONO_CHAN];
	  used_bits += 2;
          BsPutBit(mat_layerStream,  (unsigned long)windowShape[MONO_CHAN], 1);
          /*BsPutBit(fixed_stream,  window_shape, 1);*//* T.Ishikawa 980727 */
          used_bits += 1;