aud_ctrl.c

是MTK公司新出来的DVD方案

  }
  else
  {
    rTmp.Union.Bit.SubOn = FALSE;
  }

  _rAudioCtrl.sFlag.bSpkFormat = rTmp.Union.Bit.Type;

#ifdef SPDIF_PCM_FORCE_DOWNMIX
  if (_rAudioCtrl.sIEC.bFormat == SPDIF_FLAG_PCM)
  {
    rTmp.Union.Bit.Type = SPK_CFG_LR; /* default is LO/RO */
  }
#endif /* SPDIF_PCM_FORCE_DOWNMIX */

  if (_rAudioCtrl.sFlag.fgDownmixOn != FALSE)
  {
    vWriteDspSharedDInfo(D_SPKCFG, rTmp.Union.Dwrd);
    vNotifyDspSharedInfo(UOP_DSP_CONFIG_SPEAKER);
  }
}

// *********************************************************************
// Function : void vAdspAc3DualMono(BYTE bMode) large
// Description : bMode :
//                    DM_STEREO
//                    DM_L_MONO
//                    DM_R_MONO
//                    DM_M_MONO
// Parameter :
// Return    :
// *********************************************************************
void vAdspAc3DualMono(BYTE bMode) large
{
  vWriteDspSharedWInfo(W_AC3DUALMODE, bMode);
  vNotifyDspSharedInfo(UOP_DSP_AC3_DUAL_MONO_MODE);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspDynamicRange(BYTE bLevel) large
{
  if (bLevel >= DNR_MAX)
  {
    bLevel = DNR_MAX - 1;
  }

  vWriteDspSharedDInfo(D_AC3DYN_LOW, DYNAMIC_RANGE[bLevel]);
  vNotifyDspSharedInfo(UOP_DSP_AC3_DYNAMIC_LOW);

  vWriteDspSharedDInfo(D_AC3DYN_HIGH, DYNAMIC_RANGE[bLevel]);
  vNotifyDspSharedInfo(UOP_DSP_AC3_DYNAMIC_HIGH);
}

// *********************************************************************
// Function :
// Description : for global setting
// Parameter :
// Return    :
// *********************************************************************
void vAdspSpdifMode(BYTE bMode) large
{
#if 0
  BYTE bTmp;
  BYTE bIecMute;

  bTmp = bReadDspSharedBInfo(B_IECFLAG);
  bIecMute = bReadDspSharedBInfo(B_IEC_MUTE);
#endif
  switch (bMode)
  {
    case SPDIF_OFF:
      _rAudioCtrl.sFlag.fgSpdifOn = FALSE;
      break;

    case SPDIF_RAW:
      _rAudioCtrl.sFlag.fgSpdifOn = TRUE;
      _rAudioCtrl.sIEC.bFormat = SPDIF_FLAG_RAW;
      _rAudioCtrl.sIEC.bNextMode = SPDIF_FLAG_RAW;
      break;

    case SPDIF_PCM:
      _rAudioCtrl.sFlag.fgSpdifOn = TRUE;
      _rAudioCtrl.sIEC.bFormat = SPDIF_FLAG_PCM;
      _rAudioCtrl.sIEC.bNextMode = SPDIF_FLAG_PCM;
      break;

    case SPDIF_MANUAL:
      _rAudioCtrl.sFlag.fgSpdifOn = TRUE;
      _rAudioCtrl.sIEC.bFormat = SPDIF_FLAG_MANUAL;
      _rAudioCtrl.sIEC.bNextMode = SPDIF_FLAG_MANUAL;
      break;

    default:
      /* invalid option */
      return;
  }

#ifdef SPDIF_PCM_FORCE_DOWNMIX
  #ifdef KARA_FORCE_SPDIF_PCM
  if (bMode != SPDIF_OFF)
  {
    if (fgIsKaraMode())
    {
      if (_rAudioCtrl.sIEC.bNextMode != SPDIF_FLAG_PCM)
      {
        _rAudioCtrl.sIEC.bNextMode = SPDIF_FLAG_PCM;
      }
    }
  }
  #endif /* KARA_FORCE_SPDIF_PCM */
#endif /* SPDIF_PCM_FORCE_DOWNMIX */

#ifdef SPDIF_MODE_CHANGE_MUTE
  // mute digital
  if(!_rAudioCtrl.sFlag.fgSpdifOn)
  {
    vNotifyDspSharedInfo(UOP_DSP_RAW_MUTE);
  }
  // mute analog
  #ifdef TRACE_WRONG_VOL
  vWriteDspSharedDInfo(D_VOL, 1);
  #else
  vWriteDspSharedDInfo(D_VOL, 0);
  #endif
  vNotifyDspSharedInfo(UOP_DSP_MASTER_VOLUME);
#endif /* SPDIF_MODE_CHANGE_MUTE */

  vSetIecSwitching();
}

// *********************************************************************
// Function : void vAdspSpdifManualSet(BYTE bType, BYTE bMode)
// Description :
// Parameter : bType: SPDIF_CDDA, SPDIF_AC3, SPDIF_DTS, SPDIF_MPEG
//             bMode: EV_AO_OFF, EV_RAW, EV_PCM
// Return    :
// *********************************************************************
static code WORD wSpdifManualShare[SPDIF_TYPE_MAX] = {
  B_IEC_CDDA, /* SPDIF_CDDA */
  B_IEC_AC3,  /* SPDIF_AC3  */
  B_IEC_DTS,  /* SPDIF_DTS  */
  B_IEC_MP2   /* SPDIF_MPEG */
};

static code BYTE pbSpdifManualSet[3] = {
  SPDIF_MANUAL_MUTE, /* EV_AO_OFF */
  SPDIF_MANUAL_RAW,  /* EV_RAW    */
  SPDIF_MANUAL_PCM   /* EV_PCM    */
};

#if 0 //uncall
void vAdspSpdifManualSet(BYTE bType, BYTE bMode) large
{
  BYTE bTmp;
  BOOL fgMute = FALSE;

  /* error check */
  if (bType >= SPDIF_TYPE_MAX)
  {
    return;
  }

  if (bMode > EV_PCM)
  {
    bMode = EV_PCM;
  }

  // prevent pop noise for VCD
#ifdef SPDIF_MODE_CHANGE_MUTE
  bTmp = bSharedInfo(SI_A_CODE_MODE);

  switch (bTmp)
  {
    case SV_A_CODE_MPEG:
      if (bType == SPDIF_MPEG)
      {
        fgMute = TRUE;
      }
      break;

    case SV_A_CODE_DTS:
      if (bType == SPDIF_DTS)
      {
        fgMute = TRUE;
      }
      break;

    case SV_A_CODE_PCM:
      if (fgIsCddaPlay() && (bType == SPDIF_CDDA))
      {
        fgMute = TRUE;
      }
      break;

    case SV_A_CODE_AC3:
      if (bType == SPDIF_AC3)
      {
        fgMute = TRUE;
      }
      break;

    case SV_A_CODE_HDCD:
      if (fgIsCddaPlay() && (bType == SPDIF_CDDA))
      {
        fgMute = TRUE;
      }
      break;

    default:
      fgMute = FALSE;
      break;
  }

  if (fgMute == TRUE)
  {
    // mute digital
    vNotifyDspSharedInfo(UOP_DSP_RAW_MUTE);
    // mute analog
    #ifdef TRACE_WRONG_VOL
    vWriteDspSharedDInfo(D_VOL, 1);
    #else
    vWriteDspSharedDInfo(D_VOL, 0);
    #endif
    vNotifyDspSharedInfo(UOP_DSP_MASTER_VOLUME);

    vSetIecSwitching();
  }
#endif /* SPDIF_MODE_CHANGE_MUTE */

  vWriteDspSharedBInfo(wSpdifManualShare[bType], pbSpdifManualSet[bMode]);
  vNotifyDspSharedInfo(UOP_DSP_IEC_FLAG);
}
#endif /* uncall */

#ifndef TWO_CHANNEL_ONLY
  #ifdef SPDIF_PCM_CH_SELECT
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
#if 0//uncall
void vAdspSpdifCh(BYTE bCh) large
{
  BYTE bTmp;

  bTmp = bReadDspSharedBInfo(B_IEC_PCMCH);

  /* error check */
  if (bCh > SPDIF_IEC_CH78)
  {
    bCh = SPDIF_IEC_LR;
  }

    #ifdef SPDIF_PCM_FORCE_DOWNMIX
  if (_rAudioCtrl.sIEC.bFormat == SPDIF_FLAG_PCM)
  {
    bCh = SPDIF_IEC_LR;
  }
    #endif /* SPDIF_PCM_FORCE_DOWNMIX */

  if (bTmp != bCh)
  {
    vWriteDspSharedBInfo(B_IEC_PCMCH, bCh);
    vNotifyDspSharedInfo(UOP_DSP_CONFIG_MICROPHONE_IEC);
  }
}
#endif//uncall
  #endif /* SPDIF_PCM_CH_SELECT */

  #ifdef SPDIF_PCM_FREQ_SELECT
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    : None
// *********************************************************************
#if 0 //uncall
void vAdspPcmFreq(BYTE bMode) large
{
    #ifdef PCM_FREQ_CHANGE_MUTE
  // mute digital
  vNotifyDspSharedInfo(UOP_DSP_RAW_MUTE);
  // mute analog
      #ifdef TRACE_WRONG_VOL
  vWriteDspSharedDInfo(D_VOL, 1);
      #else
  vWriteDspSharedDInfo(D_VOL, 0);
      #endif
  vNotifyDspSharedInfo(UOP_DSP_MASTER_VOLUME);

  switch (bMode)
  {
    case ADSP_IEC_PCM_96K:
      _rAudioCtrl.sPcmFreq.bFreq = ADSP_IEC_PCM_96K;
      break;

    case ADSP_IEC_PCM_192K:
      _rAudioCtrl.sPcmFreq.bFreq = ADSP_IEC_PCM_192K;
      break;

    case ADSP_IEC_PCM_48K:
    default:
      _rAudioCtrl.sPcmFreq.bFreq = ADSP_IEC_PCM_48K;
      break;
  }

  vSetPcmFreqSwitching();
    #else /* not define PCM_FREQ_CHANGE_MUTE */
  switch (bMode)
  {
    case ADSP_IEC_PCM_96K:
      bMode = ADSP_IEC_PCM_96K;
      break;

    case ADSP_IEC_PCM_192K:
      bMode = ADSP_IEC_PCM_192K;
      break;

    case ADSP_IEC_PCM_48K:
    default:
      bMode = ADSP_IEC_PCM_48K;
      break;
  }

  // TODO: add notification here
  if (bMode != bReadDspSharedBInfo(B_IEC_MAX_FREQ))
  {
    vWriteDspSharedBInfo(B_IEC_MAX_FREQ, bMode);
    vNotifyDspSharedInfo(UOP_DSP_IEC_DOWN_SAMPLE);
  }
    #endif /* not define PCM_FREQ_CHANGE_MUTE */
}
#endif /* uncall */
  #endif /* SPDIF_PCM_FREQ_SELECT */

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static code BYTE pbSpkToCfg[16] =
{
  SPK_CFG_LR,     /* 0000:None */
  SPK_CFG_LR,     /* 0001:LR */
  SPK_CFG_21,     /* 0010:LS */
  SPK_CFG_22,     /* 0011:LR+LS */
  SPK_CFG_22,     /* 0100: RS */
  SPK_CFG_22,     /* 0101: LR+RS */
  SPK_CFG_22,     /* 0110: LS+RS */
  SPK_CFG_22,     /* 0111: LR+LS+RS */
  SPK_CFG_MONO,   /* 1000: C */
  SPK_CFG_30,     /* 1001: C+LR */
  SPK_CFG_32,     /* 1010: C+LS */
  SPK_CFG_32,     /* 1011: C+LR+LS */
  SPK_CFG_32,     /* 1100: C+RS */
  SPK_CFG_32,     /* 1101: C+LR+RS */
  SPK_CFG_32,     /* 1110: C+LS+RS */
  SPK_CFG_32      /* 1111: C+LR+LS+RS */
};

#define SPK_TO_CFG_MASK  (SPK_LR | SPK_LS_RS | SPK_CNTR)

void vAdspSpkConfig(strucSpkConfig rSpk) large
{
  strucDspSpkConfig rTmp;

  BYTE bCurrSpk = SPK_LR;

  if (_rAudioCtrl.sFlag.fgDownmixOn == TRUE)
  {
    return;
  }

#ifdef SPDIF_PCM_FORCE_DOWNMIX
  if (_rAudioCtrl.sIEC.bFormat == SPDIF_FLAG_PCM)
  {
    return;
  }
#endif /* SPDIF_PCM_FORCE_DOWNMIX */

  rTmp.Union.Dwrd = 0;

  if (rSpk.Fr == 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;
  }

  switch (rSpk.Cntr)
  {
    case SPK_LARGE:
      bCurrSpk |= SPK_CNTR;
      rTmp.Union.Bit.CSize = ADSP_SPK_LARGE;
      break;

    case SPK_OFF:
      bCurrSpk &= (~SPK_CNTR);
      break;

    case SPK_SMALL:
    default:
      bCurrSpk |= SPK_CNTR;
      rTmp.Union.Bit.CSize = ADSP_SPK_SMALL;
      break;
  }

  switch (rSpk.Rear)
  {
    case SPK_LARGE:
      bCurrSpk |= SPK_LS_RS;
      rTmp.Union.Bit.LsSize = ADSP_SPK_LARGE;
      rTmp.Union.Bit.RsSize = ADSP_SPK_LARGE;
      break;

    case SPK_OFF:
      bCurrSpk &= (~SPK_LS_RS);
      break;

    case SPK_SMALL:
    default:
      bCurrSpk |= SPK_LS_RS;
      rTmp.Union.Bit.LsSize = ADSP_SPK_SMALL;
      rTmp.Union.Bit.RsSize = ADSP_SPK_SMALL;
      break;
  }

  if (rSpk.Sub == ADSP_ON)
  {
    bCurrSpk |= SPK_SUB;
    rTmp.Union.Bit.SubOn = TRUE;
  }
  else
  {
    bCurrSpk &= (~SPK_SUB);
    rTmp.Union.Bit.SubOn = FALSE;
  }

#if 0
  switch (rSpk.Cb)
  {
    case SPK_LARGE:
      rTmp.Union.Bit.CbOn = TRUE;
      rTmp.Union.Bit.CbSize = ADSP_SPK_LARGE;
      break;

    case SPK_OFF:
      rTmp.Union.Bit.CbOn = FALSE;
      break;


    case SPK_SMALL:
    default:
      rTmp.Union.Bit.CbOn = TRUE;
      rTmp.Union.Bit.CbSize = ADSP_SPK_SMALL;
      break;
  }

  switch (rSpk.Ch7)
  {
    case SPK_LARGE:
      rTmp.Union.Bit.Ch7On = TRUE;
      rTmp.Union.Bit.Ch7Size = ADSP_SPK_LARGE;
      break;

    case SPK_OFF:
      rTmp.Union.Bit.Ch7On = FALSE;
      break;

    case SPK_SMALL:
    default:
      rTmp.Union.Bit.Ch7On = TRUE;
      rTmp.Union.Bit.Ch7Size = ADSP_SPK_SMALL;
      break;
  }
#endif

  rTmp.Union.Bit.Type = pbSpkToCfg[bCurrSpk & SPK_TO_CFG_MASK];
  _rAudioCtrl.sFlag.bSpkFormat = rTmp.Union.Bit.Type;

  vSetSharedInfo(SH_SPK_CFG, bCurrSpk);

//  if (dwReadDspSharedDInfo(D_SPKCFG) != rTmp.Union.Dwrd)
  {
    vWriteDspSharedDInfo(D_SPKCFG, rTmp.Union.Dwrd);
    vNotifyDspSharedInfo(UOP_DSP_CONFIG_SPEAKER);
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static code DWRD dwChDelayUop[DELAY_CH_MAX] = {
  UOP_DSP_CONFIG_DELAY_C,
  UOP_DSP_CONFIG_DELAY_L,
  UOP_DSP_CONFIG_DELAY_R,
  UOP_DSP_CONFIG_DELAY_LS,
  UOP_DSP_CONFIG_DELAY_RS,
  UOP_DSP_CONFIG_DELAY_CB,
  UOP_DSP_CONFIG_DELAY_CH7,
  UOP_DSP_CONFIG_DELAY_SUBWOOFER
};