aud_ctrl.c

是MTK公司新出来的DVD方案

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 04/07/22 4:13p    $       ****************/
/***************  $Revision:: 12               $       ****************/
/***************                                       ****************/
/***************   Description : Audio Control         ****************/
/***************                 Interface Module      ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#define _AUD_CTRL_C_

#pragma NOAREGS

#include "general.h"
#include "../../procdef.h"

#include "..\..\common\dsp\dspshm.h"
#include "..\..\common\dsp\dsp_uop.h"

#include ".\dsp\adsp.c"

//#define DEBUG_ADSP

// *********************************************************************
// Function :
// Description : Group 1 is DSP information
// Parameter :
// Return    :
// *********************************************************************

// for W_PROCMOD
#define FLAG_BASS_TO_SUB    0x0010
#define FLAG_BASS_TO_LR     0x0000

#define FLAG_SPECTRUM_ON    0x0001
#define FLAG_SPECTRUM_OFF   0x0000

#define FLAG_POST_DRC_ON    0x0002
#define FLAG_POST_DRC_OFF   0x0000

#define FLAG_KARAOKE_SCORE  0x0004
#define FLAG_NO_SCORE       0x0000

#define FLAG_POST_AUTO_ON   0x0008 // if auto on, DRC_ON/OFF setting is invalid
#define FLAG_POST_AUTO_OFF  0x0000

#define FLAG_BASS_ODCT      0x0020 // for 1379 bass overflow detection of AC3

#define FLAG_LTRT_DOWNMIX   0x0400 // only for MT1379
#define FLAG_CH78_DOWNMIX   0x0800 // only for MT1379

#define FLAG_BASS_OFF       0x1000

// for B_DACBIT
#define FLAG_DAC_AUTOMUTE   0x20
#define FLAG_DAC_DEEMPH     0x40

static void vInitAdspGeneral(void) large
{
  WORD wFlag;
  BYTE bFlag;

  wFlag = 0
#ifdef BASS_TO_SUB
   | FLAG_BASS_TO_SUB
#endif
#ifdef SPTM_SUPPORT
   | FLAG_SPECTRUM_ON
#endif
#ifdef PLAYER_SURROUND
   | FLAG_POST_AUTO_ON
#endif
#ifdef AC3_BASS_OVERFLOW_DETECT
   | FLAG_BASS_ODCT
#endif
#ifdef SIMULTANEOUS_DOWNMIX_OUTPUT_LTRT
   | FLAG_LTRT_DOWNMIX
#endif
#ifdef SIMULTANEOUS_DOWNMIX_OUTPUT
   | FLAG_CH78_DOWNMIX
#endif
   ;

  vWriteDspSharedWInfo(W_PROCMOD, wFlag);

  #ifdef AUDIO_DATA_16BIT
  bFlag = 16;  //16-Bit
  #elif defined(AUDIO_DATA_18BIT)
  bFlag = 18;  //18-Bit
  #elif defined(AUDIO_DATA_20BIT)
  bFlag = 20;  //20-Bit
  #else // default is 24 bit
  bFlag = 24;  //24-Bit
  #endif

  #ifdef DSP_AUTO_MUTE
  bFlag |= FLAG_DAC_AUTOMUTE;
  #endif
  #ifdef DAC_DEEMPH
  bFlag |= FLAG_DAC_DEEMPH;
  #endif

  vWriteDspSharedBInfo(B_DACBIT, bFlag);

#ifdef AC3_DITHER_MUTE
  vWriteDspSharedDInfo(D_MUTE_THRESHOLD, 0x18);
#else
  vWriteDspSharedDInfo(D_MUTE_THRESHOLD, 0);
#endif

  vWriteDspSharedDInfo(D_LEVEL_THRESHOLD, 3);

#ifdef AUDIO_IN_EN
  vAdspAinSel(AIN_SEL_OFF);
#endif
}

// *********************************************************************
// Function :
// Description : DSP Group 2 & 3 Initial, include channel trim
// Parameter :
// Return    :
// *********************************************************************
static void vInitAdspVolume(void) large
{
  vWriteDspSharedBInfo(B_VOLUPORDER, 3);    /* volume display up order */
  vWriteDspSharedBInfo(B_VOLDOWNORDER, 6);  /* volume display down order */
  vWriteDspSharedBInfo(B_SOFTMUTEORDER, 4); /* pause key fade in/out */
  vWriteDspSharedWInfo(W_ERRORMUTEBANK, 0);

  vWriteDspSharedDInfo(D_VOL,      0x00020000);
  vWriteDspSharedDInfo(D_TRIM_C,   0x00020000);
  vWriteDspSharedDInfo(D_TRIM_L,   0x00020000);
  vWriteDspSharedDInfo(D_TRIM_R,   0x00020000);
  vWriteDspSharedDInfo(D_TRIM_LS,  0x00020000);
  vWriteDspSharedDInfo(D_TRIM_RS,  0x00020000);
  vWriteDspSharedDInfo(D_TRIM_CB,  0x00020000);
  vWriteDspSharedDInfo(D_TRIM_CH7, 0x00020000);
  vWriteDspSharedDInfo(D_TRIM_SUB, 0x00020000);
  vWriteDspSharedDInfo(D_TRIM_LFE, 0x00020000);
  vWriteDspSharedDInfo(D_DIALOGUE, 0x00020000);
}

// *********************************************************************
// Function :
// Description : DSP Group 7 Initial
// Parameter :
// Return    :
// *********************************************************************
#define SPDIF_FLAG_MANUAL  SPDIF_FLAG_MANUAL_PCM  /* send PCM data for non-RAW data output stream */
//#define SPDIF_FLAG_MANUAL  SPDIF_FLAG_MANUAL_MUTE

void vInitAdspSpdif(void) large
{
  vWriteDspSharedBInfo(B_IECFLAG, SPDIF_FLAG_RAW);
  vWriteDspSharedBInfo(B_IEC_MUTE, ADSP_ON);

#ifndef SIMULTANEOUS_DOWNMIX_OUTPUT
  vWriteDspSharedBInfo(B_IEC_PCMCH, SPDIF_IEC_LR);
#else
  vWriteDspSharedBInfo(B_IEC_PCMCH, SPDIF_IEC_CH78);
#endif

  vWriteDspSharedWInfo(W_SPEED, 0);
  vWriteDspSharedBInfo(B_IEC_CDDA, SPDIF_FLAG_RAW);
  vWriteDspSharedBInfo(B_IEC_DTS, SPDIF_FLAG_RAW);
  vWriteDspSharedBInfo(B_IEC_MP2, SPDIF_FLAG_RAW);
  vWriteDspSharedBInfo(B_IEC_AC3, SPDIF_FLAG_RAW);
  vWriteDspSharedBInfo(B_IEC_MAX_FREQ, ADSP_IEC_PCM_48K);
}

// *********************************************************************
// Function :
// Description : DSP Group 6 Initial
// Parameter :
// Return    :
// *********************************************************************
void vInitAdspSpk(void) large
{
  vWriteDspSharedDInfo(D_SPKCFG, 0x07F002); // 2.0 ch, LO/RO
//  vWriteDspSharedDInfo(D_SPKCFG, 0x07F03F); //7.1 ch

  vWriteDspSharedBInfo(B_CUTOFF_FREQ, 100); // 100Hz or 200Hz

  vWriteDspSharedWInfo(W_AC3_SPKCFG, 0xFFFF); // default is not used
  vWriteDspSharedWInfo(W_DTS_SPKCFG, 0xFFFF); // default is not used
  vWriteDspSharedWInfo(W_MP2_SPKCFG, 0xFFFF); // default is not used

  vWriteDspSharedWInfo(W_CHDELAY_C, 0);
  vWriteDspSharedWInfo(W_CHDELAY_L, 0);
  vWriteDspSharedWInfo(W_CHDELAY_R, 0);
  vWriteDspSharedWInfo(W_CHDELAY_LS, 0);
  vWriteDspSharedWInfo(W_CHDELAY_RS, 0);
  vWriteDspSharedWInfo(W_CHDELAY_CB, 0);
  vWriteDspSharedWInfo(W_CHDELAY_CH7, 0);
  vWriteDspSharedWInfo(W_CHDELAY_SUB, 0);
}

// *********************************************************************
// Function :
// Description : DSP Group 4, 5, 8 (karaoke) Initial
// Parameter :
// Return    :
// *********************************************************************
void vInitAdspKara(void) large
{
#ifdef PLAYER_KARAOKE
  vWriteDspSharedBInfo(B_MPDOWNSAMPLE, MIC_DOWNSAMPLE_RATIO);
#else
  vWriteDspSharedBInfo(B_MPDOWNSAMPLE, 2);    // 1/4
#endif
#ifdef VOCAL_ASSIST_MIC_CNT
  vWriteDspSharedBInfo(B_MPUPORDER, 8);       // 2^8/12K = 256/12K = 21ms
  vWriteDspSharedBInfo(B_MPDOWNORDER, 6);
#else
  vWriteDspSharedBInfo(B_MPUPORDER, 4);
  vWriteDspSharedBInfo(B_MPDOWNORDER, 10);
#endif
  vWriteDspSharedWInfo(B_MP_CHMIX, MIC_MIX_LR);

  vWriteDspSharedDInfo(D_MPVOL1, ((DWRD)(0xFFFFE)));
  vWriteDspSharedDInfo(D_MPVOL2, ((DWRD)(0xFFFFE)));

  vWriteDspSharedBInfo(B_MPFLAG, 0x00); //MIC OFF, ROBUST OFF
  vWriteDspSharedDInfo(D_MPECHOVOL, 0x400000);
  vWriteDspSharedDInfo(D_MPDEPTH, 0x400000);
  vWriteDspSharedWInfo(W_MPDELAY, 128);

  vWriteDspSharedDInfo(D_MPEQGAIN_DRY, 0x10000);
  vWriteDspSharedDInfo(D_MPEQGAIN_B1, 0x40000);
  vWriteDspSharedDInfo(D_MPEQGAIN_B2, 0x40000);
  vWriteDspSharedDInfo(D_MPEQGAIN_B3, 0x40000);
  vWriteDspSharedBInfo(B_MP_REC_FLAG, 0);
  vWriteDspSharedDInfo(D_MIC_THRESHOLD, 0x8000);  

  vWriteDspSharedWInfo(W_KEYLEVEL, 0);
  vWriteDspSharedDInfo(D_MPTHRESHOLD, 0x8000);
  vWriteDspSharedBInfo(B_KARAFLAG, 0);
  vWriteDspSharedDInfo(D_LRMIXRATIO, 0);

  // microphone additional features
  vWriteDspSharedDInfo(D_MP_CHORUS_MIX_R, 0);
  vWriteDspSharedDInfo(D_MP_CHORUS_FB_R, 0);
  vWriteDspSharedBInfo(B_MP_CHORUS_DELAY, 5);
  vWriteDspSharedBInfo(B_MP_CHORUS_DEPTH, 5);
  vWriteDspSharedBInfo(B_MP_CHORUS_FREQ, 4);
  vWriteDspSharedBInfo(B_MP_REVERB_FLAG, 0);
  vWriteDspSharedBInfo(B_MP_REVERB_BANK1, 46);
  vWriteDspSharedBInfo(B_MP_REVERB_BANK2, 58);
  vWriteDspSharedBInfo(B_MP_REVERB_BANK3, 66);
  vWriteDspSharedBInfo(B_MP_REVERB_BANK4, 78);
  vWriteDspSharedDInfo(D_MP_REVERB_GAIN, 0);
}

// *********************************************************************
// Function :
// Description : DSP Group 11, 12, 13 Initial
// Parameter :
// Return    :
// *********************************************************************
void vInitAdspDecoder(void) large
{
  // assume default is melody on
#ifdef AC3_KARA_MODE
  vWriteDspSharedWInfo(W_AC3KARAMOD, DSP_AC3_KARA_BOTH);
#else
  vWriteDspSharedWInfo(W_AC3KARAMOD, DSP_AC3_KARA_AWARE);
#endif

#ifdef NO_DTS_DECODE
  vWriteDspSharedBInfo(B_IEC_OPTION, ADSP_IEC_DTS_RAW);
#else
  vWriteDspSharedBInfo(B_IEC_OPTION, ADSP_IEC_DTS_PCM);
#endif

  vWriteDspSharedWInfo(W_AC3DUALMODE, DM_STEREO);
  vWriteDspSharedWInfo(W_AC3COMPMOD, 0x0002);
  vWriteDspSharedDInfo(D_AC3DYN_LOW, 0);
  vWriteDspSharedDInfo(D_AC3DYN_HIGH, 0);

  vWriteDspSharedBInfo(B_DTSFLAG, 1);

  vWriteDspSharedBInfo(B_MPEGDRC, 0x0080);
  vWriteDspSharedWInfo(W_MPEGERRDET, 0x0001);

  vWriteDspSharedWInfo(W_PINKNOISE, 0x0000);
  
// SACD output mode control 
#ifdef SACD_PCM_OUTPUT
  vWriteDspSharedWInfo(B_SACD_PCM_MOD, 1);
#else
  vWriteDspSharedWInfo(B_SACD_PCM_MOD, 0);
#endif
}

// *********************************************************************
// Function :
// Description : DSP Group 7 (equalizer), 8, 9 initial, include channel equalizer
// Parameter :
// Return    :
// *********************************************************************
void vInitAdspSurr(void) large
{
  BYTE i, j;
  WORD wAddr;

  _rAudioCtrl.uSurrType.Byte = 0;
  _rAudioCtrl.uSurrType.Bit.fgChEq = ADSP_OFF;
  _rAudioCtrl.uSurrType.Bit.bVsurrType = AUD_VSURR_OFF;
  _rAudioCtrl.uSurrType.Bit.fgBassBoost = ADSP_OFF;
  _rAudioCtrl.uSurrType.Bit.fgTrebleBoost = ADSP_OFF;
  _rAudioCtrl.uSurrType.Bit.fgBassPipe = ADSP_OFF;
  _rAudioCtrl.uSurrType.Bit.fgReverb = ADSP_OFF;

  vWriteDspSharedBInfo(B_EQFLAG, 0);
  vWriteDspSharedBInfo(B_EQBANDNUM, CH_EQ_BAND_NO - 1);
  vWriteDspSharedBInfo(B_SBASSDELAYNUM, SBDELAY[AUD_BASS_PIPE_DELAY_DEFAULT]);
  vWriteDspSharedDInfo(D_SBASSBOOSTGAIN, GAINBAND[AUD_BASS_BOOST_GAIN_DEFAULT]);
  vWriteDspSharedDInfo(D_SBASSCLEARGAIN, GAINBAND[AUD_TREBLE_BOOST_GAIN_DEFAULT]);

  vWriteDspSharedWInfo(W_PROLOGICCFG, 0);
  vWriteDspSharedWInfo(W_PLSURRDELAY, 0x66);
  vWriteDspSharedWInfo(W_PLIICONFIG, 0);
  vWriteDspSharedWInfo(W_PLIIMODE, 3);
  vWriteDspSharedBInfo(B_VSURRFLAG, DSP_VSURR_OFF);
  vWriteDspSharedBInfo(B_VSURRDELAYNUM, SBDELAY[AUD_VSURR_DELAY_DEFAULT]);
  vWriteDspSharedDInfo(D_VSURRGAIN, VSURRGAIN[AUD_VSURR_GAIN_DEFAULT]);
  vWriteDspSharedDInfo(D_VSURRWIDEGAIN, VSURRGAIN[AUD_VSURR_WGAIN_DEFAULT]);

  vWriteDspSharedBInfo(B_NEO6_FLAG, 0);
  vWriteDspSharedWInfo(W_NEO6_CGAIN, 0x199999);

  vWriteDspSharedBInfo(B_REVERBFLAG, 0);
  vWriteDspSharedDInfo(D_REVERBGAIN, ECHO_LEVEL[AUD_REVERB_GAIN_DEFAULT]);
  vWriteDspSharedBInfo(B_REVERBBANK0, 79);
  vWriteDspSharedBInfo(B_REVERBBANK1, 67);
  vWriteDspSharedBInfo(B_REVERBBANK2, 59);
  vWriteDspSharedBInfo(B_REVERBBANK3, 47);

  for (i = 0; i < 7; i ++)
  {
    for (j = 0; j < EQ_BAND_MAX; j++)
    {
      wAddr = D_C_DRY + ((WORD)(j + i * EQ_BAND_MAX)) * 4;

      if (j == 0)
      {
        vWriteDspSharedDInfo(wAddr, 0x10000);
      }
      else
      {
        vWriteDspSharedDInfo(wAddr, 0x00000);
      }
    }
  }
}

// *********************************************************************
// Function : void vInitAdspHdcd(void) large
// Description : Init HDCD parameter
// Parameter :  NONE
// Return    :  NONE
// *********************************************************************
void vInitAdspHdcd(void) large
{
  BYTE i;

  i = (0
#ifdef HDCD_EN
        | ADSP_HDCD_ENABLE
  #ifdef HDCD_AUTO_LEVEL
        | ADSP_HDCD_AUTO_LEVEL
  #endif
  #ifdef HDCD_FILTER
        | ADSP_HDCD_FILTER
        | ADSP_HDCD_DITHER
  #endif
  #ifdef HDCD_CERTIFICATION
        | ADSP_HDCD_NO_POST
  #endif
#endif
  );

  vWriteDspSharedWInfo(W_HDCDCONFIG, i);
  vWriteDspSharedWInfo(W_HDCDUPSAMPLING, 1);
  vWriteDspSharedWInfo(W_HDCDDITHERMODE, 7);
  vWriteDspSharedWInfo(W_HDCDAOUTBLENGTH, 24);
}

// *********************************************************************
// Function : vInitKaraokeScore(void)
// Description : Initialization of Karaoke scoring function
//               
// Parameter :
// Return    :
// *********************************************************************
void vInitKScore(void) large
{
  vWriteDspSharedBInfo(B_KSCORECONFIG,DSP_KSCORE_OFF);
  vWriteDspSharedBInfo(B_KSCORE_MAX,100);
  vWriteDspSharedBInfo(B_KSCORE_MIN,0);
  vWriteDspSharedBInfo(B_KSCORE_SCORE,0);
  vWriteDspSharedWInfo(W_KSCORE_HIT0,0);
  vWriteDspSharedWInfo(W_KSCORE_HIT1,0);
  vWriteDspSharedWInfo(W_KSCORE_MISS,0);
  vWriteDspSharedBInfo(B_KSCORE_STRATEGY,0);
  vWriteDspSharedWInfo(W_KSCORE_MICTHD,0);
}

// *********************************************************************
// Function :
// Description : Audio DSP Control Share Memory Initial Routine,
//               called from vUserInit()
// Parameter :
// Return    :
// *********************************************************************
void vInitAdspShareInfo(void) large
{
  vInitAdspGeneral();
  vInitAdspSpk();
  vInitAdspKara();
  vInitAdspSurr();
  vInitAdspVolume();
  vInitAdspSpdif();
  vInitAdspDecoder();
  vInitAdspHdcd();
  vInitKScore();
  vWriteDspSharedWInfo(W_VOCDTKN,0);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspInit(BYTE bVolume) large
{
  if (bVolume > MAX_VOL_LEVEL)
  {
    bVolume = MAX_VOL_LEVEL;
  }

  vWriteDspSharedDInfo(D_VOL, VOLUME[bVolume]);

  _rAudioCtrl.sVol.bCurVol = bVolume;
  _rAudioCtrl.sVol.fgIsMute = FALSE;  // - is not mute.
  _rAudioCtrl.sVol.fgLower = FALSE;  // - no lower.

  _rAudioCtrl.cCurKey = 0;
  _rAudioCtrl.sEcho.fgMic = FALSE;
  _rAudioCtrl.sVocal.bVocalMode = VOCAL_NO_ASSIST;
  _rAudioCtrl.sVocal.fgMelody = TRUE;
  _rAudioCtrl.sVocal.fgVoiceCancel = FALSE;
#ifdef VOCAL_ASSIST_MIC_CNT
  _rAudioCtrl.sVocal.fgMicActive = FALSE;
  _rAudioCtrl.sVocal.bMicCnt = 0;
#endif

  _rAudioCtrl.sFlag.fgDownmixOn = TRUE; // default is LO/RO
  _rAudioCtrl.sFlag.bSpkFormat = SPK_CFG_LR;
  _rAudioCtrl.sFlag.fgKaraMode = FALSE; /* default status is karaoke off */
  _rAudioCtrl.sFlag.fgVocalAssist = FALSE;

  _rAudioCtrl.sFlag.fgSpdifOn = FALSE;
  _rAudioCtrl.sIEC.bFormat = SPDIF_FLAG_RAW;
  _rAudioCtrl.sIEC.bNextMode = SPDIF_FLAG_RAW;
  vResetIecSwitching();

#ifdef PCM_FREQ_CHANGE_MUTE
  _rAudioCtrl.sPcmFreq.bFreq = ADSP_IEC_PCM_48K;
  vResetPcmFreqSwitching();
#endif

  // for audio in
  _rAudioCtrl.sFlag.bAudioInMode = DSP_AIN_DISABLE;

  _rAudioCtrl.sFlag.bPinkNoiseSpk = PN_SPK_OFF;

  _rAudioCtrl.sFlag.fgDspStop = FALSE;

  vSetSharedInfo(SH_SPK_CFG, SPK_LR);

#ifdef MIC_AUTOMUTE
  _rAudioCtrl.bMicAutomuteCnt = MIC_AUTOMUTE_ON_CNT;

  vSetSharedInfo(SH_MIC_MIX_CH, MIC_MIX_LR);
  vSetSharedInfo(SH_MIC_GAIN_1, 0);
  vSetSharedInfo(SH_MIC_GAIN_2, 0);
  vSetSharedInfo(SH_MIC_AUTOMUTE_OFF_LEVEL_HI, 0);
  vSetSharedInfo(SH_MIC_AUTOMUTE_OFF_LEVEL_LO, 0);
  vSetSharedInfo(SH_MIC_AUTOMUTE_ON_LEVEL_HI, 0);
  vSetSharedInfo(SH_MIC_AUTOMUTE_ON_LEVEL_LO, 0);
#endif /* MIC_AUTOMUTE */
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vAdspReset(void) large
{
  WriteAUD(AUD_BSCFG, 0x0);

  // this is play type dependant, called from vPlayerReset() in combine.c
#if 0
  _rAudioCtrl.sVocal.bVocalMode = VOCAL_NO_ASSIST;
  _rAudioCtrl.sVocal.fgVoiceCancel = FALSE;
#endif
}

#if (!defined(SET_VSURR_IN_SPKCFG) && defined(PLAYER_SURROUND))