digest.c

MTK 1389E SOURCE CODE

      {
        vDgstNumInit(TRUE);
        fgRet = fgDgstNumState();
      }
      else
      {
        fgRet = FALSE;
      }
      break;
    }
  } /* switch (_bIRKey) */

  return (fgRet);
}

// *********************************************************************
// Wait Digest Initial Sub-state Functions
// *********************************************************************

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vDgstInitInit(BYTE fgInit) large
{
  _rDigest.bState = DGST_STATE_INIT;

  /* set input timeout */
  vIrSetTimeOut(IR_TIMEOUT_DGST_INIT);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vDgstInitExit(void) large
{
  vIrSetTimeOut(IR_TIMER_VOID);

  /* if UOP return OK and not timeout, switch to menu state */
  vDgstMenuInit(TRUE);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BOOL fgDgstInitState(void) large
{
  BOOL fgRet = TRUE;

  switch (_bIRKey)
  {
    case IR_TIME_OUT:
      vSetExitInputState();
      break;

    case IR_DONE:
      vDgstInitExit();
      break;

    default:
      break;
  }

  return (fgRet);
}

// *********************************************************************
// Wait Digest Resume Sub-state Functions
// *********************************************************************

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vDgstResumeInit(BYTE fgInit) large
{
  /* set input timeout */
  vIrSetTimeOut(IR_TIMEOUT_DGST_RESUME);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vDgstResumeExit(void) large
{
  vIrSetTimeOut(IR_TIMER_VOID);

  /* if UOP return OK and not timeout, switch to type state */
  vDgstTypeInit(TRUE);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BOOL fgDgstResumeState(void) large
{
  BOOL fgRet = TRUE;

  switch (_bIRKey)
  {
    case IR_TIME_OUT:
      vSetExitInputState();
      break;

    case IR_DONE:
      vDgstResumeExit();
      break;

    default:
      break;
  }

  return (fgRet);
}

// *********************************************************************
// Number Select Input state
// *********************************************************************

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vDgstNumInit(BYTE fgInit) large
{
  vOsdPosHili(OSD_POS_HILI_CLEAR, 0, 0);
  vDgstMenuBtnUnsel(DGST_STATE_NUM);

#ifdef NO_ADD10_KEY
  vNumInInitState(NUM_IN_SEQ_WAIT, 2);
#else
  vNumInInitState(NUM_IN_TYPE_1, 1);
#endif

  vOsdShowDgstMenuSelect(1, _rDigest.bSelNoMax, 0, OSD_DGST_SEL_HILI | 0); /* with hi-li */
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vDgstNumExit(BYTE bSelNo) large
{
  vOsdShowDgstMenuSelect(1, _rDigest.bSelNoMax, 0, 0); /* without hi-li */

  if ((bSelNo > 0) && (bSelNo <= _rDigest.bSelNoMax))
  {
    if (fgDgstPlayControl(SV_DGST_PLAY, bSelNo) == TRUE)
    {
      vDgstDispExit();
      vDgstMenuExit(FALSE);

      /* note still in the same state */
      vSetExitInputState();

      return;
    }
  }

  /* select fail */
  if ((_bIRKey == IR_UP) && (_rDigest.fgDispValid == TRUE))
  {
    vDgstDispGotoItem(0);
  }
  else
  {
    vDgstMenuGotoItem(DGST_MENU_BTN_EXIT);
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BOOL fgDgstNumState(void) large
{
  BOOL fgRetValue = TRUE;

  switch (_bIRKey)
  {
    case IR_CLEAR:
#ifdef NO_ADD10_KEY
      vNumInInitState(NUM_IN_SEQ_WAIT, 2);
#else
      vNumInInitState(NUM_IN_TYPE_1, 1);
#endif
      vOsdShowDgstMenuSelect(1, _rDigest.bSelNoMax, _rNumInStateCtx.wNum, OSD_DGST_SEL_HILI | 0); /* with hi-li */
      break;

    case IR_ENTER:
    case IR_PLAY:
    case IR_PLAY_ENTER:
    case IR_PLAY_PAUSE:
    {
      if (_rNumInStateCtx.rState.fgComplete)
      {
        if ((_rNumInStateCtx.wNum > 0) &&
            (_rNumInStateCtx.wNum <= _rDigest.bSelNoMax) &&
            (_rNumInStateCtx.rState.fgCancel == FALSE))
        {
          vDgstNumExit(_rNumInStateCtx.wNum);
        }
        else
        {
          vDgstNumExit(0);
        }
      }
      break;
    } /* IR_ENTER */

    case IR_DONE:
      /* ignore it */
      break;

    default:
    {
      if (_bIRKey <= IR_ADD10 || _bIRKey == IR_ADD5)  // megaa ADD5
      {
        if (_rNumInStateCtx.rState.fgComplete)
        {
#ifdef NO_ADD10_KEY
          vNumInInitState(NUM_IN_SEQ_WAIT, 2);
#else
          vNumInInitState(NUM_IN_TYPE_1, 1);
#endif
        }

        fgNumInState();

        vOsdShowDgstMenuSelect(1, _rDigest.bSelNoMax, _rNumInStateCtx.wNum,
                               OSD_DGST_SEL_HILI | _rNumInStateCtx.rState.bDigNum); /* with hi-li */
      }
      else /* > IR_ADD10 and not IR_ADD5 */
      {
        vDgstNumExit(0);
        fgRetValue = FALSE;
      }
      break;
    } /* default */
  } /* switch (_bIRKey) */

  return (fgRetValue);
}

// *********************************************************************
// Module Entry Functions
// *********************************************************************

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vDigestInit(BYTE fgInit) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bDom = bSharedInfo(SI_DVD_DOM);

#if (DRAM_SZ == DRAM_2M) || defined(USE_DRAM_CFG1)
  vOsdSetMemBlk(OSD_MEM_BLK_DYNAMIC, OSD_MEM_DEFAULT);
#endif  

  /* TODO: need to check is play and in not menu */
  if (fgIsDiscPlay(bPbcState) || (bPbcState == SV_STOP_RESUME))
  {
    if (fgIsDvdPlay())
    {
      if ((bDom == SV_VTSTT_DOM) || (bDom == SV_ATSTT_DOM))
      {
        _rDigest.fgResume = TRUE;
      }
      else
      {
        _rDigest.fgResume = FALSE;
      }
    }
#ifdef VCD_SUPPORT    
    else if (fgIsVcdPlay())
    {
      if ((bSharedInfo(SI_PBC_SWITCH) == SV_PBC_ON) &&
          (bSharedInfo(SI_VCD_DOM) == SV_SELECT_LIST))
      {
        _rDigest.fgResume = FALSE;
      }
      else
      {
        _rDigest.fgResume = TRUE;
      }
    }
#endif    
  }
  else
  {
    _rDigest.fgResume = FALSE;
  }

  /* set digest control mode */
  vSetSharedInfo(SI_USR_DIGEST_CTRL, SV_DGST_ONCE);

#ifndef HILI_USE_OSD
  /* set hilight color */
  vSetHLCol(HL_1, 0x0000); /* green */
#endif

  /* initial sub-state */
  vDgstTypeInit(TRUE);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vDigestExit(void) large
{
  if (_rDigest.bState == DGST_STATE_TYPE)
  {
    vDgstTypeExit();
  }
  else if ((_rDigest.bState == DGST_STATE_MENU) || (_rDigest.bState == DGST_STATE_DISP))
  {
    /* let WB disappear quickly, disable is faster than delete */
    vOsdSetSt(OSD_ST_BURST);
    vDisableWB(WB_DGST_DISP1);
    vDisableWB(WB_DGST_DISP2);
    vDisableWB(WB_DGST_DISP1A);
    vDisableWB(WB_DGST_DISP2A);
    vDisableWB(WB_DGST_MENU);
    vOsdSetSt(OSD_ST_NML);
    /* let WB disappear quickly end*/

    vDgstDispExit();
    vDgstMenuExit(TRUE);
  }
  else if (_rDigest.bState == DGST_STATE_EXIT)
  {
     vDeleteWB(WB_DGST_DISP1);
     vDeleteWB(WB_DGST_DISP2);
     vDeleteWB(WB_DGST_DISP1A);
     vDeleteWB(WB_DGST_DISP2A);
     vDeleteWB(WB_DGST_MENU);
  }
  else if (_rDigest.bState == DGST_STATE_NUM)
  {
    /* let WB disappear quickly, disable is faster than delete */
    vOsdSetSt(OSD_ST_BURST);
    vDisableWB(WB_DGST_DISP1);
    vDisableWB(WB_DGST_DISP2);
    vDisableWB(WB_DGST_DISP1A);
    vDisableWB(WB_DGST_DISP2A);
    vDisableWB(WB_DGST_MENU);
    vOsdSetSt(OSD_ST_NML);
    /* let WB disappear quickly end*/

    vDgstDispExit();
    if (_rNumInStateCtx.rState.fgComplete)
    {
      /* number is selected OK */
      vDgstMenuExit(FALSE);
    }
    else
    {
      vDgstMenuExit(TRUE);
    }
  }

  /* assume change color is disabled */
  vOsdPosHili(OSD_POS_HILI_CLEAR, 0, 0);

  /* status recall, temp add */
  if (_rDigest.fgResume == TRUE)
  {
    vStatusDispRecall();
  }
#if (DRAM_SZ == DRAM_2M) || defined(USE_DRAM_CFG1)
  vOsdSetMemBlk(OSD_MEM_BLK_STATIC, OSD_MEM_DEFAULT);
#endif  
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BOOL fgDigestState(void) large
{
  BOOL fgRet = TRUE;

  /* sub-state function */
  switch (_rDigest.bState)
  {
    case DGST_STATE_TYPE:
      fgRet = fgDgstTypeState();
      break;

    case DGST_STATE_MENU:
      fgRet = fgDgstMenuState();
      break;

    case DGST_STATE_DISP:
      fgRet = fgDgstDispState();
      break;

    case DGST_STATE_INIT:
      fgRet = fgDgstInitState();
      break;

    case DGST_STATE_RESUME:
      fgRet = fgDgstResumeState();
      break;

    case DGST_STATE_NUM:
      fgRet = fgDgstNumState();
      break;

    default:
      vSetExitInputState();
      return (TRUE);
  }

  if (fgRet == FALSE)
  {
    switch (_bIRKey)
    {
      case IR_DIGEST:
      {
        vSetExitInputState();
        fgRet = TRUE;
        break;
      }

      default:
#if 0
        if (fgIsAVContrlKey(_bIRKey))
        {
          /* pass the A/V control key */
          fgRet = FALSE;
        }
#else
        fgRet = TRUE; /* not allow setup menu and A/V control key */
#endif
        break;
    }
  }

  return (fgRet);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vDigestHandleUpdate(BYTE bItem, BYTE bVal) large
{
  switch (bItem)
  {
    case DGST_UPD_NO:
      /* the page last item */
      if (bVal == (_rDigest.bPageNo * DGST_VIEW_NS + _rDigest.bPageItemMax - 1))
      {
        _rDigest.fgDispValid = TRUE;
      }
      break;

    default:
      break;
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vDigestUsrPbcChange(void) large
{
  if ((bSharedInfo(SI_USR_PBC_CTRL) != SV_USR_DIGEST) && 
      (_rDigest.bState == DGST_STATE_EXIT))
  {
    fgSetPlayPostKey(IR_TIME_OUT);
  }
}

#else /* PLAYER_DIGEST dummy function */

static code BYTE pbDigestCodeSegment[1] = { FALSE }; /* for code segment */

void vDigestInit(BYTE fgInit) large { return; }

BOOL fgDigestState(void) large { return (pbDigestCodeSegment[0]); }
void vDigestExit(void) large { return; }

void vDigestHandleUpdate(BYTE bItem, BYTE bVal) large { return; }
void vDigestUsrPbcChange(void) large { return; }

#endif /* PLAYER_DIGEST */