play_vcd.c

MTK1389 SOURCE CODE

          vOsdPosShow(OSD_POS_PBC_2, OSD_MSG_PBC_ON, OSD_TIMEOUT_SHORT);
        }
        else
        {
          vOsdPosShow(OSD_POS_PBC_2, OSD_MSG_PBC_OFF, OSD_TIMEOUT_SHORT);
        }

        VfdShowPbcSwitch(bTmp1 == SV_PBC_ON);

        /* note no need to update VFD in combine.c */
        //bRet = UOP_OK;
      }
      break;
    } /* UOP_PBC_SWITCH */

#ifdef PLAYER_DIGEST
    case UOP_DIGEST:
    {
      if (fgIsInputStateValid(INPUT_STATE_DIGEST))
      {
        if (bUopRet == SV_NO_ERROR)
        {
          fgSetPlayPostKey(IR_DONE);
        }
        else /* error occur */
        {
          fgSetPlayPostKey(IR_TIME_OUT);
        }
      }
      break;
    }
#endif    

    /* case UOP_PROGRAM: */
    /* case UOP_RANDOM: */
    case UOP_SHUFFLE:
      if (bUopRet == SV_NO_ERROR)
      {
        bTmp1 = bSharedInfo(SI_USR_AUX_CTRL);
        bTmp2 = bSharedInfo(SI_REPEAT_MODE);

        if (fgISUsrSeqPlay(bTmp1) && fgISUsrSeqPlay(bTmp2))
        {
          break;
        }

        if (bSharedInfo(SI_USR_PBC_CTRL) == SV_SHUFFLE)
        {
          vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_SHUFFLE_ON, OSD_TIMEOUT_SHORT);
        }
        else
        {
          vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_SHUFFLE_OFF, OSD_TIMEOUT_SHORT);
        }
      }
      break;

    /* case UOP_MEMORY: */
    #ifdef PLAYER_BOOKMARK
    case UOP_BOOKMARK:
      if (bUopRet == SV_NO_ERROR)
      {
        vBookmarkUpdate();
      }
      break;
    #endif

    /* item play */
    /* case UOP_TIME_PLAY: */
    /* case UOP_TITLE_PLAY: */
    /* case UOP_PTT_PLAY: */
    case UOP_TRACK_PLAY:
      if (!fgIsInGoto())  // megaa Goto
      {
        if (bUopRet == SV_NO_ERROR)
        {
          vOsdDisplayChange(DISP_PLAY_INFO, 0);
        }
        else
        {
          vOsdDisplayChange(DISP_PLAY_INFO, PLAY_INFO_CLEAR);
        }
      }
      break;

    /* case UOP_MP3_PLAY: */
    /* case UOP_JPEG_PLAY: */

    default:
      break;
  }

  return (bRet);
}
#endif /*#ifndef NEW_PLAY */

BOOL fgVCDRemainKey(void) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bType = bCurrRemainType();

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

#ifdef DISPLAY_SHOW_INFO_FIRST
  vChangeInputState(INPUT_STATE_VCD_DISPLAY, FALSE);
#else
  /* Todo: for VCD PBC on, only SINGLE REMAIN/ELAPSED */
  /* for PBC off, all 4 mode is valid */

  bType++;

  bType = bVcdCheckRemainShow(TRUE, bType); /* check only */

  if (bType > OSD_SHOW_VCD_REMAIN_MAX)
  {
    bType = OSD_SHOW_DISABLE;
  }

  if (bType != bCurrRemainType())
  {
    vOsdDisplayChange(DISP_REMAIN_CHG, bType);
  }

  // To show some other information
  /* VcdShowInfo(); */
#endif

  return (UOP_OK);
}

BOOL fgVCDSearchKey(BOOL fgGoto) large
{
  BYTE bMode = bSharedInfo(SI_USR_PBC_CTRL);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bTrkNo = bSharedInfo(SI_TRACK_NO);

  if (fgIsUsrCtrlMode(bMode))
  {
    vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }

#ifdef PLAYER_GOTO
  if ((bPbcState != SV_STOP) && (bPbcState != SV_STOP_RESUME) && fgGoto)
  {
    #ifdef GOTO_IN_TRACK_ONLY
    if (bTrkNo != 0)
    #endif
    {
      vChangeInputState(INPUT_STATE_GOTO, FALSE);
    }
    #ifdef GOTO_IN_TRACK_ONLY
    else
    {
      vOsdShowError(SV_ERR_GENERAL, OSD_TIMEOUT_SHORT);
    }
    #endif

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

  /*
  if ((bSharedInfo(SI_PBC_SWITCH) == SV_PBC_ON) &&
      (bSharedInfo(SI_VCD_DOM) == SV_SELECT_LIST))
  */
  if (bSharedInfo(SI_TRACK_NO) == 0)
  {
    /* in PBC menu, show number select */
    vChangeInputState(INPUT_STATE_SELECT_NUM, FALSE);
  }
  else /* not in PBC menu */
  {
    if (_rSearchStateCtx.bType == SEARCH_VCD_TIME_DISC)
    {
      if (fgIsDiscPlay(bPbcState) || (bPbcState == SV_STOP_RESUME))
      {
      _rSearchStateCtx.bType = SEARCH_VCD_TIME_TRACK;
      vChangeInputState(INPUT_STATE_VCD_TIME_SEARCH, FALSE);
    }
      else
      {
        _rSearchStateCtx.bType = SEARCH_VCD_TRACK;
        vChangeInputState(INPUT_STATE_VCD_TRACK_SEARCH, FALSE);
      }
    }
    else if (_rSearchStateCtx.bType == SEARCH_VCD_TIME_TRACK)
    {
      _rSearchStateCtx.bType = SEARCH_VCD_TRACK;
      vChangeInputState(INPUT_STATE_VCD_TRACK_SEARCH, FALSE);
    }
    else /* after track select and default is disc time search */
    {
      _rSearchStateCtx.bType = SEARCH_VCD_TIME_DISC;
      vChangeInputState(INPUT_STATE_VCD_TIME_SEARCH, FALSE);
    }
  }

  return (UOP_OK);
}

static BYTE bVCDGetRepeatType(BYTE bType)
{
  switch (bType)
  {
    case SV_REPEAT_TRACK:
      return (SV_REPEAT_ALL);

    case SV_REPEAT_ALL:
      return (SV_REPEAT_NONE);

    case SV_REPEAT_NONE:
      return (SV_REPEAT_TRACK);

    default:
      return (0xff);
  }
}

BOOL fgVCDRepeatKey(void) large
{
  BYTE bUsrCtrl = bSharedInfo(SI_USR_PBC_CTRL);
  BYTE bRepeatType;
  BYTE bPbcState = bSharedInfo(SI_PBC_SWITCH);

  if (bPbcState == SV_PBC_ON)
  {
    vOsdShowError(SV_ERR_PBC_OFF_ONLY, OSD_TIMEOUT_SHORT);
  }
  else /* SV_PBC_OFF */
  {
    if (0
#ifdef PROGRAM_NO_REPEAT
        || (bUsrCtrl == SV_PROGRAM)
#endif
#ifdef RANDOM_SHUFFLE_NO_REPEAT
        || (bUsrCtrl == SV_RANDOM) || (bUsrCtrl == SV_SHUFFLE)
#endif
      )
    {
      vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
      return (UOP_OK);
    }

    bRepeatType = bVCDGetRepeatType(bSharedInfo(SI_REPEAT_MODE));

    if (bRepeatType == 0xff)
    {
      bRepeatType = bVCDGetRepeatType(bSharedInfo(SI_USR_PBC_CTRL));
    }

    if (bRepeatType == 0xff)
    {
      bRepeatType = SV_REPEAT_TRACK;
    }

    vSendUopCmd(UOP_REPEAT, bRepeatType, 0, 0);
  } /* SV_PBC_OFF */

  return (UOP_OK);
}


BOOL fgVCDFFKey(void) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bPbcSpeed = bSharedInfo(SI_PBC_SPEED);

#ifdef VCD_TRACK0_NO_FF_FR
  if (bSharedInfo(SI_TRACK_NO) == 0)
  {
    return (UOP_OK);
  }
#endif

  if (!fgIsDiscPlay(bPbcState))
  {
    vOsdShowError(SV_ERR_PLAYBACK_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#ifdef PAUSE_NO_TRICK
  else if (bPbcState == SV_PAUSE)
  {
    vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#endif

  if (bPbcState == SV_FF)
  {
    if (bPbcSpeed < VCD_FAST_MAX - 1) /* VCD */
    {
      bPbcSpeed++;
    }
    else
    {
#ifdef TRICK_MODE_USE_PLAY
      vSendUopCmd(UOP_PLAY, 0, 0, 0);
      return (UOP_OK);
#else
      bPbcSpeed = 0;
#endif
    }
  }
  else
  {
    bPbcSpeed = SV_TWO;
  }

  vSendUopCmd(UOP_FORWARD, SV_FAST, bPbcSpeed, pbVCDFastSpeedTbl[bPbcSpeed]);

  return (UOP_OK);
}

BOOL fgVCDFRKey(void) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bPbcSpeed = bSharedInfo(SI_PBC_SPEED);

#ifdef VCD_TRACK0_NO_FF_FR
  if (bSharedInfo(SI_TRACK_NO) == 0)
  {
    return (UOP_OK);
  }
#endif

  if (!fgIsDiscPlay(bPbcState))
  {
    vOsdShowError(SV_ERR_PLAYBACK_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#ifdef PAUSE_NO_TRICK
  else if (bPbcState == SV_PAUSE)
  {
    vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#endif

  if (bPbcState == SV_FR)
  {
    if (bPbcSpeed < VCD_FAST_MAX - 1) /* VCD */
    {
      bPbcSpeed++;
    }
    else
    {
#ifdef TRICK_MODE_USE_PLAY
      vSendUopCmd(UOP_PLAY, 0, 0, 0);
      return (UOP_OK);
#else
      bPbcSpeed = 0;
#endif
    }
  }
  else
  {
    bPbcSpeed = SV_TWO;
  }

  vSendUopCmd(UOP_REVERSE, SV_FAST, bPbcSpeed, pbVCDFastSpeedTbl[bPbcSpeed]);

  return (UOP_OK);
}

#ifndef DISABLE_SF
BOOL fgVCDSFKey(void) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bPbcSpeed = bSharedInfo(SI_PBC_SPEED);

  if (!fgIsDiscPlay(bPbcState))
  {
    vOsdShowError(SV_ERR_PLAYBACK_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#ifdef PAUSE_NO_TRICK
  else if (bPbcState == SV_PAUSE)
  {
    vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#endif

#ifdef ZOOM_NO_SLOW_STEP
  if (bSharedInfo(SI_ZOOM_SWITCH) != SV_ZOOM_1)
  {
    vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#endif

  if(bPbcState == SV_SF)
  {
    if(bPbcSpeed < VCD_SLOW_MAX - 1)
    {
      bPbcSpeed++;
    }
    else
    {
#ifdef TRICK_MODE_USE_PLAY
      vSendUopCmd(UOP_PLAY, 0, 0, 0);
      return (UOP_OK);
#else
      bPbcSpeed = 0;
#endif

    }
  }
  else
  {
    bPbcSpeed = SV_TWO;
  }

  vSendUopCmd(UOP_FORWARD, SV_SLOW, bPbcSpeed, 0);

  return (UOP_OK);
}
#endif /*#ifndef DISABLE_SF */

BOOL fgVCDNumKey(void) large
{
  BYTE bMode = bSharedInfo(SI_USR_PBC_CTRL);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bTrkNs = bSharedInfo(SI_TRACK_NS);

  if (fgIsUsrCtrlMode(bMode))
  {
    vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }

  /* when PBC on, the number key input is only valid in MENU */
  /* when PBC off, the number key is to select track */

  if ((bSharedInfo(SI_PBC_SWITCH) == SV_PBC_ON) &&
      (bSharedInfo(SI_VCD_DOM) == SV_SELECT_LIST) &&
      fgIsDiscPlay(bPbcState))
  {
    /* number select */
    vChangeInputState(INPUT_STATE_SELECT_NUM, TRUE);
  }
#ifndef PBC_ON_NUM_SEL_TRK
  if ((bSharedInfo(SI_PBC_SWITCH) == SV_PBC_ON) &&
      (bSharedInfo(SI_VCD_DOM) == SV_PLAY_LIST) &&
      fgIsDiscPlay(bPbcState))
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#endif
  else /* current state is PBC on */
  {
#ifdef NUM_KEY_SEARCH /* track select */
    if (
  #ifdef ONE_TRACK_NO_SEARCH
        (bTrkNs > 1)
  #else
        (bTrkNs > 0)
  #endif
        &&
  #ifdef NUM_KEY_DIRECT_SEARCH_CHECK_RANGE
    #ifdef NO_ADD10_KEY
        ((_bIRKey < IR_ADD10) && (_bIRKey * 10 <= bTrkNs))
    #else
        ((_bIRKey <= IR_ADD10 && _bIRKey <= bTrkNs) || (_bIRKey == IR_ADD5 && 5 <= bTrkNs))  // megaa ADD5
    #endif
  #else
        (1)
  #endif
      )
    {
      _rSearchStateCtx.bType = SEARCH_VCD_TRACK;
  #ifdef NUM_KEY_DIRECT_SEARCH
      vChangeInputState(INPUT_STATE_VCD_TRACK_SEARCH, TRUE);
  #else
      vChangeInputState(INPUT_STATE_VCD_TRACK_SEARCH, FALSE);
  #endif
    }
    else /* if only one track, can not do PTT search */
#endif
    {
      vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
      return (UOP_OK);
    }
  }

  return (UOP_OK);
}

BOOL fgVCDPlayKey(void) large
{
  BYTE bState = bSharedInfo(SI_PBC_STATE);
  BYTE bPbc = bSharedInfo(SI_PBC_SWITCH);
  BYTE bMode = bSharedInfo(SI_USR_PBC_CTRL);

  /* if already in play state, show error */
  if (bState == SV_PLAY)
  {
    if ((bPbc == SV_PBC_ON) && (bSharedInfo(SI_VCD_DOM) == SV_SELECT_LIST))
    {
      /* it could be default key, pass to RISC */
      vSendUopCmd(UOP_PLAY, 0, 0, 0);
      return (UOP_OK);
    }
    else
    {
#ifdef DISCARE_PLAY_KEY_WHEN_PLAY
      return (UOP_OK);
#else
      return (UOP_FAIL);
#endif
    }
  }

  /* check for VCD/SVCD */
#ifdef VCD_PLAY_PBC_ON
  #if (STOP_RESUME_STYLE == STOP_RESUME_TWO_KEYS)
  if (bState == SV_STOP_RESUME)
  {
    vSendUopCmd(UOP_STOP, 0, 0, SV_STOP_FORCE);
    bState = SV_STOP;
  }
  #endif

  if (bState == SV_STOP)
  {
    if ((bSharedInfo(SI_PBC_CTRL_VALID) == SV_PBC_ON) &&
        (bPbc == SV_PBC_OFF) && (fgIsUsrCtrlMode(bMode) == FALSE))
    {
      #ifdef SETUP_MENU_PBC_CTRL
      if (bSharedInfo(SH_VCD_USR_PBC_OFF) == FALSE)
      #endif
      {
        vSetSharedInfo(SI_VCD_PBC_OFF, FALSE); /* user force to PBC on */
        vSendUopCmd(UOP_PBC_SWITCH, 0, 0, 0);
      }
    } /* PBC_OFF */
  } /* bState */
#endif /* VCD_PLAY_PBC_ON */

#if (STOP_RESUME_STYLE == STOP_RESUME_TWO_KEYS)
  if ((bState == SV_STOP) || (bState == SV_STOP_RESUME))
  {
    vSendUopCmd(UOP_PLAY, 0, 0, 0); /* restart play */
  }
  else
#elif (STOP_RESUME_STYLE == STOP_RESUME_TWO_STOP)
  if (bState == SV_STOP_RESUME)
  {
    vSendUopCmd(UOP_RESUME_PLAY, 0, 0, 0); /* resume play */
  }
  else
#endif
  {
    vSendUopCmd(UOP_PLAY, 0, 0, 0);
  }

  return (UOP_OK);
}