vfdcore.c

mtkDVD源代码程序4*16 很好玩的内置5.1环绕音效 大家可以玩一下

    {
      bWheelPos--;
      if (!bWheelPos)
      {
        bWheelPos = VFD_WHEEL_FANS;
      }
    }
    else  // if ((bPbcState != SV_FF) && (bPbcState != SV_SF))
  #endif /* VFD_WHEEL_REVERSE_ROTATE */
    {
      bWheelPos++;
      if(bWheelPos > VFD_WHEEL_FANS)
      {
        bWheelPos = 1;
      }
    }
  }
  else if (bType == VFD_WHEEL_ALL)
  {
    bWheelPos = VFD_WHEEL_FANS + 1;
  }
  else if (bType == VFD_WHEEL_CLEAR)
  {
    bWheelPos = 0;
  }

  pbList = &(pbVfdWheel[bWheelPos][0]);
  bTest1 = *pbList;
  bTest2 = *(pbList +1);
  bTest3 = *(pbList +2);
  bTest4 = *(pbList +3);

  VfdUpdateStart();
  VfdScanList(pbList);
  VfdUpdateStop();
#endif /* (VFD_WHEEL_SZ > 0) */
}

#if (VFD_CALENDAR_SZ > 0)
/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdCalendar(WORD start_index) large
{
}
#endif /* (VFD_CALENDAR_SZ > 0) */

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdSetChar(BYTE bSeg, BYTE bCode) large
{
  BYTE *pbChar;

  pbChar = ppbVfdCharNum[bSeg][bCode];

  /* no need to call VfdUpdateStart() here, VfdSetChar() is a local function */
#ifdef VFD_VOLATILE_MSG
  if (fgIsVfdSegBackupOn())
  {
    VfdScanListBackup(pbChar);
  }
  else
#endif
  {
    VfdScanList(pbChar);
  }
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdSegment(BYTE bPos, BYTE bNum, BYTE bMask) large
{
#ifdef VFD_VOLATILE_MSG
  if (fgIsVfdSegBackupOn())
#endif
  {
    VfdUpdateStart();
  }

  if (bPos == VFD_MIN100) /* hour */
  {
    VfdSetChar(VFD_MIN100, bNum & 0x0f);
  }
#ifdef VFD_CHAP100
  else if (bPos == VFD_CHAP100)
  {
    VfdSetChar(VFD_CHAP100, bNum & 0x0f);
  }
#endif
  else if (bPos < VFD_FIELD_MAX)
  {
    /* set low number first */
    VfdSetChar(bPos+1, bNum & 0x0f);

    /* set high number */
    bNum >>= 4;
    VfdSetChar(bPos, ((bMask == 0) || bNum) ? bNum : CHAR_CLEAR);
  }

#ifdef VFD_VOLATILE_MSG
  if (fgIsVfdSegBackupOn())
#endif
  {
    VfdUpdateStop();
  }
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdIcon(WORD wOffset) large
{
  BYTE code * pbList;
  BYTE i;

  pbList = (_pbVfdIconMacro + wOffset);

#ifdef VFD_VOLATILE_MSG
  if (fgIsVfdSegBackupOn())
  {
    for (i = 0; i < VFD_BACKUP_ICON_SZ;i++)
    {
      if (wOffset == wBackupIcon[i])
      {
        VfdScanListBackup(pbList);
        return;
      }
    }
  }
#endif /* VFD_VOLATILE_MSG */

  VfdUpdateStart();
  VfdScanList(pbList);
  VfdUpdateStop();
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdMsg(BYTE bIndex) large
{
  BYTE code * pbMsgList;

#ifdef VFD_VOLATILE_MSG
  BYTE i;

  if (fgIsVfdSegBackupOn())
  {
    _rVfdFlag.fgSegBackupOn = FALSE;
    _bVfdRestoreCnt = 0;

    /* clear backup shadow */
    for (i = 0;i < VFD_SHADOW_LEN;i++)
    {
      VfdBackupShadowWrite(i, 0);
    }
  }
#endif /* VFD_VOLATILE_MSG */

  pbMsgList = pbVfdMsg[bIndex];

  VfdUpdateStart();
  VfdScanList(pbMsgList);
  VfdUpdateStop();
}

//#ifndef VFD_NO_DIRECT_MSG
/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdMsgDirect(BYTE bIndex) large
{
  BYTE code * pbMsgList;

  VfdStbSend(VFD_MODE);
  VfdStbSend(pbVfdDispCmd[VFD_DISP_MODE_DEFAULT]);
  VfdStbSend(VFD_ADDRESS_FIX);

  for (pbMsgList = pbVfdMsg[bIndex]; *pbMsgList != VFD_LIST_END; pbMsgList += 3)
  {
    VfdClrStb();
    VfdSend(_pbVfdRefresh[*pbMsgList] | VFD_ADDRESS_MASK);
    VfdSend(*(pbMsgList+1)); /* only need to do byte or */
    VfdSetStb();
  }
}
//#endif /* !VFD_NO_DIRECT_MSG */

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdErrMsgDirect(BYTE bCode) large
{
#ifdef VFD_SHOW_ERR
  BYTE code * pbChar;

  VfdClearAllDirect();

  if (bCode > PLAYER_ERR_DRAM_TEST)
  {
    VfdStbSend(VFD_MODE);
    VfdStbSend(pbVfdDispCmd[VFD_DISP_MODE_DEFAULT]);
    VfdStbSend(VFD_ADDRESS_FIX);
  
    for (pbChar = pbVfdMsg[VFDMSG_err]; *pbChar != VFD_LIST_END; pbChar += 3)
    {
      _bVfdBuf = *(pbChar+1); /* only need to do byte or */

      VfdClrStb();
      VfdSend(_pbVfdRefresh[*pbChar] | VFD_ADDRESS_MASK);
      VfdSend(_bVfdBuf);
      VfdSetStb();
      
      VfdWorkShadowWrite(*pbChar, _bVfdBuf);
    }

    VfdStbSend(VFD_MODE);
    VfdStbSend(pbVfdDispCmd[VFD_DISP_MODE_DEFAULT]);
    VfdStbSend(VFD_ADDRESS_FIX);

    /* set low number first */
    for (pbChar = ppbVfdCharNum[VFD_SECOND + 1][bCode & 0x0f]; *pbChar != VFD_LIST_END; pbChar += 3)
    {
      _bVfdBuf = *(pbChar+1) | VfdWorkShadowRead(*pbChar); /* only need to do byte or */

      VfdClrStb();
      VfdSend(_pbVfdRefresh[*pbChar] | VFD_ADDRESS_MASK);
      VfdSend(_bVfdBuf);
      VfdSetStb();
      
      VfdWorkShadowWrite(*pbChar, _bVfdBuf);
    }

    /* set high number */
    bCode >>= 4;
    for (pbChar = ppbVfdCharNum[VFD_SECOND][bCode & 0x0f]; *pbChar != VFD_LIST_END; pbChar += 3)
    {
      _bVfdBuf = *(pbChar+1) | VfdWorkShadowRead(*pbChar); /* only need to do byte or */

      VfdClrStb();
      VfdSend(_pbVfdRefresh[*pbChar] | VFD_ADDRESS_MASK);
      VfdSend(_bVfdBuf);
      VfdSetStb();
      
      VfdWorkShadowWrite(*pbChar, _bVfdBuf);
    }
  }
  else
  {
  #ifdef VFDMSG_err
    VfdMsgDirect(VFDMSG_err);
  #endif
  }
#endif /* VFD_SHOW_ERR */
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdClearNum(BYTE bPos) large
{
#ifdef VFD_VOLATILE_MSG
  if (fgIsVfdSegBackupOn())
#endif
  {
    VfdUpdateStart();
  }

  if (bPos == VFD_MIN100) /* hour */
  {
    VfdSetChar(VFD_MIN100, CHAR_CLEAR);
  }
  else
  {
    /* set low number first */
    VfdSetChar(bPos+1, CHAR_CLEAR);

    /* set high number */
    VfdSetChar(bPos, CHAR_CLEAR);
  }

#ifdef VFD_VOLATILE_MSG
  if (fgIsVfdSegBackupOn())
#endif
  {
    VfdUpdateStop();
  }
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdClearAll(void) large
{
  BYTE i;

#ifdef VFD_VOLATILE_MSG
  if (fgIsVfdSegBackupOn())
  {
    _rVfdFlag.fgSegBackupOn = FALSE;
    _bVfdRestoreCnt = 0;

    /* clear backup shadow */
    for (i = 0;i < VFD_SHADOW_LEN; i++)
    {
      VfdBackupShadowWrite(i, 0);
    }
  }
#endif /* VFD_VOLATILE_MSG */

  VfdUpdateStart();

  for (i = 0; i < VFD_SHADOW_LEN; i++)
  {
    VfdWorkShadowWrite(i, 0);
    VfdUpdateByte(i);
  }

  VfdUpdateStop();

#ifdef VFD_HDCD_LED
  _bVfdLed = 0;   // clear HDCD LED.
#endif
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdClearAllDirect(void) large
{
  BYTE i;

  VfdStbSend(VFD_MODE);
  //VfdStbSend(pbVfdDispCmd[VFD_DISP_MODE_DEFAULT]);
  VfdStbSend(VFD_ADDRESS_FIX);

  for (i=0;i<VFD_SHADOW_LEN;i++)
  {
    VfdClrStb();
    VfdSend(_pbVfdRefresh[i] | VFD_ADDRESS_MASK);
    VfdSend(0);
    VfdSetStb();
  }
  
  VfdStbSend(pbVfdDispCmd[VFD_DISP_MODE_DEFAULT]);
}

#if 0
/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdSetAll(void) large
{
  BYTE i;

  VfdUpdateStart();

  for (i = 0; i < VFD_SHADOW_LEN; i++)
  {
    VfdWorkShadowWrite(i, 0xff);
    VfdUpdateByte(i);
  }

  VfdUpdateStop();
}
#endif

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdUpdateNow(void) large
{
  BYTE i;

  VfdStbSend(VFD_MODE);
  VfdStbSend(pbVfdDispCmd[_bVfdDispMode]);
  VfdStbSend(VFD_ADDRESS_FIX);

  for (i = 0;i < VFD_SHADOW_LEN;i++)
  {
    VfdClrStb();
    VfdSend(_pbVfdRefresh[i] | VFD_ADDRESS_MASK);
    _bVfdBuf = VfdWorkShadowRead(i);
    VfdUpdateShadowWrite(i, _bVfdBuf);
    VfdSend(_bVfdBuf);
    VfdSetStb();
  }
}

#ifdef VFD_VOLATILE_MSG
/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdBackup(void) large
{
  BYTE i;
  BYTE *pbList;

  if (_rVfdFlag.fgSegBackupOn == TRUE)
  {
    return;
  }

  /* clear backup shadow first */
  for (i = 0;i < VFD_SHADOW_LEN;i++)
  {
    VfdBackupShadowWrite(i, 0);
  }

  /* copy work shadow to backup shadow */
  /* segments */
  for (i = 0;i < VFD_CHAR_NO;i++)
  {
    pbList = ppbVfdCharNum[i][CHAR_CLEAR];
    
    VfdBackupSeg(pbList);
  }
  /* icons */
  for (i = 0; i < VFD_BACKUP_ICON_SZ;i++)
  {
    pbList = (_pbVfdIconMacro + wBackupIcon[i]);

    VfdBackupIcon(pbList);
  }

  _rVfdFlag.fgSegBackupOn = TRUE;
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdRestore(void) large
{
  BYTE i;
  BYTE *pbList;

  if (_rVfdFlag.fgSegBackupOn == FALSE)
  {
    return;
  }

  VfdUpdateStart();

  /* clear work shadow first */
  /* segments */
  for (i = 0; i < VFD_CHAR_NO;i++)
  {
    pbList = ppbVfdCharNum[i][CHAR_CLEAR];

    VfdScanList(pbList);
  }
  /* icons */
  for (i = 0; i < VFD_BACKUP_ICON_SZ;i++)
  {
    pbList = (_pbVfdIconMacro + wBackupIcon[i]);

    VfdClearIcon(pbList);
  }

  /* copy backup shadow to work shadow */
  for (i = 0;i < VFD_SHADOW_LEN;i++)
  {
    _bVfdBuf = VfdBackupShadowRead(i);
    
    if (_bVfdBuf != 0)
    {
      _bVfdBuf |= VfdWorkShadowRead(i);
      VfdWorkShadowWrite(i, _bVfdBuf);
    }
  }

  VfdUpdateStop();

  _rVfdFlag.fgSegBackupOn = FALSE;
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void VfdMsgVolatile(BYTE bIndex, BYTE bTime) large
{
  BYTE code * pbList;
  BYTE i;

  if (fgIsVfdSegBackupOn() == FALSE)
  {
    VfdBackup();
  }

  VfdUpdateStart();

  /* celar segments */
  for (i = 0; i < VFD_CHAR_NO;i++)
  {
    pbList = ppbVfdCharNum[i][CHAR_CLEAR];

    VfdScanList(pbList);
  }
  /* clear icons */