aud_ctrl.c

mtk1389L latest sourcecode enjoy

  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;
  }
  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)
  {
		#ifdef DSP_FAKE_4CH
		{
			// if there is fake 4 channel, reset it while we do downmix;
			void vDspSwitchFake4CH(BOOL fgFlag);
		   	vDspSwitchFake4CH(FALSE);
		}
		#endif
    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
  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    */
};

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);
}

#ifndef TWO_CHANNEL_ONLY
  #ifdef SPDIF_PCM_CH_SELECT
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
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 /* SPDIF_PCM_CH_SELECT */

  #ifdef SPDIF_PCM_FREQ_SELECT
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    : None
// *********************************************************************
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 */

#ifdef SUPPORT_HDMI
    if(fgTVisHDMI())
    {
      if(bSharedInfo(SI_HDMI_AUDIO_SOURCE) == SV_SPDIF)
      {
         //vAdspMute(1,0);
        _rHDMIAudioCtrl.bAudioChange = 1;
        _rHDMIAudioCtrl.bAudioCount = 40;
        _rHDMIAudioCtrl.bAudioMuteOK = 0;
        _rHDMIAudioCtrl.bAudioSPDIFFreq = 1;
        
      }
    }
#endif //#ifdef SUPPORT_HDMI
    
  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);
#ifdef SUPPORT_HDMI
    if(!fgTVisHDMI())
    {
      vNotifyDspSharedInfo(UOP_DSP_IEC_DOWN_SAMPLE);
    }
#else    
    vNotifyDspSharedInfo(UOP_DSP_IEC_DOWN_SAMPLE);
#endif //#ifdef SUPPORT_HDMI
  }
    #endif /* not define PCM_FREQ_CHANGE_MUTE */
}
  #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)
  {
  #ifdef DSP_FAKE_4CH
	  {
		  // if we make downmix off, and if keyshift non 0 or MIC on, do downmix 4ch effort again.
		  void vDspSwitchFake4CH(BOOL fgFlag);
		  if ((_rAudioCtrl.cCurKey != 0) || (bEepromReadByte(MIC_SW_POS) == EV_ON))
		  {
			  vDspSwitchFake4CH(TRUE);
		  }
	  }
  #endif /* DSP_FAKE_4CH */

    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)
  {