aud_ctrl.c

mtk1389L latest sourcecode enjoy

    case SPK_LARGE:
      bCurrSpk |= SPK_LS_RS;
      rTmp.Union.Bit.LsSize = ADSP_SPK_LARGE;
      rTmp.Union.Bit.RsSize = ADSP_SPK_LARGE;
#ifdef SUPPORT_DDEX
      rTmp.Union.Bit.CbSize = ADSP_SPK_LARGE;
      rTmp.Union.Bit.Ch7Size = ADSP_SPK_LARGE;
#endif
      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;
#ifdef SUPPORT_DDEX
      rTmp.Union.Bit.CbSize = ADSP_SPK_SMALL;
      rTmp.Union.Bit.Ch7Size = ADSP_SPK_SMALL;
#endif
      break;
  }

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

#ifdef SUPPORT_DDEX
  if (rSpk.Cb == ADSP_ON)
  {
    rTmp.Union.Bit.CbOn = TRUE;
    bCurrSpk |= SPK_CB;
  }
  else
  {
    rTmp.Union.Bit.CbOn = FALSE;
    bCurrSpk &= (~SPK_CB);
  }
  if (rSpk.Ch7 == ADSP_ON)
  {
    rTmp.Union.Bit.Ch7On = TRUE;
    bCurrSpk |= SPK_CH7;
  }
  else
  {
    rTmp.Union.Bit.Ch7On = FALSE;
    bCurrSpk &= (~SPK_CH7);
  }
#endif

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

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

// 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    :
// *********************************************************************
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 /* not TWO_CHANNEL_ONLY */

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

// *********************************************************************
// 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)
  {
    vWriteDspSharedWInfo(W_AC3KARAMOD, wTmp2);
    vNotifyDspSharedInfo(UOP_DSP_AC3_KARAOKE_MODE);