enc_lpc.c

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

	SampleRateMode = fs16kHz;
	FineRateControl = OFF;
	NumEnhLayers = 0;
	BandwidthScalabilityMode = OFF;
	BWS_nb_bitrate = 0;
  }
  PreProcessingSW = ON;

  /* evalute encoder parameter string */
  parav = CmdLineParseString(encPara,SEPACHAR,&parac);
  result = CmdLineEval(parac,parav,NULL,switchList,1,NULL);
  if (result) {
     if (result==1) {
        EncLpcInfo(stdout);
        exit (1);
     }
     else
        CommonExit(1,"encoder parameter string error");
  }

  if (strstr(encPara, "-celp_sys") != NULL) 
    sysFlag = 1;

  if (numChannel != 1 ) 
  {
    CommonExit(1,"EncLpcInit: Multi-channel audio input is not supported");
  }

  if ( BWS_nb_bitrate != 0 ) {
    BandwidthScalabilityMode = ON;
    ExcitationMode = MultiPulseExc;
    SampleRateMode = fs8kHz;
    FineRateControl  = OFF;
  }

  if ( (ExcitationMode == MultiPulseExc) && (SampleRateMode==fs16kHz) ) {
    BandwidthScalabilityMode = OFF;
    BWS_nb_bitrate = 0;
  }

  if (((LosslessCodingMode==ON) &&
       ((QuantizationMode==VectorQuantizer) ||
	(FineRateControl==OFF))) ) {
    CommonExit(1,"EncLpcInit: Specified combination of options (1) is not supported");
  }

  if (((BandwidthScalabilityMode==ON) &&
       ((ExcitationMode==RegularPulseExc) ||
	(FineRateControl==ON) ||
	(SampleRateMode==fs16kHz))) ) {
    CommonExit(1,"EncLpcInit: Specified combination of options (2) is not supported");
  }

  if (((NumEnhLayers>0) && (ExcitationMode==RegularPulseExc))) {
    CommonExit(1,"EncLpcInit: Specified combination of options (3) is not supported");
  }

  if (((SampleRateMode==fs8kHz) && (ExcitationMode==RegularPulseExc))) {
    CommonExit(1,"EncLpcInit: Specified combination of options (4) is not supported");
  }

  if ((ExcitationMode == MultiPulseExc) &&
      (SampleRateMode==fs16kHz) &&
      (FineRateControl == ON) &&
      ((InputConfiguration < 0) || (InputConfiguration > 31))) {
    CommonExit(1,"EncLpcInit: MPE_Configuration 0...31 must be specified when FRC is used");
  }
  
  if ((FineRateControl == ON) && (varBitRate == 0))
  {
    CommonExit(1,"EncLpcInit: FineRateControl must be used in combination with -vr switch");
  }
  
  /* -------------------------------------------------------------------*/
  /* Memory allocation                                                  */
  /* -------------------------------------------------------------------*/
  hdrStream = BsOpenBufferWrite(bitHeader);
#if 0 /* dh 990412 */
  if (bitHeader != NULL)
  {
	  p_bitstream->p_bitstream_buffer_start = bitHeader->data;
	  p_bitstream->buffer_length = (bitHeader->size+7)/8;
	  p_bitstream->start_offset = 0;
	  p_bitstream->valid_bits = 0;
  }
  else
  {
	  p_bitstream->p_bitstream_buffer_start = NULL;
	  p_bitstream->buffer_length = 0;
	  p_bitstream->start_offset = 0;
	  p_bitstream->valid_bits = 0;
  }
#endif
  /* ---------------------------------------------------------------- */
  /* Conversion of parameters from float to longs                     */
  /* ---------------------------------------------------------------- */
  bit_rate           = (long)(bitRate+.5);
  sampling_frequency = (long)(fSample+.5);

  /* ---------------------------------------------------------------- */
  /* Encoder Initialisation                                           */
  /* ---------------------------------------------------------------- */
  celp_initialisation_encoder (hdrStream, bit_rate, sampling_frequency, ExcitationMode,
                               SampleRateMode, QuantizationMode, FineRateControl, LosslessCodingMode,
                               &RPE_configuration, Wideband_VQ, &MPE_Configuration,
                               NumEnhLayers, BandwidthScalabilityMode, &BWS_configuration,
                               BWS_nb_bitrate, InputConfiguration, &frame_size, &n_subframes, &sbfrm_size,
                               &lpc_order, &num_lpc_indices, &num_shape_cbks, &num_gain_cbks,
                               &n_lpc_analysis, &window_offsets, &window_sizes, 
                               &n_lag_candidates, &min_pitch_frequency, &max_pitch_frequency, 
                               &org_frame_bit_allocation, &InstanceContext,
			       sysFlag);

  /* system interface(flexmux) configuration */
  /* only single CELP layer(layer=0) */
  if (sysFlag) {
    numLayer = 1;
    initObjDescr(frameData->od);
    presetObjDescr(frameData->od, numLayer);
    
    for (layer=0; layer<numLayer; layer++) {
      initESDescr(&(frameData->od->ESDescriptor[layer]));
      presetESDescr(frameData->od->ESDescriptor[layer], layer);

      /* elementary stream configuration */
      /* DecConfigDescriptor configuration */
      frameData->layer[layer].bitRate = (int)bitRate;
      frameData->od->ESDescriptor[layer]->DecConfigDescr.avgBitrate.value = frameData->layer[layer].bitRate;
      frameData->od->ESDescriptor[layer]->DecConfigDescr.bufferSizeDB.value = 0;

      /* ALConfigDescriptor configuration */
      frameData->od->ESDescriptor[layer]->ALConfigDescriptor.useAccessUnitStartFlag.value=1;
      frameData->od->ESDescriptor[layer]->ALConfigDescriptor.useAccessUnitEndFlag.value=1;
      frameData->od->ESDescriptor[layer]->ALConfigDescriptor.useRandomAccessPointFlag.value=0;
      frameData->od->ESDescriptor[layer]->ALConfigDescriptor.usePaddingFlag.value=0;
      frameData->od->ESDescriptor[layer]->ALConfigDescriptor.seqNumLength.value=0;

      /* AudioSpecificConfig configuration */
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.audioDecoderType.value = 1;
      if (fSample < 12000.) {
	frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.samplingFreqencyIndex.value = 0xb;	/* 8000Hz */
      } else {
	frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.samplingFreqencyIndex.value = 0x8;	/* 16000Hz */
      }
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.channelConfiguration.value = 1;	/* mono */
      
      /* CelpSpecificConfig configuration */
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.celpSpecificConfig.excitationMode.value = ExcitationMode;
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.celpSpecificConfig.sampleRateMode.value = SampleRateMode;
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.celpSpecificConfig.fineRateControl.value = FineRateControl;

      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.celpSpecificConfig.RPE_Configuration.value = RPE_configuration;
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.celpSpecificConfig.MPE_Configuration.value = MPE_Configuration;
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.celpSpecificConfig.numEnhLayers.value = NumEnhLayers;
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.celpSpecificConfig.bandwidthScalabilityMode.value = BandwidthScalabilityMode;
    }

    advanceODescr(hdrStream, frameData->od, 1);

    for (layer=0; layer<numLayer; layer++){ 
      advanceESDescr(hdrStream, frameData->od->ESDescriptor[layer], 1);
    }
    
    tmpBitBuf = BsAllocBuffer(512);
  }

  if (ExcitationMode == RegularPulseExc)
  {
      *frameNumSample = frame_size;
      *delayNumSample = 2*frame_size;
  }
  
  if (ExcitationMode == MultiPulseExc)
  {
    *frameNumSample = frame_size;
    if (SampleRateMode == fs16kHz)
    {
      *delayNumSample = NEC_FRQ16_NLA;
    }
    else
    {
      if (BandwidthScalabilityMode == OFF)
      {
        *delayNumSample = NEC_PAN_NLA;
      }
      else
      {
        *delayNumSample = NEC_FRQ16_NLA+NEC_LPF_DELAY;
      }
    }
  }

  BsClose(hdrStream);
}

/* ------------------------------------------------------------------- */
/* EncLpcFrame()                                                       */
/* Encode one audio frame into one bit stream frame with               */
/* LPC-based encoder core.                                             */
/* ------------------------------------------------------------------- */
void EncLpcFrame (
  float **sampleBuf,      /* in: audio frame samples                   */
                          /*     sampleBuf[numChannel][frameNumSample] */
  BsBitBuffer *bitBuf,    /* out: bit stream frame                     */
                          /*      or NULL during encoder start up      */
  int frameAvailNumBit,   /* in: total num bits available for          */
                          /*     this frame (incl. bit reservoir)      */
  int frameNumBit,        /* in: average num bits per frame            */
  int frameMaxNumBit)     /* in: max num bits per frame                */
{
  BsBitStream *bitStream;
  
  /* -------------------------------------------------------------------*/
  /* Memory allocation                                                  */
  /* -------------------------------------------------------------------*/
  if (sysFlag) {	/* for flexmux bitstream, use writeFlexMuxPDU() */
    if (bitBuf)
      bitStream = BsOpenBufferWrite(tmpBitBuf);
    else
      bitStream = NULL;

    celp_coder(sampleBuf, bitStream, sampling_frequency, bit_rate,
	       ExcitationMode,
		  SampleRateMode,
		  QuantizationMode, FineRateControl,
		  LosslessCodingMode,RPE_configuration, Wideband_VQ,
		  MPE_Configuration,NumEnhLayers, BandwidthScalabilityMode,
		  BWS_configuration,PreProcessingSW,
		  frame_size, 
	  n_subframes, sbfrm_size, lpc_order, num_lpc_indices, num_shape_cbks, num_gain_cbks, 
	  n_lpc_analysis, window_offsets, window_sizes, n_lag_candidates, 
	  min_pitch_frequency, max_pitch_frequency, org_frame_bit_allocation,
	  InstanceContext);

    if (bitBuf) {
      BsClose(bitStream);

      bitStream = BsOpenBufferWrite(bitBuf);
      writeFlexMuxPDU(0 , bitStream , tmpBitBuf);
      BsClose(bitStream);
    }
  } else {
    if (bitBuf)
      bitStream = BsOpenBufferWrite(bitBuf);
    else
      bitStream = NULL;

    celp_coder(sampleBuf, bitStream, sampling_frequency, bit_rate,
	       ExcitationMode,
		  SampleRateMode,
		  QuantizationMode, FineRateControl,
		  LosslessCodingMode,RPE_configuration, Wideband_VQ,
		  MPE_Configuration,NumEnhLayers, BandwidthScalabilityMode,
		  BWS_configuration,PreProcessingSW,
		  frame_size, 
	  n_subframes, sbfrm_size, lpc_order, num_lpc_indices, num_shape_cbks, num_gain_cbks, 
	  n_lpc_analysis, window_offsets, window_sizes, n_lag_candidates, 
	  min_pitch_frequency, max_pitch_frequency, org_frame_bit_allocation,
	  InstanceContext);
    
    if (bitBuf!=NULL)
      BsClose(bitStream);
  }

}
/* ---------------------------------------------------------------------*/
/* EncLpcFree()                                                         */
/* Free memory allocated by LPC-based encoder core.                     */
/* ---------------------------------------------------------------------*/
void EncLpcFree ()
{
  /* -----------------------------------------------------------------*/
  /* Free all the arrays that were initialised                        */
  /* -----------------------------------------------------------------*/ 
  celp_close_encoder(ExcitationMode, SampleRateMode,
		     BandwidthScalabilityMode, sbfrm_size, 
                     org_frame_bit_allocation, window_offsets, window_sizes, 
		     n_lpc_analysis, &InstanceContext);
}

/* end of enc_lpc.c */