scan.c

MTK 1389E SOURCE CODE

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 05/10/03 6:20p    $       ****************/
/***************  $Revision:: 2                $       ****************/
/***************                                       ****************/
/***************   Description : Track scan            ****************/
/***************                 module                ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#include "general.h"

#ifdef PLAYER_SCAN

#pragma NOAREGS

#define SCAN_DEFAULT_SHOW_TIME    5
#define SCAN_DEFAULT_GAP          3

enum {
  SCAN_TYPE_NONE,
  SCAN_TYPE_GROUP,
  SCAN_TYPE_TRACK,
  SCAN_TYPE_TIME_GROUP,
  SCAN_TYPE_TIME_TRACK,
  SCAN_TYPE_MAX
};

typedef struct {
  WORD wMsg;
  BYTE bType;
} sScanType;

static code sScanType prDAScanType[] = {
  { OSD_MSG_SCAN_GROUP,    SCAN_TYPE_GROUP }, 
  { OSD_MSG_SCAN_TRACK,    SCAN_TYPE_TRACK },
  { OSD_MSG_SCAN_TIME_TTL, SCAN_TYPE_TIME_GROUP },
  { OSD_MSG_SCAN_TIME_PTT, SCAN_TYPE_TIME_TRACK }
};

typedef struct sScan
{
  /* BYTE 1 */
  BYTE bType;          /* scan type */
  /* BYTE 2 */
  BYTE bCurItem;       /* current item for input state */
  /* BYTE 3 */
  BYTE bSelNoMax;      /* selection number max, max 99, for menu */
  /* BYTE 4 */
  BYTE bTypeParm;      /* parameter for digest type */
} sScan;

static xdata sScan _rScan;


void vScanShowTypePage(void) large
{
  BYTE i;
  BYTE bDispIdx;
  BYTE bTypeValid;

  vOsdPosPaste(OSD_POS_DGST_TYPE_LINE_1, OSD_MSG_SCAN_SEL_TYPE);

  bDispIdx = 0;
  bTypeValid = 0;

  for (i = 0; i < TBL_SIZE(prDAScanType); i++)
  {
    if ((prDAScanType[i].bType == SCAN_TYPE_NONE) || (prDAScanType[i].bType >= SCAN_TYPE_MAX))
    {
      break;
    }

    vOsdPosPaste(OSD_POS_DGST_TYPE_LINE_1 + 1 + bDispIdx, prDAScanType[i].wMsg);
    bTypeValid |= (1 << i);
    bDispIdx++;
  }

  _rScan.bSelNoMax = bDispIdx;
  _rScan.bTypeParm = bTypeValid;
}

void vScanGotoTypeItem(BYTE bItem) large
{
  if (bItem >= _rScan.bSelNoMax)
  {
    return;
  }

  vOsdPosHili(OSD_POS_HILI_SHOW, OSD_POS_DGST_TYPE_LINE_1 + 1 + bItem, 0);

  _rScan.bCurItem = bItem;
}

BOOL fgScanTypeSelect(BYTE bType) large
{
  BYTE bDom = bSharedInfo(SI_DVD_DOM);
  BYTE bParm1 = 0;
  BYTE bParm2 = 0;
  BYTE bParm3 = SCAN_DEFAULT_SHOW_TIME;
  BOOL fgRet = TRUE;

  _rScan.bType = bType;

  switch (bType)
  {
    case SCAN_TYPE_GROUP:
      bParm1 = (SV_DGST_GROUP << 4);
      break;

    case SCAN_TYPE_TRACK:
      bParm1 = (SV_DGST_TRACK << 4);
      break;

    case SCAN_TYPE_TIME_GROUP:
      bParm1 = (SV_DGST_TIME_GRP << 4);
      bParm2 = SCAN_DEFAULT_GAP;
      break;

    case SCAN_TYPE_TIME_TRACK:
      bParm1 = (SV_DGST_TIME_TRK << 4);
      bParm2 = SCAN_DEFAULT_GAP;
      break;

    default:
      _rScan.bType = SCAN_TYPE_NONE;
      break;
  }

  if (fgRet == TRUE)
  {
    _rScan.bTypeParm = bParm2;

    if (_rScan.bType == SCAN_TYPE_NONE)
    {
      /* error condition! */
      vSetExitInputState();
    }
    else
    {
      vSendUopCmd(UOP_SCAN, bParm1, bParm2, bParm3);
    }
  }

  return (fgRet);
}


void vScanInit(BYTE fgInit) large
{
#ifndef HILI_USE_OSD
  vSetHLCol(HL_1, 0x0000); /* green */
#endif

  vOsdShowWb(OSD_WB_USER);

  _rScan.bType = SCAN_TYPE_NONE;

#ifdef ALL_WB_USE_TRUECOLOR
  vCreateWB(WB_DGST_TYPE, TRUE);
  vSetWBTcColor(WB_DGST_TYPE);
#else
  vCreateWB(WB_DGST_TYPE, FALSE);
#endif
  vEnableWB(WB_DGST_TYPE);

  vScanShowTypePage();
  
  if (_rScan.bSelNoMax > 0)
  {
    vOsdPosHili(OSD_POS_HILI_SHOW, OSD_POS_DGST_TYPE_LINE_1 + 1, 0);
    _rScan.bCurItem = 0;
  }
}

BOOL fgScanState(void) large
{
  BOOL fgRet = TRUE;
  BYTE i, bDispIdx, bTypeValid;

  switch (_bIRKey)
  {
    case IR_UP:
      if (_rScan.bCurItem > 0)
      {
        vScanGotoTypeItem(_rScan.bCurItem - 1);
      }
      break;

    case IR_DOWN:
      if (_rScan.bCurItem + 1 < _rScan.bSelNoMax)
      {
        vScanGotoTypeItem(_rScan.bCurItem + 1);
      }
      break;

    case IR_ENTER:
    case IR_PLAY:
    case IR_PLAY_ENTER:
    case IR_PLAY_PAUSE:
      if (bSharedInfo(SI_USR_PBC_CTRL) == SV_SCAN)
      {
        vSendUopCmd(UOP_SCAN, 0, 0, 0);
        break;
      }
      bDispIdx = 0;
      bTypeValid = _rScan.bTypeParm;

      for (i = 0; i < TBL_SIZE(prDAScanType); i++)
      {
        if (bTypeValid & (1 << i))
        {
          bDispIdx++;
          if (bDispIdx == (_rScan.bCurItem + 1))
          {
            break;
          }
        }
      }

      if ((bDispIdx > 0) && (bDispIdx <= _rScan.bSelNoMax))
      {
        /* send UOP command first */
        if (fgScanTypeSelect(prDAScanType[i].bType) == TRUE)
        {
          vScanExit();
          break;
        }
      }

      /* range check invalid, force escape input state */
      vSetExitInputState();
      break;

    case IR_DIGEST:
      if (bSharedInfo(SI_USR_PBC_CTRL) == SV_SCAN)
      {
        vSendUopCmd(UOP_SCAN, 0, 0, 0);
      }
      else
      {
        vSetExitInputState();
      }
      break;

    default:
      fgRet = FALSE;
      break;
  } /* switch (_bIRKey) */

  return (fgRet);
}

void vScanExit(void) large
{
  vDeleteWB(WB_DGST_TYPE);
  vOsdShowWb(OSD_WB_RESTORE);
}

#else  // #ifdef PLAYER_SCAN

static code BYTE pbDAScanCodeSegment[1] = { FALSE };

void vScanInit(BYTE fgInit) large { return; }

BOOL fgScanState(void) large { return (pbDAScanCodeSegment[0]); }
void vScanExit(void) large { return; }

#endif  // #ifdef PLAYER_SCAN