play_com.c

MTK 1389E SOURCE CODE

#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

BOOL fgCOMOsdLangKey(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);

  fgEepromWriteByte(OSD_LANG_POSITION, bLang);

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

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

BOOL fgCOMGameKey(void) large
{
  /*
  vChangeInputState(INPUT_STATE_GAME, FALSE);
  _bIRKey = IR_NONE;
  return (UOP_OK);
  */

  // 20050401, CR00002256, show prohibit for non-supported keys
  return (UOP_FAIL);  
}

BOOL fgCOMFunctionKey(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 */

  // 20050401, CR00002256, show prohibit for non-supported keys
  return (UOP_FAIL);  
#endif /* AUDIO_IN_EN */
}

BOOL fgCOMVfdDark(void) large
{
  VfdBright(VFD_DISP_DARK);

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

BOOL fgCOMVfdBright(void) large
{
  VfdBright(VFD_DISP_BRIGHT);

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

BOOL fgCOMTvFormatKey(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;
    }
  }
  #ifdef PLAY_NO_CHG_TV_FMT
  else if (!fgIsNonPlay())
  {
    if (fgIsDiscPlay(bPbcState) || fgIsInDigest(bPbcState))
    {
      fgChange = FALSE;
    }
  }
  #endif /* PLAY_NO_CHG_TV_FMT */
#endif /* MTK_TVE */

#ifdef JPG_PREVIEW_SUPPORT
  // 20050516, prohibit p/n switch when JPEG preview is still decoding. Or JPEG preview might be overwritten by background logo.
  if (fgChange && fgIsIsoPlay() && fgFlCheckStatus (FL_STATUS_IN_MENU) && fgFlCheckStatus (FL_STATUS_JPEG_DECODING))
    fgChange = FALSE ;
#endif

  /* change the format */
  if (fgChange)
  {
    switch (bTvSystem)
    {
      case SV_NTSC:
#ifdef PSCAN_EN
        if ((bTvOut != SV_TVE_DIRECT) && (bPScan == SV_ON))
        {
          vOsdShowTvFormat(OSD_MSG_PAL_PSCAN);
        }
        else
#endif /* PSCAN_EN */
        {
          vOsdShowTvFormat(OSD_MSG_PAL);
        }
        bTvSystem = SV_PAL;
        break;

      case SV_PAL:
#ifdef PSCAN_EN
        if ((bTvOut != SV_TVE_DIRECT) && (bPScan == SV_ON))
        {
          vOsdShowTvFormat(OSD_MSG_MULTI_PSCAN);
          //vOsdShowTvFormat(OSD_MSG_AUTO_PSCAN);
        }
        else
#endif /* PSCAN_EN */
        {
          vOsdShowTvFormat(OSD_MSG_MULTI);
          //vOsdShowTvFormat(OSD_MSG_AUTO);
        }
        bTvSystem = SV_AUTO;
        break;

      case SV_AUTO:
      default:
#ifdef PSCAN_EN
  #ifdef PN_IP_SAME_KEY
    #if 1 // force P-Scan on
        // ** when VGA, switch to non-Pscan, must set component to YUV or RGB
        if (bTvOut == SV_TVE_DIRECT || bTvOut == SV_TVE_VGA)
        {
          if (bTvOut == SV_TVE_DIRECT)
            bPScan = SV_OFF;

          // Choose one as default
          bTvOut = SV_TVE_YCBCR;
          //bTvOut = SV_TVE_RGB;
          if (bEepromReadByte(TV_COMP_POS) != bTvOut)
          {
            fgEepromWriteByte(TV_COMP_POS, bTvOut);
          }

          bSetCompOut(0, 0);
        }
    #else // don't force P-Scan on
        if (bTvOut == SV_TVE_DIRECT)
        {
          bPScan = SV_OFF;
        }
    #endif // don't force P-Scan on

        if (bTvOut != SV_TVE_DIRECT)
        {
          if (bPScan == SV_OFF)
          {
            /* switch to P-SCAN on */
            bPScan = SV_ON;
          }
          else
          {
            /* switch to P-SCAN off */
            bPScan = SV_OFF;
          }

          if (bEepromReadByte(TV_PSCAN_EN_POS) != bPScan)
          {
            fgEepromWriteByte(TV_PSCAN_EN_POS, bPScan);
          }

          vVideoPScanMode(bPScan, bTvOut);
        }
  #endif /* PN_IP_SAME_KEY */

        if (bPScan == SV_ON)
        {
  #ifdef PSCAN_FORCE_TV_AUTO
          vOsdShowTvFormat(OSD_MSG_PROGRESSIVE);
          bTvSystem = SV_AUTO;
  #else
          vOsdShowTvFormat(OSD_MSG_NTSC_PSCAN);
          bTvSystem = SV_NTSC;
  #endif
        }
        else
#endif /* PSCAN_EN */
        {
          vOsdShowTvFormat(OSD_MSG_NTSC);
          bTvSystem = SV_NTSC;
        }
        break;
    }

    vVideoTvSystem(bTvSystem);

#ifdef PSCAN_EN /* if P-Scan is enabled, TV system must sync with menu */
    fgEepromWriteByte(TV_SYSTEM_POSITION, bTvSystem);
#endif
  } /* if (fgChange) */
  else /* fgChange == FALSE */
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
  }

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

#ifdef PSCAN_EN
BOOL fgCOMPScanKey(void) large
{
  BYTE bTvOut = bSharedInfo(SI_TVE_OUT_MODE);
  BYTE bPScan = bSharedInfo(SI_PSCAN_EN);

  if (bPScan == SV_OFF)
  {
    bPScan = SV_ON;

    if ((bTvOut == SV_TVE_DIRECT) || (bTvOut == SV_TVE_VGA))
    {
      bTvOut = SV_TVE_YCBCR;
    }
  }
  else
  {
    bPScan = SV_OFF;

    if (bTvOut == SV_TVE_VGA)
    {
      bTvOut = SV_TVE_YCBCR;
    }
  }

  if (bEepromReadByte(TV_PSCAN_EN_POS) != bPScan)
  {
    fgEepromWriteByte(TV_PSCAN_EN_POS, bPScan);
  }

  if (bEepromReadByte(TV_COMP_POS) != bTvOut)
  {
    fgEepromWriteByte(TV_COMP_POS, bTvOut);
  }

  if (bPScan == SV_ON)
  {
    vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_PROGRESSIVE, OSD_TIMEOUT);
  }
  else
  {
    vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_INTERLACE, OSD_TIMEOUT);
  }

  VfdShowPScanType(bPScan, bTvOut);

   vVideoPScanMode(bPScan, bTvOut);

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

BOOL fgCOMVGAKey(void) large
{
  // for turn on VGA mode only
  if (bEepromReadByte(TV_PSCAN_EN_POS) != SV_ON)
  {
    fgEepromWriteByte(TV_PSCAN_EN_POS, SV_ON);
  }

  if (bEepromReadByte(TV_COMP_POS) != SV_TVE_VGA)
  {
    fgEepromWriteByte(TV_COMP_POS, SV_TVE_VGA);
  }

  vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_VGA, OSD_TIMEOUT);

  VfdShowPScanType(SV_ON, SV_TVE_VGA);

  vVideoPScanMode(SV_ON, SV_TVE_VGA);

  _bIRKey = IR_NONE;
  return (UOP_OK);
}
#endif /* PSCAN_EN */

BOOL fgCOMCompKey(void) large
{
  BYTE bMode;

#ifdef MTK_TVE
  bMode = bEepromReadByte(TV_COMP_POS);

  switch (bMode)
  {
    case SV_TVE_DIRECT:
      bMode = SV_TVE_YCBCR;
      vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_YUV, OSD_TIMEOUT);
      break;

    case SV_TVE_YCBCR:
      bMode = SV_TVE_RGB;
      vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_RGB, OSD_TIMEOUT);
      break;

    case SV_TVE_RGB:
  #ifdef PSCAN_EN
      bMode = SV_TVE_VGA;
      vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_VGA, OSD_TIMEOUT);
  #else
      bMode = SV_TVE_DIRECT;
      vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_OFF, OSD_TIMEOUT);
  #endif
      break;

  #ifdef PSCAN_EN
    case SV_TVE_VGA:
  #endif
    default:
      bMode = SV_TVE_DIRECT;
      vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_OFF, OSD_TIMEOUT);
      break;
  }

  fgEepromWriteByte(TV_COMP_POS, bMode);

  bSetCompOut(0, 0);

#elif (defined(SCART_SELECTION) && !defined(MTK_TVE))
  bMode = bEepromReadByte(SCART_POS);

	switch (bMode)
	{
  	case EV_RGB:
  		fgEepromWriteByte(SCART_POS, EV_YPBPR);
  		vTvRGBOut(TRUE);
  		vOsdPosShow(OSD_POS_AUD_CTRL, OSD_MSG_SCART_YPBPR, OSD_TIMEOUT);
  		break;

  	case EV_YPBPR:
  	default:
  		fgEepromWriteByte(SCART_POS, EV_RGB);
  		vTvRGBOut(FALSE);
  		vOsdPosShow(OSD_POS_AUD_CTRL, OSD_MSG_RGB, OSD_TIMEOUT);
  		break;
	}
#endif /* SCART_SELECTION !MTK_TVE */

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

#ifdef ENABLE_ZOOM_USER_MODE
BOOL fgCOMDirKey(void) large
{
  BYTE bHScale, bVScale;

  if (bSharedInfo(SI_ZOOM_SWITCH) != SV_ZOOM_USR)
  {
    // bypass the key
    return (UOP_OK);
  }

  bHScale = bSharedInfo(SI_ZOOM_USR_H);
  bVScale = bSharedInfo(SI_ZOOM_USR_V);

  switch (_bIRKey)
  {
    case IR_UP: // vertical zoom in
    {
      if (bVScale >= ZOOM_USR_V_BASE)
      {
        if (bVScale >= (ZOOM_USR_V_MAX - ZOOM_IN_V_STEP))
        {
          bVScale = ZOOM_USR_V_MAX;
        }
        else
        {
          bVScale += ZOOM_IN_V_STEP;
        }
      }
      else
      {
        bVScale += ZOOM_OUT_V_STEP;
      }
      break;
    } // IR_UP, vertical zoom in

    case IR_DOWN: // vertical zoom out
    {
      if (bVScale <= ZOOM_USR_V_BASE)
      {
        if (bVScale <= (ZOOM_USR_V_MIN + ZOOM_OUT_V_STEP))
        {
          bVScale = ZOOM_USR_V_MIN;
        }
        else
        {
          bVScale -= ZOOM_OUT_V_STEP;
        }
      }
      else
      {
        bVScale -= ZOOM_IN_V_STEP;
      }
      break;
    } // IR_DOWN, vertical zoom out

    case IR_RIGHT: // horizontal zoom in
    {
      if (bHScale >= ZOOM_USR_H_BASE)
      {
        if (bHScale >= (ZOOM_USR_H_MAX - ZOOM_IN_H_STEP))
        {
          bHScale = ZOOM_USR_H_MAX;
        }
        else
        {
          bHScale += ZOOM_IN_H_STEP;
        }
      }
      else
      {
        bHScale += ZOOM_OUT_H_STEP;
      }
      break;
    } // IR_RIGHT, horizontal zoom in

    case IR_LEFT: // horizontal zoom out
    {
      if (bHScale <= ZOOM_USR_H_BASE)
      {
        if (bHScale <= (ZOOM_USR_H_MIN + ZOOM_OUT_H_STEP))
        {
          bHScale = ZOOM_USR_H_MIN;
        }
        else
        {
          bHScale -= ZOOM_OUT_H_STEP;
        }
      }
      else
      {
        bHScale -= ZOOM_IN_H_STEP;
      }
      break;
    } // IR_LEFT, horizontal zoom out

    default:
      return (UOP_FAIL);
  }

#ifdef VCD_MENU_NO_ZOOM_OUT
  if (fgIsVcdPlay() && (bSharedInfo(SI_TRACK_NO) == 0))
  {
    if (bHScale < ZOOM_USR_H_BASE)
    {
      bHScale = ZOOM_USR_H_BASE;
    }

    if (bVScale < ZOOM_USR_V_BASE)
    {
      bVScale = ZOOM_USR_V_BASE;
    }
  }
#endif /* VCD_MENU_NO_ZOOM_OUT */

  if ((bHScale != bSharedInfo(SI_ZOOM_USR_H)) ||
      (bVScale != bSharedInfo(SI_ZOOM_USR_V)))
  {
    vSendUopCmd(UOP_ZOOM_IN, SV_ZOOM_USR, bHScale, bVScale);
  }

  _bIRKey = IR_NONE;
  return (UOP_OK);
}
#endif /* ENABLE_ZOOM_USER_MODE */

#ifdef SUPPORT_CAPTURE_LOGO
BOOL fgCOMCaptureKey(void) large
{
  if (fgIsInputStateValid(INPUT_STATE_LOGO_CAPTURE) == FALSE)
  {
    if (fgIsLogoCaptureAllow())
    {
      vChangeInputState(INPUT_STATE_LOGO_CAPTURE, FALSE);
    }
  }

  _bIRKey = IR_NONE;
  return (UOP_OK);