stpcheck.c

mtk1389L latest sourcecode enjoy

#if (defined(MT1389_REV_HD) && defined(SUPPORT_HDMI))
  if(bEepromReadByte(HDMI_POS) == SV_ON)
  {
    _wInvalid &= ~(VDO_PSCAN_EN|VDO_COMP_MODE|VDO_HD_MODE);
  }
#endif //#ifdef SUPPORT_HDMI
#ifdef SUPPORT_CAPTURE_LOGO
  if (fgIsLogoCaptureAllow() == FALSE)
  {
    _wInvalid &= ~LOGO_CAPTURE_ITEM;
  }
#endif /* SUPPORT_CAPTURE_LOGO */

#ifdef PSCAN_EN
  if ((bTvOut != SV_TVE_YCBCR) && (bTvOut != SV_TVE_RGB))
  {
    _wInvalid &= ~VDO_PSCAN_EN;

    if (bTvOut != SV_TVE_VGA)
    {
  #ifndef PSCAN_SIMPLE_MENU
      _wInvalid &= ~(VDO_PSCAN_MODE | VDO_PSCAN_VIDEO);
  #endif

  #if (defined(MT1389_REV_HD) && !defined(SIMPLE_MENU))
      _wInvalid &= ~VDO_HD_MODE;
  #endif

    }
	/*in 89BC 8M version, we could just gray it dynamically. Alfonso*/
#if !defined(MT1389_REV_C) && !defined(MT1389_REV_D) && !defined(MT1389_REV_E) && !defined(MT1389_REV_HD)
	if (_fgIs1389Lite)
	{
		_wInvalid &= ~DENOISE_ITEM;
		_wInvalid &= ~WARMTH_FILTER_ITEM;
	}
#endif /* #if !defined(MT1389_REV_C) && !defined(MT1389_REV_D) && !defined(MT1389_REV_E) && !defined(MT1389_REV_HD) */
    return;
  }

  if (bPScan != SV_ON)
  {
#ifndef PSCAN_SIMPLE_MENU
    _wInvalid &= ~(VDO_PSCAN_MODE | VDO_PSCAN_VIDEO);
#endif
  }
  #ifndef PSCAN_SIMPLE_MENU
  if ((bMode != SV_PSCAN_AUTO) && (bMode != SV_PSCAN_VIDEO))
  {
    _wInvalid &= ~VDO_PSCAN_VIDEO;
  }
  #endif
#ifdef MT1389_REV_HD
  if (bSharedInfo(SI_HD_MODE) != SV_HD_MODE_OFF)
  {
	  _wInvalid &= ~VDO_PSCAN_EN;
  }
#endif /* MT1389_REV_HD*/
#endif /* PSCAN_EN */

/*in 89BC 8M version, we could just gray it dynamically. Alfonso*/
#if !defined(MT1389_REV_C) && !defined(MT1389_REV_D) && !defined(MT1389_REV_E) && !defined(MT1389_REV_HD)
  if (_fgIs1389Lite)
  {
    _wInvalid &= ~DENOISE_ITEM;
    _wInvalid &= ~WARMTH_FILTER_ITEM;
  }
#endif /* #if !defined(MT1389_REV_C) && !defined(MT1389_REV_D) && !defined(MT1389_REV_E) && !defined(MT1389_REV_HD) */
}

#ifndef PLAYER_2_CHANNEL
// *********************************************************************
// Function : void vChkSpdif(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vChkSpdif(void) large
{
  if (bEepromReadByte(IEC958_POSITION) != EV_PCM)
 	_wInvalid &= ~(1 << 1);
}

// *********************************************************************
// Function : void vChkEq(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
static void vChkEq(void) large
{
#ifdef PLAYER_SURROUND
  #ifndef PLAYER_ADV_EQ
  BYTE bMode = bEepromReadByte(EQ_PRESET_POS);

  if (bMode != EV_NONE)
  {
    //_wInvalid &= ~(EQ_BASS_ITEM | EQ_SBASS_ITEM | EQ_TREBLE_ITEM);
  }
  #endif // PLAYER_ADV_EQ
#endif // PLAYER_SURROUND
}

#if (defined(PLAYER_SURROUND) || defined(DOLBY_PROLOGIC) || defined(DOLBY_PROLOGIC2))
// *********************************************************************
// Function : void vChk3D(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vChk3D(void) large
{
  #ifndef SET_VSURR_IN_SPKCFG
    #ifdef DOLBY_PROLOGIC
  BYTE bProLogic = bEepromReadByte(PROLOG_SW_POS);

  if (bProLogic == EV_PROLOGIC_ON)
  {
    _wInvalid &= ~(DDD_VSURR);
  }
  else
  {
    _wInvalid |= DDD_VSURR;
  }
    #elif (defined(DOLBY_PROLOGIC2))
  BYTE bProLogic = bEepromReadByte(PROLOG_SW_POS);

  if (bProLogic != EV_PL2_OFF)
  {
    _wInvalid &= ~(DDD_VSURR);
  }
  else
  {
    _wInvalid |= DDD_VSURR;
  }
    #endif // DOLBY_PROLOGIC

  if (fgCheckIsVSurrValid(bSharedInfo(SI_A_CODE_MODE),
                          bSharedInfo(SI_DISC_TYPE),
                          bSharedInfo(SI_INIT_STATE)) == FALSE)
  {
    _wInvalid &= ~(DDD_VSURR);
  }
  #endif /* !SET_VSURR_IN_SPKCFG */

  // ProLogic is not available for downmix mode
  #ifndef PLAYER_2_CHANNEL
	if (bEepromReadByte(SPEAKER_POSITION) != EV_DOWN_OFF)
	{
		#if (defined(DOLBY_PROLOGIC) || defined(DOLBY_PROLOGIC2))
		_wInvalid &= ~(DDD_PROLOGIC);
		#endif
	}
  #endif /* PLAYER_2_CHANNEL */
  
  #if 1
	// We have the prologicII on, only when both of the conditions stands: 
	//	1. The adsp lib supports; (not 2 channel) 
	//	2. The DownMix was turned "off".
	//												Commented by Alfonso, 2005/09/20
	if ((bSharedInfo(SI_DSP_FEATURE) & SV_PROGIC_II) && // support 1.
		(bEepromReadByte(SPEAKER_POSITION) == EV_DOWN_OFF))	// support 2.
	{
		_wInvalid |= (DDD_PROLOGIC);
	}
    else
	{
		_wInvalid &= ~(DDD_PROLOGIC);
	}
  #else
	// AlanCheng wanna make the PL2 option(in setup menu) be grayout, in run time, through the share info.
	// by alfonso, 2005 0704.
	{
		BYTE bAllowPL2 = bSharedInfo(SI_PROLOGIC_II_SUPPORT);
		if (bAllowPL2 == SV_OFF)
		{
			_wInvalid &= ~(DDD_PROLOGIC);
		}	else if (bAllowPL2 == SV_ON)
		{
			_wInvalid |= (DDD_PROLOGIC);
		}
	}
  #endif

  #ifdef CHK_PASSWD_VCD_EN
    if (bEepromReadByte(VCD_PASSWRD_POSITION) == FALSE)
    {
      _wInvalid &= ~(0x01);
    }
  #endif

#ifdef DDISC_FTYPE_WMA_SUPPORT  // temp. added
  if( bSharedInfo(SI_A_CODE_MODE) == SV_A_CODE_WMA)
  {
  	_wInvalid |= (DDD_PROLOGIC);
  }
#endif
}
#endif // PLAYER_SURROUND || DOLBY_PROLOGIC || DOLBY_PROLOGIC2

// *********************************************************************
// Function : void vCheckSp(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vCheckSp(void) large
{
  #if 0
  if (bEepromReadByte(CNTR_SPK_POSITION) == EV_SPK_OFF)
  {
    _wInvalid &= ~SPEAKER_CENTER;
  }
  if (bEepromReadByte(REAR_SPK_POSITION) == EV_SPK_OFF)
  {
    _wInvalid &= ~(SPEAKER_LS | SPEAKER_RS);
  }
  if (bEepromReadByte(SUB_SPK_POSITION) == EV_SPK_OFF)
  {
    _wInvalid &= ~SPEAKER_SUB;
  }
  #endif
}
#endif /* !PLAYER_2_CHANNEL */

// *********************************************************************
// Function : void vVerIn(void) large
// Description : version page, only back to main can be selected
// Parameter : None
// Return    : None
// *********************************************************************
void vVerIn(void) large
{
  #ifdef NO_REGION_CODE
    _wInvalid = VERSION_MAIN;
  #else
  _wInvalid = REGION_ITEM | VERSION_MAIN;
  #endif
}

// *********************************************************************
// Function : void vChkSeq(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
#ifndef PLAYER_2_CHANNEL
  #ifdef PLAYER_SEQ
void vChkSeq(void) large
{
  if (bEepromReadByte(BASS_SW_POS) == EV_OFF)
  {
    _wInvalid &= ~(1<<3);
  }
  if (bEepromReadByte(SBASS_SW_POS) == EV_OFF)
  {
    _wInvalid &= ~(1<<4);
  }
  if (bEepromReadByte(CLEAR_SW_POS) == EV_OFF)
  {
    _wInvalid &= ~(1<<5);
  }
}
  #endif /* PLAYER_SEQ */
#endif /* PLAYER_2_CHANNEL */

#ifdef PLAYER_KARAOKE
// *********************************************************************
// Function : void vChkKok(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
  #ifndef PLAYER_2_CHANNEL
void vChkKok(void) large
{
}
  #endif
#endif /* PLAYER_KARAOKE */

#ifdef DOLBY_PROLOGIC2
#if 0
static void vChkPL2(void) large
{
  BYTE bProLogic = bEepromReadByte(PROLOG_SW_POS);

  if (bProLogic != EV_PL2_MUSIC)
  {
    _wInvalid &= ~(PL2_PANO_ITEM | PL2_DIM_ITEM | PL2_CWID_ITEM);
  }
}
#endif
static void vChkPL2(void) large
{
  BYTE bSwitch = bEepromReadByte(PROLOG_SW_POS);

  if ((bSwitch == EV_PL2_ON) || (bSwitch == EV_PL2_AUTO))
  {
    if (bEepromReadByte(PL2_MODE_POS) != EV_PL2_MUSIC)
    {
      _wInvalid &= ~(PL2_PANO_ITEM | PL2_DIM_ITEM | PL2_CWID_ITEM);
    }
  }
  else
  {
    _wInvalid &= ~(PL2_MODE_ITEM | PL2_PANO_ITEM | PL2_DIM_ITEM | PL2_CWID_ITEM);
  }
}
static void vChkHDCD() large    //Jerry_chen
{
  BYTE bSwitch = bEepromReadByte(PROLOG_SW_POS);

  if ((bSwitch == EV_PL2_ON) || (bSwitch == EV_PL2_AUTO))
  {
      _bInvalidItem &= ~(HDCD_FILTER_1X | HDCD_FILTER_2X );
  }
}

#endif

#ifdef SUPPORT_DDEX
// *********************************************************************
// Function : void vChkDDEX(void) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vChkDDEX(void) large
{
  BYTE bSwitch = bEepromReadByte(DDEX_ENABLE_POSITION);

  if (bSwitch == EV_DDEX_OFF)
  {
    _wInvalid &= ~0x08;
  }
}
#endif

#if(defined(MIC_ON_KEYSHIFT_FORCING_DOWNMIX_2CH)||defined(SETUP_INVALID_ITEM)||defined(SETUP_CHECK_INVALID_HDCD))
void vChkItemValid(BYTE bMenu,BYTE bEntry) large
{
  switch(bMenu)
  {
  #ifdef DOWNMIX_SHOW_UI  //MIC_ON_KEYSHIFT_FORCING_DOWNMIX_2CH
  	case SPEAKER_PAGE:
  		if(bEntry == 1)
  		{
	    	if((bEepromReadByte(MIC_SW_POS) == EV_ON) || (_rAudioCtrl.cCurKey != 0))
	    	{
	    		if(bEepromReadByte(SPEAKER_POSITION) != EV_DOWN_OFF)
						_bInvalidItem &= ~(/*(1<<0) | (1<<2) |*/ (1<<3));
	    	}
  		}
			break;
		#endif
		#ifdef SETUP_INVALID_ITEM
    case 1:  //general page
      vCheckGenItem(bEntry);
    break;
		#endif
#ifdef SETUP_CHECK_INVALID_HDCD
   case HDCD_PAGE:
     vChkHDCD();
     break;
#endif		
    default:
    break;
  }
}
#endif
#ifdef SETUP_INVALID_ITEM
void vCheckGenItem(BYTE bEntry) large
{
  switch(bEntry)
  {
    case 1: //TV_DISPLAY
      if (bSharedInfo(SI_HD_MODE) != SV_HD_MODE_OFF)
	_bInvalidItem &= 0xfc;
    break;
	  
    default:
    break;
  }
}
#endif


#ifdef SUPPORT_HDMI
void vChkHDMI(void) large
{
  if(bEepromReadByte(HDMI_POS) == EV_OFF)
  {
    _wInvalid &= ~(HDMI_RES_SWITCH|HDMI_HDCP_SWITCH|HDMI_VIDEO_SWITCH|HDMI_AUDIO_SWITCH|HDMI_SRC_SWITCH);
  }
}
#endif //#ifdef SUPPORT_HDMI