player.c

mtk1389L latest sourcecode enjoy

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 07/05/18 1:56p    $       ****************/
/***************  $Revision:: 6                $       ****************/
/***************                                       ****************/
/***************   Description :                       ****************/
/***************                                       ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#define _PLAYER_C_

#pragma NOAREGS
#include "general.h"

/*  for module Tester */
#include "./tst/tst.h"

extern BYTE xdata _bVfdKeyScan;
  #ifdef SUPPORT_SACD
/* For SACD to send Psedo tray in */
extern BYTE xdata _fgPsedoTrayIn;
  #endif

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

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

static xdata BYTE _fgOldTvSystem; //[add by SY]
// *********************************************************************
// 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

// *********************************************************************
// 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;
  }
}

/***************************************************************************
     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() || fgIsPcdPlay())
        {
          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
}

/***************************************************************************
     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;
    }
    vSetSharedInfo(SI_RISC_SHM_RP, _bShmRp);
  }
  else
  {
    /* no more info to update */
    vClearShmUpdCnt();
  }
#else
  if (_bSMUpdate)
  {
    vHandleSM();
    _bSMUpdate = FALSE;
    ClrSmBusy();
  }
#endif
}
extern xdata BYTE _bIsSetupMenuShow;
// *********************************************************************
// Function : void vPlayerInit(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
static void vPlayerInit(void) large
{
  /* note: player function is loaded in vUserInit() */

  #ifdef SUPPORT_DRM
  _bDRMState=DRM_MAX_ST;
  _rOsdStateCtx.fgDRMShow=FALSE;
  #endif
#ifdef SUPPORT_USB_COPY //yan 070409
_bUSBUIState=USBUI_MAX_ST;
_bSourceDev = SV_DEVID_CDVDROM;
_bSaveToDev = SV_DEVID_CDVDROM;
_bUSBChange = FALSE;
_bUSBSavToEnter=FALSE;
_bUSBSwitchSuccess=FALSE;
_bUSBCounter = 0;
_bUSBPercent = 0;
_bUSBPercentCnt = FALSE;
_bUSBInterput = FALSE;
#endif
  _rOsdStateCtx.fgUopUpdate = FALSE;
  _rOsdStateCtx.bUopRetId = UOP_NONE;
  _rOsdStateCtx.bUopRetVal = SV_NO_ERROR;
  _rOsdStateCtx.fgSetupShow = FALSE;
  _bIsSetupMenuShow = FALSE;     
#ifdef PLAYER_GOTO
  _rOsdStateCtx.fgGotoShow = FALSE;  //megaa Goto
  _rOsdStateCtx.fgVRemoteShow = FALSE;  //megaa Goto
#endif
  _rOsdStateCtx.fgZoomBrShow = FALSE;
  _rEqState.bDispType = OSD_EQ_TYPE_DISABLE;

  // for player timer
  _bPlayerTimerBeepCnt = 0;

  // reset input state
  /* vResetInputState(); */
  _bInputState = INPUT_STATE_NONE;
  _fgInputResend = FALSE;
  _fgInputEscape = FALSE;
  _bIrTimer = IR_TIMER_VOID;
  _bIrTimerBeepCnt = 0;

  // for RISC communication states
  _bLastSyncUop = UOP_NONE;
  _bLastPbcState = SV_PBC_INIT;

  // reset osd state
  /* vResetOsdState(); */
  _rOsdStateCtx.fgTimeShow = FALSE;
  _rOsdStateCtx.bTimeType = OSD_SHOW_DISABLE;
  _rOsdStateCtx.fgRemainMsgShow = FALSE;
  _rOsdStateCtx.fgPlayInfoShow = FALSE;
  _rOsdStateCtx.bPlayInfoType = OSD_INFO_DISABLE;
  _rOsdStateCtx.fgPlayShow = FALSE;
  _rOsdStateCtx.bPlayType = OSD_SHOW_PLAY;
  _rOsdStateCtx.fgRepeatShow = FALSE;
  _rOsdStateCtx.fgABShow = FALSE;
  _rOsdStateCtx.fgUsrCtrlShow = FALSE;
  _rOsdStateCtx.fgZoomShow = FALSE;
  _rOsdStateCtx.fgTimePos = OSD_SHOW_TIME_LEFT;
  _rOsdStateCtx.bDynamicWB = WB_INDEX_MAX;

#ifdef EN_DISC_ID_CHK
   //vResetDiscInitFlag()
  _rOsdStateCtx.bDiscIDFound = 0;
  _rOsdStateCtx.bDiscInitFlag = 0;
#endif

  // this state is not affected by tray-in/out
  _rOsdStateCtx.bAudioStatus = OSD_AUDIO_SHOW_NORMAL;
  _rOsdStateCtx.fgAudioStatusRecall = FALSE;

  // reset search state
  _rSearchStateCtx.bType = SEARCH_NONE;

#ifdef SETUP_NO_AGL_MARK
  _rOsdStateCtx.fgAngleShow = TRUE;
#endif

// Seiya: Added on 2004/07/27 for dual mono switch.
#ifdef DVD_VR_SUPPORT
  // LLY.1008, reset DVD-VR dual mono type as L channel while power-on
  // and this procedure wiil be done for open/close action: vPlayerReset()
  vSetSharedInfo(SH_VR_DUAL_MONO_MODE, AUDIO_MONO_LEFT);
#endif

  // reset program state