num_proc.c

是MTK公司新出来的DVD方案

/***************     MTK CONFIDENTIAL & COPYRIGHTED    ****************/
/***************                                       ****************/
/***************  $Modtime:: 04/05/03 2:57p    $       ****************/
/***************  $Revision:: 2                $       ****************/
/***************                                       ****************/
/*************** Description : common routines for     ****************/
/***************               number key processing   ****************/
/***************                                       ****************/
/***************     Company : MediaTek Inc.           ****************/
/***************  Programmer :                         ****************/
/**********************************************************************/

#define _NUM_PROC_C_

#pragma NOAREGS
#include "general.h"

/************************************************************************
     Function : WORD wWRDToBCD(WORD wVal)
  Description : convert HEX WORD to 2 BCD
    Parameter : wVal - HEX number
    Return    : BCD number 0 and 1
************************************************************************/
WORD wWRDToBCD(WORD wVal) large
{
  WORD wBcd = 0;

  if (wVal > 9999)
  {
    wVal = 9999;
  }

  while (wVal >= 100)
  {
    wBcd++;
    wVal -= 100;
  }

  /* note this method is only valid for little endian */
  wVal = (WORD)bHEXToBCD((BYTE)wVal);
  wBcd = 256 * (WORD)bHEXToBCD((BYTE)wBcd) + wVal;

  return (wBcd);
}

// *********************************************************************
// Convert Digit to real number
// *********************************************************************
static code const WORD pwDig2Hex[5] = { 1, 10, 100, 1000, 10000 };

WORD wDigToNum(BYTE bCnt, BYTE *pbDig) large
{
  BYTE bIdx;
  WORD wNum = 0;
  
  for (bIdx = 0; bIdx < bCnt; bIdx++)
  {
    wNum += pbDig[bIdx] * pwDig2Hex[bCnt - bIdx - 1];
  }

  return (wNum);
}

// *********************************************************************
// General number input process function
// *********************************************************************
void vNumInInitState(BYTE bType, BYTE bCnt) large
{
  _rNumInStateCtx.rState.bInputType = bType;
  _rNumInStateCtx.rState.bTotalDigNum = bCnt;

  for (bCnt = 0; bCnt < 5; bCnt++)
  {
    _rNumInStateCtx.bDig[bCnt] = 0;
  }

  _rNumInStateCtx.wNum = 0;
  _rNumInStateCtx.rState.bDigNum = 0;
  _rNumInStateCtx.rState.fgComplete = FALSE;
  _rNumInStateCtx.rState.fgCancel = FALSE;
}

// *********************************************************************
// 
// *********************************************************************
BOOL fgNumInState1(void) large
{
  _rNumInStateCtx.rState.fgComplete = FALSE;

  if (_bIRKey == IR_CLEAR)
  {
    _rNumInStateCtx.rState.bDigNum = 0;
    _rNumInStateCtx.wNum = 0;
  }
  else if (_bIRKey > IR_ADD10 && _bIRKey != IR_ADD5)  // megaa ADD5
  {
    return (FALSE);
  }
#ifndef NO_ADD10_KEY
  else if (_bIRKey == IR_ADD10)
  {
    if (_rNumInStateCtx.rState.bInputType == NUM_IN_TYPE_4)
    {
      if ((_rNumInStateCtx.wNum + 10) <= 999)
      {
        _rNumInStateCtx.wNum += 10;
      }
    }
    else
    {
      if ((_rNumInStateCtx.wNum + 10) <= 99)
      {
        _rNumInStateCtx.wNum += 10;
      }
    }

    if (_rNumInStateCtx.rState.bDigNum == 0)
    {
      _rNumInStateCtx.rState.bDigNum = 1;
    }
  }
#endif
  // megaa ADD5 begin
#ifndef NO_ADD5_KEY
  else if (_bIRKey == IR_ADD5)
  {
    if (_rNumInStateCtx.rState.bInputType == NUM_IN_TYPE_4)
    {
      if ((_rNumInStateCtx.wNum + 5) <= 999)
      {
        _rNumInStateCtx.wNum += 5;
      }
    }
    else
    {
      if ((_rNumInStateCtx.wNum + 5) <= 99)
      {
        _rNumInStateCtx.wNum += 5;
      }
    }

    if (_rNumInStateCtx.rState.bDigNum == 0/* && _rNumInStateCtx.wNum >= 10*/)  // Is this right???!!!
    {
      _rNumInStateCtx.rState.bDigNum = 1;
    }
  }
#endif
  // megaa ADD5 end
  else /* if (_bIRKey >= IR_NUM0) */
  {
#ifdef USE_NUM0_AS_NUM10
    if ((_rNumInStateCtx.wNum == 0) && (_bIRKey == IR_NUM0))
    {
      _rNumInStateCtx.wNum = 10;
    }
    else
#endif
    {
      _rNumInStateCtx.wNum += _bIRKey;
    }

    if (_rNumInStateCtx.wNum > 0)
    {
      _rNumInStateCtx.rState.bDigNum = 2;
      _rNumInStateCtx.rState.fgComplete = TRUE;
    }
  }

  return (TRUE);
}

// *********************************************************************
// 
// *********************************************************************
BOOL fgNumInState2(void) large
{
  BYTE bDigNum = _rNumInStateCtx.rState.bDigNum;

  if (_bIRKey <= IR_ADD10)
  {
#ifndef NO_ADD10_KEY
    if (_bIRKey == IR_ADD10)
    {
      return (TRUE); /* don't care +10 key */
    }
#endif

    _rNumInStateCtx.bDig[bDigNum] = _bIRKey;

    _rNumInStateCtx.rState.bDigNum++;

    if (_rNumInStateCtx.rState.bDigNum == _rNumInStateCtx.rState.bTotalDigNum)
    {
      _rNumInStateCtx.rState.fgComplete = TRUE;
    }
    else
    {
      _rNumInStateCtx.rState.fgComplete = FALSE;
    }
  }
  // megaa ADD5 begin
#ifndef NO_ADD5_KEY
  else if (_bIRKey == IR_ADD5)
  {
    return (TRUE); /* don't care +5 key ????!!! */
  }
#endif
  // megaa ADD5 end
  else if ((_bIRKey == IR_CLEAR) && (bDigNum > 0))
  {
    _rNumInStateCtx.bDig[bDigNum - 1] = 0;
    _rNumInStateCtx.rState.bDigNum--;
    _rNumInStateCtx.rState.fgComplete = FALSE;
  }
  else
  {
    return(FALSE);
  }

  return(TRUE);
}

// *********************************************************************
// for DVD PTT search and VCD/CDDA track search, only input 1 number
// *********************************************************************
BOOL fgNumInState3(void) large
{
  if (_bIRKey == IR_CLEAR)
  {
    _rNumInStateCtx.wNum = 0;
    _rNumInStateCtx.rState.bDigNum = 0;
    _rNumInStateCtx.rState.fgComplete = FALSE;
    _rNumInStateCtx.rState.fgCancel = FALSE;
  }
#ifdef PTT_TRK_SEARCH_CONFIRM
  else if (fgIsPlayEnterKey(_bIRKey))
  {
    if (_rNumInStateCtx.rState.bDigNum > 0)
    {
      _rNumInStateCtx.rState.bDigNum = 1;
      _rNumInStateCtx.rState.fgComplete = TRUE;
    }
  }
#endif
  else if (_bIRKey > IR_ADD10 && _bIRKey != IR_ADD5)  // megaa ADD5
  {
    return (FALSE);
  }
#ifndef NO_ADD10_KEY
  else if (_bIRKey == IR_ADD10)
  {
    if ((_rNumInStateCtx.wNum + 10) <= 99)
    {
      _rNumInStateCtx.wNum += 10;
    }
  }
#endif
#ifndef NO_ADD5_KEY
  // megaa ADD5 begin
  else if (_bIRKey == IR_ADD5)
  {
    if ((_rNumInStateCtx.wNum + 5) <= 99)
    {
      _rNumInStateCtx.wNum += 5;
    }
  }
#endif
  // megaa ADD5 end
  else /* if (_bIRKey >= IR_NUM0) */
  {
    if (_rNumInStateCtx.rState.bDigNum > 0)
    {
      /* if press number key again, clean current number buffer */
      _rNumInStateCtx.wNum = 0;
    }
    
#ifdef USE_NUM0_AS_NUM10
    if ((_rNumInStateCtx.wNum == 0) && (_bIRKey == IR_NUM0))
    {
      _rNumInStateCtx.wNum = 10;
    }
    else
#endif
    {
      _rNumInStateCtx.wNum += _bIRKey;
    }

    if (_rNumInStateCtx.wNum > 0)
    {
      _rNumInStateCtx.rState.bDigNum = 1;
#ifndef PTT_TRK_SEARCH_CONFIRM
     _rNumInStateCtx.rState.fgComplete = TRUE; 
#endif
    }
  }

  return (TRUE);
}

// *********************************************************************
// for VCD/CDDA time search
// *********************************************************************
BOOL fgVCDTimeSearchNumInState(void) large
{
  BYTE bDigNum = _rNumInStateCtx.rState.bDigNum;

  if (_bIRKey < IR_ADD10)
  {
    if (bDigNum == 2) /* check ten second field */
    {
      if (_bIRKey >= IR_NUM6)
      {
        return (TRUE);
      }
    }

    _rNumInStateCtx.bDig[bDigNum] = _bIRKey;

    _rNumInStateCtx.rState.bDigNum++;
  
    if (_rNumInStateCtx.rState.bDigNum == _rNumInStateCtx.rState.bTotalDigNum)
    {
      _rNumInStateCtx.rState.fgComplete = TRUE;
    }
  }
  else if ((_bIRKey == IR_CLEAR) && (bDigNum > 0))
  {
    _rNumInStateCtx.bDig[bDigNum - 1] = 0;
    _rNumInStateCtx.rState.bDigNum = bDigNum - 1;
    _rNumInStateCtx.rState.fgComplete = FALSE;
  }
  else
  {
    return (FALSE);
  }

  return (TRUE);
}

// *********************************************************************
// for DVD time search
// *********************************************************************
BOOL fgDVDTimeSearchNumInState(void) large
{
  BYTE bDigNum = _rNumInStateCtx.rState.bDigNum;

  if (_bIRKey < IR_ADD10)
  {
    if ((bDigNum == 1) || (bDigNum == 3))
    {
      if (_bIRKey >= IR_NUM6)
      {
        return(TRUE);
      }
    }

    _rNumInStateCtx.bDig[bDigNum] = _bIRKey;

    _rNumInStateCtx.rState.bDigNum++;

    if (_rNumInStateCtx.rState.bDigNum == _rNumInStateCtx.rState.bTotalDigNum)
    {
      _rNumInStateCtx.rState.fgComplete = TRUE;
    }
  }
  else if ((_bIRKey == IR_CLEAR) && (bDigNum > 0))
  {
    _rNumInStateCtx.bDig[bDigNum - 1] = 0;
    _rNumInStateCtx.rState.bDigNum = bDigNum - 1;
    _rNumInStateCtx.rState.fgComplete = FALSE;
  }
  else
  {
    return(FALSE);
  }

  return(TRUE);
}

// *********************************************************************
// For number key sequence input, no time limit
// *********************************************************************
BOOL fgKeySeqWaitNumInState(void) large
{
  if (_bIRKey <= IR_ADD10)
  {
#ifndef NO_ADD10_KEY
    if (_bIRKey == IR_ADD10)
    {
      return (TRUE); /* don't care +10 key */
    }
#endif

    _rNumInStateCtx.bDig[_rNumInStateCtx.rState.bDigNum] = _bIRKey;
    _rNumInStateCtx.rState.bDigNum++;
    _rNumInStateCtx.wNum = wDigToNum(_rNumInStateCtx.rState.bDigNum, _rNumInStateCtx.bDig);

    if (_rNumInStateCtx.rState.bDigNum == _rNumInStateCtx.rState.bTotalDigNum)
    {
      _rNumInStateCtx.rState.fgComplete = TRUE;
    }
  }
#ifndef NO_ADD5_KEY
  // megaa ADD5 begin
  else if (_bIRKey == IR_ADD5)
  {
    return (TRUE);  // don't care +5 key 
  }
#endif
  // megaa ADD5 end
  else if ((_bIRKey == IR_CLEAR) && (_rNumInStateCtx.rState.bDigNum > 0))
  {
    _rNumInStateCtx.rState.bDigNum--;
    _rNumInStateCtx.bDig[_rNumInStateCtx.rState.bDigNum] = 0;
    _rNumInStateCtx.wNum = wDigToNum(_rNumInStateCtx.rState.bDigNum, _rNumInStateCtx.bDig);
    _rNumInStateCtx.rState.fgComplete = FALSE;
  }
  else /* other keys */
  {
    return (FALSE);
  }

  return (TRUE);
}

// *********************************************************************
// For number key sequence input, time limited
// *********************************************************************
BOOL fgKeySeqLimitNumInState(void) large
{
  BYTE bIdx, bTmp;
  
  if (_bIRKey <= IR_ADD10)
  {
#ifndef NO_ADD10_KEY
    if (_bIRKey == IR_ADD10)
    {
      return (TRUE); /* don't care +10 key */
    }
#endif
    _rNumInStateCtx.bDig[_rNumInStateCtx.rState.bDigNum] = _bIRKey;
    _rNumInStateCtx.rState.bDigNum++;
    _rNumInStateCtx.wNum = wDigToNum(_rNumInStateCtx.rState.bDigNum, _rNumInStateCtx.bDig);

    if (_rNumInStateCtx.rState.bDigNum == _rNumInStateCtx.rState.bTotalDigNum)
    {
      _rNumInStateCtx.rState.fgComplete = TRUE;
    }
  }
#ifndef NO_ADD5_KEY
  // megaa ADD5 begin
  else if (_bIRKey == IR_ADD5)
  {
    return (TRUE);  // don't care +5 key
  }
#endif
  // megaa ADD5 end
  else if ((_bIRKey == IR_CLEAR) && (_rNumInStateCtx.rState.bDigNum > 0))
  {
    _rNumInStateCtx.rState.bDigNum--;
    _rNumInStateCtx.bDig[_rNumInStateCtx.rState.bDigNum] = 0;
    _rNumInStateCtx.wNum = wDigToNum(_rNumInStateCtx.rState.bDigNum, _rNumInStateCtx.bDig);
    _rNumInStateCtx.rState.fgComplete = FALSE;
  }
  else if (((_bIRKey == IR_TIME_OUT) || (fgIsPlayEnterKey(_bIRKey))) &&
           (_rNumInStateCtx.rState.bDigNum > 0))
  {
    bTmp = _rNumInStateCtx.rState.bTotalDigNum - _rNumInStateCtx.rState.bDigNum;

    if (bTmp > 0)
    {
      for (bIdx = (_rNumInStateCtx.rState.bTotalDigNum - 1); bIdx > 0; bIdx--)
      {
        _rNumInStateCtx.bDig[bIdx] = _rNumInStateCtx.bDig[bIdx - bTmp];
      }
           
      for (bIdx = 0; bIdx < bTmp; bIdx++)
      {
        _rNumInStateCtx.bDig[bIdx] = 0;
      }

      _rNumInStateCtx.rState.bDigNum = _rNumInStateCtx.rState.bTotalDigNum;

      _rNumInStateCtx.wNum = wDigToNum(_rNumInStateCtx.rState.bDigNum, _rNumInStateCtx.bDig);
    }
    
    _rNumInStateCtx.rState.fgComplete = TRUE;
  }
  else /* other keys */
  {
    return (FALSE);
  }

  return (TRUE);
}

// *********************************************************************
// Number input state
// *********************************************************************
BOOL fgNumInState(void) large
{
  BOOL fgRet = TRUE;
  
  switch (_rNumInStateCtx.rState.bInputType)
  {
    case NUM_IN_TYPE_1:
    case NUM_IN_TYPE_4:
      fgRet = fgNumInState1();
      break;

    case NUM_IN_TYPE_2:
      fgRet = fgNumInState2();
      break;

    case NUM_IN_TYPE_3:
      fgRet = fgNumInState3();
      break;

    case NUM_IN_VCD_TIME:
      fgRet = fgVCDTimeSearchNumInState();
      break;

    case NUM_IN_DVD_TIME:
      fgRet = fgDVDTimeSearchNumInState();
      break;

    case NUM_IN_SEQ_WAIT:
      fgRet = fgKeySeqWaitNumInState();
      break;

    case NUM_IN_SEQ_LIMIT:
      fgRet = fgKeySeqLimitNumInState();
      break;

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

  return (fgRet);
}