play_pcd.c

MTK 1389E SOURCE CODE

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 05/12/02 3:16p    $       ****************/
/***************  $Revision:: 3                $       ****************/
/***************                                       ****************/
/***************   Description :                       ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#define _PLAY_PCD_C_

#pragma NOAREGS
#include "general.h"

#if defined (DDISC_FTYPE_JPEG_SUPPORT) && defined(SUPPORT_DATA_DISC) && defined (SUPPORT_PCD)

// *********************************************************************
// Function : BOOL fgPCDFsMenuShow(BOOL fgOnOff)
// Description :
// Parameter : None
// Return    : None
// *********************************************************************
void vPCDFsMenuShow(BYTE bMode) large
{
  switch (bMode)
  {
    case FS_MENU_SHOW_INIT:
    case FS_MENU_SHOW_ON:
      vFsMenuInit(TRUE);
      break;

    case FS_MENU_SHOW_REFRESH:
      vFsMenuInit(FALSE);
      break;

    case FS_MENU_SHOW_HIDE:
      /* not support yet! */
      break;

    default:
      break;
  }
}

// *********************************************************************
// Function : void vPCDInit(BYTE bType) large
// Description : PCD play module initial
// Parameter : None
// Return    : None
// *********************************************************************
void vPCDInit(BYTE bType) large
{
  /* vPCDFsMenuShow(FS_MENU_SHOW_INIT); */
 #ifdef SUPPORT_DRM
  if (fgIsInSetupMenu()||fgIsInDRMShow())
 #else
  if (fgIsInSetupMenu())
  #endif	
  {
    vPCDFsMenuShow(FS_MENU_SHOW_INIT);
    vOsdPosClear(OSD_POS_INIT);
  }
  else
  {
    vPCDFsMenuShow(FS_MENU_SHOW_ON);
  }
}

// *********************************************************************
// Function : void vPCDExit(void) large
// Description : PCD play module exit
// Parameter : None
// Return    : None
// *********************************************************************
void vPCDExit(void) large
{
  BYTE bValue;
  
  vFsMenuExit();

  /* make sure the WB is deleted */
  vDeleteWB(FSMENU_OSD_WBIDX_BASIC);
  vDeleteWB(FSMENU_OSD_WBIDX_SEC);

/*
  Restore SI_DEFAULT_LOGO by Bright_liu 2005/12/02, for CQ(PL00001431)
  I don't know why not to change the share info in stprisc.c -> bSetLogoType()
  Maybe the logo type changed in setup menu, so I restore the share info just like vISOExit()  
*/
  switch (bEepromReadByte(LOGO_TYPE_POSITION))
  {
    case EV_LOGO_JACKET:
      bValue = SV_LOGO_JACKET;
      break;

    case EV_LOGO_BLUE:
      bValue = SV_LOGO_COLOR;
      break;

    case EV_LOGO_CAPTURED:
      bValue = SV_LOGO_CAPTURE;
      break;

    case EV_LOGO_DEFAULT:
    default:
      bValue = SV_LOGO_FLASH;
      break;
  }
  vSetSharedInfo(SI_DEFAULT_LOGO, bValue);
}

// *********************************************************************
// JPEG zoom mode
// *********************************************************************
static code BYTE pbPcdZoomRatio[] = {
  50, 75, 100, 125, 150, 200
};

#define PCD_ZOOM_MAX    TBL_SIZE(pbPcdZoomRatio)

void vPCDZoomInit(BYTE fgInit) large
{
  /* tell RISC to turn on zoom mode */
  vSendUopCmd(UOP_ZOOM_IN, 0, 0, 0);
}

BOOL fgPCDZoomState(void) large
{
  BYTE bZoom = bSharedInfo(SI_ZOOM_SWITCH);
  BOOL fgRet = TRUE;
  BYTE bIdx;
  
  switch (_bIRKey)
  {
    case IR_FF: /* zoom in */
    {
      for (bIdx = 0; bIdx < PCD_ZOOM_MAX; bIdx++)
      {
        if (pbPcdZoomRatio[bIdx] > bZoom)
        {
          vSendUopCmd(UOP_ZOOM_IN, pbPcdZoomRatio[bIdx], 0, 0);
          break;
        }
      }
      
      if ((bIdx == PCD_ZOOM_MAX) && (bZoom != pbPcdZoomRatio[PCD_ZOOM_MAX - 1]))
      {
        vSendUopCmd(UOP_ZOOM_IN, pbPcdZoomRatio[PCD_ZOOM_MAX - 1], 0, 0);
      }
      break;
    } /* zoom in */

    case IR_FR: /* zoom out */
    {
      for (bIdx = PCD_ZOOM_MAX; bIdx > 0 ; bIdx--)
      {
        if (pbPcdZoomRatio[bIdx - 1] < bZoom)
        {
          vSendUopCmd(UOP_ZOOM_IN, pbPcdZoomRatio[bIdx - 1], 0, 0);
          break;
        }
      }

      if ((bIdx == 0) && (bZoom != pbPcdZoomRatio[0]))
      {
        vSendUopCmd(UOP_ZOOM_IN, pbPcdZoomRatio[0], 0, 0);
      }
      break;
    } /* zoom out */

    case IR_ZOOM_IN:
    case IR_ZOOM_OUT:
      /* escape zoom mode */
      vSetExitInputState();
      break;

    default:
      fgRet = FALSE;
      break;
  }
  
  return (fgRet);
}

void vPCDZoomExit(void) large
{
  BYTE bZoom = bSharedInfo(SI_ZOOM_SWITCH);
  BYTE bItemType = bSharedInfo(SI_ISO_ITEM_TYPE);

  if (fgIsPcdPlay() || (fgIsIsoPlay() && fgFlCheckStatus(FL_STATUS_IN_JPEG)))
  {
    if (bZoom != 0)
    {
      /* tell RISC to turn off zoom mode */
      if (fgIsHiPriorityKey(_bIRKey) == FALSE)
      {
        vSendUopCmd(UOP_ZOOM_IN, 0, 0, 0);
      }
    } /* bZoom != 0 */
  }

  // force clear OSD
  vOsdShowZoomPct(0);
}

/************************************************************************
     Function : void vOsdUpdate(void)
  Description : Update OSD/VFD
    Parameter : None
    Return    : None
************************************************************************/
BYTE bPCDHandleUopRet(BYTE bUopId, BYTE bUopRet) large
{
  BYTE bTmp;
  BYTE bRet = UOP_UPDATE;

#ifndef PLAYER_FLMENU   
  vFsMenuHandleUopRet(bUopId, bUopRet); //Mars,[2002/9/18],to handle uop return in jpg digest mode 
#endif

  if (bUopRet != SV_NO_ERROR)
  {
    return (UOP_FAIL); /* show error */
  }

  switch (bUopId)
  {
    case UOP_DIGITAL_BTN:
    case UOP_ARROW_BTN:
    {
      bRet = UOP_OK; /* no show error */
      break;
    }

    /* normal playback */
    case UOP_PLAY:
      vOsdShowPlayStatus(OSD_SHOW_PLAY, OSD_TIMEOUT_SHORT);
      break;

    /* case UOP_PAUSE: */
    /* case UOP_STOP: */
    case UOP_NEXT:
      vOsdShowPlayStatus(OSD_SHOW_NEXT_ITEM, OSD_TIMEOUT_SHORT);
      break;

    case UOP_PREVIOUS:
      vOsdShowPlayStatus(OSD_SHOW_PREV_ITEM, OSD_TIMEOUT_SHORT);
      break;

    case UOP_REPEAT:
    {
      //bTmp = bSharedInfo(SI_REPEAT_MODE);
      bTmp = bFlGetRepeatType();
      
      if (bUopRet == SV_NO_ERROR)
      {
        switch (bTmp)
        {
          case SV_REPEAT_ALL:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_REPEAT_ALL, OSD_TIMEOUT_SHORT);
            break;
              
          case SV_SINGLE: //Mars Wen,[2002/8/7]
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_MP3_SINGLE, OSD_TIMEOUT_SHORT);
            break;
        
          case SV_REPEAT_TRACK:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_REPEAT_ONE, OSD_TIMEOUT_SHORT);
            break;
        
          case SV_SHUFFLE:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_MP3_SHUFFLE, OSD_TIMEOUT_SHORT);
            break;
          
          case SV_RANDOM:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_MP3_RANDOM, OSD_TIMEOUT_SHORT);
            break;

          case SV_REPEAT_NONE:
          case SV_REPEAT_ABNONE:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_REPEAT_OFF, OSD_TIMEOUT_SHORT);
            break;

          default:
            break;
        } /* switch () */
        
        bRet = UOP_OK;
      }
      break;
    } /* UOP_REPEAT */

    /* trick mode control */
    /* case UOP_FORWARD: */
    /* case UOP_REVERSE: */
    /* case UOP_STEP: */
    /* case UOP_STEP_BACK: */
    /* case UOP_A_TO_B: */
    /* case UOP_FREEZE: */

    /* PBC control */
    /* case UOP_MENU_CALL: */
    /* case UOP_RETURN: */
    /* case UOP_CHANGE_ASTN: */
    /* case UOP_CHANGE_SPSTN: */
    /* case UOP_CHANGE_AGL: */
    /* case UOP_RESUME_PLAY: */
    /* case UOP_RESUME: */
    /* case UOP_DEFAULT: */
    /* case UOP_TOP: */
    /* case UOP_GOUP: */
    /* case UOP_STILL_OFF: */
    /* case UOP_MEMORY_PLAY: */

    /* non-PBC control */
    /* case UOP_PBC_SWITCH: */
    /* case UOP_DIGEST: */
    /* case UOP_PROGRAM: */
    case UOP_RANDOM:
    case UOP_SHUFFLE:
    {
      bTmp = bSharedInfo(SI_USR_PBC_CTRL);
      if (bUopRet == SV_NO_ERROR)
      {
        switch (bTmp)
        {
          case SV_SHUFFLE:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_MP3_SHUFFLE, OSD_TIMEOUT_SHORT);
            break;

          case SV_RANDOM:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_MP3_RANDOM, OSD_TIMEOUT_SHORT);
            break;            

          case SV_REPEAT_NONE:
          case SV_REPEAT_ABNONE:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_NORMAL_MODE, OSD_TIMEOUT_SHORT);
            break;

          default:
            break;
        }
        
        bRet = UOP_OK;
      }
      break;
    } /* UOP_SHUFFLE */

    /* case UOP_MEMORY: */
    /* case UOP_BOOKMARK: */

    /* item play */
    /* case UOP_TIME_PLAY: */
    /* case UOP_TITLE_PLAY: */
    /* case UOP_PTT_PLAY: */
    /* case UOP_TRACK_PLAY: */
    /* case UOP_MP3_PLAY: */
    /* case UOP_JPEG_PLAY: */

    default:
      break;
  }

  return (bRet);
}

BYTE fgPCDFFKey(void) large
{
  vSendUopCmd(UOP_FORWARD, 0, 0, 0);

  return (UOP_OK);
}

BYTE fgPCDFRKey(void) large
{

  vSendUopCmd(UOP_REVERSE, 0, 0, 0);

  return (UOP_OK);
}


BYTE fgPCDPauseKey(void) large
{
  if (bSharedInfo(SI_PBC_STATE) == SV_PAUSE)
  {
    vSendUopCmd(UOP_PLAY, 0, 0, 0);
  }
  else
  {
    vSendUopCmd(UOP_PAUSE, 0, 0, 0);
  }

  return (UOP_OK);
}

BYTE fgPCDDisplayKey(void) large
{
  /* show display info */
  vOsdShowError(SV_ERR_DISC_NOT_SUPPORT, OSD_TIMEOUT_SHORT);
  return (UOP_OK);
}

#if defined(PLAYER_FLMENU)
BYTE fgPCDRepeatKey(void) large
{
  BYTE bType = bFlNextRepeatType();

  if (bType == SV_SHUFFLE) {
    vSendUopCmd(UOP_SHUFFLE, SV_ON, 0x0, 0x0);
  }
  else if (bType == SV_RANDOM) {
    vSendUopCmd(UOP_RANDOM, SV_ON, 0x0, 0x0);
  }
  else {
    vSendUopCmd(UOP_REPEAT, bType, 0x0, 0x0);
  }
  
  return (UOP_OK);
}
#else
BYTE fgPCDRepeatKey(void) large
{
  return (UOP_OK);
}
#endif


BYTE fgPCDShuffleKey(void) large
{
  return (UOP_OK);
}

BYTE fgPCDZoomInKey(void) large
{
  vChangeInputState(INPUT_STATE_PCD_ZOOM, FALSE);

  return (UOP_OK);
}


#else   // #if (defined(DDISC_FTYPE_JPEG_SUPPORT) && defined(SUPPORT_DATA_DISC))

static code BYTE pbPcdZoomRatio[] = { 0 };

//void vPCDFsMenuShow(BYTE bMode) large
void vPCDInit(BYTE bType) large  
{ 
  BYTE bTmp = pbPcdZoomRatio[0];
} 
void vPCDExit(void) large  { }
void vPCDZoomInit(BYTE fgInit) large  { }
BOOL fgPCDZoomState(void) large  { return TRUE; }
void vPCDZoomExit(void) large  { }
BYTE bPCDHandleUopRet(BYTE bUopId, BYTE bUopRet) large
{
  return (UOP_OK);
}

#endif  // #if (defined(DDISC_FTYPE_JPEG_SUPPORT) && defined(SUPPORT_DATA_DISC))