aud_ctrl.c

是MTK公司新出来的DVD方案

// Parameter :
// Return    :
// *********************************************************************
void vAdspKaraAC3(BYTE bMode) large
{
  WORD wTmp1;
  
  switch (bMode)
  {
    case KARA_V1:
      wTmp1 = DSP_AC3_KARA_V1;
      break;

    case KARA_V2:
      wTmp1 = DSP_AC3_KARA_V2;
      break;

    case KARA_BOTH:
      wTmp1 = DSP_AC3_KARA_BOTH;
      break;

    case KARA_NONE:
    default:
      wTmp1 = DSP_AC3_KARA_DISABLE;
      break;
  } /* switch (bMode) */

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

    if (wReadDspSharedWInfo(W_AC3KARAMOD) != wTmp1)
    {
      vWriteDspSharedWInfo(W_AC3KARAMOD, wTmp1);
      vNotifyDspSharedInfo(UOP_DSP_AC3_KARAOKE_MODE);
    }
  }
}
#endif /* AC3_KARA_MODE */

static code DWRD dwMicEqUop[MIC_EQ_MAX] =
{
  UOP_DSP_MICROPHONE_EQ_DRY_GAIN,
  UOP_DSP_MICROPHONE_EQ_BAND1_GAIN,
  UOP_DSP_MICROPHONE_EQ_BAND2_GAIN,
  UOP_DSP_MICROPHONE_EQ_BAND3_GAIN
};

static code WORD wMicEqShare[MIC_EQ_MAX] =
{
  D_MPEQGAIN_DRY, /* DRY */
  D_MPEQGAIN_B1,  /* BASS */
  D_MPEQGAIN_B2,  /* MIDDLE */
  D_MPEQGAIN_B3   /* TREBLE */
};

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspMicEq(BYTE bBand, BYTE bGain) large
{
  DWRD dwVal;

  if (bBand > MIC_EQ_TRE)
  {
    return;
  }

  if (bBand == MIC_EQ_DRY)
  {
    if (bGain >= GAIN_DRY_MAX)
    {
      bGain = GAIN_DRY_MAX -1;
    }
    dwVal = GAINDRY[bGain];
  }
  else
  {
    if (bGain >= GAIN_BAND_MAX)
    {
      bGain = GAIN_BAND_MAX -1;
    }
    dwVal = GAINBAND[bGain];
  }

  vWriteDspSharedDInfo(wMicEqShare[bBand], dwVal);
  vNotifyDspSharedInfo(dwMicEqUop[bBand]);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspMicVol(BYTE bChannel, BYTE bLevel) large
{
#ifdef MIC_AUTOMUTE
  BYTE bTmp1, bTmp2;
  WORD wTmp;
#endif

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

  if (bChannel & AUD_MIC_VOL_1)
  {
    vWriteDspSharedDInfo(D_MPVOL1, MICGAIN[bLevel]);
    vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_1_VOLUME);
  }

  if (bChannel & AUD_MIC_VOL_2)
  {
    vWriteDspSharedDInfo(D_MPVOL2, MICGAIN[bLevel]);
    vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_2_VOLUME);
  }

#ifdef MIC_AUTOMUTE
  if (bChannel & AUD_MIC_VOL_1)
  {
    vSetSharedInfo(SH_MIC_GAIN_1, bLevel);
    bTmp1 = bLevel;
  }
  else
  {
    bTmp1 = bSharedInfo(SH_MIC_GAIN_1);
  }

  if (bChannel & AUD_MIC_VOL_2)
  {
    vSetSharedInfo(SH_MIC_GAIN_2, bLevel);
    bTmp2 = bLevel;
  }
  else
  {
    bTmp2 = bSharedInfo(SH_MIC_GAIN_2);
  }

  if (bTmp2 > bTmp1)
  {
    bTmp1 = bTmp2;
  }

  wTmp = *((WORD *)((BYTE *)MICGAIN + bLevel * 4 + 1));

  #ifdef VOCAL_ASSIST_MIC_CNT
  wTmp >>= 2;
  #endif

  vSetSharedInfo(SH_MIC_AUTOMUTE_OFF_LEVEL_HI, bHiByte(wTmp));
  vSetSharedInfo(SH_MIC_AUTOMUTE_OFF_LEVEL_LO, bLoByte(wTmp));

  wTmp >>= 2;

  vSetSharedInfo(SH_MIC_AUTOMUTE_ON_LEVEL_HI, bHiByte(wTmp));
  vSetSharedInfo(SH_MIC_AUTOMUTE_ON_LEVEL_LO, bLoByte(wTmp));
#endif
}

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

  vWriteDspSharedDInfo(D_MPTHRESHOLD, MICTH[bLevel]);
  vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_THRESHOLD);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BOOL fgAdspIsMicOn(void) large
{
  // if not in karaoke mode, microphone should be off
  if (fgIsKaraMode() == FALSE)
  {
    return (FALSE);
  }

#ifdef VOCAL_ASSIST_MIC_CNT
  return (_rAudioCtrl.sVocal.fgMicActive);
#else /* not use VOCAL_ASSIST_MIC_CNT */
  if (bReadDspSharedBInfo(B_MIC_LEVELMODE) == ADSP_ON)
  {
    return (TRUE);
  }
  else
  {
    return (FALSE);
  }
#endif /* not use VOCAL_ASSIST_MIC_CNT */
}

#ifdef KARAOKE_SIMPLE_ECHO
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspEchoLevel(BYTE bLevel) large
{
  if (bLevel >= ECHO_LEVEL_MAX)
  {
    bLevel = ECHO_LEVEL_MAX - 1;
  }

  vWriteDspSharedWInfo(W_MPDELAY, (WORD)(ECHO_DELAY[bLevel]));
  vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_ECHO_DELAY);

  vWriteDspSharedDInfo(D_MPDEPTH, ECHO_DEPTH[bLevel]);
  vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_ECHO_DEPTH);

  vWriteDspSharedDInfo(D_MPECHOVOL, ECHO_LEVEL[bLevel]);
  vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_ECHO_VOLUME);
}
#else /* original echo */
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspEchoDelay(BYTE bMode) large
{
  if (bMode >= DELAY_ECHO_MAX)
  {
    bMode = DELAY_ECHO_MAX - 1;
  }

  vWriteDspSharedWInfo(W_MPDELAY, (WORD)(ECHO_DELAY[bMode]));
  vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_ECHO_DELAY);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspEchoDepth(BYTE bMode) large
{
  if (bMode >= ECHO_LEVEL_MAX)
  {
    bMode = ECHO_LEVEL_MAX - 1;
  }

  vWriteDspSharedDInfo(D_MPDEPTH, ECHO_DEPTH[bMode]);
  vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_ECHO_DEPTH);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspEchoVol(BYTE bMode) large
{
  if (bMode >= ECHO_LEVEL_MAX)
  {
    bMode = ECHO_LEVEL_MAX - 1;
  }

  vWriteDspSharedDInfo(D_MPECHOVOL, ECHO_LEVEL[bMode]);
  vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_ECHO_VOLUME);
}
#endif /* original echo */

#ifndef DROP_DUMMY_FUNC
// *********************************************************************
// Function :
// Description : microphone mixing channel setting
// Parameter :
// Return    :
// *********************************************************************
void vAdspMicMix(BYTE bCh, BYTE bMode) large
{
  strucMicMix rTmp;

  rTmp.Union.Byte = bReadDspSharedBInfo(B_MP_CHMIX);

  rTmp.Union.Bit.Reserve = 0;

  if (bCh & MIC_MIX_LR)
  {
    rTmp.Union.Bit.MicLR = bMode;
  }

  if (bCh & MIC_MIX_LS_RS)
  {
    rTmp.Union.Bit.MicLsRs = bMode;
  }

  if (bCh & MIC_MIX_C)
  {
    rTmp.Union.Bit.MicC= bMode;
  }

  if (bCh & MIC_MIX_CH78)
  {
    rTmp.Union.Bit.MicCh78= bMode;
  }

#ifdef MIC_AUTOMUTE
  vSetSharedInfo(SH_MIC_MIX_CH, rTmp.Union.Byte);

  if (fgIsMicAutomuteOn())
  {
    vWriteDspSharedWInfo(B_MP_CHMIX, 0);
  }
  else
#endif /* MIC_AUTOMUTE */
  {
    vWriteDspSharedWInfo(B_MP_CHMIX, rTmp.Union.Byte);
  }

  vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_FLAG);
}
#endif

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
#if 0
void vAdspEchoCtrl(BYTE bMode) large
{
}
#endif

  #ifdef KARAOKE_MIC_REC
// *********************************************************************
// Function : void vAdspMicRec(BYTE bMode) large
// Description :
// Parameter : bMode - MIC_STOP / MIC_REC / MIC_PLAY
// Return    :
// *********************************************************************
void vAdspMicRec(BYTE bMode) large
{
//  vWriteDspSharedBInfo(B_MP_REC_FLAG, bMode);
  switch(bMode)
  {
    case MIC_STOP:
      vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_RECORDER_STOP);
      break;
    case MIC_REC:
      vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_RECORDER_REC);
      break;
    case MIC_PLAY:
      vNotifyDspSharedInfo(UOP_DSP_MICROPHONE_RECORDER_PLAY);
      break;
    default:
      ;
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BYTE bAdspMicRecState(BYTE bMode) large
{
  BYTE bState;

  switch (bMode)
  {
    case MIC_REC_REC:
      bState = bReadDspSharedBInfo(B_MIC_REC_STATE);
      break;

    case MIC_REC_PLAY:
      bState = bReadDspSharedBInfo(B_MIC_PLAY_STATE);
      break;

    case MIC_REC_ORG:
    default:
      bState = 0;
      break;
  }

  return (bState);
}
  #endif /* KARAOKE_MIC_REC */

#endif /* PLAYER_KARAOKE */

#if ((defined(PLAYER_KARAOKE) || defined(USE_EXTERNAL_KARAOKE)) && (defined(SUPPORT_AUDIO_KEY_ADJUST)))
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
char cAdspAudKeyCtrl(BYTE bMode) large
{
  BYTE bTmp;
  WORD wCurKey;

#ifdef DTS_NO_KEY_SHIFT
  bTmp = bSharedInfo(SI_A_CODE_MODE);
  if (bTmp == SV_A_CODE_DTS)
  {
    bMode = AUDIO_KEY_RESUME;
  }
#endif /* DTS_NO_KEY_SHIFT */

  switch (bMode)
  {
    case AUDIO_KEY_PLUS:
      _rAudioCtrl.cCurKey ++;
      break;

    case AUDIO_KEY_MINUS:
      _rAudioCtrl.cCurKey --;
      break;

    case AUDIO_KEY_RESUME:
    default:
      _rAudioCtrl.cCurKey = ZERO_KEY_LEVEL;
      break;
  }

  if (_rAudioCtrl.cCurKey > MAX_KEY_LEVEL)
  {
    _rAudioCtrl.cCurKey = MAX_KEY_LEVEL;
  }
  else if (_rAudioCtrl.cCurKey < MIN_KEY_LEVEL)
  {
    _rAudioCtrl.cCurKey = MIN_KEY_LEVEL;
  }

  wCurKey = wReadDspSharedWInfo(W_KEYLEVEL);

  if (wCurKey != (WORD)(_rAudioCtrl.cCurKey))
  {
    vWriteDspSharedWInfo(W_KEYLEVEL, (WORD)(_rAudioCtrl.cCurKey));
    vNotifyDspSharedInfo(UOP_DSP_KEY_SHIFT_LEVEL);
  }

  return (_rAudioCtrl.cCurKey);
}
#endif /* (PLAYER_KARAOKE || USE_EXTERNAL_KARAOKE) && SUPPORT_AUDIO_KEY_ADJUST */

#ifdef PLAYER_SURROUND
// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspSetChEq(BYTE bMode) large
{
  strucDspEqFlag rTmp;

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

  if (bMode == ADSP_OFF)
  {
    _rAudioCtrl.uSurrType.Bit.fgChEq = ADSP_OFF;
    if (rTmp.Union.Bit.ChEqOn)
    {
      rTmp.Union.Bit.ChEqOn = FALSE;
      vWriteDspSharedBInfo(B_EQFLAG, rTmp.Union.Byte);
      vNotifyDspSharedInfo(UOP_DSP_EQUALIZER_FLAG);
    }
  }
  else if (bMode == ADSP_ON)
  {
    _rAudioCtrl.uSurrType.Bit.fgChEq = ADSP_ON;
    if (!rTmp.Union.Bit.ChEqOn)
    {
      rTmp.Union.Bit.ChEqOn = TRUE;
      vWriteDspSharedBInfo(B_EQFLAG, rTmp.Union.Byte);
      vNotifyDspSharedInfo(UOP_DSP_EQUALIZER_FLAG);
    }
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
static code DWRD dwChEqUop[EQ_CH_MAX] = {
  UOP_DSP_EQUALIZER_CHANNEL_CHANGE + (0x00010000 * EQ_CH_C),
  UOP_DSP_EQUALIZER_CHANNEL_CHANGE + (0x00010000 * EQ_CH_L),
  UOP_DSP_EQUALIZER_CHANNEL_CHANGE + (0x00010000 * EQ_CH_R),
  UOP_DSP_EQUALIZER_CHANNEL_CHANGE + (0x00010000 * EQ_CH_LS),
  UOP_DSP_EQUALIZER_CHANNEL_CHANGE + (0x00010000 * EQ_CH_RS),
  UOP_DSP_EQUALIZER_CHANNEL_CHANGE + (0x00010000 * EQ_CH_CB),
  UOP_DSP_EQUALIZER