player.c

mtkDVD源代码程序4*16 很好玩的内置5.1环绕音效 大家可以玩一下

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 05/12/02 4:07p    $       ****************/
/***************  $Revision:: 8                $       ****************/
/***************                                       ****************/
/***************   Description :                       ****************/
/***************                                       ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#define _PLAYER_C_

#pragma NOAREGS
#include "general.h"

// *********************************************************************
// Local Define
// *********************************************************************
#ifdef JPEG_DECODING_SHOW_VFD_WHEEL
extern xdata BYTE _bWorkingStt;
#endif

#ifdef SRV_SHOW_ERROR_COUNTER
static xdata BYTE _pbSrvErrTrace[5];
#endif /* SRV_SHOW_ERROR_COUNTER */

#ifdef PLAYER_GOTO
BYTE _bPrevNtscPal;
#endif

// *********************************************************************
// Function : void vSendUopCmd(BYTE bCmd, BYTE bParm1, BYTE bParm2, BYTE bParm3)
// Description : Send UOP to RISC
// Parameter : None
// Return    : None
// *********************************************************************
#if !defined(PC_EMULATION)
void vSendUopCmd(BYTE bCmd, BYTE bParm1, BYTE bParm2, BYTE bParm3) large
{
#ifdef PLAYER_STOP_SRV_STOP
  if (bCmd == UOP_STOP)
  {
    _bLastSyncUop = UOP_STOP;
  }
  else if (bCmd <= UOP_PLAYBACK_MAX) /* note not for UOP_STOP */
  {
    _bUISrvStatus = PLAYER_SRV_NORMAL;
  }
  else if ((bCmd == UOP_POWER) || (bCmd == UOP_OPEN_CLOSE))
  {
    _bLastSyncUop = bCmd;
  }
#endif

  SendIRCmd(bCmd, bParm1, bParm2, bParm3);
}
#endif

#if defined(AUDIO_IN_EN) || defined(EEPROM_LASTMEM_EJECT_WR_BACK) || defined(EN_DISC_ID_CHK)
// *********************************************************************
// Function : void vSendPeriCmd(BYTE bCmd, BYTE bParm1, BYTE bParm2)
// Description : Send peripheral command to main loop
// Parameter : None
// Return    : None
// *********************************************************************
void vSendPeriCmd(BYTE bCmd, BYTE bParm1, BYTE bParm2) large
{
  if (fgIsPeriCmdBusy())
  {
    // Command Busy, if this does happen, we need to add command queue
#ifdef RS232_LOG_UI
    DBGLogS("UIPeriCmd fail!");
    DBGLogB(_pbUIPeriCmd[0], bCmd, bParm1, bParm2);
#endif
    return;
  }
  else
  {
    _pbUIPeriCmd[1] = bParm1;
    _pbUIPeriCmd[2] = bParm2;
    _pbUIPeriCmd[0] = bCmd;
  }
}
#endif

#ifndef REDUCE_POWER_MODE          
/***************************************************************************
     Function : void vSendPlayerIdle(void)
  Dsecription :
    Parameter : None
       Return : None
***************************************************************************/
void vSendPlayerIdle(void) large
{
#ifdef PLAYER_IDLE
  BYTE bInitState = bSharedInfo(SI_INIT_STATE);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bMode = 0xff;

  switch (bInitState)
  {
    case SV_TRAY_OPENING:
    case SV_TRAY_ERROR:
    case SV_NO_DISC:
    case SV_UNKNOWN_DISC:
      bMode = SV_PWR_IDLE_STOP;
      break;

    case SV_DISC_IDENTIFIED:
      /* need more check */
      break;

    default:
      return; /* error! */
  }

  if (bMode == 0xff)
  {
    switch (bPbcState)
    {
      case SV_STOP:
      case SV_STOP_RESUME:
      case SV_PTL_ERR:
      case SV_REGION_ERR:
      case SV_DISC_ERR:
      case SV_SET_TMP_PTL:
        bMode = SV_PWR_IDLE_STOP;
        break;

      case SV_STILL:
      case SV_DIGEST:
        // for PCD/JPG in still/digest mode can enter screen saver
        if (fgIsIsoPlay()
#ifdef SUPPORT_PCD
          || fgIsPcdPlay()
#endif
          )
        {
          bMode = SV_PWR_IDLE_PAUSE;
        }
        else
        {
          /* DVD/VCD is not allowed in still mode */
          return;
        }
        break;

      case SV_PAUSE:
      case SV_STEP:
      case SV_STEP_BACK:
      case SV_SETUP_PAUSE:
        bMode = SV_PWR_IDLE_PAUSE;
        break;

      default:
        return; /* error! */
    }
  }

  if (bMode != 0xff)
  {
    vSendUopCmd(UOP_POWER, bMode, 0, 0);
  }
#endif
}
#endif // REDUCE_POWER_MODE

/***************************************************************************
     Function : void vSendPlayerActive(void)
  Dsecription :
    Parameter : None
       Return : None
***************************************************************************/
void vSendPlayerActive(void) large
{
#ifdef PLAYER_IDLE
  vSendUopCmd(UOP_POWER, SV_PWR_ACTIVE, 0, 0);
#endif
}

#ifdef SRV_SHOW_ERROR_COUNTER
/************************************************************************
     Function : void vPlayerShowSrvErr(void)
  Description : 
    Parameter : None
    Return    : None
************************************************************************/
void vPlayerShowSrvErr(void) large
{
  _bSrvErrorTimer++;
  if (_bSrvErrorTimer >= 100)  // 2 Seconds
  {
    // show Err count on OSD
    if (_bSrvShowErrIdx == 0xFF)
    {
      if (fgIsNonPlay() == FALSE)
      {
        _pbSrvErrTrace[4] = _pbSrvErrTrace[3];
        _pbSrvErrTrace[3] = _pbSrvErrTrace[2];
        _pbSrvErrTrace[2] = _pbSrvErrTrace[1];
        _pbSrvErrTrace[1] = _pbSrvErrTrace[0];
        _pbSrvErrTrace[0] = bHEXToBCD(_bSrvErrShowCnt);

        vOsdShowServoError(_pbSrvErrTrace);
      }
    }

    _bSrvErrorTimer = 0;
    _bSrvErrShowCnt = 0;
  }
}
#endif /* SRV_SHOW_ERROR_COUNTER */

#ifdef PLAYER_KARAOKE
/************************************************************************
     Function : void vPlayerMicLevelDetect(void)
  Description : 
    Parameter : None
    Return    : None
************************************************************************/
static void vPlayerMicLevelDetect(void) large
{
  BYTE bVocalMode = bAdspCurrVocal();

  if ((bVocalMode == VOCAL_AUDIO1) || (bVocalMode == VOCAL_AUDIO2))
  {
    if (fgAdspIsMicOn() && (_fgVocalOn == TRUE))
    {
      /* switch vocal off */
      if (bVocalMode == VOCAL_AUDIO1)
      {
        vSendUopCmd(UOP_VOCAL_ASSIST, 1, 0, 0);
      }
      else /* if (bVocalMode == VOCAL_AUDIO2) */
      {
        vSendUopCmd(UOP_VOCAL_ASSIST, 0, 0, 0);
      }

#ifdef RS232_LOG_UI
      DBGLogS("Vocal off");
#endif

      _fgVocalOn = FALSE;
    }
    else if (!fgAdspIsMicOn() && (_fgVocalOn == FALSE))
    {
      if (bVocalMode == VOCAL_AUDIO1)
      {
        vSendUopCmd(UOP_VOCAL_ASSIST, 0, 0, 0);
      }
      else /* if (bVocalMode == VOCAL_AUDIO2) */
      {
        vSendUopCmd(UOP_VOCAL_ASSIST, 1, 0, 0);
      }

#ifdef RS232_LOG_UI
      DBGLogS("Vocal on");
#endif

      _fgVocalOn = TRUE;
    }
  } /* VOCAL_AUDIO1 || VOCAL_AUDIO2 */
  #ifdef AC3_KARA_MODE
  else if ((bVocalMode == VOCAL_V1) || (bVocalMode == VOCAL_V2) || (bVocalMode == VOCAL_BOTH))
  {
    // note VOCAL_NONE does not vocal assist
    if (fgAdspIsMicOn() && (_fgVocalOn == TRUE))
    {
      /* switch vocal off */
      #ifdef AC3_KARA_MIC_ON_VOCAL // use another vocal for mic on
      if (bVocalMode == VOCAL_V1)
      {
        vAdspKaraAC3(KARA_V2);
      }
      else if (bVocalMode == VOCAL_V2)
      {
        vAdspKaraAC3(KARA_V1);
      }
      else if (bVocalMode == VOCAL_BOTH)
      {
        vAdspKaraAC3(KARA_NONE);
      }
      #else // use no vocal for mic on
      vAdspKaraAC3(KARA_NONE);
      #endif
  
      _fgVocalOn = FALSE;
    }
    else if (!fgAdspIsMicOn() && (_fgVocalOn == FALSE))
    {
      #ifdef AC3_KARA_MIC_OFF_BOTH
      vAdspKaraAC3(KARA_BOTH);
      #else // turn on the selected vocal only
      if (bVocalMode == VOCAL_V1)
      {
        vAdspKaraAC3(KARA_V1);
      }
      else if (bVocalMode == VOCAL_V2)
      {
        vAdspKaraAC3(KARA_V2);
      }
      else if (bVocalMode == VOCAL_BOTH)
      {
        vAdspKaraAC3(KARA_BOTH);
      }
      #endif // turn on the selected vocal only
  
      _fgVocalOn = TRUE;
    }
  } /* VOCAL_V1 || VOCAL_V2 || VOCAL_BOTH */
  #endif /* AC3_KARA_MODE */
  #ifdef VOCAL_ASSIST_MIC_CNT  // if vocal assist is done by 8032
  else if ((bVocalMode == VOCAL_LEFT) || (bVocalMode == VOCAL_RIGHT))
  {
    if (fgAdspIsMicOn() && (_fgVocalOn == TRUE))
    {
      /* switch vocal off */
      if (bVocalMode == VOCAL_LEFT)
      {
        vAdspKaraLR(KARA_RIGHT); /* switch to R channel */
      }
      else /* if (bVocalMode == VOCAL_RIGHT) */
      {
        vAdspKaraLR(KARA_LEFT); /* switch to L channel */
      }
  
      _fgVocalOn = FALSE;
    }
    else if (!fgAdspIsMicOn() && (_fgVocalOn == FALSE))
    {
      /* switch vocal on */
      #ifdef VCD_VA_MIC_OFF_STEREO // use stereo as default
      vAdspKaraLR(KARA_STEREO);
      #else // use another channel
      if (bVocalMode == VOCAL_LEFT)
      {
        vAdspKaraLR(KARA_LEFT); /* switch to L channel */
      }
      else /* if (bVocalMode == VOCAL_RIGHT) */
      {
        vAdspKaraLR(KARA_RIGHT); /* switch to R channel */
      }
      #endif
  
      _fgVocalOn = TRUE;
    }
  }
  else if (bVocalMode == VOCAL_VOICE_CANCEL)
  {
    if (fgAdspIsMicOn() && (_fgVocalOn == TRUE))
    {
      /* switch vocal off */
      vAdspKaraVC(TRUE);
  
      _fgVocalOn = FALSE;
    }
    else if (!fgAdspIsMicOn() && (_fgVocalOn == FALSE))
    {
      /* switch vocal off */
      vAdspKaraVC(FALSE);
  
      _fgVocalOn = TRUE;
    }
  }
  #endif /* VOCAL_ASSIST_MIC_CNT */
}
#endif /* PLAYER_KARAOKE */

/************************************************************************
     Function : void RISCIsrSM(void)
  Description : handle SMB interrupt
    Parameter : None
    Return    : None
************************************************************************/
void RISCIsrSM(void)
{
#if defined(NO_SM_NOTIFY)
  ClrSmBusy();
#else
  _bSMUpdate = TRUE;
  //vSetSharedInfo(SI_RISC_SM_INT_LOCK, 1);
#endif
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void SmInit(void) large
{
#if defined(NO_SM_NOTIFY)
  vSetSharedInfo(SI_RISC_SHM_RP, 0);
  vSetSharedInfo(SI_RISC_SHM_WP, 0);
#else
  ClrSmBusy();
#endif

  _bSMUpdate = FALSE;
}

/************************************************************************
     Function : void vHandleSM(void)
  Description :
    Parameter :
    Return    :
************************************************************************/
static void vHandleSM(void) large
{
  BYTE pbInfo[4];

#if defined(NO_SM_NOTIFY)
  BYTE bTmp;
  BYTE i;

  //bTmp = bSharedInfo(SI_RISC_SHM_RP);
  bTmp = _bShmRp;

  bTmp = bTmp * SV_SI_ENTRY_SZ;
  for(i = 0; i < 4; i++)
  {
    // TODO: use item
    pbInfo[3-i] = bSharedInfo(SI_SHM_FIFO_START + bTmp);
    bTmp++;
  }
#else
  pbInfo[0] = bReadBIM(BIM_TRB15);
  pbInfo[1] = bReadBIM(BIM_TRB14);
  pbInfo[2] = bReadBIM(BIM_TRB13);
  pbInfo[3] = bReadBIM(BIM_TRB12);
#endif

  vSmUpdate(pbInfo);
}

/************************************************************************
     Function : void SmTimer(void)
  Description :
    Parameter :
    Return    :
************************************************************************/
static void SmTimer(void) large
{
#if defined(NO_SM_NOTIFY)
  BYTE bWp;

  _bShmRp = bSharedInfo(SI_RISC_SHM_RP);
  bWp = bSharedInfo(SI_RISC_SHM_WP);

  if(_bShmRp != bWp)
  {
    vHandleSM();
    _bShmRp++;
    if (_bShmRp >= SV_SI_QUEUE_SZ)
    {
      _bShmRp = 0;