aud_ctrl.c

是MTK公司新出来的DVD方案

static code WORD wChDelayShare[DELAY_CH_MAX] = {
  W_CHDELAY_C,
  W_CHDELAY_L,
  W_CHDELAY_R,
  W_CHDELAY_LS,
  W_CHDELAY_RS,
  W_CHDELAY_CB,
  W_CHDELAY_CH7,
  W_CHDELAY_SUB
};

// bDelay is XX0cm, here
#if (defined(INPUT_STATE_KEY_TBL_KEEP) && defined(CHNL_DELAY_USE_TIME))
void vAdspChDelay(BYTE bChannel, BYTE bDelay) large
{
  if (bChannel >= DELAY_CH_MAX)
  {
    return;
  }

  if (bDelay > MAX_CH_DELAY_LEN * 2)
  {
    bDelay = MAX_CH_DELAY_LEN * 2;
  }

  vWriteDspSharedWInfo(wChDelayShare[bChannel], (WORD)(bDelay));
  vNotifyDspSharedInfo(dwChDelayUop[bChannel]);
}
#endif

// bTime is XX msec, here
#ifdef CHNL_DELAY_USE_TIME
void vAdspChDelayTime(BYTE bChannel, BYTE bTime) large
{
#if 0
  if (bChannel >= DELAY_CH_MAX)
  {
    return;
  }

  /* 340m/sec => 34cm/ms ~= 7*5cm */
  if (bTime > ((BYTE)(MAX_CH_DELAY_LEN / 7)))
  {
    bTime = MAX_CH_DELAY_LEN;
  }
  else
  {
    bTime  = bTime * 7;
  }

  vWriteDspSharedWInfo(wChDelayShare[bChannel], (WORD)(bTime));
  vNotifyDspSharedInfo(dwChDelayUop[bChannel]);
#endif

  BYTE bDelay;
  /* 1sec => 340m => 34000cm */
  bDelay = (BYTE) (((WORD)(34*bTime))/5);

  vAdspChDelay(bChannel, bDelay);

}
#endif /* CHNL_DELAY_USE_TIME */

#ifdef PLAYER_TRIM
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static code DWRD dwChTrimUop[TRIM_CH_MAX] = {
  UOP_DSP_TRIM_C,
  UOP_DSP_TRIM_L,
  UOP_DSP_TRIM_R,
  UOP_DSP_TRIM_LS,
  UOP_DSP_TRIM_RS,
  UOP_DSP_TRIM_CB,
  UOP_DSP_TRIM_CH7,
  UOP_DSP_TRIM_SUBWOOFER,
  UOP_DSP_LFE_LEVEL
};

static code WORD wChTrimShare[TRIM_CH_MAX] = {
  D_TRIM_C,
  D_TRIM_L,
  D_TRIM_R,
  D_TRIM_LS,
  D_TRIM_RS,
  D_TRIM_CB,
  D_TRIM_CH7,
  D_TRIM_SUB,
  D_TRIM_LFE
};

void vAdspChTrim(BYTE bChannel, BYTE bLevel) large
{
  if (bChannel >= TRIM_CH_MAX)
  {
    return;
  }

  if (bLevel >= TRIM_LEVEL_MAX)
  {
    bLevel = TRIM_LEVEL_MAX - 1;
  }

  vWriteDspSharedDInfo(wChTrimShare[bChannel], TRIM[bLevel]);
  vNotifyDspSharedInfo(dwChTrimUop[bChannel]);
}

#endif /* PLAYER_TRIM */

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
#if 0 //uncall
void vAdspDialogGain(BYTE bLevel) large
{
  if (bLevel >= TRIM_LEVEL_MAX)
  {
    bLevel = TRIM_LEVEL_MAX - 1;
  }

  vWriteDspSharedDInfo(D_DIALOGUE, TRIM[bLevel]);
  vNotifyDspSharedInfo(UOP_DSP_DIALOGUE_GAIN);
}
#endif /* uncall */

#endif /* not TWO_CHANNEL_ONLY */

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspVocalAssist(BYTE bMode) large
{
  strucDspKaraFlag rTmp1;
  WORD wTmp2;

  rTmp1.Union.Byte = bReadDspSharedBInfo(B_KARAFLAG);
  rTmp1.Union.Bit.Reserve = 0;

  if (_rAudioCtrl.sEcho.fgMic == TRUE)
  {
    wTmp2 = DSP_AC3_KARA_AWARE;
  }
  else
  {
    wTmp2 = DSP_AC3_KARA_DISABLE;
  }

  /* reset to default value first */
  _rAudioCtrl.sVocal.fgVoiceCancel = FALSE;
  rTmp1.Union.Bit.VoiceCancel = FALSE;
  rTmp1.Union.Bit.LRMix = FALSE;

  switch (bMode)
  {
    case VOCAL_VOICE_CANCEL:
      _rAudioCtrl.sVocal.fgVoiceCancel = TRUE;
#ifdef VOCAL_ASSIST_MIC_CNT
      rTmp1.Union.Bit.VoiceCancel = FALSE;
      rTmp1.Union.Bit.VocalAssist = FALSE;
#else
      rTmp1.Union.Bit.VoiceCancel = TRUE;
      rTmp1.Union.Bit.VocalAssist = TRUE;
#endif
      break;

    case VOCAL_LEFT:
      rTmp1.Union.Bit.LRMix = TRUE;
      rTmp1.Union.Bit.VoiceCancel = FALSE;
#ifdef VOCAL_ASSIST_MIC_CNT
      rTmp1.Union.Bit.VocalAssist = FALSE;
#else
      rTmp1.Union.Bit.VocalAssist = TRUE;
#endif
      break;

    case VOCAL_RIGHT:
      rTmp1.Union.Bit.LRMix = TRUE;
      rTmp1.Union.Bit.VoiceCancel = FALSE;
#ifdef VOCAL_ASSIST_MIC_CNT
      rTmp1.Union.Bit.VocalAssist = FALSE;
#else
      rTmp1.Union.Bit.VocalAssist = TRUE;
#endif
      break;

    case VOCAL_AUDIO1:
      rTmp1.Union.Bit.VoiceCancel = FALSE;
      rTmp1.Union.Bit.VocalAssist = FALSE;
      break;

    case VOCAL_AUDIO2:
      rTmp1.Union.Bit.VoiceCancel = FALSE;
      rTmp1.Union.Bit.VocalAssist = FALSE;
      break;

    case VOCAL_NONE:
      rTmp1.Union.Bit.VoiceCancel = FALSE;
      rTmp1.Union.Bit.VocalAssist = FALSE;
      wTmp2 = DSP_AC3_KARA_NONE;
      break;

    case VOCAL_V1:
      rTmp1.Union.Bit.VoiceCancel = FALSE;
      rTmp1.Union.Bit.VocalAssist = FALSE;
      wTmp2 = DSP_AC3_KARA_V1;
      break;

    case VOCAL_V2:
      rTmp1.Union.Bit.VoiceCancel = FALSE;
      rTmp1.Union.Bit.VocalAssist = FALSE;
      wTmp2 = DSP_AC3_KARA_V2;
      break;

    case VOCAL_BOTH:
      rTmp1.Union.Bit.VoiceCancel = FALSE;
      rTmp1.Union.Bit.VocalAssist = FALSE;
      wTmp2 = DSP_AC3_KARA_BOTH;
      break;

    case VOCAL_NO_ASSIST:
    default:
      _rAudioCtrl.sVocal.fgVoiceCancel = FALSE;
      rTmp1.Union.Bit.VocalAssist = FALSE;
      rTmp1.Union.Bit.VoiceCancel = FALSE;
#ifdef AC3_KARA_MODE
      wTmp2 = DSP_AC3_KARA_BOTH;
#else
      wTmp2 = DSP_AC3_KARA_AWARE;
#endif      
      bMode = VOCAL_NO_ASSIST;
      break;
  }

  /* set the internal flag */
  if (bMode == VOCAL_NO_ASSIST)
  {
    _rAudioCtrl.sFlag.fgVocalAssist = FALSE;
  }
  else
  {
    _rAudioCtrl.sFlag.fgVocalAssist = TRUE;
  }

  _rAudioCtrl.sVocal.bVocalMode = bMode;

#ifdef VOCAL_ASSIST_MIC_CNT
  _rAudioCtrl.sVocal.fgMicActive = FALSE;
  _rAudioCtrl.sVocal.bMicCnt = 0;
#endif

  /* notify the ADSP */
  if (bReadDspSharedBInfo(B_KARAFLAG) != rTmp1.Union.Byte)
  {
    vWriteDspSharedBInfo(B_KARAFLAG, rTmp1.Union.Byte);
    vNotifyDspSharedInfo(UOP_DSP_KARAOKE_FLAG);
  }

  if (_rAudioCtrl.sVocal.fgMelody == FALSE)
  {
    wTmp2 |= DSP_AC3_NO_MELODY;
  }

  if (wReadDspSharedWInfo(W_AC3KARAMOD) != wTmp2)
  {
#ifdef RS232_LOG
   DBGLogS(" write DSP shared  ");
   DBGLogB(bHiByte(wTmp2),bLoByte(wTmp2),0xff,0xff);
   DBGLogS("\n");
#endif    
    vWriteDspSharedWInfo(W_AC3KARAMOD, wTmp2);
    vNotifyDspSharedInfo(UOP_DSP_AC3_KARAOKE_MODE);
  }
}
// *********************************************************************
// Function : void vAdspKaraLR(BYTE bMode)
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspKaraLR(BYTE bMode) large
{
  BYTE bLevel;
#ifdef VOCAL_ASSIST_MIC_CNT
  strucDspKaraFlag rTmp;
#endif

  if (bMode == KARA_LEFT)
  {
    bLevel = LRMIX_LEFT_ONLY;
  }
  else if (bMode == KARA_RIGHT)
  {
    bLevel = LRMIX_RIGHT_ONLY;
  }
#ifdef VOCAL_ASSIST_MIC_CNT
  else if (bMode == KARA_STEREO)
  {
    rTmp.Union.Byte = bReadDspSharedBInfo(B_KARAFLAG);
    rTmp.Union.Bit.LRMix = FALSE;
    vWriteDspSharedBInfo(B_KARAFLAG, rTmp.Union.Byte);
    vNotifyDspSharedInfo(UOP_DSP_KARAOKE_FLAG);    
    return;
  }
#endif /* VOCAL_ASSIST_MIC_CNT */
  else
  {
    return;
  }

  _rAudioCtrl.bKaraMixRatioLR = bLevel;

  if (fgIsVocalAssistOn())
  {
    vWriteDspSharedDInfo(D_LRMIXRATIO, LRMIX[bLevel]);
    vNotifyDspSharedInfo(UOP_DSP_LR_MIX_RATIO);

  #ifdef VOCAL_ASSIST_MIC_CNT /* if the state is not sync */
    rTmp.Union.Byte = bReadDspSharedBInfo(B_KARAFLAG);
    rTmp.Union.Bit.LRMix = TRUE;
    rTmp.Union.Bit.VoiceCancel = FALSE;
    rTmp.Union.Bit.VocalAssist = FALSE;
    rTmp.Union.Bit.Reserve = 0;

    if (bReadDspSharedBInfo(B_KARAFLAG) != rTmp.Union.Byte)
    {
      vWriteDspSharedBInfo(B_KARAFLAG, rTmp.Union.Byte);
      vNotifyDspSharedInfo(UOP_DSP_KARAOKE_FLAG);
    }
  #endif /* VOCAL_ASSIST_MIC_CNT */
  }
}

#ifdef PLAYER_KARAOKE
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspKaraMode(BYTE bMode) large
{
  /* note: the ADSP will clear its buffer automatically, so no need to mute first */

  /* TODO: restore vocal asssit and LR mix setting */
  /* TODO: if set to karaoke mode and SPDIF is on, should we force to PCM output? */
  strucDspMicFlag rTmp;
  BYTE bChange;

  bChange = FALSE;

  rTmp.Union.Byte = bReadDspSharedBInfo(B_MPFLAG);
  rTmp.Union.Bit.Reserve = 0;

  if (bMode == KARA_MODE_ENABLE)
  {
    _rAudioCtrl.sFlag.fgKaraMode = TRUE;
    _rAudioCtrl.sEcho.fgMic = TRUE;

    if (rTmp.Union.Bit.On != TRUE)
    {
      rTmp.Union.Bit.On = TRUE;
      bChange = TRUE;
    }

    /* set to two channel downmix mode */
  }
  else
  {
    _rAudioCtrl.sFlag.fgKaraMode = FALSE;
    _rAudioCtrl.sEcho.fgMic = FALSE;

    if (rTmp.Union.Bit.On != FALSE)
    {
      rTmp.Union.Bit.On = FALSE;
      bChange = TRUE;
    }

    /* restore the channel config is needed */
  }

#ifdef VOCAL_ASSIST_MIC_CNT
  _rAudioCtrl.sVocal.fgMicActive = FALSE;
  _rAudioCtrl.sVocal.bMicCnt = 0;
#endif

  #ifdef KARA_FORCE_SPDIF_PCM
  if ((_rAudioCtrl.sIEC.bFormat == SPDIF_FLAG_RAW) && (_rAudioCtrl.sFlag.fgSpdifOn == TRUE))
  {
    if (bMode == KARA_MODE_ENABLE)
    {
      /* set to PCM mode */
      vWriteDspSharedBInfo(B_IECFLAG, SPDIF_FLAG_PCM);
      vNotifyDspSharedInfo(UOP_DSP_IEC_FLAG);
    }
    else
    {
      /* restore to RAW mode */
      vWriteDspSharedBInfo(B_IECFLAG, SPDIF_FLAG_RAW);
      vNotifyDspSharedInfo(UOP_DSP_IEC_FLAG);
    }
  }
  #endif

  if (bChange)
  {
    vWriteDspSharedBInfo(B_MPFLAG, rTmp.Union.Byte);

  #ifdef MIC_AUTOMUTE
    /* after microphone switch, always set microphone mix off */
    vWriteDspSharedWInfo(B_MP_CHMIX, 0);

    _rAudioCtrl.bMicAutomuteCnt = MIC_AUTOMUTE_ON_CNT;
  #endif
  
    vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_FLAG);
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspSetMicEq(BYTE bMode) large
{
  strucDspMicFlag rTmp;

  rTmp.Union.Byte = bReadDspSharedBInfo(B_MPFLAG);
  rTmp.Union.Bit.Reserve = 0;

  if (bMode == ADSP_ON)
  {
    rTmp.Union.Bit.Eq = TRUE;
    /* set to two channel downmix mode */
  }
  else
  {
    rTmp.Union.Bit.Eq = FALSE;
    /* restore the channel config is needed */
  }

  vWriteDspSharedBInfo(B_MPFLAG, rTmp.Union.Byte);
  vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_FLAG);
}



#ifdef VOCAL_ASSIST_MIC_CNT
// *********************************************************************
// Function : void vAdspKaraVC(BOOL fgOn)
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspKaraVC(BOOL fgOn) large
{
  strucDspKaraFlag rTmp1;

  rTmp1.Union.Byte = bReadDspSharedBInfo(B_KARAFLAG);

  if (rTmp1.Union.Bit.VoiceCancel != fgOn)
  {
    rTmp1.Union.Bit.VoiceCancel = fgOn;

    /* notify the ADSP */
    vWriteDspSharedBInfo(B_KARAFLAG, rTmp1.Union.Byte);
    vNotifyDspSharedInfo(UOP_DSP_KARAOKE_FLAG);
  }
}
#endif /* VOCAL_ASSIST_MIC_CNT */



#ifdef AC3_KARA_MODE
  #ifdef AC3_KARA_MELODY
// *********************************************************************
// Function : void vAdspKaraMelody(BOOL fgOn)
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspKaraMelody(BOOL fgOn) large
{
  WORD wTmp1 = wReadDspSharedWInfo(W_AC3KARAMOD);

  _rAudioCtrl.sVocal.fgMelody = fgOn;

  if ((fgOn == TRUE) && ((wTmp1 & DSP_AC3_NO_MELODY) != 0))
  {
    wTmp1 &= (~DSP_AC3_NO_MELODY);
  }
  else if ((fgOn == FALSE) && ((wTmp1 & DSP_AC3_NO_MELODY) == 0))
  {
    wTmp1 |= DSP_AC3_NO_MELODY;
  }
  else
  {
    return;
  }

  vWriteDspSharedWInfo(W_AC3KARAMOD, wTmp1);
  vNotifyDspSharedInfo(UOP_DSP_AC3_KARAOKE_MODE);
}
  #endif /* AC3_KARA_MELODY */

// *********************************************************************
// Function : void vAdspKaraAC3(BYTE bMode)
// Description :