bookmark.c

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

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 05/10/03 8:34p    $       ****************/
/***************  $Revision:: 9                $       ****************/
/***************                                       ****************/
/***************   Description : Bookmark function     ****************/
/***************                 module                ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#include "general.h"

#pragma NOAREGS

#ifdef PLAYER_BOOKMARK

#define BOOKMARK_ITEM_INVALID 0
#define BOOKMARK_ITEM_VALID   1

typedef struct structBookmark
{
  /* BYTE 1 */
  BYTE bCurItemNo:4;
  BYTE bCurItemState:2;
  BYTE bItemType:2;
  /* BYTE 2 */
  BYTE bNoMax; /* for error check */
} strucBookmark;

static xdata strucBookmark _rBookmarkState;

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
#define BOOKMARK_ITEM_CLEAR_ALL    0xff

void vBookmarkClearItem(BYTE bItem) large
{
  BYTE bIdx;

  if (bItem == BOOKMARK_ITEM_CLEAR_ALL)
  {
    for (bIdx = 0; bIdx < SV_BOOKMARK_ITEM_SIZE * BOOKMARK_NS; bIdx++)
    {
      vSetSharedInfo(SI_USR_BOOKMARK_ITEM_1 + bIdx, 0xff);
    }
  }
  else if (bItem < BOOKMARK_NS)
  {
    for (bIdx = 0; bIdx < SV_BOOKMARK_ITEM_SIZE; bIdx++)
    {
      vSetSharedInfo(SI_USR_BOOKMARK_ITEM_1 + bItem * SV_BOOKMARK_ITEM_SIZE + bIdx, 0xff);
    }
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vBookmarkReset(void) large
{
  _rBookmarkState.bItemType = SV_BOOKMARK_NONE_ITEM;

  vBookmarkClearItem(BOOKMARK_ITEM_CLEAR_ALL);
}

// *********************************************************************
// Function :
// Description : This will be called in this module and from digest!
// Parameter :
// Return    :
// *********************************************************************
BOOL fgIsBookmarkItemValid(BYTE bCurItem) large
{
  BYTE bTmp1, bTmp2, bCnt;
  BOOL fgRet = TRUE;

  if (bCurItem == BOOKMARK_ITEM_NO)
  {
    bCnt = BOOKMARK_NS;
    bCurItem = BOOKMARK_NS;
  }
  else if (bCurItem >= BOOKMARK_NS)
  {
    return (FALSE);
  }
  else
  {
    bCurItem++;
    bCnt = 1;
  }

  do {
    bCnt--;
    bCurItem--;

    bTmp1 = bSharedInfo(SI_USR_BOOKMARK_ITEM_1 + bCurItem * SV_BOOKMARK_ITEM_SIZE);

    if ((bTmp1 == 0xff) || (bTmp1 > _rBookmarkState.bNoMax))
    {
      fgRet = FALSE;
      continue;
    }

    if (_rBookmarkState.bItemType == SV_BOOKMARK_TT_CH_ITEM)
    {
      bTmp2 = bSharedInfo(SI_USR_BOOKMARK_ITEM_1 + bCurItem * SV_BOOKMARK_ITEM_SIZE + 1);
      if ((bTmp2 == 0) || (bTmp2 > bSharedInfo(SI_DVD_TT_CH + bTmp1 - 1)))
      {
        fgRet = FALSE;
        continue;
      }
    }

    fgRet = TRUE;
  } while ((bCnt > 0) && (fgRet == FALSE));

  return (fgRet);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vBookmarkShowList(void) large
{
  BYTE bIdx;

  for (bIdx = 0; bIdx < BOOKMARK_NS; bIdx++)
  {
    if (fgIsBookmarkItemValid(bIdx))
    {
      vOsdShowMarkItem(bIdx, OSD_MARK_ITEM_VALID);
    }
    else
    {
      vOsdShowMarkItem(bIdx, OSD_MARK_ITEM_INVALID);
    }
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
#define BOOKMARK_INFO_CLEAR 0xff

void vBookmarkShowInfo(BYTE bCurItem) large
{
  WORD wSi;

  if (bCurItem >= BOOKMARK_NS)
  {
    if (_rBookmarkState.bItemType == SV_BOOKMARK_TRACK_ITEM)
    {
      vOsdShowMarkTrack(OSD_MARK_INFO_CLEAR, 0, 0);
    }
    else if (_rBookmarkState.bItemType == SV_BOOKMARK_TT_CH_ITEM)
    {
      vOsdShowMarkTtCh(OSD_MARK_INFO_CLEAR, 0, 0, 0, 0);
    }
    return;
  }

  wSi = SI_USR_BOOKMARK_ITEM_1 + bCurItem * SV_BOOKMARK_ITEM_SIZE;

  if (_rBookmarkState.bItemType == SV_BOOKMARK_TRACK_ITEM)
  {
    vOsdShowMarkTrack(bSharedInfo(wSi + 0),  /* track */
                      bSharedInfo(wSi + 5),  /* min */
                      bSharedInfo(wSi + 6)); /* sec */
  }
  else if (_rBookmarkState.bItemType == SV_BOOKMARK_TT_CH_ITEM)
  {
    vOsdShowMarkTtCh(bSharedInfo(wSi + 0),  /* title */
                     bSharedInfo(wSi + 1),  /* chapter */
                     bSharedInfo(wSi + 4),  /* hour */
                     bSharedInfo(wSi + 5),  /* min */
                     bSharedInfo(wSi + 6)); /* sec */
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
#define BOOKMARK_MSG_CLEAR  0x00
#define BOOKMARK_MSG_MARK   0x01
#define BOOKMARK_MSG_PLAY   0x02

void vBookmarkShowMessage(BYTE bType) large
{
  vOsdPosClear(OSD_POS_MARK_MSG_1);
  vOsdPosClear(OSD_POS_MARK_MSG_2);

  if (bType == BOOKMARK_MSG_CLEAR)
  {
    return;
  }
  else if (bType == BOOKMARK_MSG_PLAY)
  {
    vOsdPosPaste(OSD_POS_MARK_MSG_1, OSD_MSG_PLAY_KEY_PLAY);
    vOsdPosPaste(OSD_POS_MARK_MSG_2, OSD_MSG_CLEAR_KEY_CLEAN);
  }
  else if (bType == BOOKMARK_MSG_MARK)
  {
    vOsdPosPaste(OSD_POS_MARK_MSG_1, OSD_MSG_PLAY_KEY_MARK);
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vBookmarkGotoItem(BYTE bItem) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

  if (bItem >= BOOKMARK_NS)
  {
    return;
  }

  _rBookmarkState.bCurItemNo = bItem;

  if (fgIsBookmarkItemValid(bItem))
  {
    _rBookmarkState.bCurItemState = BOOKMARK_ITEM_VALID;
    vOsdShowMarkItem(bItem, OSD_MARK_ITEM_VALID | OSD_MARK_ITEM_HILI);
    vBookmarkShowInfo(bItem);
    vBookmarkShowMessage(BOOKMARK_MSG_PLAY);
  }
  else
  {
    _rBookmarkState.bCurItemState = BOOKMARK_ITEM_INVALID;
    vOsdShowMarkItem(bItem, OSD_MARK_ITEM_INVALID | OSD_MARK_ITEM_HILI);
    vBookmarkShowInfo(BOOKMARK_INFO_CLEAR);
    if (fgIsDiscPlay(bPbcState)) /* only in play state could mark */
    {
      if (fgIsDvdPlay())
      {
        if (bSharedInfo(SI_DVD_DOM) == SV_VTSTT_DOM)
        {
          /* if is DVD, it must in the VTS domain */
          vBookmarkShowMessage(BOOKMARK_MSG_MARK);
        }
      }
      else
      {
        vBookmarkShowMessage(BOOKMARK_MSG_MARK);
      }
    }
    else // when disc is not playing
    {
      vBookmarkShowMessage(BOOKMARK_MSG_CLEAR);
    }
  }
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vBookmarkInit(BYTE fgInit) large
{
  /* chnage OSD mode to user mode */
  vOsdShowWb(OSD_WB_USER);

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

  if (fgIsDvdPlay())
  {
    _rBookmarkState.bItemType = SV_BOOKMARK_TT_CH_ITEM;
    _rBookmarkState.bNoMax = bSharedInfo(SI_TT_NS);
  }
#ifdef VCD_SUPPORT  
  else if (fgIsVcdPlay())
  {
    _rBookmarkState.bItemType = SV_BOOKMARK_TRACK_ITEM;
    _rBookmarkState.bNoMax = bSharedInfo(SI_TRACK_NS);
  }
#endif  
  else if (fgIsIsoPlay())
  {
    /* only support max 255 files */
    _rBookmarkState.bItemType = SV_BOOKMARK_TRACK_ITEM;
    if (bSharedInfo(SI_FILE_NS_HI))
    {
      _rBookmarkState.bNoMax = 255;
    }
    else
    {
      _rBookmarkState.bNoMax = bSharedInfo(SI_FILE_NS_LO);
    }

    vDisableWB(FSMENU_OSD_WBIDX_BASIC);
    vDisableWB(FSMENU_OSD_WBIDX_SEC);
  }
#ifndef CDDA_USE_CDFS    
  else if (fgIsCddaPlay())
  {
    _rBookmarkState.bItemType = SV_BOOKMARK_TRACK_ITEM;
    _rBookmarkState.bNoMax = bSharedInfo(SI_TT_NS);
  }
#endif  
  else
  {
    vSetExitInputState();
    return;
  }

  if (_rBookmarkState.bNoMax == 0)
  {
    _rBookmarkState.bItemType = SV_BOOKMARK_NONE_ITEM;
  }

#if (DRAM_SZ == DRAM_2M) || defined(USE_DRAM_CFG1)
  vOsdSetMemBlk(OSD_MEM_BLK_DYNAMIC, OSD_MEM_DEFAULT);
#endif
  
#ifdef ALL_WB_USE_TRUECOLOR
  vCreateWB(WB_MARK, TRUE);
  vSetWBTcColor(WB_MARK);
#else
  vCreateWB(WB_MARK, FALSE);
#endif
#ifdef FONT_NO_BORDER
  vSetMsgCol4(WB_MARK, 0, 1, 1, 3);
#else
  #ifdef HILI_USE_OSD
    vSetMsgCol4(WB_MARK, 0, 0, 2, 3);
  #else
    vSetMsgCol4(WB_MARK, 0, 1, 2, 3);
  #endif
#endif
  vEnableWB(WB_MARK);

  vDrawBorderWB(WB_MARK, 0);
  vOsdPosPaste(OSD_POS_MARK_LABEL, OSD_MSG_BOOKMARK);

  vBookmarkShowList();
  vBookmarkGotoItem(0);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vBookmarkExit(void) large
{
  vDeleteWB(WB_MARK);
  vOsdPosHili(OSD_POS_HILI_CLEAR, 0, 0);


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

  /* restore OSD mode */
  vOsdShowWb(OSD_WB_RESTORE);

  if (fgIsIsoPlay())
  {
#ifdef SUPPORT_DATA_DISC
  #ifdef PLAYER_FLMENU
    vFlRecover();
  #else
    vFsMenuRecoverMenus();
  #endif
#endif
  }
#if (DRAM_SZ == DRAM_2M)  || defined(USE_DRAM_CFG1)
  else if(bSharedInfo(SH_PAUSE_SHOW_WB))
  {
   while(bSharedInfo(SI_CMD_CNT) > 0xa)
    {
      //sometimes OSD command queue can't finish because of mechanism of "set audio DAC"
      //RISC will trap in set audio dac while loop
      
      
      //wait for OSD command finish
    }
    if(bSharedInfo(SH_BOOKMARK_PLAY))
    {
      vSetSharedInfo(SH_BOOKMARK_PLAY,0);
    }
    else
    {
      vSendUopCmd(UOP_PLAY, 0, 0, 0);
    }
    // 20050513, PL00000724, clear it when RISC notify play
    //vSetSharedInfo(SH_PAUSE_SHOW_WB,0);//init
  } 
#endif  
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
BOOL fgBookmarkState(void) large
{
  BOOL fgRet = TRUE;
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

  switch (_bIRKey)
  {
    case IR_UP:
      if (_rBookmarkState.bCurItemNo >= BOOKMARK_LINE_SIZE)
      {
        vBookmarkGotoItem(_rBookmarkState.bCurItemNo - BOOKMARK_LINE_SIZE);
      }
      break;

    case IR_LEFT:
      if (_rBookmarkState.bCurItemNo > 0)
      {
        vBookmarkGotoItem(_rBookmarkState.bCurItemNo - 1);
      }
      break;

    case IR_RIGHT:
      if (_rBookmarkState.bCurItemNo + 1 < BOOKMARK_NS)
      {
        vBookmarkGotoItem(_rBookmarkState.bCurItemNo + 1);
      }
      break;

    case IR_DOWN:
      if (_rBookmarkState.bCurItemNo + 6 < BOOKMARK_NS)
      {
        vBookmarkGotoItem(_rBookmarkState.bCurItemNo +6 );
      }
      break;

    case IR_ENTER:
    case IR_PLAY:
    case IR_PLAY_ENTER:
    case IR_PLAY_PAUSE:
    {
      /* mark the point or play the marked point */
      if (_rBookmarkState.bCurItemState == BOOKMARK_ITEM_VALID)
      {
        if (fgIsBookmarkItemValid(_rBookmarkState.bCurItemNo))
        {
          vSendUopCmd(UOP_BOOKMARK, SV_BOOKMARK_PLAY, _rBookmarkState.bCurItemNo, 0);
          vSetSharedInfo(SH_BOOKMARK_PLAY,1);          
          /* escape bookmark menu */
          vSetExitInputState();
        }
        else
        {
          /* error! */
          _rBookmarkState.bCurItemState = BOOKMARK_ITEM_INVALID;
        }
      }
      else if (_rBookmarkState.bCurItemState == BOOKMARK_ITEM_INVALID)
      {
        if (fgIsDiscPlay(bPbcState)) /* only in play state could mark */
        {
          vSendUopCmd(UOP_BOOKMARK, SV_BOOKMARK_MARK, _rBookmarkState.bCurItemNo, 0);
        }
        /* don't update the item state here */
      }
      break;
    }

    case IR_CLEAR:
    {
      if (_rBookmarkState.bCurItemState == BOOKMARK_ITEM_VALID)
      {
        _rBookmarkState.bCurItemState = BOOKMARK_ITEM_INVALID;
        vSendUopCmd(UOP_BOOKMARK, SV_BOOKMARK_CLEAR, _rBookmarkState.bCurItemNo, 0);
      }
      break;
    }

    case IR_MARK:
    {
      if(bSharedInfo(SI_CMD_CNT))
      {
        break;
      }	
      /* escape bookmark menu */
      vSetExitInputState();
      break;
    }

    default:
    {
      if (fgIsAVContrlKey(_bIRKey))
      {
        /* pass the A/V control key */
        fgRet = FALSE;
      }
      break;
    }
  } /* switch (_bIRKey) */

  return (fgRet);
}

// *********************************************************************
// Function :
// Description :
// Parameter :
// Return    :
// *********************************************************************
void vBookmarkUpdate(void) large
{
  if (fgIsInputStateValid(INPUT_STATE_BOOKMARK))
  {
    vBookmarkShowList();
    vBookmarkGotoItem(_rBookmarkState.bCurItemNo);
  }
}

#else /* PLAYER_BOOKMARK dummy function */

void vBookmarkInit(BYTE fgInit) large { return; }
BOOL fgBookmarkState(void) large { return (FALSE); }
void vBookmarkExit(void) large { return; }

void vBookmarkReset(void) large { return; }
void vBookmarkUpdate(void) large { return; }

  #ifdef PLAYER_DIGEST
BOOL fgIsBookmarkItemValid(BYTE bCurItem) large { return (FALSE); }
  #endif

#endif /* PLAYER_BOOKMARK */