combine.c

MTK 1389E SOURCE CODE

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 05/09/05 3:52p    $       ****************/
/***************  $Revision:: 18               $       ****************/
/***************                                       ****************/
/***************   Description : Key-Combine State     ****************/
/***************                 Machine               ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Sung-Ching Lin        ****************/
/**********************************************************************/
#define _COMBINE_C_

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


#ifdef MT1379_MANUFACTURE_TEST
extern void vOsdShowTestInfo(BYTE bIndex) large;
extern void vCheckTestStatus(void) large;
extern BOOL  fgCheckIfTested() large;
#ifdef RS232_LOG
extern void DRS232LogS(char *pcStr);
extern void DRS232LogB(BYTE bV1, BYTE bV2, BYTE bV3, BYTE bV4);
#endif
#endif
extern void vSetupMenuClose(void) large;
extern void vShowMenuAfterPause(void) large;
extern void vSetPreviewTimer() large;
// *********************************************************************
// Static Function Prototype
// *********************************************************************
static void vShowDiscType(BYTE bDiscType) large;

/************************************************************************
     Function : void vSetPlayType(BYTE bType)
  Description : 8032 play type define, set play type dependant setting
    Parameter : None
    Return    : None
************************************************************************/
void vSetPlayType(BYTE bType) large
{
#if 0//def MT1379_MANUFACTURE_TEST
	  vWBDisable(WB_SELMENU);
	if ((bType != SV_DVD_VIDEO))// && (bType != SV_DATA))
	{
		vOsdShowTestInfo(5);
		_bPlayPostKey = IR_EJECT;
		return;
	}
/*
	else
	{
		if (fgCheckIfTested())
		{
			_bPlayPostKey=IR_EJECT;
			return;
		}
	}
	*/
#endif

  switch (bType)
  {
    case SV_DVD_VIDEO:
    case SV_DVD_AUDIO:
    case SV_MINI_DVD:
    {
#ifdef DVD_DISC_ID_CHK
      if (!fgIsDiscInitChecked())
      {
        return;
      }
      else
#endif
      {
        _bPlayType = PLAY_TYPE_DVD;
        vSetKeyState(KEY_NONISO);
        if ( fgIsInSetupMenu() )
        {
          vSetKeyState(KEY_SETUP);
        }
        vDVDInit(bType);
      }
      break;
    }


    case SV_SVCD:
    case SV_CVD:
    case SV_VCD3_0:
    case SV_VCD2_0:
    case SV_VCD1_1:
    case SV_VCD6_0:
    case SV_VCD6_1:
    {
#ifdef VCD_SUPPORT
  #ifdef VCD_DISC_ID_CHK
      if (!fgIsDiscInitChecked())
      {
        return;
      }
      else
  #endif
      {
        _bPlayType = PLAY_TYPE_VCD;
        vSetKeyState(KEY_NONISO);
        if ( fgIsInSetupMenu() )
        {
          vSetKeyState(KEY_SETUP);
        }
        vVCDInit(bType);
      }
#else
      _bPlayPostKey = IR_EJECT;
#endif /* #ifdef VCD_SUPPORT */
      break;
    }


#ifdef SUPPORT_DATA_DISC
    case SV_DATA:
    {
#ifdef ISO_DISC_ID_CHK
      if (!fgIsDiscInitChecked())
      {
        return;
      }
      else
#endif
      {
        _bPlayType = PLAY_TYPE_ISO;
        vSetKeyState(KEY_ISO);
        if ( fgIsInSetupMenu() )
        {
          vSetKeyState(KEY_SETUP);
        }
        vISOInit(bType);
      }
      break;
    }

#ifdef SUPPORT_PCD
    case SV_PCD:
    {
#ifdef PCD_DISC_ID_CHK
      if (!fgIsDiscInitChecked())
      {
        return;
      }
      else
#endif
      {
        _bPlayType = PLAY_TYPE_PCD;
        vSetKeyState(KEY_ISO);
        if ( fgIsInSetupMenu() )
        {
          vSetKeyState(KEY_SETUP);
        }
        vPCDInit(bType);
      }
      break;
    }
#endif /* SUPPORT_PCD */
#endif /* SUPPORT_DATA_DISC */

    case SV_DTS_CS:
    case SV_CDDA:
    case SV_SACD:
    case SV_CDG:
    case SV_HDCD:
    {
#ifdef CDDA_DISC_ID_CHK
      if (!fgIsDiscInitChecked())
      {
        return;
      }
      else
#endif
      {

#ifdef CDDA_USE_CDFS
        _bPlayType = PLAY_TYPE_ISO;
        vSetKeyState(KEY_ISO);
#else
        _bPlayType = PLAY_TYPE_CDDA;
        vSetKeyState(KEY_NONISO);
#endif
        if ( fgIsInSetupMenu() )
        {
          vSetKeyState(KEY_SETUP);
        }
#ifdef CDDA_USE_CDFS
        vISOInit(bType);
#else
        vCDDAInit(bType);
#endif
      }
      break;
    }

    case SV_AUDIO_IN:
    {
      _bPlayType = PLAY_TYPE_AIN;
      vSetKeyState(KEY_NONISO);
      if ( fgIsInSetupMenu() )
      {
        vSetKeyState(KEY_SETUP);
      }
      vAINInit(bType);
      break;
    }

    default:
    {
      vSetKeyState(KEY_INIT);

      if ( fgIsInSetupMenu() )
      {
        vSetKeyState(KEY_SETUP);
      }

       _bPlayType = PLAY_TYPE_NONE;
      break;
    }
  } /* switch (bType) */

  vOsdDisplayChange(DISP_INIT, 0);

#ifdef DISC_IDENT_AUTO_MUTE_OFF
  if (_bPlayType != PLAY_TYPE_NONE)
  {
    if (fgIsMute()) // if mute on
    {
      vAdspMute(ADSP_OFF, 0);
      vOsdShowMute(OSD_MUTE_CLEAR);
    }
  }
#endif

  vShowDiscType(bType);
}

/************************************************************************
     Function : void vClearPlayType(void)
  Description : Clear play type related setting
    Parameter : None
    Return    : None
************************************************************************/
void vClearPlayType(void) large
{
  if (fgIsDvdPlay())
  {
    vDVDExit();
  }
#ifdef VCD_SUPPORT
  else if (fgIsVcdPlay())
  {
    vVCDExit();
  }
#endif
#ifdef SUPPORT_DATA_DISC
  else if (fgIsIsoPlay())
  {
    vISOExit();
  }
  #ifdef SUPPORT_PCD
  else if (fgIsPcdPlay())
  {
    vPCDExit();
  }
  #endif
#endif /* SUPPORT_DATA_DISC */
#ifndef CDDA_USE_CDFS
  else if (fgIsCddaPlay())
  {
    vCDDAExit();
  }
#endif
#ifdef AUDIO_IN_EN
  else if (fgIsAinPlay())
  {
    vAINExit();
  }
#endif
  _bPlayType = PLAY_TYPE_NONE;
  vSetKeyState(KEY_INIT);

  if ( fgIsInSetupMenu() )
  {
    vSetKeyState(KEY_SETUP);
  }

}

#ifdef AUDIO_IN_EN
// *********************************************************************
// Function : void vPlayerFuncSwitch(BYTE bMode) large
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vPlayerFuncSwitch(BYTE bMode) large
{
  if (_fgNotify == FALSE) // system init stage
  {
    if (bMode == PLAYER_FUNC_AIN)
    {
      _bPlayerFuncMode = PLAYER_FUNC_AIN;
    }
    else /* if (bMode == PLAYER_FUNC_DVD) */
    {
      _bPlayerFuncMode = PLAYER_FUNC_DVD;
    }
  }
  else // system run stage
  {
    if (bMode == PLAYER_FUNC_AIN)
    {
      if (fgIsFuncAin() == FALSE)
      {
        vPlayerReset();

        _bPlayerFuncMode = PLAYER_FUNC_AIN;

        vSendUopCmd(UOP_OPEN_CLOSE, SV_PSEUDO_OPEN, 0, 0);

        _bUISrvStatus = PLAYER_SRV_STOP;

        if (_bDiscLoadSt >= DISC_LOAD_STARTUP)
        {
          _fgSkipSrvStart = TRUE;
        }
      }
    }
    else /* if (bMode == PLAYER_FUNC_DVD) */
    {
      if (fgIsFuncDvd() == FALSE)
      {
        vPlayerReset();

        _bPlayerFuncMode = PLAYER_FUNC_DVD;

        vSendUopCmd(UOP_OPEN_CLOSE, SV_PSEUDO_CLOSE, 0, 0);
      }
    }
  }
}
#endif /* AUDIO_IN_EN */

// *********************************************************************
// Function : void vPlayerReset(void) large
// Description : called from playback
// Parameter : None
// Return    : None
// *********************************************************************
void vPlayerReset(void) large
{
  BYTE i;

  /* check setup menu exist moved to WB reset */

  // clear play type, call every play module exit function
  vClearPlayType();

  // reset player timer beep count
#if (defined(DVD_MENU_SHOW_VFD_WHEEL) || defined(JPEG_DECODING_SHOW_VFD_WHEEL))
  _bPlayerTimerBeepCnt = PLAYER_TIMER_BEEP_PERIOD*2;
#else
  _bPlayerTimerBeepCnt = PLAYER_TIMER_BEEP_PERIOD;
#endif

  // reset display mode
  vOsdShowWb(OSD_WB_RESET);

  // reset zoom indicator flag
  _rOsdStateCtx.fgZoomBrShow = FALSE;

  // reset EQ state
  _rEqState.bDispType = OSD_EQ_TYPE_DISABLE;

  // reset input state
  vResetInputState();

  // for RISC communication states
  _bLastSyncUop = UOP_NONE;
  _bLastPbcState = SV_PBC_INIT;

  // reset osd state
  vOsdDisplayChange(DISP_INIT, 0);

  // reset search state
  _rSearchStateCtx.bType = SEARCH_NONE;

  // reset program state
#ifdef PLAYER_PROGRAM
  vSelMenuReset();
#endif
  // this is play type dependant
#ifdef PLAYER_KARAOKE
  if (bAdspCurrVocal() != VOCAL_NO_ASSIST)
  {
    vAdspVocalAssist(VOCAL_NO_ASSIST);
  }
  #ifdef KARAOKE_MIC_REC
  vMicRecCtrl(MIC_REC_CTRL_RESET);
  #endif
#else /* not define PLAYER_KARAOKE */
  if (bAdspCurrVocal() != AUDIO_STEREO)
  {
    vAdspLR(AUDIO_STEREO);
  }
#endif /* PLAYER_KARAOKE */
  vAdspReset();

#if !defined(NO_SM_NOTIFY)
  SmInit();
#endif

  // for vocal assist
#ifdef PLAYER_KARAOKE
  _fgVocalOn = FALSE;
#endif

#ifdef AUDIO_STREAM_CHANGE_MUTE
  _fgAstChg = FALSE;
#endif
}

/************************************************************************
     Function :
  Description : This function must be moved to screen saver moudle
    Parameter :
    Return    :  = 0 -> screen saver not allowed
                 > 0 -> screen saver allowed
************************************************************************/
BOOL fgScrSaverCheck(void) large
{
  BYTE bInitState = bSharedInfo(SI_INIT_STATE);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

  switch (bInitState)
  {
    case SV_LOADING_DISC:
    case SV_TRAY_CLOSING:
    case SV_TRAY_ERROR:
      return (FALSE); /* not allowed */

    case SV_TRAY_OPENING:
    case SV_NO_DISC:
    case SV_UNKNOWN_DISC:
      return (TRUE); /* allowed */

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

  }

  switch (bPbcState)
  {
    case SV_STOP:
    case SV_STOP_RESUME:
    case SV_PAUSE:
    case SV_STEP:
    case SV_STEP_BACK:
    case SV_SETUP_PAUSE:
    case SV_PTL_ERR:
    case SV_REGION_ERR:
    case SV_DISC_ERR:
    case SV_SET_TMP_PTL:
      return (TRUE); /* allowed */

    case SV_PLAY:
    case SV_FF:
    case SV_SF:
    case SV_FR:
    case SV_SR:
    case SV_FREEZE:
    case SV_DIGEST9:
    case SV_DIGEST4:
    case SV_PBC_INIT:
      return (FALSE); /* not allowed */

    case SV_DIGEST:
    case SV_STILL:
#ifdef SUPPORT_DATA_DISC
      if (fgIsIsoPlay()
  #ifdef SUPPORT_PCD
        || fgIsPcdPlay()
  #endif
        )
      {
        //if (fgFsMenuIsDecoding() == FALSE)
        if (fgFlCheckStatus(FL_STATUS_BUSY) == FALSE)
        {
          /* if not decoding, allowed */
          return (TRUE);
        }
        else
        {
          /* if is decoding, not allowed */
          return (FALSE);
        }
      }
      else
      {
        /* DVD/VCD is not allowed in still mode */
        return (FALSE);
      }
      break;
#endif /* SUPPORT_DATA_DISC */
    default:
      break; /* not determined */
  }

  return (FALSE); /* default is not allowed */
}

#ifdef PLAYER_STOP_SRV_STOP
/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :  = 0 -> servo stop is not allowed
                 > 0 -> servo stop is allowed
************************************************************************/
BOOL fgSrvStopCheck(void) large
{
  BYTE bInitState = bSharedInfo(SI_INIT_STATE);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

  switch (bInitState)
  {
    case SV_LOADING_DISC:
    case SV_TRAY_CLOSING:
    case SV_TRAY_OPENING:
    case SV_TRAY_ERROR:
    case SV_NO_DISC:
      return (FALSE); /* not allowed */

    case SV_UNKNOWN_DISC:
      return (TRUE); /* allowed */

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

  }

  #if (STOP_RESUME_STYLE == STOP_RESUME_TWO_KEYS)
  if (bPbcState == SV_STOP_RESUME)