flmain.c

MTK1389 SOURCE CODE

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 04/07/07 7:13p    $       ****************/
/***************  $Revision:: 11               $       ****************/
/***************                                       ****************/
/***************   Description : File List             ****************/
/***************                 Main Module           ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer : Jacob Lin             ****************/
/**********************************************************************/

/**
 *          $(PROJ_HOME)/8032/custom/demo/fslist/flmain.c
 *
 *          Bundle of the basic and common functions used to manipulate the 
 *          component "FILE BROWSER".
 */

#define __FLMAIN_C_ 
 
#include "../general.h"
#include "flcomm.h"
#include "fslist.h"
#include "flcmd.h"

#pragma NOAREGS

#ifdef PLAYER_FLMENU

typedef void (code *vRedrawFunc) (void) large;

// PRIVATE GLOBAL VARIABLES
//  on focus object

//xdata WORD _wCurrItem;
// EXTERNAL INERFACES

/**
 * Internal functions
 */

static BOOL fgFlOnInit(void);

/**
 * Init the menu and create the necessary component "FS LIST".
 */
void vFsMenuInit(BOOL fgInit) large
{
  if (fgInit)
  {
    // - totally init (init whole file browser module)
    vFlClRls();    

    //  1. init each object "file list menu, file list jpeg viewer, 
    //      and mpeg player"
    if (
       !fgFlMnInit() || !fgFlJvInit() 
#ifdef DDISC_FTYPE_MPG_SUPPORT    
       || !fgFlMpInit()
#endif       
       )
    {
      // - TODO: error handling
      return;
    }

    //  2. init shared info for configuration
    vSetSharedInfo(SI_DDISC_ACTIVE_PB_MODULE_MODE, SV_OFF);

     // 3. init control flags
    _bFlPbMode = bSharedInfo(SI_DDISC_DEF_PMODE);
    _bFlWaitUopRet = 0xFF;
    _bFlUopRetJob = 0xFF;
    _fgFlMdChg = FALSE;
      
    //  4. init the command target as "FL_CMD_TARGET_NONE" for init
    //      state
    _bFlCmdTarget = FL_CMD_TARGET_NONE;
  }
  else
  {
    // - partial init (init the module of current command target)
    switch (_bFlCmdTarget)
    {
      case FL_CMD_TARGET_MENU:
        #if 1//def JPG_INFO
        vOsdPosClear(OSD_POS_FS_INFO_BAR);
        #endif
        break;
      case FL_CMD_TARGET_JPEG:
        //vSendUopCmd(UOP_PAUSE, 0x01, 0x02, 0x00);
        break;
      case FL_CMD_TARGET_MPEG:
        break;
      case FL_CMD_TARGET_HELP:
        break;
    }
    vFlRecover();
  }

  return;
}

/**
 * Set the foregournd module as given one.
 *
 * DEF: The foregournd module means the module which the UOPs be dispatched.
 */
void vFlCtrlSetFg(BYTE bMd) large
{
  if (bSharedInfo(SI_DDISC_PB_MODULE) == bMd)
    return;

  vSetSharedInfo(SI_DDISC_PB_MODULE, bMd);
  vNotifySharedInfo(SI_DDISC_PB_MODULE, 0x0, 0x0);

  return;
}


/**
 * Set the current command target as the given one.
 *
 * DES:
 *  1. Leave the state object of the current target module.
 *  2. Enter the state object of the next one.
 */
void vFlCmdTargetLeave(BYTE bSrcTgt, BYTE bDesTgt) large
{
  switch(bSrcTgt)
  {
    case FL_CMD_TARGET_MENU:
      _wCurrItem = wFlMnLeave(FALSE);
      break;
    case FL_CMD_TARGET_JPEG:
      if (bDesTgt == FL_CMD_TARGET_HELP)
        _wCurrItem = wFlJvLeave(FALSE);
      else
        _wCurrItem = wFlJvLeave(TRUE);
      break;
#ifdef DDISC_FTYPE_MPG_SUPPORT      
    case FL_CMD_TARGET_MPEG:
      _wCurrItem = wFlMpLeave(FALSE);
      break;
#endif      
#ifdef JPEG_DDISC_DIGEST_ENABLE
    case FL_CMD_TARGET_HELP:
      _wCurrItem= wFlHpLeave(FALSE);
      break;
#endif      
    default:
      // - the current target is invalid or none
      _wCurrItem = 0x0;
      break;
  }
}

void vFlCmdTargetEnter(BYTE bTarget) large
{
  switch(bTarget)
  {
    case FL_CMD_TARGET_MENU:
      vFlMnEnter(_wCurrItem);
      break;
    case FL_CMD_TARGET_JPEG:
      vFlJvEnter(_wCurrItem);
      break;
#ifdef DDISC_FTYPE_MPG_SUPPORT      
    case FL_CMD_TARGET_MPEG:
      vFlMpEnter(_wCurrItem);
      break;
#endif      
#ifdef JPEG_DDISC_DIGEST_ENABLE
    case FL_CMD_TARGET_HELP:
      vFlHpEnter(_wCurrItem);
      break;
#endif      
    default:
      // - TODO: exception handling (thie case should not happen)
      break;
  }

  _wCurrItem = 0xFFFF;
}
 
void vFlSetCmdTarget(BYTE bTarget) large
{
//  WORD wItem;

  if (_bFlCmdTarget != bTarget)
  {
#ifdef WB_ALLOC_MIN
    if (bTarget == FL_CMD_TARGET_MENU)
      _fgFlMdChg = TRUE;
#endif
    // - we should switch the state object
    //  1. leave current
    vFlCmdTargetLeave(_bFlCmdTarget, bTarget);
    _bFlCmdTarget = bTarget;

    //  2. enter next    
    if (fgFlClIsLock())
    {
      switch (bFlClPath())
      {
        case FL_CMDPATH_SEL_1:
          vFlCmdTargetEnter(_bFlCmdTarget);
          fgSetPlayPostKey(IR_CMD_DONE);
          break;
      #ifdef ISO_AUTO_PLAY
        case FL_CMDPATH_INIT_1:
      #else
        case FL_CMDPATH_INIT_0:
      #endif
        case FL_CMDPATH_CHG_CMDTGT:
          vFlCmdTargetEnter(_bFlCmdTarget);
          break;
      }
    }
    else
    {
      vFlCmdTargetEnter(_bFlCmdTarget);
    }
    /*
    else if (_bFlWaitUopRet != UOP_STOP)
    {
      vFlCmdTargetEnter(_bFlCmdTarget);
    }
    */
  }
  else if (fgFlClIsLock())
  {
    switch (bFlClPath())
    {
      case FL_CMDPATH_SEL_1:
       _rFlCmdLock.fgLeap = TRUE;
       fgSetPlayPostKey(IR_CMD_DONE);
       break;
     }
  }

  return;
}

/**
 * Dispatch the event to the on focus object.
 */
BOOL fgFsMenuState(void) large
{
  BOOL fgIsGrabbed = FALSE;
  WORD wPos, wIdx;  // tmp
  

#if 0
  if (!fgFlCmdIsOK())
  {
    // - the command module is not ready for next one,
    //  waiting for command ack, and pass IR_CMD_DONE only
    if (_bIRKey != IR_CMD_DONE)
    {
      //vOsdShowError(SV_ERR_GENERAL, FL_MSG_TIMEOUT);
      return TRUE;
    }
  }
#endif
  // - main loop to relay message to each state machine
  #if 0
  if (bFlCmdRetOp() == FLCMD_RET_OP_SEL)
  {
    return fgFlOnMn();
  }
  #endif

  if (fgFlClIsLock())
  {
    switch(bFlClPath())
    {
      case FL_CMDPATH_SEL_0:
    #ifdef ISO_AUTO_PLAY
      case FL_CMDPATH_INIT_1:
    #else
      case FL_CMDPATH_INIT_0:
    #endif
        return fgFlOnMn();
        break;
      case FL_CMDPATH_SEL_1:
        if ((_bIRKey == IR_CMD_DONE) && 
            ((FL_ACK(_dwIrDoneParm) == SI_DDISC_PB_MODULE) || (_rFlCmdLock.fgLeap)))
        {
          vFlClNext();  // FL_CMDPATH_SEL_2:
          // tmp
          wPos = FL_ITEM_FIELD(_bFlMnCurItemIdx);
          bLoByte(wIdx) = bSharedInfo(wPos + 6);
          bHiByte(wIdx) = bSharedInfo(wPos + 7);
          vFlCmdClickItem(_bFlMnListId, wIdx);
          return TRUE;
        }
        break;
      case FL_CMDPATH_RPLC_CMDTGT:
      case FL_CMDPATH_CHG_CMDTGT:
        if ((_bIRKey == IR_CMD_DONE) && (FL_ACK(_dwIrDoneParm) == SI_DDISC_PB_MODULE))
        {
          vFlClRls();
        }
        break;
    }
  }

  switch (_bFlCmdTarget)
  {
  case FL_CMD_TARGET_MENU:
    fgIsGrabbed = fgFlOnMn();
    break;
  case FL_CMD_TARGET_JPEG:
    fgIsGrabbed = fgFlOnJv();
    break;
#ifdef DDISC_FTYPE_MPG_SUPPORT    
  case FL_CMD_TARGET_MPEG:
    fgIsGrabbed = fgFlOnMp();
    break;
#endif
#ifdef JPEG_DDISC_DIGEST_ENABLE
  case FL_CMD_TARGET_HELP:
    fgIsGrabbed = fgFlOnHp();
    break;
#endif    
  case FL_CMD_TARGET_NONE:
    // - init state
    fgIsGrabbed = fgFlOnInit();
    break;
  default:
    break;
  }
  
  return fgIsGrabbed;
}

// FOR COMPATIBLE (TMP)
void vFsMenuExit(void)
{
  vDeleteWB(FL_MENU_WB);
  vDeleteWB(FL_INFO_WB);
#ifdef JPEG_DDISC_DIGEST_ENABLE
  vDeleteWB(FL_DGTMN_WB);
#endif  

  vFlSetCmdTarget(FL_CMD_TARGET_NONE);
  
#if (DRAM_SZ == DRAM_2M)  
  vOsdSetMemBlk(OSD_MEM_BLK_STATIC);
#endif  

  return;
}

void vFlRecover(void) large
{
  switch (_bFlCmdTarget)
  {
    case FL_CMD_TARGET_MENU:
      vFlMnRecover();
      break;
    case FL_CMD_TARGET_JPEG:
      vFlJvRecover();
      break;
#ifdef DDISC_FTYPE_MPG_SUPPORT      
    case FL_CMD_TARGET_MPEG:
      vFlMpRecover();
      break;
#endif      
#ifdef JPEG_DDISC_DIGEST_ENABLE
    case FL_CMD_TARGET_HELP:
      vFlHpRecover(TRUE);
      break;
#endif      
  }
}

void vFlChgLang(BYTE bLang) large
{
  switch (_bFlCmdTarget)
  {
    case FL_CMD_TARGET_MENU:
      vFlMnChgLang(bLang);
      break;
#ifdef JPEG_DDISC_DIGEST_ENABLE      
    case FL_CMD_TARGET_JPEG:
      vFlJvChgLang(bLang);
      break;
    case FL_CMD_TARGET_HELP:
      vFlHpRecover(FALSE);
      break;
#endif      
  }
}

BOOL fgFlCheckStatus(BYTE bStatus) large
{
  if (!fgIsIsoPlay()
#ifdef SUPPORT_PCD
    && !fgIsPcdPlay()
#endif
    )
    return FALSE;

  switch (bStatus)
  {
    case FL_STATUS_BUSY:
      return ((bSharedInfo(SI_MP3_STT) == MP3STT_PB_STRT) ||
              (bSharedInfo(SI_JPG_STT) == JPEGSTT_DEC_STRT) ||
              (bSharedInfo(SI_MPIC_STT) == MPICSTT_PB_STRT));
    case FL_STATUS_OCCUPIED:
      return (fgFlClIsLock());
    case FL_STATUS_IN_MENU:
      return (_bFlCmdTarget == FL_CMD_TARGET_MENU);
    case FL_STATUS_IN_HELP:
      return (_bFlCmdTarget == FL_CMD_TARGET_HELP);
    case FL_STATUS_IN_JPEG:
      return (_bFlCmdTarget == FL_CMD_TARGET_JPEG);
    case FL_STATUS_IN_JPGDGST:
      return ((_bFlCmdTarget == FL_CMD_TARGET_JPEG) && 
              (bSharedInfo(SI_JPG_MODE) == JPEGMOD_DIGEST));
    case FL_STATUS_IN_MPEG:
      return (_bFlCmdTarget == FL_CMD_TARGET_MPEG);
    case FL_STATUS_JPEG_DECODING:
      return (bSharedInfo(SI_JPG_STT) == JPEGSTT_DEC_STRT);
  }
}
void vFlShowError(WORD wPos, WORD wMsg, BYTE bTime) large
{
#if 1//def JPG_INFO
  
  if (fgFlCheckStatus(FL_STATUS_IN_MENU))
  {
    vFlIpShowInfo(IP_INFO_ERROR, 0, wMsg);
  }
  else
  {
    vOsdPosShow(wPos, wMsg, bTime);
  }
#endif
  return;
}

#ifdef DATA_DISC_SUPPORT_PLAY_LIST
void vFlSendUopCmd(BYTE bCmd, BYTE bParam, BYTE bRetJob) large
{
  _bFlWaitUopRet = bCmd;
  _bFlUopRetJob = bRetJob;
  
  vSendUopCmd(bCmd, bParam, 0x0, 0x0);
}
#endif

void vFlHandleUopCheck() large
{
  if (fgFlClIsLock())
  {
    switch (bFlClPath())
    {
      case FL_CMDPATH_RPLC_CMDTGT:
        vFlCmdTargetEnter(_bFlCmdTarget);
        return;
    }
  }		
}	

//#ifndef NEW_PLAY
void vFlHandleUopRet(BYTE bUopId, BYTE bUopRet) large
{
  if (bUopRet != SV_NO_ERROR)
    return;
#if 0
  if (bUopId == UOP_STOP)
  {
    switch(_bFlUopRetJob)
    {
      case UOP_RET_CHG_CMDTGT:
        vFlCmdTargetEnter(_bFlCmdTarget);
        break;
      case UOP_RET_RPLC_CMDTGT:
    //vFlSetCmdTarget(FL_CMD_TARGET_MENU);
        break;
    }
    _bFlWaitUopRet = 0xFF;
  }
#endif

  if (fgFlClIsLock())
  {
    switch (bFlClPath())
    {
      case FL_CMDPATH_RPLC_CMDTGT:
        vFlCmdTargetEnter(_bFlCmdTarget);
        return;
    }
  }

  switch(_bFlCmdTarget)
  {
    case FL_CMD_TARGET_MENU:
      vFlMnHandleUopRet(bUopId);
      break;
    case FL_CMD_TARGET_JPEG:
      //vFlJvHandleUopRet(bUopId);
      break;
    case FL_CMD_TARGET_MPEG:
//      vFlMphandleUopRet(bUopId);
      break;
    case FL_CMD_TARGET_HELP:
      break;
  } 
}

#else  // #ifdef PLAYER_FLMENU

BOOL fgFsMenuState(void) large  { return TRUE; }

#endif  // #ifdef PLAYER_FLMENU