play_vcd.c

手机8032的完整代码。吐血推荐。小做改动就可以生产。

    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);
}

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))