play_non.c

mtk1389L latest sourcecode enjoy

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 07/04/09 11:49a   $       ****************/
/***************  $Revision:: 2                $       ****************/
/***************                                       ****************/
/***************   Description : Play module for       ****************/
/***************                 non-disc dependant    ****************/
/***************                 key processing        ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#pragma NOAREGS
#include "general.h"
#include "..\..\..\procdef.h"

#ifdef MTK_MENU
  #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
#else
  #ifndef PLAYER_2_CHANNEL
    #include "setup\adspr.h" /* for echo key, assume no back issue */
  #endif

  #ifdef MTK_TVE
    #include "setup\riscr.h" /* for component key */
  #endif
#endif

// *********************************************************************
// Eject Routine
// *********************************************************************
#define DO_OPEN_CLOSE_FORCE   0x80
#define DO_OPEN_CLOSE_DING    0x40
#define DO_OPEN               0x00
#define DO_CLOSE              0x01

static void vDoEject(BYTE bMode)
{
  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);
    }
  else
  {
    vOsdShowInitState(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
{
  _rOsdStateCtx.fgSetupSttTrans = TRUE;
#ifdef SUPPORT_DATA_DISC
  if (fgIsPcdPlay() ||
      (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 ((!fgIsPcdPlay()) &&
      (!(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
  _rOsdStateCtx.fgSetupShow = FALSE;

  vSetupInitState();

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

  _rOsdStateCtx.fgSetupShow = TRUE;
}

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

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

#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 bNONHandleUopRet(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 (fgIsPcdPlay() ||
            (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
// *********************************************************************
static BYTE bNONSetupKey(void) large
{
  if (_rOsdStateCtx.fgSetupSttTrans)
  {
    _bIRKey = IR_NONE;
    return (UOP_OK);
  }

#ifndef N22_CERTIFICATION
  if ((bSharedInfo(SI_OSD_STATE) != OSD_ST_INIT) &&
      (bSharedInfo(SI_OSD_CMD_BUF_FULL) != TRUE)
  #ifdef PLAYER_FLMENU
      && (!fgFlCheckStatus(FL_STATUS_IN_HELP))
  #endif
     )
  {
    /* when osd state is init, do not accept setup menu command */
    vChangeInputState(INPUT_STATE_SETUP, FALSE);
  }
#endif /* N22_CERTIFICATION */

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

/*
static code WORD pwSetOsdLan[EV_OSD_LANG_NS] = {
  OSD_MSG_OSDLANG_ENGLISH,
  OSD_MSG_OSDLANG_CHINESE
};
*/

#if (defined(DDISC_FTYPE_JPEG_SUPPORT) && defined(SUPPORT_DATA_DISC))
extern void vFsMenuChangeLang(BYTE bLangIdx) large;
#endif

static BYTE bNONOsdLangKey(void) large
{
  BYTE bLang = bEepromReadByte(OSD_LANG_POSITION);

  if (bLang >= EV_OSD_LANG_NS - 1)
  {
    bLang = 0;
  }
  else
  {
    bLang++;
  }

  vOsdSetLang(bLang);
#ifndef PLAYER_FLMENU
  #if (defined(DDISC_FTYPE_JPEG_SUPPORT) && defined(SUPPORT_DATA_DISC))
    vFsMenuChangeLang(bLang);
  #endif
#endif

#ifdef PLAYER_VRMT
  if(fgIsInputStateValid(INPUT_STATE_VREMOTE)) 
  {
    vVRMTRedrawAll();
  }
#endif

  //vOsdPosShow(OSD_POS_NORMAL, pwSetOsdLan[bLang], OSD_TIMEOUT_SHORT);
  vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_OSD_LANGUAGE, OSD_TIMEOUT_SHORT);

  fgEepromWriteByte(OSD_LANG_POSITION, bLang);
  
#if (!defined(PLAYER_FLMENU) && defined(SUPPORT_DATA_DISC))
  //Mars Wen,[2002/2/6],for JPG language switch support
  if (fgIsPcdPlay() ||
      (fgIsIsoPlay() && (bSharedInfo(SI_ISO_ITEM_TYPE) == SV_ISO_JPG)))
  {
    vFsMenuRecoverMenus();
  }
#endif

#ifdef PLAYER_FLMENU
  if (fgIsPcdPlay() || fgIsIsoPlay())
  {
    vFlChgLang(bLang); //vFlRedraw(REDRAW_CHG_LANG, bLang);
  }
#endif
  _bIRKey = IR_NONE;
  return (UOP_OK);
}

static BYTE bNONGameKey(void) large
{
  /*
  vChangeInputState(INPUT_STATE_GAME, FALSE);
  _bIRKey = IR_NONE;
  return (UOP_OK);
  */

  // 20050328, IS00001944, show prohibit for non-supported keys
  return (UOP_FAIL);
//  _bIRKey = IR_NONE;
//  return (UOP_OK);
}

static BYTE bNONFunctionKey(void) large
{
#ifdef AUDIO_IN_EN
  if (fgIsFuncAin())
  {
    // pass this key to play_ain.c
    return (UOP_OK);
  }
  else if (fgIsFuncDvd())
  {
    if (fgAINIsFuncChgAllow() == TRUE)
    {
      vPlayerFuncSwitch(PLAYER_FUNC_AIN);
    }
  }

  _bIRKey = IR_NONE;
  return (UOP_OK);
#else /* AUDIO_IN_EN */
  // 20050328, IS00001944, show prohibit for non-supported keys
  return (UOP_FAIL);
//  _bIRKey = IR_NONE;
//  return (UOP_OK);
#endif /* AUDIO_IN_EN */
}

static BYTE bNONVfdDark(void) large
{
  vVfdBrightSwitch(VFD_BRIGHT_LOW);

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

static BYTE bNONVfdBright(void) large
{
  vVfdBrightSwitch(VFD_BRIGHT_HIGH);

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

static BYTE bNONTvFormatKey(void) large
{
  BYTE bInitState = bSharedInfo(SI_INIT_STATE);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bTvSystem = bTvSystemSetting();
  BOOL fgChange = TRUE;
#ifdef PSCAN_EN
  BYTE bTvOut = bSharedInfo(SI_TVE_OUT_MODE);
  BYTE bPScan = bSharedInfo(SI_PSCAN_EN);

  #if 0 // allow VGA mode for PAL
  if (bTvOut == SV_TVE_VGA)
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
    _bIRKey = IR_NONE;
    return (UOP_OK);
  }
  #endif // allow VGA mode for PAL
#endif /* PSCAN_EN */

  /* this condition is not allowed */
#ifdef MTK_TVE
  if ((bInitState == SV_LOADING_DISC) || (bInitState == SV_TRAY_CLOSING))
  {
    fgChange = FALSE;
  }
  else if (bInitState == SV_TRAY_OPENING)
  {
    if (!fgIsTrayOutside())
    {
      fgChange = FALSE;