play_iso.c

mtk1389L latest sourcecode enjoy

  if ((bSharedInfo(SI_PBC_STATE) != SV_PLAY) ||
      (bTmp2 == 0) || (bTmp1 >= bTmp2))
  {
    return (UOP_FAIL);
  }

  // Fix the bug that after playing MPEG files in data disc, 
  // playing JPEG would make the channel OSD message appearring, which is not allowed.
  // by Alfonso, 2005-1208
  if (fgFlCheckStatus(FL_STATUS_IN_MPEG))
  {
	  if(bTmp2 == 1)
	  {
		  vOsdShowAudio(OSD_AUDIO_NORMAL + OSD_TIMEOUT, 1, 1,
                  bSharedInfo(SI_A_CH_CFG), bSharedInfo(SI_A_CODE_MODE),
                  bSharedInfo(SI_A_LCD_0), bSharedInfo(SI_A_LCD_1));
		  return(UOP_OK);
	  }
  }

  bTmp1++;
  if (bTmp1 >= bTmp2)
  {
    bTmp1 = 0;
  }
  vSendUopCmd(UOP_CHANGE_ASTN, bTmp1, 0, 0);

  return (UOP_OK);
}

BYTE fgISOAngleKey(void) large
{
  BYTE bAglNs = bSharedInfo(SI_AGL_NS);
  BYTE bAglNo = bSharedInfo(SI_AGL_NO);

  if ((bSharedInfo(SI_PBC_STATE) != SV_PLAY) ||
      (bAglNs <= 1) || (bAglNs > 9) || (bAglNo > bAglNs))
  {
    return (UOP_FAIL);
  }

  if (bAglNo >= bAglNs)
  {
    bAglNo = 1;
  }
  else
  {
    bAglNo++;
  }
  vSendUopCmd(UOP_CHANGE_AGL, bAglNo, 0, 0);

  return (UOP_OK);
}

BYTE fgISONumKey(void) large
{
  /* Check if the number selection is valid is done by FSMENU */
  vChangeInputState(INPUT_STATE_FILE_SELECT, TRUE);

  return (UOP_OK);
}

#include "..\fslist\flcomm.h"
BYTE fgISODirKey(void) large
{
  BYTE bParm;

  switch(_bIRKey)
  {
    case IR_UP:
      bParm = SV_UP;
      break;
    case IR_DOWN:
      bParm = SV_DOWN;
      break;
    case IR_LEFT:
      bParm = SV_LEFT;
      break;
    case IR_RIGHT:
      bParm = SV_RIGHT;
      break;
    case IR_ENTER:
      bParm = SV_ACTIVATE;
      break;
    default:
      return (UOP_FAIL);
  }

  vSendUopCmd(UOP_ARROW_BTN, bParm, 0, 0);

/**
  Add it by Bright_liu 2006/01/04, for CQ(PL00205078),
  When play PCD, press IR_PAUSE, then press the IR_LEFT/IR_RIGHT/IR_UP/IR_DOWN, 
  then let it play automatic, press the IR_PAUSE, it will show ERROR first.
**/
  if(fgIsPcdPlay() || fgFlCheckStatus(FL_STATUS_IN_JPEG))
  {
    _bFlVdoPbcStt = SV_PLAY;
  }

  return (UOP_OK);
}

// *********************************************************************
// Key map function
// *********************************************************************
BYTE fgISOPlayKey(void) large
{
  vSendUopCmd(UOP_PLAY, 0, 0, 0);

  return (UOP_OK);
}

BYTE fgISOPauseKey(void) large
{
#ifdef PLAYER_FLMENU
  BYTE bPbcState = bFlGetFgPbcState();
#else
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
#endif

  if (!fgIsDiscPlay(bPbcState))
  {
    vOsdShowError(SV_ERR_PLAYBACK_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }

  if (fgIsInputStateValid(INPUT_STATE_PCD_ZOOM))
  {
    vOsdShowError(OSD_MSG_ERR_INPUT_INVALID, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }  
  //if (bSharedInfo(SI_PBC_STATE) == SV_PAUSE)
  if (bPbcState == SV_PAUSE)
  {
    vSendUopCmd(UOP_PLAY, 0, 0, 0);
  }
  else
  {
    vSendUopCmd(UOP_PAUSE, 0, 0, 0);
  }

  return (UOP_OK);
}

BYTE fgISOStopKey(void) large
{
  if (fgFlCheckStatus(FL_STATUS_IN_MPEG) && (fgIsInDivX6Menu(bSharedInfo(SI_DVD_DOM))))
  {
    vSendUopCmd(UOP_STOP, 0, 0, SV_STOP_FORCE);
  }
  else if(bSharedInfo(SI_PBC_STATE) != SV_STOP) // Add the condition by Bright_liu 2005.11.17, for CQ(PL00205138)
  {
    vSendUopCmd(UOP_STOP, 0, 0, SV_STOP_NORMAL);
  }
  
  return (UOP_OK);
}

BYTE fgISONextKey(void) large
{
  vSendUopCmd(UOP_NEXT, 0, 0, 0);

  return (UOP_OK);
}

BYTE fgISOPrevKey(void) large
{
  vSendUopCmd(UOP_PREVIOUS, 0, 0, 0);

  return (UOP_OK);
}

BYTE fgISOA2BKey(void) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

/*
  Change by Bright_liu 2005/10/20/, for CQ(PL00205063)
  In PCD/JPG digest mode, press Slow, it should display error icon only.
*/
  if (!fgIsDiscPlay(bPbcState))
  {
    vOsdShowError(SV_ERR_GENERAL, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }

  vSendUopCmd(UOP_A_TO_B, 0, 0, 0);

  return (UOP_OK);
}

BYTE fgISOResumeKey(void) large
{
  vSendUopCmd(UOP_RESUME, 0, 0, 0);

  return (UOP_OK);
}

BYTE fgISOMarkKey(void) large
{
  // 20050328, IS00001944, show prohibit for non-supported keys
  return (UOP_FAIL);
//  return (UOP_OK);
}

BYTE fgISODigestKey(void) large
{
//alfonso
#ifdef MPS_DIGEST
  {
    // The playing is a mps file, hence we enter digest state machine.
    if (bSharedInfo(SI_DDISC_PB_MODULE) == SV_DDISC_MODULE_MPG)
    {
      vChangeInputState(INPUT_STATE_DIGEST, FALSE);
    }
    return (UOP_OK);
  }
#else /* MPS_DIGEST */

  // 20050328, IS00001944, show prohibit for non-supported keys
  return (UOP_FAIL);
//  return (UOP_OK);
#endif /* MPS_DIGEST */
}

#ifdef SIMPLE_ZOOM_MODE

#define ISO_ZOOM_USED_MODE   6

static code BYTE pbIsoZoomMode[ISO_ZOOM_USED_MODE] = {
  SV_ZOOM_2,
  SV_ZOOM_3,
  SV_ZOOM_4,
  SV_ZOOM_21,
  SV_ZOOM_31,
  SV_ZOOM_41
};

#endif /* SIMPLE_ZOOM_MODE */

BYTE fgISOZoomInKey(void) large
{
  BYTE bZoom;
#ifdef SIMPLE_ZOOM_MODE
  BYTE bIdx;
#endif
#ifdef ZOOM_NO_SLOW_STEP
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
#endif

  if (fgFlCheckStatus(FL_STATUS_IN_MENU))
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
  else if (fgFlCheckStatus(FL_STATUS_IN_JPEG))
  {
    vChangeInputState(INPUT_STATE_PCD_ZOOM, FALSE);
    return (UOP_OK);
  }
#ifdef ZOOM_NO_SLOW_STEP
  else if (fgFlCheckStatus(FL_STATUS_IN_MPEG))
  {
    if ((bPbcState == SV_SF) || (bPbcState == SV_SR) ||
        (bPbcState == SV_STEP) || (bPbcState == SV_STEP_BACK))
    {
      vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
      return (UOP_OK);
    }
  }
#endif

  bZoom = bSharedInfo(SI_ZOOM_SWITCH);

#ifdef ENABLE_ZOOM_USER_MODE
  if (bZoom == SV_ZOOM_USR)
  {
    vSendUopCmd(UOP_ZOOM_IN, SV_ZOOM_OFF, 0, 0);
    return (UOP_OK);
  }
#endif

  // get next zoom mode
#ifdef SIMPLE_ZOOM_MODE
  for (bIdx = 0; bIdx < ISO_ZOOM_USED_MODE; bIdx++)
  {
    if (pbIsoZoomMode[bIdx] > bZoom)
    {
      bZoom = pbIsoZoomMode[bIdx];
      break;
    }
  }
  
  if (bIdx == ISO_ZOOM_USED_MODE)
  {
    bZoom = SV_ZOOM_IN_MAX + 1;
  }
#else
  bZoom += 1;
#endif

  if (bZoom > SV_ZOOM_IN_MAX)
  {
#ifdef ZOOM_IN_OUT_SAME_KEY
    fgSetPlayPostKey(IR_ZOOM_OUT);
    return(UOP_OK);
#else
    bZoom = SV_ZOOM_OFF;
#endif
  }
  else if (bZoom < SV_ZOOM_IN_MIN)
  {
    bZoom = SV_ZOOM_IN_MIN;
  }

  vSendUopCmd(UOP_ZOOM_IN, bZoom, 0, 0);

  return (UOP_OK);
}

BYTE fgISOZoomOutKey(void) large
{
  BYTE bItemType = bSharedInfo(SI_ISO_ITEM_TYPE);
  BYTE bZoom;
#ifdef SIMPLE_ZOOM_MODE
  BYTE bIdx;
#endif
#ifdef ZOOM_NO_SLOW_STEP
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
#endif

  if (fgIsIsoItemAOnly(bItemType))
  {
    vOsdShowError(SV_ERR_DISC_NOT_SUPPORT, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
  else if (bItemType == SV_ISO_JPG)
  {
    vChangeInputState(INPUT_STATE_PCD_ZOOM, FALSE);
    return (UOP_OK);
  }
#ifdef ZOOM_NO_SLOW_STEP
  else if (fgIsIsoItemAV(bItemType))
  {
    if ((bPbcState == SV_SF) || (bPbcState == SV_SR) ||
        (bPbcState == SV_STEP) || (bPbcState == SV_STEP_BACK))
    {
      vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
      return (UOP_OK);
    }
  }
#endif

  bZoom = bSharedInfo(SI_ZOOM_SWITCH);

#ifdef ENABLE_ZOOM_USER_MODE
  if (bZoom == SV_ZOOM_USR)
  {
    vSendUopCmd(UOP_ZOOM_IN, SV_ZOOM_OFF, 0, 0);
    return (UOP_OK);
  }
#endif

  // get next zoom mode
#ifdef SIMPLE_ZOOM_MODE
  for (bIdx = 0; bIdx < ISO_ZOOM_USED_MODE; bIdx++)
  {
    if (pbIsoZoomMode[bIdx] > bZoom)
    {
      bZoom = pbIsoZoomMode[bIdx];
      break;
    }
  }
  
  if (bIdx == ISO_ZOOM_USED_MODE)
  {
    bZoom = SV_ZOOM_OUT_MAX + 1;
  }
#else
  bZoom += 1;
#endif

  if (bZoom > SV_ZOOM_OUT_MAX)
  {
    bZoom = SV_ZOOM_OFF;
  }
  else if (bZoom < SV_ZOOM_OUT_MIN)
  {
    bZoom = SV_ZOOM_OUT_MIN;
  }

  vSendUopCmd(UOP_ZOOM_IN, bZoom, 0, 0);

  return (UOP_OK);
}

#ifdef ENABLE_ZOOM_USER_MODE
BYTE fgISOZoomUsrKey(void) large
{
  BYTE bItemType = bSharedInfo(SI_ISO_ITEM_TYPE);
#ifdef ZOOM_NO_SLOW_STEP
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
#endif

  if (fgIsIsoItemAV(bItemType))
  {
#ifdef ZOOM_NO_SLOW_STEP
    if ((bPbcState == SV_SF) || (bPbcState == SV_SR) ||
        (bPbcState == SV_STEP) || (bPbcState == SV_STEP_BACK))
    {
      vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
      return (UOP_OK);
    }
#endif
  }
  else
  {
    // not supportted
    return (UOP_OK);
  }

  if (bSharedInfo(SI_ZOOM_SWITCH) != SV_ZOOM_USR)
  {
    vSendUopCmd(UOP_ZOOM_IN, SV_ZOOM_USR, ZOOM_USR_H_BASE, ZOOM_USR_V_BASE);
  }
  else
  {
    vSendUopCmd(UOP_ZOOM_IN, SV_ZOOM_OFF, 0, 0);
  }

  return (UOP_OK);
}
#endif /* ENABLE_ZOOM_USER_MODE */

BYTE fgISOSpKey(void) large
{
  BYTE bTmp1 = bSharedInfo(SI_SPST_NO);
  BYTE bTmp2 = bSharedInfo(SI_SPST_NS);


  if (!fgFlCheckStatus(FL_STATUS_IN_MPEG))
  // 20050328, IS00001944, show prohibit for non-supported keys
    return (UOP_FAIL);
//    return (UOP_OK);

  if ((bTmp1 & (~0x41)) == 0x3e) // include 0x3e, 0x3f, 0x7e, 0x7f
  {
    /* take dummy stream as subtitle disabled */
    bTmp1 = 0x00;
  }

  if ((bSharedInfo(SI_PBC_STATE) != SV_PLAY) ||
      (bTmp2 > 32) || (bTmp2 == 0) || ((bTmp1 & 0x1f) >= bTmp2))
  {
    return UOP_FAIL;
  }

  if (bTmp1 & 0x40)
  {
    if ((bTmp1 & 0x1f) >= bTmp2 - 1)
    {
      /* turn off sub-picture */
      bTmp1 = 0x00;
    }
    else
    {
      /* next sp */
      bTmp1 = ((bTmp1 & 0x1f) + 1) | 0x40;
    }
  }
  else
  {
    bTmp1 = 0x40; /* first stream is 0 */
  }

  vSendUopCmd(UOP_CHANGE_SPSTN, bTmp1, 0, 0);
  
  return (UOP_OK);
}


#else  // #ifdef SUPPORT_DATA_DISC

#ifdef SIMPLE_ZOOM_MODE
  static code BYTE pbIsoZoomMode[] = { 0 };
#endif

void vISOInit(BYTE bType) large 
{ 
  BYTE bTmp = pbIsoZoomMode[0];
}

void vISOExit(void) large { }
void vISOFsMenuShow(BYTE bMode) large { }
void vISOFSMenuFilterInit(BYTE fgInit) large  { }
BOOL fgISOFSMenuFilterState(void) large  {  return (FALSE);  }
void vISOFSMenuFilterExit(void) large  { }
void vISOFileSelectInit(BYTE fgInit) large  { }
BOOL fgISOFileSelectState(void) large  { return (TRUE);  }
void vISOTimeSearchInit(BYTE fgInit) large  { }
BOOL fgISOTimeSearchState(void) large  { return (TRUE);  }
void vISOTimeSearchExit(void) large  { }

BYTE bISOHandleUopRet(BYTE bUopId, BYTE bUopRet) large
{ 
  return (UOP_OK);
}

#endif   // #ifdef SUPPORT_DATA_DISC