uopmap.c

MTK1389 SOURCE CODE

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 04/07/20 12:19p   $       ****************/
/***************  $Revision:: 17               $       ****************/
/***************                                       ****************/
/***************   Description : Key-Combine State     ****************/
/***************                 Machine               ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Sung-Ching Lin        ****************/
/**********************************************************************/
#define _UOPMAP_C_

#pragma NOAREGS
#include "general.h"

#ifdef AUDIO_IN_EN
BOOL fgAudioInHandleCmd(void) large;
BYTE bAudioInHandleUopRet(BYTE bUopId, BYTE bUopRet) large;
#endif

// *********************************************************************
// Function : void vResetOsdState(void)
// Description : Reset OSD state
// Parameter : None
// Return    : None
// *********************************************************************
void vResetOsdState(void) large
{
  /* _rOsdStateCtx.fgUopUpdate = FALSE; */
  /* _rOsdStateCtx.bUopRetId = UOP_NONE; */
  /* _rOsdStateCtx.bUopRetVal = SV_NO_ERROR; */
  /* _rOsdStateCtx.fgSetupShow = FALSE; */
  _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.fgAngleShow = FALSE; */
  _rOsdStateCtx.fgTimePos = OSD_SHOW_TIME_LEFT;
#ifdef EEPROM_LASTMEM_EJECT_WR_BACK
  _rOsdStateCtx.fgLastMemWrBack = FALSE;
#endif

  vResetDiscInitFlag();
}

// *********************************************************************
// Function : void vScrSaverSetTimeOut(BYTE bTime) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vScrSaverSetTimeOut(BYTE bTime) large
{
  _bScrSaverTimer = bTime;

  if (bTime == 0)
  {
    _bScrSaverBeepCnt = SCR_SAVER_ON_BEEP_COUNT;

    vSetScrSaverOn();
    vSetKeyState(KEY_SCRSAV);
#ifdef PLAYER_AUTO_PWR_DOWN
    vSetSharedInfo(SH_IR_TIMER_AUTO_PWR_DOWN, AUTO_PWR_DOWN_TIMEOUT);
#endif
  }
  else
  {
    _bScrSaverBeepCnt = SCR_SAVER_OFF_BEEP_COUNT;
    vSetScrSaverOff();

#ifndef SHRINK_KEYPROC
    if (bKeyState() == KEY_SCRSAV)
    {
      if ( bKeyOldState() == KEY_SETUP )
      {
        if ( fgIsDvdPlay() || fgIsVcdPlay() ||fgIsCddaPlay() || fgIsAinPlay() )
        {
          _bKeyState = (KEY_NONISO << 4) + KEY_SETUP;
        }
        else if (fgIsIsoPlay()
#ifdef SUPPORT_PCD
                 || fgIsPcdPlay()
#endif
                )
        {
          _bKeyState = (KEY_ISO << 4) + KEY_SETUP;
        }
        else
        {
          _bKeyState = (KEY_INIT << 4) + KEY_SETUP;
        }
      }
      else
      {
        vRestorKeyState();
      }
    }
#endif //SHRINK_KEYPROC

#ifdef PLAYER_AUTO_PWR_DOWN
    vSetSharedInfo(SH_IR_TIMER_AUTO_PWR_DOWN, 0);
#endif
  }
}

// *********************************************************************
// Function : void vIrSetTimeOut(BYTE bTime) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vIrSetTimeOut(BYTE bTime) large
{
  _bIrTimer = bTime;

  if (_bIrTimer != IR_TIMER_VOID)
  {
    _bIrTimerBeepCnt = IR_TIMER_BEEP_PERIOD;
  }
  else
  {
    _bIrTimerBeepCnt = 0;
  }
}

// *********************************************************************
// Input State Function: General Number Select
// *********************************************************************
void vBtnNoInitState(BYTE fgInit) large
{
#ifdef NO_ADD10_KEY
  vNumInInitState(NUM_IN_SEQ_LIMIT, 2);
#else
  vNumInInitState(NUM_IN_TYPE_1, 1);
#endif

  /* here is some trick, not a good way! */
  if (_bIRKey > IR_ADD10 && _bIRKey != IR_ADD5)  // megaa ADD5
  {
    vOsdShowSelect2(0, 0 | OSD_SELECT_HILI, OSD_NO_DISAPPEAR);
  }

  vIrSetTimeOut(IR_TIMEOUT_SEARCH);
}

BOOL fgBtnNoInputState(void) large
{
  BOOL fgRetVal;

  fgRetVal = fgNumInState();

  if (fgRetVal == TRUE)
  {
    vIrSetTimeOut(IR_TIMEOUT_SEARCH);

    if (_rNumInStateCtx.rState.fgComplete)
    {
      vOsdShowSelect2(0, 0, 0);

      if (fgIsDvdPlay())
      {
#ifndef NEW_SHOW      
        if (fgDVDCheckSelectRange(_rNumInStateCtx.wNum) == FALSE)
#else
        if (fgCheckSelectRange(_rNumInStateCtx.wNum) == FALSE)
#endif
        {
          _rNumInStateCtx.rState.fgCancel = TRUE;
        }
      }
#ifdef VCD_SUPPORT      
      else if (fgIsVcdPlay())
      {
#ifndef NEW_SHOW            
        if (fgVCDCheckSelectRange(_rNumInStateCtx.wNum) == FALSE)
#else
        if (fgCheckSelectRange(_rNumInStateCtx.wNum) == FALSE)
#endif
        {
          _rNumInStateCtx.rState.fgCancel = TRUE;
        }
      }
#endif      

      if (_rNumInStateCtx.rState.fgCancel == FALSE)
      {
         vSendUopCmd(UOP_DIGITAL_BTN, _rNumInStateCtx.wNum, 0, 0);
         vOsdShowSelect2(_rNumInStateCtx.wNum, 2, OSD_TIMEOUT_SHORT);
      }
      else
      {
        vOsdShowError(SV_ERR_INPUT_INVALID, OSD_TIMEOUT_SHORT);
      }

      vSetExitInputState();
    }
    else
    {
      vOsdShowSelect2(_rNumInStateCtx.wNum, OSD_SELECT_HILI | _rNumInStateCtx.rState.bDigNum, OSD_NO_DISAPPEAR);
    }
  }
  else /* fgRetVal == FALSE */
  {
    vOsdShowSelect2(0, 0, 0);
    vSetExitInputState();

    if ((_bIRKey == IR_SETUP) || (_bIRKey == IR_GOTO))
    {
      fgRetVal = FALSE;
    }
    else
    {
      fgRetVal = TRUE;
    }
  }

  return (fgRetVal);
}

static code const strucInputState prInputState[INPUT_STATE_STACK_START] =
{
  /* 00 */ {vBtnNoInitState, fgBtnNoInputState, 0,  INPUT_STATE_KEY_TBL_NORMAL},
#ifdef PLAYER_PROGRAM
  /* 01 */ {vSelectInit, fgSelectState, vSelectExit, INPUT_STATE_KEY_TBL_NORMAL},
#else
  /* 01 */ {0, 0, 0, INPUT_STATE_KEY_TBL_NORMAL},
#endif
  /* 02 */ {vDVDPTTSearchInit, fgDVDPTTSearchState, 0, INPUT_STATE_KEY_TBL_NORMAL},
  /* 03 */ {vDVDTitleSearchInit, fgDVDTitleSearchState, vDVDTitleSearchExit, INPUT_STATE_KEY_TBL_NORMAL},
  /* 04 */ {vDVDTimeSearchInit, fgDVDTimeSearchState, 0, INPUT_STATE_KEY_TBL_NORMAL},
#ifdef VCD_SUPPORT
  /* 05 */ {vVCDTimeSearchInit, fgVCDTimeSearchState, 0, INPUT_STATE_KEY_TBL_NORMAL},
  /* 06 */ {vVCDTrackSearchInit, fgVCDTrackSearchState, 0, INPUT_STATE_KEY_TBL_NORMAL},
#else
  /* 05 */ {0, 0, 0, INPUT_STATE_KEY_TBL_NORMAL},
  /* 06 */ {0, 0, 0, INPUT_STATE_KEY_TBL_NORMAL},
#endif  
#ifdef PLAYER_GOTO
  /* 07 */ {vISOTimeSearchInit, fgISOTimeSearchState, vISOTimeSearchExit, INPUT_STATE_KEY_TBL_NORMAL},
#else
  /* 07 */ {0, 0, 0, INPUT_STATE_KEY_TBL_NORMAL},
#endif /* PLAYER_BASIC */
  /* 08 */ {vDVDAudioChangeInit, fgDVDAudioChangeState, vDVDAudioChangeExit, INPUT_STATE_KEY_TBL_NORMAL},
  /* 09 */ {vDVDSubtitleChangeInit, fgDVDSubtitleChangeState, vDVDSubtitleChangeExit, INPUT_STATE_KEY_TBL_NORMAL},
  /* 10 */ {vDVDAngleChangeInit, fgDVDAngleChangeState, vDVDAngleChangeExit, INPUT_STATE_KEY_TBL_NORMAL},
  /* 11 */ {vDVDDisplayChangeInit, fgDVDDisplayChangeState, vDVDDisplayChangeExit, INPUT_STATE_KEY_TBL_KEEP},
#ifdef VCD_SUPPORT
  /* 12 */ {vVCDDisplayChangeInit, fgVCDDisplayChangeState, vVCDDisplayChangeExit, INPUT_STATE_KEY_TBL_KEEP},
#else
  /* 12 */ {0, 0, 0, INPUT_STATE_KEY_TBL_KEEP},
#endif  
  /* 13 */ {vDVDPwdInputInit, fgDVDPwdInputState, 0, INPUT_STATE_KEY_TBL_NORMAL},
#ifdef PLAYER_BOOKMARK  
  /* 14 */ {vBookmarkInit, fgBookmarkState, vBookmarkExit, INPUT_STATE_KEY_TBL_SHIFT},
#else
  /* 14 */ {0, 0, 0, INPUT_STATE_KEY_TBL_SHIFT},
#endif  
  /* 15 */ {vUpgInit, fgUpgState, vUpgExit, INPUT_STATE_KEY_TBL_KEEP},
#ifdef PLAYER_DIGEST
  /* 16 */ {vDigestInit, fgDigestState, vDigestExit, INPUT_STATE_KEY_TBL_SHIFT},
#else
  /* 16 */ {0, 0, 0, INPUT_STATE_KEY_TBL_SHIFT},
#endif  
#ifndef PLAYER_BASIC
  /* 17 */ {vISOFileSelectInit, fgISOFileSelectState, vISOFileSelectExit, INPUT_STATE_KEY_TBL_NORMAL},
  /* 18 */ {0, 0, 0, INPUT_STATE_KEY_TBL_KEEP},
  #ifdef SUPPORT_PCD
  /* 19 */ {vPCDZoomInit, fgPCDZoomState, vPCDZoomExit, INPUT_STATE_KEY_TBL_KEEP},
#else
  /* 19 */ {0, 0, 0, INPUT_STATE_KEY_TBL_KEEP},
  #endif 
#else
  /* 17 */ {0, 0, 0, INPUT_STATE_KEY_TBL_NORMAL},
  /* 18 */ {0, 0, 0, INPUT_STATE_KEY_TBL_KEEP},
  /* 19 */ {0, 0, 0, INPUT_STATE_KEY_TBL_KEEP},
#endif /* PLAYER_BASIC */
  /* 20 */ {vDAHdnGrpPwdInputInit, fgDAHdnGrpInputState, 0, INPUT_STATE_KEY_TBL_NORMAL},
  /* 21 */ {vScanInit, fgScanState, vScanExit, INPUT_STATE_KEY_TBL_NORMAL},
  /* 22 */ {vInitDLockPwdInit, fgInitDLockPwdState, 0, INPUT_STATE_KEY_TBL_NORMAL},
  /* 23 */ {vLogoCapInit, fgLogoCapState, vLogoCapExit, INPUT_STATE_KEY_TBL_KEEP},
#ifdef VRMT_NOMENU_ITEM
  /* 24 */ {vVremoteInit, fgVremoteState, vVremoteExit, INPUT_STATE_KEY_TBL_SHIFT}
#else
  /* 24 */ {0, 0, 0, INPUT_STATE_KEY_TBL_SHIFT},
#endif  
};

static void vEscapeInputState(void) large
{
  /* check stacked input mode first */
  if (fgIsInSetupMenu())
  {
    // one escape make two state exit???
    vSetupMenuExit();
  }
  /* check non stack input mode start */
  else if (_bInputState >= INPUT_STATE_STACK_START)
  {
#ifdef PLAYER_NUI
    _fgInputEscape = FALSE; //[runma] add line for debug. vGotoClose will set it to true and does not set it back to false?
#endif
    return; /* no need to exit current input mode */
  }
  else if (_bInputState != INPUT_STATE_NONE) /* the non-stack input state */
  {
    /* escape current input mode */
    if (prInputState[_bInputState].vExit != 0)
    {
      prInputState[_bInputState].vExit();
    }

    _bInputState = INPUT_STATE_NONE;
    vIrSetTimeOut(IR_TIMER_VOID);
  }
#ifdef PLAYER_GOTO
  else if (fgIsInGoto())
  {
    vGotoExit();
  }
#endif /* PLAYER_GOTO */

  _fgInputResend = FALSE;
  _fgInputEscape = FALSE;
}

/* This must be called after call the input state function */
#define vUpdateInputState() if (_fgInputEscape) { vEscapeInputState(); }

void vNonStatckInputState(void) large
{
  if (fgIsHiPriorityKey(_bIRKey))
  {
    /* if is high priority key, force escape input state */
    vEscapeInputState();
  }
  else if (_bInputState < INPUT_STATE_STACK_START)
  {
    if (prInputState[_bInputState].fgState())
    {
      /* the key is grabed */
      if(_bIRKey != IR_SETUP)
      {
        _bIRKey = IR_NONE;
      }
    }

    vUpdateInputState();
  }
}

// *********************************************************************
//  Input state export function
// *********************************************************************
/* makre sure this function is only called from key function (main state) */
void vChangeInputState(BYTE bState, BOOL fgSendKey) large
{
 
  if (bState >= INPUT_STATE_MAX) /* non-valid state */
  {
    return;
  }
  else if (bState < INPUT_STATE_STACK_START)
  {
    if (_bInputState != INPUT_STATE_NONE)
    {
      if (prInputState[_bInputState].vExit != 0)
      {
        vEscapeInputState();
      }
      else
      {
        /* the input mode exit should be handled by itself */
        return;
      }
    }

    if (prInputState[bState].vInit != 0)
    {
      _bInputState = bState; /* note we must assign the state first then excute initialization */
      prInputState[_bInputState].vInit(TRUE);
    }
    else
    {
      return;
    }

#ifdef IR_SUPPORT_SHIFT_KEY
    if (prInputState[_bInputState].bKeyShiftMode == INPUT_STATE_KEY_TBL_NORMAL)
    {
      vSetShiftKeyMode(FALSE);
    }
    else if (prInputState[_bInputState].bKeyShiftMode == INPUT_STATE_KEY_TBL_SHIFT)
    {
      vSetShiftKeyMode(TRUE);
    }
    else /* if (prInputState[_bInputState].bKeyShiftMode == INPUT_STATE_KEY_TBL_KEEP) */
    {
      /* do nothing */
    }
#endif

    /* only non-stack input state need to check this */
    if (fgSendKey)
    {
      /* we can not call fgState() here, or it will cause recursive call */
      _fgInputResend = TRUE;
    }
  }
  /* start of stack input state */
  else if (bState >= INPUT_STATE_STACK_START)
  {
    /* if the non-stack input state is time dependant, force escape it first! */
    if (_bIrTimer != IR_TIMER_VOID)
    {
      vEscapeInputState();
    }

    if (bState == INPUT_STATE_SETUP)
    {
      vSetupMenuEnter();
    }
#ifdef PLAYER_GOTO
    else if (bState == INPUT_STATE_GOTO)
    {
      vGotoEnter();
    }
#endif
  }
}

/* makre sure this function is only called from input state function */
void vSetExitInputState(void) large