play_com.c

MTK 1389E SOURCE CODE

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 05/10/18 3:18p    $       ****************/
/***************  $Revision:: 29               $       ****************/
/***************                                       ****************/
/***************   Description : Play module for       ****************/
/***************                 non-disc dependant    ****************/
/***************                 key processing        ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#pragma NOAREGS
#include "general.h"
#include "..\..\procdef.h"
#include "../../custom/demo/fslist/flcomm.h" //0728

#ifndef PLAYER_2_CHANNEL
  #include "setupmn\stpadsp.h" /* for echo key, assume no back issue */
#endif

#ifdef MTK_TVE
  #include "setupmn\stprisc.h" /* for component key */
#endif

void vDoEject(BYTE bMode) large
{
  BYTE bState;

  /* update OSD and VFD ASAP */
  // let the icon and message show at the same time
  vOsdSetSt(OSD_ST_BURST);
  if (bMode & DO_CLOSE)
  {
    vOsdShowInitState(SV_TRAY_CLOSING);
    VfdShowInitStatus(SV_TRAY_CLOSING);
    }
  else
  {
    vOsdShowInitState(SV_TRAY_OPENING);
    VfdShowInitStatus(SV_TRAY_OPENING);
  }
  vOsdSetSt(OSD_ST_NML);

  if (bMode & DO_OPEN_CLOSE_FORCE)
  {
    if (bMode & DO_CLOSE)
    {
      bState = SV_FORCE_CLOSE;
    }
    else
    {
      bState = SV_FORCE_OPEN;
    }
  }
  else
  {
    bState = 0;
  }

  vSendUopCmd(UOP_OPEN_CLOSE, bState, 0, 0);

#ifdef PLAY_AUDIO_CLIP
  /* note this must after UOP_OPEN_CLOSE but use the prevois state */
  if (bMode & DO_OPEN_CLOSE_DING)
  {
    vSendUopCmd(UOP_AUDIO_CLIP, SV_ACLIP_FLASH, ACLIP_DING, 0);
  }
#endif
}

// *********************************************************************
// Function : void vSetupMenuEnter(void)
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vSetupMenuEnter(void) large
{
#if (DRAM_SZ == DRAM_2M) || defined(USE_DRAM_CFG1)
  if (fgIsDvdPlay()
#ifdef VCD_SUPPORT
  || (fgIsVcdPlay() && !fgIsVcdCddaTrk())
#endif
     )
  {
    switch (bSharedInfo(SI_PBC_STATE))
    {
    case SV_STOP:
    case SV_STOP_RESUME:
    case SV_PAUSE:
      // Allow
      break;

    default:
      // Not Allow
      vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
      // 20050428, IS00002663, if can't enter setup, clear it
      vSetSharedInfo(SH_PAUSE_SHOW_WB, 0) ;
      return;
    }
  }
  else if (fgIsNonPlay())
  {
  }
  else if (fgIsIsoPlay())
  {
    if ((fgFlCheckStatus(FL_STATUS_IN_JPEG) || fgFlCheckStatus(FL_STATUS_IN_JPGDGST)) &&
        (bSharedInfo(SI_JPG_STT) == JPEGSTT_DEC_STRT))
    {
      return;
    }
  }

#ifndef CDDA_USE_CDFS
  else  if(!fgIsCddaPlay())
  {
    return;
  }
#endif

#ifdef SUPPORT_DATA_DISC
  if (
#ifdef SUPPORT_PCD
       fgIsPcdPlay() ||
#endif
      (fgIsIsoPlay() && fgFlCheckStatus(FL_STATUS_IN_JPEG)))
  {
    vSendUopCmd(UOP_PAUSE, 0x01, 0x01, 0x00);
  }
#endif
#if (defined(SUPPORT_DATA_DISC) && defined(SETUP_PAUSE_PLAY))
  else
#endif
#ifdef SETUP_PAUSE_PLAY
  {
    vSendUopCmd(UOP_PAUSE, 0, 0, SV_SETUP_ENTER);
  }
#endif

#if 0
#ifdef SETUP_PAUSE_PLAY

  if (
#ifdef SUPPORT_PCD
      (!fgIsPcdPlay()) &&
#endif
      (!(fgIsIsoPlay() && fgIsIsoItemStill(bSharedInfo(SI_ISO_ITEM_TYPE))))
     )
  {
    vSendUopCmd(UOP_PAUSE, 0, 0, SV_SETUP_ENTER);
  }
  else
  {
    vSendUopCmd(UOP_PAUSE, 0x01, 0x01, 0x00);
  }
#endif /* SETUP_PAUSE_PLAY */
#endif

#endif /*#if (DRAM_SZ == DRAM_2M)  */
  _rOsdStateCtx.fgSetupShow = FALSE;

  vSetSharedInfo(SH_WAIT_FOR_WB_ALLOC,1);

  vSetupInitState();

#ifdef IR_SUPPORT_SHIFT_KEY
  /* force use shift key table */
  vSetShiftKeyMode(TRUE);
#endif

  _rOsdStateCtx.fgSetupShow = TRUE;
//  _bKeyOldState = _bKeyState;
  vSetKeyState(KEY_SETUP);
}

// *********************************************************************
// Function : void vSetupMenuExit(void)
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vSetupMenuExit(void) large
{
  BYTE bInitState = bSharedInfo(SI_INIT_STATE);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);


#ifndef PLAYER_BASIC
  if (fgIsIsoPlay()
  #ifdef SUPPORT_PCD
    ||fgIsPcdPlay()
  #endif
    )
  {
    vISOFsMenuShow(FS_MENU_SHOW_REFRESH); /* recall FS menu */
  }
#endif

#ifdef IR_SUPPORT_SHIFT_KEY
  /* force use normal key table */
  vSetShiftKeyMode(FALSE);
#endif

  _rOsdStateCtx.fgSetupShow = FALSE;
  vRestorKeyState();
//  _bKeyState = _bKeyOldState;

#ifdef SETUP_PAUSE_PLAY
  switch (bInitState)
  {
    case SV_LOADING_DISC:
      vSendUopCmd(UOP_PAUSE, 0, 0, SV_SETUP_EXIT);
      return;

    case SV_TRAY_CLOSING:
    case SV_TRAY_OPENING:
    case SV_TRAY_ERROR:
    case SV_NO_DISC:
    case SV_UNKNOWN_DISC:
      return;

    case SV_DISC_IDENTIFIED:
    default:
      break; /* not determined */

  }

  /* PCD and Jpeg is handled by FSMENU */
  if (
#ifdef SUPPORT_PCD
      fgIsPcdPlay() ||
#endif
      (fgIsIsoPlay() && fgIsIsoItemStill(bSharedInfo(SI_ISO_ITEM_TYPE)))
     )
  {
    return;
  }

  switch (bPbcState)
  {
    case SV_STOP:
    case SV_STOP_RESUME:
      break;

    case SV_PAUSE:
    case SV_STEP:
    case SV_STEP_BACK:
      vSendUopCmd(UOP_PLAY, 0, 0, 0);
      break;

    case SV_SETUP_PAUSE:
    case SV_PBC_INIT:
      vSendUopCmd(UOP_PAUSE, 0, 0, SV_SETUP_EXIT);
      break;

    case SV_PTL_ERR:
    case SV_REGION_ERR:
    case SV_DISC_ERR:
    case SV_SET_TMP_PTL:
      break; /* allowed */

    case SV_PLAY:
      break;

    case SV_FF:
  #ifdef TRICK_MODE_USE_PLAY
      vSendUopCmd(UOP_PLAY, 0, 0, 0);
  #else
      vSendUopCmd(UOP_FORWARD, SV_FAST, 0, 0);
  #endif
      break;

    case SV_SF:
  #ifdef TRICK_MODE_USE_PLAY
      vSendUopCmd(UOP_PLAY, 0, 0, 0);
  #else
      vSendUopCmd(UOP_FORWARD, SV_SLOW, 0, 0);
  #endif
      break;

    case SV_FR:
  #ifdef TRICK_MODE_USE_PLAY
      vSendUopCmd(UOP_PLAY, 0, 0, 0);
  #else
      vSendUopCmd(UOP_REVERSE, SV_FAST, 0, 0);
  #endif
      break;

    case SV_SR:
  #ifdef TRICK_MODE_USE_PLAY
      vSendUopCmd(UOP_PLAY, 0, 0, 0);
  #else
      vSendUopCmd(UOP_REVERSE, SV_SLOW, 0, 0);
  #endif
      break;

    case SV_FREEZE:
    case SV_DIGEST9:
    case SV_DIGEST4:
    case SV_DIGEST:
    case SV_STILL:
    default:
      break;
  }
#endif /* SETUP_PAUSE_PLAY */

  //pause before show WB
  if(bSharedInfo(SH_PAUSE_SHOW_WB) == SV_SHOW_SETUP)
  {
    // 20050428, IS00002663, don't clear yet, we'll clear this flag when RISC notify PBC_STATE
    //vSetSharedInfo(SH_PAUSE_SHOW_WB,0);//init
    vSendUopCmd(UOP_PLAY, 0, 0, 0);
  }
}

#ifdef EN_DISC_ID_CHK
// *********************************************************************
// For disc ID check password
// *********************************************************************
void vNONDLockPwdInit(BYTE fgInit) large
{
  vNumInInitState(NUM_IN_TYPE_2, PASSWORD_LEN);

  //show disc lock information here
  vOsdShowPassword(0, PASSWORD_LEN, 0);

  /* no input timeout */
  vIrSetTimeOut(IR_TIMER_VOID);
}

BOOL fgNONDLockPwdState(void) large
{
  BOOL fgRetVal = TRUE;

  if (fgIsPlayEnterKey(_bIRKey))
  {
    if (_rNumInStateCtx.rState.fgComplete)
    {
      vOsdShowPassword(OSD_PASSWORD_CLEAR, PASSWORD_LEN, 0);
      vOsdPosClear(OSD_POS_PLAY_INFO);

      if (_rNumInStateCtx.rState.fgCancel == FALSE)
      {
        if (fgDVDComparePwd(_rNumInStateCtx.bDig) == TRUE)
        {
          /* password check OK */
          vSetDiscInitFlag(DISC_INIT_PWD_OK);
        }
        else /* password check error */
        {
          /* pass IR_PASSWORD to main state to
             ask user input password again */
          _bIRKey = IR_PASSWORD;
          fgRetVal = FALSE;
        }
      }
      else /* ? */
      {
        vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_PWD_ERR, OSD_TIMEOUT);
        /* pass STOP to main state */
        _bIRKey = IR_STOP;
        fgRetVal = FALSE;
      }

      vSetExitInputState();
    } /* fgComplete */
  }
  else if ((_bIRKey < IR_ADD10) || (_bIRKey == IR_CLEAR))
  {
    if ((_rNumInStateCtx.rState.fgComplete == FALSE) || (_bIRKey == IR_CLEAR))
    {
      fgNumInState();

      vOsdShowPassword(_rNumInStateCtx.rState.bDigNum, PASSWORD_LEN, _rNumInStateCtx.bDig);
    }
  }
  else /* if (_bIRKey >= IR_ADD10) */
  {
    if (_bIRKey < IR_INTERNAL_KEY_START)
    {
      /* don't pass the key */
      fgRetVal = TRUE;
    }
    else
    {
      /* pass the key */
      fgRetVal = FALSE;
    }
  }

  return (fgRetVal);
}
#endif /* EN_DISC_ID_CHK */

// *********************************************************************
// From combine.c
// *********************************************************************
// *********************************************************************
// Handle system UOP return
// *********************************************************************
BYTE bCOMHandleUopRet(BYTE bUopId, BYTE bUopRet) large
{
  BYTE bRet = UOP_UPDATE;
  BYTE bTmp1, bTmp2;

  if (bUopRet != SV_NO_ERROR)
  {
    bRet = UOP_FAIL; /* show error */
  }
  else
  {
    bRet = UOP_UPDATE;
  }

  switch (bUopId)
  {
    case UOP_ZOOM_IN:
    {
#ifdef DDISC_FTYPE_JPEG_SUPPORT
      if (bUopRet != SV_NO_ERROR)
      {
  #ifdef PLAYER_ZOOMIN_INDICATOR
        vDisableWB(WB_ZOOM_BR);
  #endif

        bTmp1 = bSharedInfo(SI_ZOOM_SWITCH);
        bTmp2 = bSharedInfo(SI_ISO_ITEM_TYPE);

        if (
#ifdef SUPPORT_PCD
            fgIsPcdPlay() ||
#endif
            (fgIsIsoPlay() && (bTmp2 == SV_ISO_JPG)))
        {
          vOsdShowZoomPct(bTmp1);

          if ((bTmp1 == 0) && fgIsInputStateValid(INPUT_STATE_PCD_ZOOM))
          {
            /* need to escape zoom control mode */
            fgSetPlayPostKey(IR_ZOOM_IN);
          }
        }
      }
#endif /* DDISC_FTYPE_JPEG_SUPPORT */
      break;
    }

    /* case UOP_ZOOM_OUT: */
    /* case UOP_SHOW_LOGO: */
#ifdef SUPPORT_CAPTURE_LOGO
    case UOP_CAPTURE:
      if (fgIsInputStateValid(INPUT_STATE_LOGO_CAPTURE) == TRUE)
      {
        if (bUopRet == SV_NO_ERROR)
        {
          fgSetPlayPostKey(IR_CAPTURE);
        }
        else
        {
          fgSetPlayPostKey(IR_TIME_OUT);
        }
      }
#endif /* SUPPORT_CAPTURE_LOGO */
      break;

    /* case UOP_AUDIO_CLIP: */
    /* case UOP_VOCAL_ASSIST: */

    case UOP_POWER:
      break;

    case UOP_OPEN_CLOSE:
    {
      if (bUopRet == SV_NO_ERROR)
      {
#if 0
        bTmp1 = bSharedInfo(SI_INIT_STATE);

        if (bTmp1 == SV_TRAY_OPENING)
        {
          vOsdPosShow(OSD_POS_PLAY_STATUS, OSD_MSG_OPEN, OSD_NO_DISAPPEAR);
        }
        else if(bTmp1 == SV_TRAY_CLOSING)
        {
          vOsdPosShow(OSD_POS_PLAY_STATUS, OSD_MSG_CLOSE, OSD_NO_DISAPPEAR);
        }
#endif
      }
      break;
    }

    default:
      break;
  }

  return (bRet);
}

// *********************************************************************
// From extuop.c
// *********************************************************************
BOOL fgCOMSetupKey(void) large
{
  BYTE bState;

  bState = bSharedInfo(SI_PBC_STATE);

#if defined(MT1389_REV_E_512K) && defined(PLAYER_KARAOKE) && !defined(RISC_FULL_CUSTOM_MMAP)
  // 20050830: In 4+2 model, don't allow Setup Menu in Jpeg
  if ((fgIsDiscPlay(bState)) && fgFlCheckStatus(FL_STATUS_IN_JPEG) /*(bSharedInfo(SI_ISO_ITEM_TYPE) == SV_ISO_JPG)*/)
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
    _bIRKey = IR_NONE;
    return (UOP_OK);
  }
#endif  // #ifdef MT1389_REV_E_512K

  // 20050503, PL00000140, prohibit setup key when user press enter to play MPG file but playback javen't started yet.
  if (fgIsIsoPlay() && bState == SV_PRE_PLAY)
    return UOP_FAIL ;
  
#if (DRAM_SZ == DRAM_2M) || defined(USE_DRAM_CFG1)
  // 20050428, IS00002663, if entering setup, don't accept key again
//  if (bSharedInfo(SH_PAUSE_SHOW_WB) == SV_SHOW_SETUP)
  // 20050623, PL00001170, switching between these keys also should be prohibited
  //20050630, PL00001181, add check if _fgSetupProhibit
  if (bSharedInfo(SH_PAUSE_SHOW_WB) != 0 || _fgSetupProhibit)
    return UOP_FAIL ;

  // 20050617, PL00001125, if current file finish and entering next file, we should prohibit entering setup, or MPS will play next file when entering setup
  if (fgFlCheckStatus (FL_STATUS_IN_MPEG) && bState == SV_STOP)
    return UOP_FAIL ;
  // 20050511, when step, also send pause command and enter setup
//  if(((bState >= SV_PLAY) && (bState <= SV_SR)) && ((_bPlayType != PLAY_TYPE_ISO) || (_bFlCmdTarget == FL_CMD_TARGET_MPEG))&& //0728
  if(((bState >= SV_PLAY) && (bState <= SV_STEP_BACK) && (bState != SV_PAUSE)) && ((!fgIsIsoPlay() && !fgIsPcdPlay()) || (_bFlCmdTarget == FL_CMD_TARGET_MPEG))&& //0728
     (_bPlayType != PLAY_TYPE_CDDA) && 
#ifdef VCD_SUPPORT
      !fgIsVcdCddaTrk() &&  
#endif
      (_bTrayStatus == TRAY_ST_IN) && _bPlayType != PLAY_TYPE_NONE)    // 20050519, PL00000996, sometimes PBC state is kept at play when tray out
  {
    vSetSharedInfo(SH_PAUSE_SHOW_WB,SV_SHOW_SETUP);
    //vSendUopCmd(UOP_PAUSE, 0, 0, SV_SETUP_ENTER);
    if(_bPlayType == PLAY_TYPE_DVD)
    {
      vSendUopCmd(UOP_PAUSE, 0, 0, SV_SHOW_MENU);
    }
    else
    {
      if (bSharedInfo(SI_JPG_STT) == JPEGSTT_DEC_STRT)
        vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
      else
        vSendUopCmd(UOP_PAUSE, 0, 0, 0);
    }
  }
  else
#endif
  {
#ifndef N22_CERTIFICATION
    if ((bSharedInfo(SI_OSD_STATE) != OSD_ST_INIT) &&
        (bSharedInfo(SI_OSD_CMD_BUF_FULL) != TRUE)
        && (bSharedInfo(SI_MPV_PAUSE) == 1 || (bState != SV_PAUSE))   // Wait for SI_MPV_PAUSE == 1, so that RISC is really paused
  #ifdef PLAYER_FLMENU
        && (!fgFlCheckStatus(FL_STATUS_IN_HELP))
  #endif
       )
    {
      /* when osd state is init, do not accept setup menu command */
      if(_bTrayStatus != TRAY_ST_MIDDLE)
      {
        vChangeInputState(INPUT_STATE_SETUP, FALSE);
      }
    }