bitmux.c

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

  } else {    /* block type is either start, stop, or long */
    BsPutBit(fixed_stream, max_sfb, 6); /* let max_sfb_l = 49, the max number of sfb's */
    bit_count += 6;

    if((qc_select == AAC_QC)
       ){
      switch(predictor_type) {
      case NOK_BWP:
        nok_bwp_encode (fixed_stream, nr_of_sfb, nok_bwp_status);
        bit_count += nok_bwp_status->side_info;
        break;
        
      case MONOPRED:
        CommonExit(-1,"\nMonopred not implemented");
        break;
        
      case NOK_LTP:
	{
	  int ltp_present;
	  
	  ltp_present = 0;
	  if(nok_lt_statusLeft->global_pred_flag)
	    ltp_present = 1;
	  if(stereo_flag)
	    if(nok_lt_statusRight->global_pred_flag)
	      ltp_present = 1;

	  BsPutBit(fixed_stream, ltp_present, 1);
	  bit_count += 1;

	  if(ltp_present)
	  {
	    /* predictor data for left channel. */
	    bit_count += 
	      nok_ltp_encode(fixed_stream, windowSequence, nr_of_sfb, 
			     nok_lt_statusLeft, qc_select,
			     NO_CORE, -1);

	    if(stereo_flag)
	      /* predictor data for right channel. */
	      bit_count += 
		nok_ltp_encode(fixed_stream, windowSequence, nr_of_sfb, 
			       nok_lt_statusRight, qc_select,
			       NO_CORE, -1);
	  }
	}
        break;
        
        
      case PRED_NONE:
        BsPutBit(fixed_stream,0,1);  /* no prediction_data_present */
        bit_count += 1; 
        break;
        
      default:
        CommonExit(-1,"\nUnknown preditcor type");
      }
    }
  }  
  return(bit_count);
}



/*****************************************************************************/
/* write_tns_data(...), write TNS data.                            */
/*****************************************************************************/
int write_tns_data(TNS_INFO* tnsInfoPtr,       /* TnsInfo structure */
                   WINDOW_SEQUENCE windowSequence,     /* block type */
                   BsBitStream* fixed_stream,  /* Pointer to bitstream */
                   int writeFlag)              /* 1 means write, 0 means count only */ 
{
  int bit_count = 0;
  int numWindows = 1;
  int len_tns_nfilt;
  int len_tns_length;
  int len_tns_order;
  int filtNumber;
  int resInBits;
  unsigned long unsignedIndex;
  int w;

  if (writeFlag) {
    BsPutBit(fixed_stream,tnsInfoPtr->tnsDataPresent,LEN_TNS_PRES);
  }
  bit_count += LEN_TNS_PRES;

  /* If TNS is not present, bail */
  if (!tnsInfoPtr->tnsDataPresent) {
    return bit_count;
  }

  /* Set window-dependent TNS parameters */
  if (windowSequence == EIGHT_SHORT_SEQUENCE) {
    numWindows = MAX_SHORT_IN_LONG_BLOCK;
    len_tns_nfilt = LEN_TNS_NFILTS;
    len_tns_length = LEN_TNS_LENGTHS;
    len_tns_order = LEN_TNS_ORDERS;
  } else {
    numWindows = 1;
    len_tns_nfilt = LEN_TNS_NFILTL;
    len_tns_length = LEN_TNS_LENGTHL;
    len_tns_order = LEN_TNS_ORDERL;
  }

/*  fprintf(stderr,"numWindows %5d len_tns_nfilt %5d\n",numWindows,len_tns_nfilt);*/
  
  /* Write TNS data */
  bit_count += numWindows * len_tns_nfilt;
/*  fprintf(stderr,"TNS count (1) %5d\n",bit_count);*/
  for (w=0;w<numWindows;w++) {
    TNS_WINDOW_DATA* windowDataPtr = &tnsInfoPtr->windowData[w];
    int numFilters = windowDataPtr->numFilters;
/*	fprintf(stderr,"numFilters %5d\n",numFilters);*/
    if (writeFlag) {
      BsPutBit(fixed_stream,numFilters,len_tns_nfilt); /* n_filt[] = 0 */
    }
    if (numFilters) {
      bit_count += LEN_TNS_COEFF_RES;
/*	  fprintf(stderr,"TNS count (2) %5d\n",bit_count);*/
      resInBits = windowDataPtr->coefResolution;
      resInBits = windowDataPtr->coefResolution;
      if (writeFlag) {
	BsPutBit(fixed_stream,resInBits-DEF_TNS_RES_OFFSET,LEN_TNS_COEFF_RES);
      }
      bit_count += numFilters * (len_tns_length+len_tns_order);
/*	  fprintf(stderr,"TNS count (3) %5d\n",bit_count);*/
      for (filtNumber=0;filtNumber<numFilters;filtNumber++) {
	TNS_FILTER_DATA* tnsFilterPtr=&windowDataPtr->tnsFilter[filtNumber];
	int order = tnsFilterPtr->order;
	if (writeFlag) {
/*	  fprintf(stderr,"&& %5d\n",tnsFilterPtr->length);*/
	  BsPutBit(fixed_stream,tnsFilterPtr->length,len_tns_length);
	  BsPutBit(fixed_stream,order,len_tns_order);
	}
	if (order) {
	  bit_count += (LEN_TNS_DIRECTION + LEN_TNS_COMPRESS);
/*	  fprintf(stderr,"TNS count (4) %5d\n",bit_count);*/
	  if (writeFlag) {
	    BsPutBit(fixed_stream,tnsFilterPtr->direction,LEN_TNS_DIRECTION);
	    BsPutBit(fixed_stream,tnsFilterPtr->coefCompress,LEN_TNS_COMPRESS);
	  }
	  bit_count += order * resInBits;
/*	  fprintf(stderr,"TNS count (5) %5d\n",bit_count);*/
	  if (writeFlag) {
	    int i;
	    for (i=1;i<=order;i++) {
	      unsignedIndex = (unsigned long) (tnsFilterPtr->index[i])&(~(~0<<resInBits));
	      BsPutBit(fixed_stream,unsignedIndex,resInBits);
	    }
	  }
	}
      }
    }
  }
  return bit_count;
}


static int write_spectral_data(int counter, int len[], int data[], 
                               BsBitStream *fixed_stream)
{
  int bit_count = 0;
  int i;

  for(i=0; i<counter; i++) {
    if (len[i] > 0) {  /* only send out non-zero codebook data */
      BsPutBit(fixed_stream,data[i],len[i]);
      bit_count += len[i];
    }
  }
  return (bit_count);
}


/* write single channel element header */
int write_aac_sce(BsBitStream *fixed_stream)
{
  int bit_count = 0;

  /* write ID_SCE, single_element_channel() identifier */
  BsPutBit(fixed_stream,0,3);  
  bit_count += 3;

  /* write the element_identifier_tag */
  BsPutBit(fixed_stream,0,4);  
  bit_count += 4;

  return (bit_count);
}

int write_aac_cpe(int nr_of_sfb, WINDOW_SEQUENCE windowSequence, BsBitStream *fixed_stream, int num_window_groups,
                  int window_group_length[], WINDOW_SHAPE window_shape, int common_window, int ms_mask, int ms_used[10][10],
		  PRED_TYPE predictor_type, NOK_BW_PRED_STATUS *nok_bwp_status, QC_MOD_SELECT qc_select,
                  NOK_LT_PRED_STATUS *nok_lt_status)
{
  int bit_count = 0;
  int i,j;

  /* write ID_CPE, channel_pair_element identifier */
  BsPutBit(fixed_stream,1,3);  
  bit_count += 3;

  /* write the element_instance_tag */
  BsPutBit(fixed_stream,0,4);
  bit_count += 4;

  /* write the common_window flag */
  BsPutBit(fixed_stream, common_window, 1);
  bit_count += 1;

  if (common_window) {
    bit_count += write_ics_info(nr_of_sfb, windowSequence, fixed_stream, window_shape,
                                num_window_groups, window_group_length, 0, qc_select,
                                predictor_type, nok_bwp_status, &nok_lt_status[0], 
				&nok_lt_status[1], common_window);

    /* write the ms_mask_present flags */
    BsPutBit(fixed_stream,ms_mask,2);
    bit_count += 2;
    
    if (ms_mask == 1) {
      for (i=0; i<num_window_groups; i++) {
        for (j=0; j<nr_of_sfb; j++) {
          BsPutBit(fixed_stream, ms_used[i][j],1);
          bit_count += 1;
        }
      }
    }
  }
  return (bit_count);
}


int write_ind_cha_stream(int nr_of_sfb, WINDOW_SEQUENCE windowSequence, int scale_factors[], 
                         BsBitStream *fixed_stream, BsBitBuffer *gcBitBufCh, TNS_INFO *tnsInfo,
                         int book_vector[], int data[], int len[], int qdebug, int scale_flag,
                         int huff[13][1090][4], int counter, int num_window_groups, int window_group_length[],
                         int global_gain, WINDOW_SHAPE window_shape, int noise_nrg[],  PRED_TYPE predictor_type,
                         NOK_LT_PRED_STATUS *nok_lt_status, NOK_BW_PRED_STATUS *nok_bwp_status, 
                         int common_window, QC_MOD_SELECT qc_select)
{
  int output_book_vector[SFB_NUM_MAX*2];
  int bit_count = 0;
  int reducedInfo=0;
  /* the 8-bit global_gain is the first scalefactor */
  /*  BsPutBit(fixed_stream,scale_factors[0],8);  */
  BsPutBit(fixed_stream,global_gain,8);  
  bit_count += 8;
  if ( (qdebug > 2)  ) {
    fprintf(stderr,"\nglobal_gain %d ",global_gain);
  }

  if ((!common_window) && (!scale_flag))
    /* write out ICS Info block */  
    bit_count += write_ics_info(nr_of_sfb, 
                                windowSequence, 
                                fixed_stream, 
                                window_shape, 
                                num_window_groups, 
                                window_group_length,
                                reducedInfo,
                                qc_select,
                                predictor_type, 
                                nok_bwp_status,
                                nok_lt_status,
				NULL,
				common_window);


  /* write out section_data() information to the bitstream */
  bit_count += sort_book_numbers(book_vector, output_book_vector, nr_of_sfb, qdebug, windowSequence, fixed_stream, 1,num_window_groups);

  /* scale_factor_data() information */
  bit_count += write_scalefactor_bitstream(nr_of_sfb, scale_factors, book_vector, fixed_stream, 1,
                                             window_group_length, num_window_groups, global_gain,
                                             windowSequence, noise_nrg, qdebug, huff);

    
  if (!scale_flag) {
  
    /* no pulse_data_present() */
    BsPutBit(fixed_stream,0,1);
    bit_count += 1;

    /* TNS data */
    if (tnsInfo) {              /* TNS active */
      bit_count += write_tns_data( tnsInfo, windowSequence, fixed_stream, 1 );
    } else {                    /* switch it off */
      BsPutBit(fixed_stream,0,1);
      bit_count += 1;
    }

    /* write gain_control_data()  TK */
    if (gcBitBufCh && (gcBitBufCh->numBit > 0)) {		/* gain_control_data() present */
      BsPutBit(fixed_stream,1,1);		/* switches on the gain control */
      bit_count += 1;
      BsPutBuffer(fixed_stream, gcBitBufCh); /* gain_control_data() */
      bit_count += gcBitBufCh->numBit;
    }
    else {
      BsPutBit(fixed_stream,0,1);		/* switches off the gain control */
      bit_count += 1;
    }
  }

  /* write out the spectral_data() */
  bit_count += write_spectral_data(counter, len, data, fixed_stream);

  return(bit_count);
}


int write_fill_elements(BsBitStream *fixed_stream, int numFillBits)
{

  int i;
  int cnt;
  int bitCount = numFillBits;

  /* write fill elements */    
  while(bitCount>7) {
    /* Fill elements ID */
    BsPutBit(fixed_stream, 6, 3);
    bitCount -= 3;
    
    /* check for escape values */
    cnt = (bitCount-4)>>3;
    if(cnt>=15) {

      BsPutBit(fixed_stream, 15, 4);
      bitCount -= 4;

      BsPutBit(fixed_stream, ((cnt-15)>255)?255:cnt-15, 8);  
      bitCount -= 8;
      cnt = ((cnt>270)?270:cnt)-1;
 
    } else {
      BsPutBit(fixed_stream, cnt, 4);
      bitCount -= 4;
    }

    for(i=0; i<cnt; i++) {
      BsPutBit(fixed_stream, 0, 8);
      bitCount -= 8;
    }

  } /* while(bitCount>7) */

  return (numFillBits-bitCount);
}


int write_aac_end_id(BsBitStream *fixed_stream)
{
  BsPutBit(fixed_stream,7,3);

  return (3);
}