play_non.c

mtk1389L latest sourcecode enjoy

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

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

      case SV_PAL:
#ifdef PSCAN_EN
        if ((bTvOut != SV_TVE_DIRECT) && (bPScan == SV_ON))
        {
  #ifdef TV_TYPE_AUTO_AUTO
          vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_AUTO_PSCAN, OSD_TIMEOUT);
  #else
          vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_MULTI_PSCAN, OSD_TIMEOUT);
  #endif
        }
        else
#endif /* PSCAN_EN */
        {
  #ifdef TV_TYPE_AUTO_AUTO
          vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_AUTO, OSD_TIMEOUT);
  #else
          vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_MULTI, OSD_TIMEOUT);
  #endif
        }
        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
          vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_PROGRESSIVE, OSD_TIMEOUT);
          bTvSystem = SV_AUTO;
  #else
          vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_NTSC_PSCAN, OSD_TIMEOUT);
          bTvSystem = SV_NTSC;
  #endif
        }
        else
#endif /* PSCAN_EN */
        {
          vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_NTSC, OSD_TIMEOUT);
          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
static BYTE bNONPScanKey(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);
  }

   vVideoPScanMode(bPScan, bTvOut);

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

static BYTE bNONVGAKey(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);

  vVideoPScanMode(SV_ON, SV_TVE_VGA);

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

static BYTE bNONCompKey(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
static BYTE bNONDirKey(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
static BYTE bNONCaptureKey(void) large
{
  if (fgIsInputStateValid(INPUT_STATE_LOGO_CAPTURE) == FALSE)
  {
    if (fgIsLogoCaptureAllow())
    {
      vChangeInputState(INPUT_STATE_LOGO_CAPTURE, FALSE);
    }
  }
  
  _bIRKey = IR_NONE;
  return (UOP_OK);
}
#endif /* SUPPORT_CAPTURE_LOGO */


static BYTE bNONPlayKey(void) large
{
  if (fgIsNonPlay())
  {
    _bIRKey = IR_NONE;
    /* when tray is open, PLAY key is eject key */
    if (bSharedInfo(SI_INIT_STATE) == SV_TRAY_OPENING)
    {
      vDoEject(DO_CLOSE | DO_OPEN_CLOSE_FORCE);
    }
  }

  /* don't clear _bIRKey */
  return (UOP_OK);
}

#ifdef NO_DISC_STOP_CLEAR
static BYTE bNONStopKey(void) large
{
  if (fgIsNonPlay())
  {
    _bIRKey = IR_NONE;
    if (bSharedInfo(SI_INIT_STATE) == SV_NO_DISC)
    {
      vClearWB(WB_NORMAL_HEAD1);
    }
  }

  return(UOP_OK);
}
#endif /* NO_DISC_STOP_CLEAR */

#ifdef SUPPORT_VOLUME_ADJUST
static BYTE bNONVolumeUpKey(void) large
{
  BOOL fgFromMute = FALSE;
  BYTE bVal = bAdspCurrVol();

#ifdef MUTE_NO_VOL_KEY
  if (fgIsMute()) /* if mute on */
  {
    return (UOP_FAIL);
  }
#endif

  if (bVal < MAX_VOL_LEVEL)
  {
    bVal ++;
  }

  /* change volume level first */
  vAdspVolume(bVal);

  if (fgIsMute()) /* if mute on */
  {
    fgFromMute = TRUE;
    /* turn mute off first */
    vAdspMute(ADSP_OFF, 0);
  }

#ifdef PLAYER_FLMENU
  if (fgFlCheckStatus(FL_STATUS_IN_MENU))
  {
    if (fgFromMute)
      vFlIpShowInfo(IP_INFO_VOLUME, bVal, FLIP_VOLUME_REDRAW);
    else
      vFlIpShowInfo(IP_INFO_VOLUME, bVal, FLIP_VOLUME_UP);
  }
  else
#endif /* PLAYER_FLMENU */
  {
    vOsdShowVol(bVal, OSD_TIMEOUT);
  }

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

static BYTE bNONVolumeDownKey(void) large
{
  BYTE fgFromMute = FALSE;
  BYTE bVal = bAdspCurrVol();

#ifdef MUTE_NO_VOL_KEY
  if (fgIsMute()) /* if mute on */
  {
    return (UOP_FAIL);
  }
#endif

  if (bVal > MIN_VOL_LEVEL)
  {
    bVal --;
  }

  /* change volume level first */
  vAdspVolume(bVal);

  if (fgIsMute()) /* if mute on */
  {
    fgFromMute = TRUE;
    /* turn mute off first */
    vAdspMute(ADSP_OFF, 0);
  }

#ifdef PLAYER_FLMENU
  if (fgFlCheckStatus(FL_STATUS_IN_MENU))
  {
    if (fgFromMute)
      vFlIpShowInfo(IP_INFO_VOLUME, bVal, FLIP_VOLUME_REDRAW);
    else
      vFlIpShowInfo(IP_INFO_VOLUME, bVal, FLIP_VOLUME_DOWN);
  }
  else
#endif /* PLAYER_FLMENU */
  {
    vOsdShowVol(bVal, OSD_TIMEOUT);
  }

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

static BYTE bNONMuteKey(void) large
{
  if (fgIsMute()) // mute off
  {
    vAdspMute(ADSP_OFF, 0);
    vOsdShowMute(OSD_MUTE_OFF);
  }
  else // mute on
  {
    vAdspMute(ADSP_ON, 0);
    vOsdShowMute(OSD_MUTE_ON);
  }

  _bIRKey = IR_NONE;
  return (UOP_OK);
}
#endif

static BYTE bNONKaraokeKey(void) large
{
#ifdef PLAYER_KARAOKE
   if (fgIsKaraMode())
   {
      fgEepromWriteByte(MIC_SW_POS, EV_OFF);
      bSetMic(NULL_POSITION, 0);
      vOsdShowEchoLevel(OSD_MIC_OFF);
   }
   else /* not in karaoke mode */
   {
      fgEepromWriteByte(MIC_SW_POS, EV_ON);
      bSetMic(NULL_POSITION, 0);
      vOsdShowEchoLevel(OSD_MIC_ON);
   }
#endif /* PLAYER_KARAOKE */

  _bIRKey = IR_NONE;
  return (UOP_OK);
}

static BYTE bNONSurroundKey(void) large
{
#ifdef N22_CERTIFICATION
  if (bEepromReadByte(SPEAKER_POSITION) == EV_DOWN_N22)
  {
    fgEepromWriteByte(SPEAKER_POSITION, EV_DOWN_OFF);
    //clear message
    vOsdPosShow(OSD_POS_AUD_CTRL, OSD_MSG_SPATIALIZER_N22, 1);
  }
  else
  {
    fgEepromWriteByte(SPEAKER_POSITION, EV_DOWN_N22);
    vOsdPosShow(OSD_POS_AUD_CTRL, OSD_MSG_SPATIALIZER_N22, OSD_NO_DISAPPEAR);
  }
  bSpkConfig(NULL_POSITION, 0);
#elif (defined(PLAYER_SURROUND))
  BYTE bType;
  BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);

  if (fgIsNonPlay())
  {
    _bIRKey = IR_NONE;
    return (UOP_OK);
  }
  else if (fgIsDvdPlay() || (bDiscType == SV_DTS_CS)) // multi-channel use equalizer
  {
    bType = bEepromReadByte(EQ_PRESET_POS) + 1;

    if (bType >= AUD_EQ_TYPE_MAX)
    {
      bType = AUD_EQ_TYPE_NONE;
    }

    fgEepromWriteByte(EQ_PRESET_POS, bType);

    bSetEqPreset(NULL_POSITION, 0);
    vOsdShowSurrType(bType, OSD_POS_AUD_CTRL);
  }