play_vcd.c

MTK 1389E SOURCE CODE

BOOL fgVCDResumeKey(void) large
{
  BYTE bState = bSharedInfo(SI_PBC_STATE);

#if (STOP_RESUME_STYLE == STOP_RESUME_TWO_KEYS)
  if ((bState == SV_STOP) || (bState == SV_STOP_RESUME))
  {
    vSendUopCmd(UOP_RESUME_PLAY, 0, 0, 0); /* resume play */
    return (UOP_OK);
  }
#elif (STOP_RESUME_STYLE == STOP_RESUME_TWO_STOP)
  if (bState == SV_STOP_RESUME)
  {
    fgSetPlayPostKey(IR_PLAY);
    return (UOP_OK);
  }
#endif

  vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);

  return (UOP_OK);
}

BOOL fgVCDNextKey(void) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bPbcSwitch = bSharedInfo(SI_PBC_SWITCH);
  BYTE bRepeatMode = bSharedInfo(SI_REPEAT_MODE);

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

#ifdef VCD_LAST_TRACK_NEXT_STOP
  if (!fgIsRepeatMode(bRepeatMode) && (bPbcSwitch == SV_PBC_OFF))
  {
    vSendUopCmd(UOP_NEXT, SV_VCD_NEXT_STOP, 0, 0);
    return (UOP_OK);
  }
#else   /* not VCD_LAST_TRACK_NEXT_STOP */
  #ifdef PLAYER_PROGRAM
  if (!fgIsRepeatMode(bRepeatMode) && (bSharedInfo(SI_USR_PBC_CTRL) == SV_PROGRAM))
  {
    if (bSharedInfo(SI_USR_PROGRAM_NO) >= bSharedInfo(SI_USR_PROGRAM_NS))
    {
      vOsdShowError(SV_ERR_LIST_END_TRK, OSD_TIMEOUT_SHORT);
      return (UOP_OK);
    }
  }
  #endif
#endif  /* not VCD_LAST_TRACK_NEXT_STOP */

  vSendUopCmd(UOP_NEXT, VCD_PBC_NEXT_STYLE, 0, 0);

  return (UOP_OK);
}

BOOL fgVCDPrevKey(void) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bPbcSwitch = bSharedInfo(SI_PBC_SWITCH);
  BYTE bRepeatMode = bSharedInfo(SI_REPEAT_MODE);

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

#ifdef VCD_SHUFFLE_NO_PREV
  if (bSharedInfo(SI_USR_PBC_CTRL) == SV_SHUFFLE)
  {
    return (UOP_FAIL);
  }
#endif

  /* check if next track is valid */
#ifdef VCD_FIRST_TRACK_PREV_STOP
  if (!fgIsRepeatMode(bRepeatMode) && (bPbcSwitch == SV_PBC_OFF))
  {
    vSendUopCmd(UOP_PREVIOUS, (SV_VCD_PREV_STOP | VCD_PREV_STYLE), VCD_GOTOP_OFFSET, 0);
    return (UOP_OK);
  }
#else  /* not VCD_FIRST_TRACK_PREV_STOP */
  #ifdef PLAYER_PROGRAM
  if (!fgIsRepeatMode(bRepeatMode) && (bSharedInfo(SI_USR_PBC_CTRL) == SV_PROGRAM))
  {
    if (bSharedInfo(SI_USR_PROGRAM_NO) <= 1)
    {
      vOsdShowError(SV_ERR_LIST_HEAD_TRK, OSD_TIMEOUT_SHORT);
      return (UOP_OK);
    }
  }
  #endif
#endif /* VCD_FIRST_TRACK_PREV_STOP */

  vSendUopCmd(UOP_PREVIOUS, (VCD_PBC_PREV_STYLE | VCD_PREV_STYLE), VCD_GOTOP_OFFSET, 0);

  return (UOP_OK);
}

BOOL fgVCDStepFKey(void) large
{
#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

  vSendUopCmd(UOP_STEP, 0, 0, 0);

  return (UOP_OK);
}

BOOL fgVCDStepRKey(void) large
{
#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

  vSendUopCmd(UOP_STEP_BACK, 0, 0, 0);

  return (UOP_OK);
}


BOOL fgVCDReturnKey(void) large
{
  if (bSharedInfo(SI_PBC_SWITCH) == SV_PBC_ON)
  {
    vSendUopCmd(UOP_RETURN, 0, 0, 0);
  }
  else
  {
    vOsdShowError(SV_ERR_PBC_ON_ONLY, OSD_TIMEOUT_SHORT);
  }

  return (UOP_OK);
}

BOOL fgVCDAudioKey(void) large
{
  BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);
  BYTE bTmp1 = bSharedInfo(SI_AST_NO);
  BYTE bTmp2 = bSharedInfo(SI_AST_NS);
  BYTE bMode = bAdspCurrVocal();
  BYTE bType;

  /* if is in karaoke mode, the Audio key is not available */
#ifdef PLAYER_KARAOKE
  #if 0
  if (fgIsVocalAssistOn() && (!fgIsVoiceCancel()))
  {
    return (UOP_FAIL);
  }
  #else
  if (fgIsVocalAssistOn())
  {
    vAdspVocalAssist(VOCAL_NO_ASSIST);
  }
  #endif
#endif /* PLAYER_KARAOKE */

  if ((IS_SVCD_TYPE(bDiscType)
#ifdef CVD_4AST
   || (bDiscType == SV_CVD)
#endif
  ) && (bTmp2 > 1))
  {
    bTmp1++;
    if (bTmp1 >= bTmp2)
    {
      bTmp1 = 0;
    }
    vSendUopCmd(UOP_CHANGE_ASTN, bTmp1, 0, 0);
  }
  else /* 2 channel audio stream */
  {
#if 0
    return (UOP_FAIL);
#else
    /* TODO: write to serial EEPROM content */
    switch (bMode)
    {
      case AUDIO_STEREO:
        bMode = AUDIO_MONO_LEFT;
        break;

      case AUDIO_MONO_LEFT:
        bMode = AUDIO_MONO_RIGHT;
        break;

      case AUDIO_MONO_RIGHT:
#ifdef AUD_EN_MIXED_MONO
        bMode = AUDIO_MONO_MIXED;
#else
        bMode = AUDIO_STEREO;
#endif
        break;

      case AUDIO_MONO_MIXED:
      default:
        bMode = AUDIO_STEREO;
        break;
    } /* switch() */

    vAdspLR(bMode);
    vVCDShowAudioLR(TRUE); /* show OSD */
#endif
  } /* 2 channel audio stream */

  return (UOP_OK);
}

BOOL fgVCDSpKey(void) large
{
#ifdef SVCD_OGT
  BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);
  BYTE bTmp1 = bSharedInfo(SI_SPST_NO);
  BYTE bTmp2 = bSharedInfo(SI_SPST_NS);

  if (IS_SVCD_TYPE(bDiscType) && (bTmp2 > 1))
  {
    bTmp1++;
    if (bTmp1 >= bTmp2)
    {
      bTmp1 = 0;
    }
    vSendUopCmd(UOP_CHANGE_SPSTN, bTmp1, 0, 0);
    return (UOP_OK);
  }
  else
#endif
  {
    return (UOP_FAIL);
  }
}


BOOL fgVCDPbcKey(void) large
{
  BYTE bMode = bSharedInfo(SI_USR_PBC_CTRL);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

  if (fgIsDiscPlay(bPbcState) && fgIsUsrCtrlMode(bMode))
  {
    if (bMode == SV_PROGRAM)
    {
      vSendUopCmd(UOP_PROGRAM, SV_PROGRAM_STOP, 0, 0);
    }
    else if (bMode == SV_SHUFFLE)
    {
      vSendUopCmd(UOP_SHUFFLE, SV_OFF, 0, 0);
    }
    else if (bMode == SV_RANDOM)
    {
      vSendUopCmd(UOP_RANDOM, SV_OFF, 0, 0);
    }
    else
    {
      vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
      return (UOP_OK);
    }
  }

  if (bSharedInfo(SI_PBC_SWITCH) == SV_PBC_ON)
  {
    #ifdef SETUP_MENU_PBC_CTRL
    vSetSharedInfo(SH_VCD_USR_PBC_OFF, TRUE);
    #endif

    if ((bSharedInfo(SI_TRACK_NO) == 0) && (bPbcState != SV_STOP))
    {
      vSendUopCmd(UOP_PBC_SWITCH, 1, 0, 0);
    }
    else
    {
      /* switch to PBC OFF at any time */
      vSendUopCmd(UOP_PBC_SWITCH, 0, 0, 0);
    }
  }
  else /* switch to PBC ON need to check */
  {
    if (bSharedInfo(SI_PBC_CTRL_VALID) == SV_PBC_ON) /* disc with PBC */
    {
#ifdef VCD_FORCE_PBC_ON_OFF
      if (bPbcState != SV_STOP)
      {
        vSetSharedInfo(SI_VCD_PBC_OFF, FALSE); /* user force to PBC on */
        #ifdef SETUP_MENU_PBC_CTRL
        vSetSharedInfo(SH_VCD_USR_PBC_OFF, FALSE);
        #endif
        vSendUopCmd(UOP_PBC_SWITCH, 1, 0, 0);
      }
      else
#endif /* VCD_FORCE_PBC_ON_OFF */

      /* we do not check setup menu seting here! */
      /* only in fully stop can switch to PBC on */
      if (bPbcState == SV_STOP)
      {
        vSetSharedInfo(SI_VCD_PBC_OFF, FALSE); /* user force to PBC on */
        #ifdef SETUP_MENU_PCB_CTRL
        vSetSharedInfo(SH_VCD_USR_PBC_OFF, FALSE);
        #endif
        vSendUopCmd(UOP_PBC_SWITCH, 0, 0, 0);
#ifdef VCD_PBC_ON_PLAY
        vOsdPosShow(OSD_POS_PBC_2, OSD_MSG_PBC_ON, OSD_TIMEOUT_SHORT);
        vSendUopCmd(UOP_PLAY, 0, 0, 0);
#endif
      }
      else
      {
        vOsdShowError(SV_ERR_STOP_ONLY, OSD_TIMEOUT_SHORT);
      }
    }
    else /* if (bSharedInfo(SI_PBC_CTRL_VALID) == SV_PBC_OFF) */ /* VCD 1.1 */
    {
      vOsdShowError(SV_ERR_DISC_NOT_SUPPORT, OSD_TIMEOUT_SHORT);
    }
  } /* switch to PBC ON */

  return (UOP_OK);
}

#ifdef PLAYER_DIGEST
BOOL fgVCDDigestKey(void) large
{
  BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);

  /* need to check PBC on/off and switch input state */
#ifdef PLAYER_DIGEST
  vChangeInputState(INPUT_STATE_DIGEST, FALSE);
#endif

  return (UOP_OK);
}
#endif


#ifdef SIMPLE_ZOOM_MODE

#define VCD_ZOOM_USED_MODE   6

static code BYTE pbVcdZoomMode[VCD_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 */

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

  if (
#if ((!defined DISABLE_SF) && (!defined DISABLE_SR))   	
  	  (bPbcState == SV_SF) || (bPbcState == SV_SR) ||
#endif  	  
      (bPbcState == SV_STEP) || (bPbcState == SV_STEP_BACK))
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#endif

  /* for CDDA track */
  if (bSharedInfo(SI_A_CODE_MODE) == SV_A_CODE_PCM)
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }

#ifdef VCD_MENU_NO_ZOOM_IN
  if (bSharedInfo(SI_TRACK_NO) == 0)
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
  else
#endif /* VCD_MENU_NO_ZOOM_IN */
  {
    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 < VCD_ZOOM_USED_MODE; bIdx++)
    {
      if (pbVcdZoomMode[bIdx] > bZoom)
      {
        bZoom = pbVcdZoomMode[bIdx];
        break;
      }
    }
    
    if (bIdx == VCD_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);
}

#ifndef DISABLE_ZOOM_OUT
BOOL fgVCDZoomOutKey(void) large
{
  BYTE bZoom;
#ifdef SIMPLE_ZOOM_MODE
  BYTE bIdx;
#endif
#ifdef ZOOM_NO_SLOW_STEP
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

  if (
#if ((!defined DISABLE_SF) && (!defined DISABLE_SR))   	
  	  (bPbcState == SV_SF) || (bPbcState == SV_SR) ||
#endif  	  
      (bPbcState == SV_STEP) || (bPbcState == SV_STEP_BACK))
  {
    vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#endif

#ifdef VCD_MENU_NO_ZOOM_OUT
  if (bSharedInfo(SI_TRACK_NO) == 0)
  {
    bZoom = SV_ZOOM_OFF;
  #ifdef VCD_MENU_NO_ZOOM_IN
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
  #endif
  }
  else
#endif /* VCD_MENU_NO_ZOOM_OUT */
  {
    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 < VCD_ZOOM_USED_MODE; bIdx++)
    {
      if (pbVcdZoomMode[bIdx] > bZoom)
      {
        bZoom = pbVcdZoomMode[bIdx];
        break;
      }
    }
    
    if (bIdx == VCD_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);
}
#endif /*#ifndef DISABLE_ZOOM_OUT */

#ifdef ENABLE_ZOOM_USER_MODE
BOOL fgVCDZoomUsrKey(void) large
{
  #ifdef ZOOM_NO_SLOW_STEP
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

  if (
#if ((!defined DISABLE_SF) && (!defined DISABLE_SR))   	
  	  (bPbcState == SV_SF) || (bPbcState == SV_SR) ||
#endif  	  
      (bPbcState == SV_STEP) || (bPbcState == SV_STEP_BACK))
  {
    vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
  #endif

  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 */

#ifdef PLAYER_VRMT
BOOL fgVCDVremoteKey(void) large
{
  vChangeInputState(INPUT_STATE_VREMOTE, FALSE);
  return (UOP_OK);
}
#endif /* PLAYER_VRMT */

#endif /* VCD_SUPPORT */