play_vcd.c

MTK 1389e版 MINI组合音响代码

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 03/10/14 6:21p    $       ****************/
/***************  $Revision:: 2                $       ****************/
/***************                                       ****************/
/***************   Description :                       ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#define _PLAY_VCD_C_

#pragma NOAREGS
#include "general.h"



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

  vBookmarkReset();

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

// *********************************************************************
// 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);
    vSetSharedInfo(SH_VCD_USR_PBC_OFF, TRUE); //BillDen
  }
  else
  {
    vSetSharedInfo(SI_VCD_PBC_OFF, FALSE);
    vSetSharedInfo(SH_VCD_USR_PBC_OFF, FALSE); //BillDen
  }
#endif /* SETUP_MENU_PBC_CTRL */
}

// *********************************************************************
// Time Check Function
// *********************************************************************
static BOOL fgCheckDiscTimeValid(BYTE bMin, BYTE bSec) large
{
  BYTE bTmp;

  bTmp = bBCDToHEX(bSharedInfo(SI_TIME_TOTAL_MM));

  if (bMin > bTmp)
  {
    return (FALSE);
  }
  else if (bMin < bTmp)
  {
    return (TRUE);
  }

  bTmp = bBCDToHEX(bSharedInfo(SI_TIME_TOTAL_SS));

  if (bSec > bTmp)
  {
    return (FALSE);
  }
  else
  {
    return (TRUE);
  }
}

static BOOL fgCheckTrackTimeValid(BYTE bMin, BYTE bSec) large
{
  BYTE bTmp;

  bTmp = bBCDToHEX(bSharedInfo(SI_TIME_TOTAL_TRACK_MM));

  if (bMin > bTmp)
  {
    return (FALSE);
  }
  else if (bMin < bTmp)
  {
    return (TRUE);
  }

  bTmp = bBCDToHEX(bSharedInfo(SI_TIME_TOTAL_TRACK_SS));

  if (bSec > bTmp)
  {
    return (FALSE);
  }
  else
  {
    return (TRUE);
  }
}

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

  vNumInInitState(NUM_IN_VCD_TIME, 4);

  if (_rSearchStateCtx.bType == SEARCH_VCD_TIME_TRACK)
  {
    vOsdShowVcdTimeSearch(0, OSD_SEARCH_TRACK, 0);
  }
  else
  {
    vOsdShowVcdTimeSearch(0, OSD_SEARCH_DISC, 0);
  }

  vIrSetTimeOut(IR_TIMEOUT_SEARCH);
}

BOOL fgVCDTimeSearchState(void) large
{
  BOOL fgRetValue;
  BYTE bMin, bSec;

/*bywhy 2003/02/20*/
  if ((_bIRKey <= IR_ADD10) || (_bIRKey == IR_CLEAR)|| (_bIRKey == IR_RETURN) || (_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);

      bMin = _rNumInStateCtx.bDig[0] * 10 + _rNumInStateCtx.bDig[1];
      bSec = _rNumInStateCtx.bDig[2] * 10 + _rNumInStateCtx.bDig[3];

      if (_rNumInStateCtx.rState.fgCancel == FALSE)
      {
        if (_rSearchStateCtx.bType == SEARCH_VCD_TIME_TRACK)
        {
          if (fgCheckTrackTimeValid(bMin, bSec) == TRUE)
          {
#ifdef SEARCH_INPUT_SHOW
            vOsdShowVcdTimeSearch(OSD_VCD_SEARCH_END, OSD_SEARCH_TRACK, _rNumInStateCtx.bDig);
#endif

            vSendUopCmd(UOP_TIME_PLAY, SV_TIME_TRACK, bMin, bSec);
          }
          else
          {
            vOsdShowError(SV_ERR_INPUT_INVALID, OSD_TIMEOUT_SHORT);
          }
        }
        else
        {
          if (fgCheckDiscTimeValid(bMin, bSec) == 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, bMin, bSec);
          }
          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);
        }

        if (fgIsCddaPlay())
        {
          vSendUopCmd(UOP_DIGITAL_BTN, _rNumInStateCtx.wNum, 0, 0);
        }
        else
        {
          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)
    {
    #ifndef BBK_MENU
      if(bType > OSD_SHOW_SINGLE_REMAIN)
      {
        bType = OSD_SHOW_DISABLE;
      }
    #else
      if(bType > OSD_SHOW_VCD_REMAIN_MAX)
      {
        bType = OSD_SHOW_DISABLE;
      }
    #endif
    }
    else /* PBC off */
    {
      if(bType > OSD_SHOW_VCD_REMAIN_MAX)
      {
#ifdef CDDA_NO_DISPLAY_OFF
        if (fgIsCddaPlay())
        {
          bType = OSD_SHOW_SINGLE_ELAPSED;
        }
        else
#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
************************************************************************/
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)
      {

	  bTmp1=bSharedInfo(SI_TRACK_NO);
      if (bTmp1 <= 99)
        vVfdWord(VFD_WORD_CH, bHEXToBCD(bTmp1), 1);      	      	
      else
        vVfdWord(VFD_WORD_CH, 0, 1);      	

      vVfdWordClr(VFD_WORD_TT);
      vVfdSymbol(VFD_SYM_PLAYINFO_TRACK);

      }
      /* 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);
      }

    #ifdef BBK_MENU
      if(fgIsInGoto())
      {
        vOsdPosClear(OSD_POS_ZOOM);
      	vSendUopCmd(UOP_ZOOM_IN, SV_ZOOM_1, 0, 0x80);

	vGotoClose();
	vGotoExit();
      }
    #endif

      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))