aud_ctrl.c

是MTK公司新出来的DVD方案

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BOOL fgCheckIsVSurrValid(BYTE bAudioType, BYTE bDiscType, BYTE bInitState) large
{
  BOOL fgValid;
#ifdef DOLBY_PROLOGIC
  strucPrologicFlag rTmp;
#elif (defiend(DOLBY_PROLOGIC2))
  strucDspPLIIConfig rTmp;
#endif

  if (bInitState == SV_DISC_IDENTIFIED)
  {
    /* check multi-channel bit-stream */
    switch (bDiscType)
    {
      case SV_DVD_VIDEO:
      case SV_DVD_AUDIO:
      case SV_MINI_DVD:
      case SV_DTS_CS:
        fgValid = FALSE;
        break;

      case SV_DATA:
        fgValid = TRUE;
        break;

      case SV_SVCD:
      case SV_CVD:
      case SV_VCD3_0:
      case SV_VCD2_0:
      case SV_VCD1_1:
      case SV_VCD6_0:
      case SV_VCD6_1:
      case SV_PCD:
      case SV_CDDA:
      case SV_CDG:
      case SV_HDCD:
      default:
        fgValid = TRUE;
        break;
    } /* switch (bDiscType) */
  }
  else
  {
    fgValid = TRUE;
  }

  /* check Pro-Logic */
#ifdef DOLBY_PROLOGIC
  rTmp.Union.Word = wReadDspSharedWInfo(W_PROLOGICCFG);

  if (rTmp.Union.Bit.On == TRUE)
  {
    fgValid = FALSE;
  }
#elif (defiend(DOLBY_PROLOGIC2))
  rTmp.Union.Word = wReadDspSharedWInfo(W_PLIICONFIG);

  if (rConfig.Union.Bit.En == TRUE)
  {
    fgValid = FALSE;
  }
#endif /* DOLBY_PROLOGIC2 */

  return (fgValid);
}
#endif /* !SET_VSURR_IN_SPKCFG && PLAYER_SURROUND */

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspAudioTypeChange(BYTE bAudioType, BYTE bDiscType, BYTE bInitState) large
{
  BYTE bAudBsCfg = bReadAUD(AUD_BSCFG);
  BYTE bTmp;

#ifdef CDDA_FAST_LOWER_VOL
  if ((bInitState == SV_TRAY_OPENING) &&
      (_rAudioCtrl.sVol.fgLower == TRUE))
  {
    bTmp = bAdspCurrVol();
    vWriteDspSharedDInfo(D_VOL, VOLUME[bTmp]);
    vNotifyDspSharedInfo(UOP_DSP_MASTER_VOLUME);
    _rAudioCtrl.sVol.fgLower = FALSE;
  }
#endif /* CDDA_FAST_LOWER_VOL */

  if (bInitState == SV_DISC_IDENTIFIED)
  {
    _rAudioCtrl.sFlag.fgDspStop = FALSE;
  }
  else /* disc not identified */
  {
    _rAudioCtrl.sFlag.fgDspStop = TRUE;
    return;
  }

  if (bAudioType == SV_A_CODE_NONE)
  {
    bAudBsCfg = 0x00;

#if (!defined(SET_VSURR_IN_SPKCFG) && defined(PLAYER_SURROUND))
    /* for virtual surround */
    bTmp = bReadDspSharedBInfo(B_VSURRFLAG);
    if (fgCheckIsVSurrValid(bAudioType, bDiscType, SV_DISC_IDENTIFIED))
    {
      /* virtual surround is allowed */
      if ((_rAudioCtrl.uSurrType.Bit.bVsurrType == AUD_VSURR_MTK) &&
          (bTmp == DSP_VSURR_OFF))
      {
        vWriteDspSharedBInfo(B_VSURRFLAG, DSP_VSURR_MTK);
        vNotifyDspSharedInfo(UOP_DSP_VIRTUAL_SURROUND_FLAG);
      }
    }
    else
    {
      /* virtual surround is not allowed */
      if (bTmp != DSP_VSURR_OFF)
      {
        vWriteDspSharedBInfo(B_VSURRFLAG, DSP_VSURR_OFF);
        vNotifyDspSharedInfo(UOP_DSP_VIRTUAL_SURROUND_FLAG);
      }
    }
#endif /* !SET_VSURR_IN_SPKCFG && PLAYER_SURROUND */
  }
  else /* audio stream type valid */
  {
    bAudBsCfg = 0x00;

    switch (bAudioType)
    {
      case SV_A_CODE_MPEG:
        break;

      case SV_A_CODE_DTS:
#ifdef DTS_NO_KEY_SHIFT
        if (_rAudioCtrl.cCurKey != ZERO_KEY_LEVEL)
        {
          _rAudioCtrl.cCurKey = ZERO_KEY_LEVEL;
          vWriteDspSharedWInfo(W_KEYLEVEL, (WORD)(_rAudioCtrl.cCurKey));
          vNotifyDspSharedInfo(UOP_DSP_KEY_SHIFT_LEVEL);
        }
#endif /* DTS_NO_KEY_SHIFT */
        break;

      case SV_A_CODE_PCM:
        if (fgIsDvdPlay())
        {
          bAudBsCfg = 0x02;
        }
        break;

      case SV_A_CODE_AC3:
        break;

      case SV_A_CODE_SDDS:
        break;

      case SV_A_CODE_MP3:
        break;

      case SV_A_CODE_WAV:
        break;

      case SV_A_CODE_MLP:
        break;

      case SV_A_CODE_WMA:
        break;

      case SV_A_CODE_HDCD:
        break;

      default:
        break;
    }
  } /* audio stream type valid */

  if (bAudBsCfg != bReadAUD(AUD_BSCFG))
  {
    WriteAUD(AUD_BSCFG, bAudBsCfg);
  }
}

#if 0
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspProcMode(BYTE bMode, BOOL fgOnOff) large
{
  WORD wFlag;
  WORD wMask;

  wFlag = wReadDspSharedWInfo(W_PROCMOD);

  switch (bMode)
  {
    case AUD_BASS_TO_SUB:
      wMask = FLAG_BASS_TO_SUB;
      break;

    case AUD_SPECTRUM:
      wMask = FLAG_SPECTRUM_ON;
      break;

    default:
      return;
  }

  if (((wFlag & wMask) != 0) && (fgOnOff == ADSP_OFF))
  {
    wFlag &= (~wMask);
    vWriteDspSharedWInfo(W_PROCMOD, wFlag);
    vNotifyDspSharedInfo(UOP_DSP_PROCESSING_MODE);
  }
  else if (((wFlag & wMask) == 0) && (fgOnOff == ADSP_ON))
  {
    wFlag |= wMask;
    vWriteDspSharedWInfo(W_PROCMOD, wFlag);
    vNotifyDspSharedInfo(UOP_DSP_PROCESSING_MODE);
  }
}
#endif

#ifdef PLAYER_SURROUND
  #ifndef NO_POST_DRC_ON_OFF

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
#if 0//incall
void vAdspPostDRC(BYTE bMode) large
{
  WORD wFlag;

  wFlag = wReadDspSharedWInfo(W_PROCMOD);

  switch (bMode)
  {
    case AUD_DRC_POST_OFF:
      wFlag &= (~(FLAG_POST_AUTO_ON | FLAG_POST_DRC_ON));
      break;

    case AUD_DRC_POST_ON:
      wFlag &= (~FLAG_POST_AUTO_ON);
      wFlag |= FLAG_POST_DRC_ON;
      break;

    case AUD_DRC_POST_AUTO:
      wFlag |= FLAG_POST_AUTO_ON;
      break;

    default:
      return;
  }

  vWriteDspSharedWInfo(W_PROCMOD, wFlag);
  vNotifyDspSharedInfo(UOP_DSP_PROCESSING_MODE);
}
#endif /* uncall */
  #endif /* NO_POST_DRC_ON_OFF */
#endif /* PLAYER_SURROUND */

// *********************************************************************
// Function :
// Description : adjust system master volume
// Parameter :
// Return    :
// *********************************************************************
void vAdspVolume(BYTE bLevel) large
{
  if (bLevel > MAX_VOL_LEVEL)
  {
    bLevel = MAX_VOL_LEVEL;
  }
  else if (bLevel < MIN_VOL_LEVEL)
  {
    bLevel = MIN_VOL_LEVEL;
  }

#ifdef VOL_ZERO_AS_MUTE
  if ((_rAudioCtrl.sVol.bCurVol == 0) && (bLevel != 0)
  #ifdef SPDIF_MODE_CHANGE_MUTE
      && (fgIsIecSwitching() == FALSE)
  #endif
  #ifdef PCM_FREQ_CHANGE_MUTE
      && (fgIsPcmFreqSwitching() == FALSE)
  #endif
     )
  {
    vNotifyDspSharedInfo(UOP_DSP_UNMUTE);
  }
#endif

  _rAudioCtrl.sVol.bCurVol = bLevel;

#ifdef VOL_ZERO_AS_MUTE
  if ((bLevel == 0)
  #ifdef SPDIF_MODE_CHANGE_MUTE
      && (fgIsIecSwitching() == FALSE)
  #endif
  #ifdef PCM_FREQ_CHANGE_MUTE
      && (fgIsPcmFreqSwitching() == FALSE)
  #endif
     )
  {
    vNotifyDspSharedInfo(UOP_DSP_RAW_MUTE);
  }
#endif

  if ((fgIsMute() == FALSE)
  #ifdef SPDIF_MODE_CHANGE_MUTE
      && (fgIsIecSwitching() == FALSE)
  #endif
  #ifdef PCM_FREQ_CHANGE_MUTE
      && (fgIsPcmFreqSwitching() == FALSE)
  #endif
     )
  {
    if (dwReadDspSharedDInfo(D_VOL) != VOLUME[bLevel])
    {
      vWriteDspSharedDInfo(D_VOL, VOLUME[bLevel]);
      vNotifyDspSharedInfo(UOP_DSP_MASTER_VOLUME);
    }
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspMute(BOOL fgOnOff, BYTE bTime) large
{
  BYTE bIecMute = bReadDspSharedBInfo(B_IEC_MUTE);

  /* doing optional mute on/off control here */
  if (fgOnOff == ADSP_ON) /* mute on */
  {
    if (1
#ifdef SPDIF_MODE_CHANGE_MUTE
        && (fgIsIecSwitching() == FALSE)
#endif
#ifdef PCM_FREQ_CHANGE_MUTE
        && (fgIsPcmFreqSwitching() == FALSE)
#endif
       )
    {
#ifdef MUTE_KEY_MUTE_SPDIF
      vNotifyDspSharedInfo(UOP_DSP_RAW_MUTE);
#endif
#ifdef TRACE_WRONG_VOL
      vWriteDspSharedDInfo(D_VOL, 1);
#else
      vWriteDspSharedDInfo(D_VOL, 0);
#endif
      vNotifyDspSharedInfo(UOP_DSP_MASTER_VOLUME);
    } /* fgIsIecSwitching() == FALSE */

    if (bTime == 0)
    {
      _rAudioCtrl.sVol.fgIsMute = TRUE;
      vResetIecSwitching();
#ifdef PCM_FREQ_CHANGE_MUTE
      vResetPcmFreqSwitching();
#endif
    }
    else
    {
      if (fgIsIecSwitching() == FALSE)
      {
        _rAudioCtrl.sIEC.bState = AUD_IEC_SW_UNMUTE;
      }

      /* temp mute only, not really mute, don't change flag */
      if (bTime > _rAudioCtrl.sIEC.bCnt)
      {
        _rAudioCtrl.sIEC.bCnt = bTime;
      }
    }
  }
  else if (fgOnOff == ADSP_OFF) /* mute off */
  {
    _rAudioCtrl.sVol.fgIsMute = FALSE;

    if (1
#ifdef SPDIF_MODE_CHANGE_MUTE
        && (fgIsIecSwitching() == FALSE)
#endif
#ifdef PCM_FREQ_CHANGE_MUTE
        && (fgIsPcmFreqSwitching() == FALSE)
#endif
        )
    {
#ifdef MUTE_KEY_MUTE_SPDIF
      vNotifyDspSharedInfo(UOP_DSP_UNMUTE);
#endif
      vWriteDspSharedDInfo(D_VOL, VOLUME[_rAudioCtrl.sVol.bCurVol]);
      vNotifyDspSharedInfo(UOP_DSP_MASTER_VOLUME);
    }
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspLR(BYTE bMode) large
{
  strucDspKaraFlag rTmp;
  BYTE bType;

  rTmp.Union.Byte = bReadDspSharedBInfo(B_KARAFLAG);

  rTmp.Union.Bit.VoiceCancel = FALSE;
  rTmp.Union.Bit.VocalAssist = FALSE;
  rTmp.Union.Bit.Reserve = 0;

  switch (bMode)
  {
    case AUDIO_MONO_LEFT:
      bType = LRMIX_LEFT_ONLY;
      rTmp.Union.Bit.LRMix = TRUE;
      break;

    case AUDIO_MONO_RIGHT:
      bType = LRMIX_RIGHT_ONLY;
      rTmp.Union.Bit.LRMix = TRUE;
      break;

    case AUDIO_MONO_MIXED:
      bType = LRMIX_BOTH;
      rTmp.Union.Bit.LRMix = TRUE;
      break;

    case AUDIO_STEREO:
    default:
      rTmp.Union.Bit.LRMix = FALSE;
      bMode = AUDIO_STEREO;
      break;
  } /* switch() */

  vWriteDspSharedBInfo(B_KARAFLAG, rTmp.Union.Byte);
  vNotifyDspSharedInfo(UOP_DSP_KARAOKE_FLAG);

  _rAudioCtrl.sVocal.bVocalMode = bMode;
  _rAudioCtrl.sVocal.fgVoiceCancel = FALSE;

  if (_rAudioCtrl.sVocal.bVocalMode != AUDIO_STEREO)
  {
    vWriteDspSharedDInfo(D_LRMIXRATIO, LRMIX[bType]);
    vNotifyDspSharedInfo(UOP_DSP_LR_MIX_RATIO);
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspSpkDownmix(strucDownmixConfig rSpk) large
{
  strucDspSpkConfig rTmp;
//  BYTE bChanged;

  rTmp.Union.Dwrd = 0;

  switch (rSpk.Mode)
  {
    case DOWNMIX_OFF:
      rTmp.Union.Bit.Type = SPK_CFG_LR;
      _rAudioCtrl.sFlag.fgDownmixOn = FALSE;
      break;

    case DOWNMIX_LO_RO:
      rTmp.Union.Bit.Type = SPK_CFG_LR;
      _rAudioCtrl.sFlag.fgDownmixOn = TRUE;
      break;

    case DOWNMIX_LT_RT:
    default:
      rTmp.Union.Bit.Type = SPK_CFG_LT_RT;
      _rAudioCtrl.sFlag.fgDownmixOn = TRUE;
      break;
  }

  if (rSpk.Front == SPK_LARGE)
  {
    rTmp.Union.Bit.LSize = ADSP_SPK_LARGE;
    rTmp.Union.Bit.RSize = ADSP_SPK_LARGE;
  }
  else
  {
    rTmp.Union.Bit.LSize = ADSP_SPK_SMALL;
    rTmp.Union.Bit.RSize = ADSP_SPK_SMALL;
  }

  if (rSpk.Sub == ADSP_ON)
  {
    rTmp.Union.Bit.SubOn = TRUE;