enc_par.c

语音压缩算法

{
  /* Akira 980506 */
  PAN_FreeLpcAnalysisEncoder(1, InstCtxt->PHI_Priv);
  /*
  PAN_FreeLpcAnalysisEncoder(1);
  */
  IPC_HVXCFree();
}


/* ---------- functions ---------- */


char *EncParInfo (
  FILE *helpStream)		/* in: print encPara help text to helpStream */
				/*     if helpStream not NULL */
				/* returns: core version string */
{
  if (helpStream != NULL) {
    fprintf(helpStream,
	    PROGVER "\n"
	    "encoder parameter string format:\n"
	    "  list of tokens (tokens separated by characters in \"%s\")\n",
	    SEPACHAR);
    CmdLineHelp(NULL,NULL,switchList,helpStream);
  }
  return PROGVER;
}


/* EncParInit() */
/* Init parametric encoder core. */

void EncParInit (
  int numChannel,		/* in: num audio channels */
  float fSample,		/* in: sampling frequency [Hz] */
  float bitRate,		/* in: total bit rate [bit/sec] */
  char *encPara,		/* in: encoder parameter string */
  int *frameNumSample,		/* out: num samples per frame */
  int *delayNumSample,		/* out: encoder delay (num samples) */
  BsBitBuffer *bitHeader)	/* out: header for bit stream */
{
  int parac;
  char **parav;
  int result;
  BsBitStream *hdrStream;
  int i;
  int maxCh;

  /* evalute encoder parameter string */
  parav = CmdLineParseString(encPara,SEPACHAR,&parac);
  result = CmdLineEval(parac,parav,NULL,switchList,1,NULL);
  if (result) {
    if (result==1) {
      EncParInfo(stdout);
      CommonExit(1,"encoder core aborted ...");
    }
    else
      CommonExit(1,"encoder parameter string error");
  }
  EPparaMode = MP4ModeParName[MODEPAR_HVX];

  
  
  if (EPdelayMode)
    ipc_encDelayMode = DM_LONG;
  else
    ipc_encDelayMode = DM_SHORT;

  if (EPvrMode)
    ipc_bitstreamMode = BM_VARIABLE;
  else
    ipc_bitstreamMode = BM_CONSTANT;


  /* AI 990209 */
  ipc_rateMode = ENC4K;		/* 4000 kbps */
  if (bitRate <= 3999.5)
    ipc_rateMode = ENC3K;	/* 3850 kbps */
  if (bitRate <= 3849.5)
    ipc_rateMode = ENC2K;	/* 2000 kbps */

#if 0
  ipc_rateMode = 2;	/* 4000 kbps */
  if (bitRate <= 3999.5)
    ipc_rateMode = 1;	/* 3850 kbps */
  if (bitRate <= 3849.5)
    ipc_rateMode = 0;	/* 2000 kbps */
#endif

  if (EPdebugLevel >= 1) {
    printf("EncParInit: numChannel=%d  fSample=%f  bitRate=%f  "
	   "encPara=\"%s\"\n",
	   numChannel,fSample,bitRate,encPara);
    printf("EncParInit: debugLevel=%d  mode=\"%s\"\n",
	   EPdebugLevel,EPparaMode);
    printf("EncParInit: encDlyMode=%d  vrMode=%d  rateMode=%d\n",
	   ipc_encDelayMode,ipc_bitstreamMode,ipc_rateMode);
  }

  EPmode = -1;
  do
    EPmode++;
  while (EPmode < MODEPAR_NUM &&
	 strcmp(EPparaMode,MP4ModeParName[EPmode]) != 0);
  if (EPmode >= MODEPAR_NUM)
    CommonExit(1,"EncParInit: unknown parametric codec mode %s",EPparaMode);

  maxCh = (EPmode == MODEPAR_MIX) ? 2 : 1;
  if (numChannel != maxCh)
    CommonExit(1,"EncParInit: audio data must have %d channel(s) (%d)",
	       maxCh,numChannel);

  CmdLineParseFree(parav);

  EPfSample = fSample;
  EPbitRate = bitRate;

  hdrStream = BsOpenBufferWrite(bitHeader);
  if (BsPutBit(hdrStream,EPmode,2))
    CommonExit(1,"EncParInit: error generating bit stream header");
  switch (EPmode) {
  case MODEPAR_HVX:
    EncParInitHvx(hdrStream);
    break;
  }
  BsClose(hdrStream);

  testFrame = 0;	/* for EPtest!=0 or EPmixMode<0 */

  /* init sample buffer */
  if (CommonFreeAlloc((void**)&EPsampleBuf,
		      EPsampleBufSize*sizeof(float)) == NULL)
    CommonExit(1,"EncParInit: memory allocation error");
  for (i=0; i<EPsampleBufSize; i++)
    EPsampleBuf[i] = 0;
  if (EPmode == MODEPAR_MIX) {
    if (CommonFreeAlloc((void**)&EPsampleBuf2,
			EPsampleBufSize*sizeof(float)) == NULL)
      CommonExit(1,"EncParInit: memory allocation error");
    for (i=0; i<EPsampleBufSize; i++)
      EPsampleBuf2[i] = 0;
  }

  *frameNumSample = EPframeNumSample;
  *delayNumSample = EPdelayNumSample;

  if (EPdebugLevel >= 1) {
    printf("EncParInit: modeInt=%d\n",EPmode);
    printf("EncParInit: frmNumSmp=%d  dlyNumSmp=%d  hdrNumBit=%ld\n",
	   *frameNumSample,*delayNumSample,BsBufferNumBit(bitHeader));
    printf("EncParInit: dly=%d  buf=%d  frm=%d\n",
	   EPdelayNumSample,EPsampleBufSize,EPframeNumSample);
    printf("EncParInit: ILdly=%d  ILbuf=%d  ILoff=%d\n",
	   ILdelayNumSample,ILsampleBufSize,ILdelayOff);
    printf("EncParInit: HVXdly=%d  HVXbuf=%d  HVXoff=%d\n",
	   HVXdelayNumSample,HVXsampleBufSize,HVXdelayOff);
  }
}


/* EncParFrame() */
/* Encode one audio frame into one bit stream frame with */
/* parametric encoder core. */

void EncParFrame (
  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 *stream;
  int i;
  int hvxcFrame1;
  int mixMode;
  int ilBits;

  if (EPdebugLevel >= 1)
    printf("EncParFrame: %s  availNum=%d  num=%d  maxNum=%d\n",
	   (bitBuf==NULL)?"start up":"normal",
	   frameAvailNumBit,frameNumBit,frameMaxNumBit);

  /* update sample buffer */
  for (i=0; i<EPsampleBufSize-EPframeNumSample; i++)
    EPsampleBuf[i] = EPsampleBuf[i+EPframeNumSample];
  for (i=0; i<EPframeNumSample; i++)
    EPsampleBuf[EPsampleBufSize-EPframeNumSample+i] = sampleBuf[0][i];
  if (EPmode == MODEPAR_MIX) {
    for (i=0; i<EPsampleBufSize-EPframeNumSample; i++)
      EPsampleBuf2[i] = EPsampleBuf2[i+EPframeNumSample];
    for (i=0; i<EPframeNumSample; i++)
      EPsampleBuf2[EPsampleBufSize-EPframeNumSample+i] = sampleBuf[1][i];
  }

  if (bitBuf)
    stream = BsOpenBufferWrite(bitBuf);
  else
    stream = NULL;
  switch (EPmode) {
  case MODEPAR_HVX:
    if (bitBuf)
      EncParFrameHvx(EPsampleBuf,stream,
		     frameAvailNumBit,frameNumBit,frameMaxNumBit);
    break;
  }
  if (bitBuf==NULL)
    /* encoder start up */
    return;
  BsClose(stream);

  if (EPdebugLevel >= 1)
    printf("EncParFrame: numBit=%ld\n",BsBufferNumBit(bitBuf));

}


/* EncParFree() */
/* Free memory allocated by parametric encoder core. */

void EncParFree ()
{
  if (EPdebugLevel >= 1)
    printf("EncParFree: ...\n");

  if (!EPfree)
    return;
  if (EPmode != MODEPAR_IL)
    EncParFreeHvx();
}


/* EncHvxcInit() */
/* Init HVXC encoder core. */

void EncHvxcInit(
  int numChannel,		/* in: num audio channels */
  float fSample,		/* in: sampling frequency [Hz] */
  float bitRate,		/* in: total bit rate [bit/sec] */
  char *encPara,		/* in: encoder parameter string */
  int *frameNumSample,		/* out: num samples per frame */
  int *delayNumSample,		/* out: encoder delay (num samples) */
  BsBitBuffer *bitHeader,	/* out: header for bit stream */
  ENC_FRAME_DATA* frameData	/* out: system interface(AI 990616) */
  )
{
  int parac;
  char **parav;
  int result;
  BsBitStream *hdrStream;
  int i;
  int maxCh;

  int layer, numLayer;	/* AI 990616 */

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

  if (strstr(encPara, "-hvxc_sys") != NULL) 
    sysFlag = 1;	/* use system interface(flexmux) (AI 990616) */
  
  EPparaMode = MP4ModeParName[MODEPAR_HVX];

  if (EPdelayMode)
    ipc_encDelayMode = DM_LONG;
  else
    ipc_encDelayMode = DM_SHORT;

  if (EPvrMode)
    ipc_bitstreamMode = BM_VARIABLE;
  else
    ipc_bitstreamMode = BM_CONSTANT;


  ipc_rateMode = ENC4K;		/* 4000 kbps */
  if (bitRate <= 3999.5)
    ipc_rateMode = ENC3K;	/* 3850 kbps */
  if (bitRate <= 3849.5)
    ipc_rateMode = ENC2K;	/* 2000 kbps */

#if 0
  ipc_rateMode = 2;	/* 4000 kbps */
  if (bitRate <= 3999.5)
    ipc_rateMode = 1;	/* 3850 kbps */
  if (bitRate <= 3849.5)
    ipc_rateMode = 0;	/* 2000 kbps */
#endif

  EPrateMode = ipc_rateMode;

  if (EPdebugLevel >= 1) {
    printf("EncHvxcInit: numChannel=%d  fSample=%f  bitRate=%f  "
	   "encPara=\"%s\"\n",
	   numChannel,fSample,bitRate,encPara);
    printf("EncHvxcInit: debugLevel=%d  mode=\"%s\"\n",
	   EPdebugLevel,EPparaMode);
    printf("EncHvxcInit: encDlyMode=%d  vrMode=%d  rateMode=%d\n",
	   ipc_encDelayMode,ipc_bitstreamMode,ipc_rateMode);
  }

  EPmode = 0;	/* HVXC only */
  
  CmdLineParseFree(parav);

  EPfSample = fSample;
  EPbitRate = bitRate;

  hdrStream = BsOpenBufferWrite(bitHeader);

  /* system interface(flexmux) configuration (AI 990616) */
  /* only single HVXC layer(layer=0) */
  if (sysFlag) {
    numLayer = 1;
    initObjDescr(frameData->od);
    presetObjDescr(frameData->od, numLayer-1);
    frameData->od->streamCount.value=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 = bitRate;
      frameData->od->ESDescriptor[layer]->DecConfigDescr.avgBitrate.value = frameData->layer[layer].bitRate;
      frameData->od->ESDescriptor[layer]->DecConfigDescr.bufferSizeDB.value = 0;
      
      /* ALConfigDescriptor configuration */
#ifdef AL_CONFIG        
      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;
#endif
      /* AudioSpecificConfig configuration */
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.audioDecoderType.value = 5;	/* HVXC core, actual ObjectTypeID = 9 ? */
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.samplingFreqencyIndex.value = 0xb;	/* 8000Hz */
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.channelConfiguration.value = 1;	/* mono */
      
      /* hvxcSpecificConfig configuration */
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.hvxcSpecificConfig.HVXCvarMode.value = ipc_bitstreamMode;	/* HVXCvarMode */
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.hvxcSpecificConfig.HVXCrateMode.value = EPrateMode;	/* HVXCrateMode */
      frameData->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.specConf.hvxcSpecificConfig.extensionFlag.value = EPextensionFlag;	/* extensionFlag */
    }

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

    for (layer=0; layer<numLayer; layer++){ 
      advanceESDescr(hdrStream, frameData->od->ESDescriptor[layer], 1);
    }
    
    tmpBitBuf = BsAllocBuffer(80);	/* temporary bitBuf for flexmux(AI 990616) */
  }

  EncParInitHvx(hdrStream);
  BsClose(hdrStream);

  /* init sample buffer */
  if (CommonFreeAlloc((void**)&EPsampleBuf,
		      EPsampleBufSize*sizeof(float)) == NULL)
    CommonExit(1,"EncHvxcInit: memory allocation error");
  for (i=0; i<EPsampleBufSize; i++)
    EPsampleBuf[i] = 0;

  *frameNumSample = EPframeNumSample;
  *delayNumSample = EPdelayNumSample;

  if (EPdebugLevel >= 1) {
    printf("EncHvxcInit: modeInt=%d\n",EPmode);
    printf("EncHvxcInit: frmNumSmp=%d  dlyNumSmp=%d  hdrNumBit=%ld\n",
	   *frameNumSample,*delayNumSample,BsBufferNumBit(bitHeader));
    printf("EncHvxcInit: dly=%d  buf=%d  frm=%d\n",
	   EPdelayNumSample,EPsampleBufSize,EPframeNumSample);
    printf("EncHvxcInit: HVXdly=%d  HVXbuf=%d  HVXoff=%d\n",
	   HVXdelayNumSample,HVXsampleBufSize,HVXdelayOff);
  }
}

/* EncHvxcFrame() */
/* Encode one audio frame into one bit stream frame with */
/* HVXC encoder core. */

void EncHvxcFrame (
  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 */
  ENC_FRAME_DATA* frameData	/* in/out: system interface(AI 990616) */
  )
{
  BsBitStream *stream;
  int i;

  if (EPdebugLevel >= 1)
    printf("EncParFrame: %s  availNum=%d  num=%d  maxNum=%d\n",
	   (bitBuf==NULL)?"start up":"normal",
	   frameAvailNumBit,frameNumBit,frameMaxNumBit);

  /* update sample buffer */
  for (i=0; i<EPsampleBufSize-EPframeNumSample; i++)
    EPsampleBuf[i] = EPsampleBuf[i+EPframeNumSample];
  for (i=0; i<EPframeNumSample; i++)
    EPsampleBuf[EPsampleBufSize-EPframeNumSample+i] = sampleBuf[0][i];

  if (bitBuf) {
    if (sysFlag) {	/* for flexmux bitstream, use writeFlexMuxPDU() */
      /* firstly, audio data are stored in tmpBitBuf temporarily */
      stream = BsOpenBufferWrite(tmpBitBuf);
      EncParFrameHvx(EPsampleBuf,stream,
		     frameAvailNumBit,frameNumBit,frameMaxNumBit);
    
      BsClose(stream);
      /* secondly, (Header+Payload) are output in bitBuf */
      stream = BsOpenBufferWrite(bitBuf);
      writeFlexMuxPDU(0 , stream , tmpBitBuf);
      BsClose(stream);
    }
    else {	/* for raw bitstresm, output directly */
      stream = BsOpenBufferWrite(bitBuf);
      EncParFrameHvx(EPsampleBuf,stream,
		     frameAvailNumBit,frameNumBit,frameMaxNumBit);
    
      BsClose(stream);
    }
  }
  else {
    /* encoder start up */
  }

  if (EPdebugLevel >= 1)
    printf("EncParFrame: numBit=%ld\n",BsBufferNumBit(bitBuf));
}

/* EncParFree() */
/* Free memory allocated by parametric encoder core. */

void EncHvxcFree ()
{
  if (EPdebugLevel >= 1)
    printf("EncHvxcFree: ...\n");

  EncParFreeHvx();
}



/* end of enc_par.c */