play_vcd.c

MTK 1389E SOURCE CODE

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 05/04/01 5:54p    $       ****************/
/***************  $Revision:: 2                $       ****************/
/***************                                       ****************/
/***************   Description :                       ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#define _PLAY_VCD_C_

#pragma NOAREGS
#include "general.h"

#ifdef VCD_SUPPORT
// *********************************************************************
// Function : void vVCDInit(BYTE bType) large
// Description : VCD play module initial
// Parameter : None
// Return    : None
// *********************************************************************
void vVCDInit(BYTE bType) large
{
#ifdef SETUP_MENU_PBC_CTRL
  vSetSharedInfo(SH_VCD_USR_PBC_OFF, bSharedInfo(SI_VCD_PBC_OFF));
#endif

  #ifdef PLAYER_BOOKMARK
  vBookmarkReset();
  #endif

#if (defined(USE_8032_AUTO_PLAY) && defined(VCD_AUTO_PLAY))
  #ifdef VCD_LAST_MEM
  vSendUopCmd(UOP_PLAY, SV_STOP_PLAY_CHK_LASTMEM, 0, 0);
  #else
  vSendUopCmd(UOP_PLAY, 0, 0, 0);
  #endif
#endif
  /*if (IS_SVCD_TYPE(bSharedInfo(SI_DISC_TYPE)))
    vWBEnable(WB_NORMAL_PBC2);*/
}

// *********************************************************************
// Function : void vVCDExit(void) large
// Description : VCD play module exit
// Parameter : None
// Return    : None
// *********************************************************************
void vVCDExit(void) large
{
#ifdef SETUP_MENU_PBC_CTRL
  //FIXME: assume 0 PBC on, 1 PBC off, defined in menu.h
  if (bEepromReadByte(VCD_PBC_SW_POSITION) == SV_OFF) /* PBC OFF */
  {
    vSetSharedInfo(SI_VCD_PBC_OFF, TRUE);
  }
  else
  {
    vSetSharedInfo(SI_VCD_PBC_OFF, FALSE);
  }
#endif /* SETUP_MENU_PBC_CTRL */
}

// *********************************************************************
// Time Search State Machine
// *********************************************************************
void vVCDTimeSearchInit(BYTE fgInit) large
{
  /* the search type is assigned in main state */

  vNumInInitState(NUM_IN_VCD_TIME, 4);

  vOsdShowVcdTimeSearch(0, 
    (_rSearchStateCtx.bType == SEARCH_VCD_TIME_TRACK ? OSD_SEARCH_TRACK : OSD_SEARCH_DISC),
    0);

  vIrSetTimeOut(IR_TIMEOUT_SEARCH);
}

BOOL fgVCDTimeSearchState(void) large
{
  BOOL fgRetValue;
  sTimeChkInfo rTimeChk;

  if ((_bIRKey <= IR_ADD10) || (_bIRKey == IR_CLEAR) || (_bIRKey == IR_ADD5))  // megaa ADD5
  {
    /* we accept +10, +5 key but do no action */
    fgRetValue = fgNumInState();

    if (_rNumInStateCtx.rState.fgComplete)
    {
      vSetExitInputState();
      vOsdShowVcdTimeSearch(0, OSD_SEARCH_CLEAR, 0);

      rTimeChk.bHH = 0;
      rTimeChk.bMM = _rNumInStateCtx.bDig[0] * 10 + _rNumInStateCtx.bDig[1];
      rTimeChk.bSS = _rNumInStateCtx.bDig[2] * 10 + _rNumInStateCtx.bDig[3];

      if (_rNumInStateCtx.rState.fgCancel == FALSE)
      {
        if (_rSearchStateCtx.bType == SEARCH_VCD_TIME_TRACK)
        {
          rTimeChk.bType = E_TRACK_TIME;
          if (fgCheckTimeValid(&rTimeChk) == TRUE)
          {
#ifdef SEARCH_INPUT_SHOW
            vOsdShowVcdTimeSearch(OSD_VCD_SEARCH_END, OSD_SEARCH_TRACK, _rNumInStateCtx.bDig);
#endif

            vSendUopCmd(UOP_TIME_PLAY, SV_TIME_TRACK, rTimeChk.bMM, rTimeChk.bSS);
          }
          else
          {
            vOsdShowError(SV_ERR_INPUT_INVALID, OSD_TIMEOUT_SHORT);
          }
        }
        else
        {
          rTimeChk.bType = E_DISC_TIME;
          if (fgCheckTimeValid(&rTimeChk) == TRUE)
          {
#ifdef SEARCH_INPUT_SHOW
            vOsdShowVcdTimeSearch(OSD_VCD_SEARCH_END, OSD_SEARCH_DISC, _rNumInStateCtx.bDig);
#endif

            if (bSharedInfo(SI_PBC_SWITCH) == SV_PBC_ON)
            {
              /* switch to PBC off first */
              vSendUopCmd(UOP_PBC_SWITCH, 0, 0, 0);
            }

            vSendUopCmd(UOP_TIME_PLAY, SV_TIME_DISC, rTimeChk.bMM, rTimeChk.bSS);
          }
          else
          {
            vOsdShowError(SV_ERR_INPUT_INVALID, OSD_TIMEOUT_SHORT);
          }
        }
      }
      else
      {
        vOsdShowError(SV_ERR_INPUT_INVALID, OSD_TIMEOUT_SHORT);
      }

      _rSearchStateCtx.bType = SEARCH_NONE;
    }
    else /* _rNumInStateCtx.rState.fgComplete */
    {
      if (_rSearchStateCtx.bType == SEARCH_VCD_TIME_TRACK)
      {
        vOsdShowVcdTimeSearch(_rNumInStateCtx.rState.bDigNum, OSD_SEARCH_TRACK, _rNumInStateCtx.bDig);
      }
      else
      {
        vOsdShowVcdTimeSearch(_rNumInStateCtx.rState.bDigNum, OSD_SEARCH_DISC, _rNumInStateCtx.bDig);
      }

      vIrSetTimeOut(IR_TIMEOUT_SEARCH);
    }
  }
  else /* >= IR_ADD10 and not IR_CLEAR, IR_ADD5 */
  {
    vSetExitInputState();
    vOsdShowVcdTimeSearch(0, OSD_SEARCH_CLEAR, 0);

    if (_bIRKey == IR_SELECT)
    {
      return (FALSE); /* pass to main state change search mode */
    }
    else
    {
      _rSearchStateCtx.bType = SEARCH_NONE;
    }
  }

  return (TRUE);
}

// *********************************************************************
// Track Search State Machine
// *********************************************************************
void vVCDTrackSearchInit(BYTE fgInit) large
{
  /* the search type is assigned in main state */

#ifdef NO_ADD10_KEY
  vNumInInitState(NUM_IN_SEQ_LIMIT, 2);
#else
  vNumInInitState(NUM_IN_TYPE_3, 1);
#endif

  vOsdShowSelectTrk(0, bSharedInfo(SI_TRACK_NS), 0 | OSD_SELECT_HILI, OSD_NO_DISAPPEAR);

  vIrSetTimeOut(IR_TIMEOUT_SEARCH);
}

BOOL fgVCDTrackSearchState(void) large
{
  BOOL fgRetValue;
  BYTE bTrkNs = bSharedInfo(SI_TRACK_NS);

#ifndef NO_ADD10_KEY
  /* check range here */
  if ((_bIRKey <= IR_ADD10) && (_rNumInStateCtx.rState.bDigNum == 0))
  {
    if (_rNumInStateCtx.wNum + _bIRKey > bTrkNs)
    {
      vIrSetTimeOut(IR_TIMEOUT_SEARCH);
      /* don't process the key */
      return (TRUE);
    }
  }
#endif /* NO_ADD10_KEY */

// megaa ADD5 begin
#ifndef NO_ADD5_KEY
  /* check range here */
  if ((_bIRKey == IR_ADD5) && (_rNumInStateCtx.rState.bDigNum == 0))
  {
    if (_rNumInStateCtx.wNum + 5 > bTrkNs)
    {
      vIrSetTimeOut(IR_TIMEOUT_SEARCH);
      /* don't process the key */
      return (TRUE);
    }
  }
#endif /* NO_ADD5_KEY */
// megaa ADD5 end

  fgRetValue = fgNumInState();

  if (fgRetValue == TRUE)
  {
    if (_rNumInStateCtx.rState.fgComplete == TRUE)
    {
      vOsdShowSelectTrk(0, 0, OSD_SELECT_CLEAR, 0);
      vSetExitInputState();
      _rSearchStateCtx.bType = SEARCH_NONE;

      if ((_rNumInStateCtx.rState.fgCancel) || (_rNumInStateCtx.wNum > bTrkNs))
      {
        vOsdShowError(SV_ERR_INPUT_INVALID, OSD_TIMEOUT_SHORT);
      }
      else
      {
        if ((bSharedInfo(SI_TRACK_NO) != 0) &&
            (_rNumInStateCtx.wNum <= bTrkNs) &&
            (bSharedInfo(SI_PBC_SWITCH) == SV_PBC_ON))
        {
          /* switch to PBC off first */
          vSendUopCmd(UOP_PBC_SWITCH, 0, 0, 0);
        }

#ifndef CDDA_USE_CDFS  
        if (fgIsCddaPlay())
        {
          vSendUopCmd(UOP_DIGITAL_BTN, _rNumInStateCtx.wNum, 0, 0);
        }
        else
#endif        
        {
          vSendUopCmd(UOP_TRACK_PLAY, _rNumInStateCtx.wNum, 0, 0);
        }

        #ifdef SEARCH_INPUT_SHOW
        vOsdShowSelectTrk(_rNumInStateCtx.wNum, bTrkNs, 2, OSD_TIMEOUT_SHORT);
        #endif
      }
    }
    else /* not complete yet! */
    {
      /* update OSD only */
      vOsdShowSelectTrk(_rNumInStateCtx.wNum, bTrkNs, 1 | OSD_SELECT_HILI, OSD_NO_DISAPPEAR);
      vIrSetTimeOut(IR_TIMEOUT_SEARCH);
    }
  }
  else /* the key is not grabed, assume exit input state */
  {
    vSetExitInputState();
    vOsdShowSelectTrk(0, 0, OSD_SELECT_CLEAR, 0);
    _rSearchStateCtx.bType = SEARCH_NONE;

    if (_bIRKey == IR_TIME_OUT)
    {
      fgRetValue = TRUE;
    }
  }

  return (fgRetValue);
}

// *********************************************************************
// Change display mode
// *********************************************************************
void vVCDDisplayChangeInit(BYTE fgInit) large
{
  vOsdDisplayChange(DISP_REMAIN_CHG_INIT, bCurrRemainType());
  vIrSetTimeOut(IR_TIMEOUT_DISPLAY);
}

BOOL fgVCDDisplayChangeState(void) large
{
  BYTE bType = bCurrRemainType();

  if (_bIRKey != IR_DISPLAY)
  {
    vSetExitInputState();

    if (_bIRKey == IR_TIME_OUT)
    {
      return (TRUE);
    }
  }
  else /* if (_bIRKey == IR_DISPLAY) */
  {
    bType++;

    if (bSharedInfo(SI_PBC_SWITCH) == SV_PBC_ON)
    {
      if(bType > OSD_SHOW_SINGLE_REMAIN)
      {
        bType = OSD_SHOW_DISABLE;
      }
    }
    else /* PBC off */
    {
      if(bType > OSD_SHOW_VCD_REMAIN_MAX)
      {
#ifndef CDDA_USE_CDFS        	
#ifdef CDDA_NO_DISPLAY_OFF
        if (fgIsCddaPlay())
        {
          bType = OSD_SHOW_SINGLE_ELAPSED;
        }
        else
#endif
#endif
        {
          bType = OSD_SHOW_DISABLE;
        }

      }
    }

    vOsdDisplayChange(DISP_REMAIN_CHG_INIT, bType);
    vIrSetTimeOut(IR_TIMEOUT_DISPLAY);
    return (TRUE);
  }

  return (FALSE);
}

void vVCDDisplayChangeExit(void) large
{
  vOsdDisplayChange(DISP_REMAIN_CHG_EXIT, 0);
}

/************************************************************************
     Function : void vOsdUpdate(void)
  Description : Update OSD/VFD
    Parameter : None
    Return    : None
************************************************************************/
#ifndef NEW_PLAY
BYTE bVCDHandleUopRet(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_DIGITAL_BTN:
    case UOP_ARROW_BTN:
    {
      if (bUopRet == SV_NO_ERROR)
      {
        bRet = UOP_UPDATE; /* still allow update */
      }
      break;
    }

    /* normal playback */
    case UOP_RESUME:
    case UOP_RESUME_PLAY:
      if (bUopRet == SV_NO_ERROR)
      {
        VfdShowPlayInfo(VFD_INFO_TRACK, 0, bSharedInfo(SI_TRACK_NO));
      }
      /* don't break here */
    case UOP_PLAY:
      if (bUopRet == SV_NO_ERROR)
      {
        vOsdShowPlayStatus(OSD_SHOW_PLAY, OSD_TIMEOUT_SHORT);
      }
      break;

    /* case UOP_PAUSE: */
    /* case UOP_STOP: */
    case UOP_NEXT:
      if (bUopRet == SV_NO_ERROR)
      {
        if (!fgIsInDigest(bSharedInfo(SI_PBC_STATE)))
          vOsdShowPlayStatus(OSD_SHOW_NEXT_TRK, OSD_TIMEOUT_SHORT);
      }
      break;

    case UOP_PREVIOUS:
      if (bUopRet == SV_NO_ERROR)
      {
        if (!fgIsInDigest(bSharedInfo(SI_PBC_STATE)))
          vOsdShowPlayStatus(OSD_SHOW_PREV_TRK, OSD_TIMEOUT_SHORT);
#ifdef KARAOKE_SCORING
        vAdspResetKScore();
#endif
      }
      break;

    case UOP_REPEAT:
      bTmp1 = bSharedInfo(SI_REPEAT_MODE);
      bTmp2 = bSharedInfo(SI_USR_AUX_CTRL);
      if ((bUopRet == SV_NO_ERROR) && (!fgISUsrSeqPlay(bTmp2)))
      {
        switch (bTmp1)
        {
          case SV_REPEAT_ALL:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_REPEAT_ALL, OSD_TIMEOUT_SHORT);
#ifdef PLAYER_GOTO
            // megaa Goto begin
            if (fgIsInGoto())
            {
              vShowGotoRepeat(OSD_MSG_ICON_RPT_ALL);
            }
            // megaa Goto end
#endif
            break;

          case SV_REPEAT_TRACK:
          case SV_REPEAT_LIST:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_REPEAT_TRACK, OSD_TIMEOUT_SHORT);
#ifdef PLAYER_GOTO
            // megaa Goto begin
            if (fgIsInGoto())
            {
              vShowGotoRepeat(OSD_MSG_ICON_RPT_TRK);
            }
            // megaa Goto end
#endif
            break;

          case SV_REPEAT_NONE:
          case SV_REPEAT_ABNONE:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_REPEAT_OFF, OSD_TIMEOUT_SHORT);
#ifdef PLAYER_GOTO
            // megaa Goto begin
            if (fgIsInGoto())
            {
              vShowGotoRepeat(OSD_MSG_OFF);
            }
            // megaa Goto end
#endif
            break;

          default:
            break;
        } /* switch () */
      }
      break;

    /* trick mode control */
    /* case UOP_FORWARD: */
    /* case UOP_REVERSE: */
    /* case UOP_STEP: */
    /* case UOP_STEP_BACK: */
    /* case UOP_A_TO_B: */
    /* case UOP_FREEZE: */

    /* PBC control */
    /* case UOP_MENU_CALL: */

    case UOP_RETURN:
    {
      if (bUopRet == SV_NO_ERROR)
      {
        vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_PBC_MENU, OSD_TIMEOUT);
      }
      break;
    } /* UOP_RETURN */

    case UOP_CHANGE_ASTN:
    case UOP_NEXT_ASTN:
    {
      if (bUopRet == SV_NO_ERROR)
      {
        bTmp1 = bSharedInfo(SI_DISC_TYPE);
        bTmp2 = bSharedInfo(SI_AST_NS);
        if (IS_SVCD_TYPE(bTmp1)
#ifdef CVD_4AST
        || (bTmp1 == SV_CVD)
#endif
        )
        {
          if (bTmp2 > 0)
          {
#ifdef PLAYER_KARAOKE
            if ((bAdspCurrVocal() != VOCAL_AUDIO1) && (bAdspCurrVocal() != VOCAL_AUDIO2))
#endif
            {
              vOsdShowAudioN(OSD_AUDIO_NORMAL | OSD_TIMEOUT, bSharedInfo(SI_AST_NO) + 1, bTmp2);
            }
          }
          else
          {
            vOsdShowAudioN(OSD_AUDIO_CLEAR, 0, 0);
          }
        }
      }
      break;
    } /* UOP_NEXT_ASTN */

#ifdef SVCD_OGT
    case UOP_CHANGE_SPSTN:
    case UOP_NEXT_SPSTN:
    case UOP_SP_SWITCH:
    case UOP_NEXT_SPSTN_NOSP:
      if (bUopRet == SV_NO_ERROR)
      {
        bTmp1 = bSharedInfo(SI_DISC_TYPE);
        if (IS_SVCD_TYPE(bTmp1))
        {
          vOsdShowSubtitleNo(bSharedInfo(SI_SPST_NO));
        }
      }
      break;
#endif

    /* case UOP_CHANGE_AGL: */
    /* case UOP_DEFAULT: */
    /* case UOP_TOP: */
    /* case UOP_GOUP: */
    /* case UOP_STILL_OFF: */
    /* case UOP_MEMORY_PLAY: */

    /* non-PBC control */
    case UOP_PBC_SWITCH:
    {
      if (bUopRet == SV_NO_ERROR)
      {
        if (fgIsInGoto())
          break;

        bTmp1 = bSharedInfo(SI_PBC_SWITCH);
        if (bTmp1 == SV_PBC_ON)
        {
          vOsdPosShow(OSD_POS_PBC_2, OSD_MSG_PBC_ON, OSD_TIMEOUT_SHORT);
        }