play_cda.c

MTK 1389E SOURCE CODE

  /* track select */
  _rSearchStateCtx.bType = SEARCH_VCD_TRACK;
  vChangeInputState(INPUT_STATE_VCD_TRACK_SEARCH, TRUE);

  return (UOP_OK);
}

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

  /* if already in play state, show error */
  if (bState == SV_PLAY)
  {
#ifdef DISCARE_PLAY_KEY_WHEN_PLAY
    return (UOP_OK);
#else
    return (UOP_FAIL);
#endif
  }
  else if (fgIsInDigest(bState))
  {
    /* in track scan mode, PLAY/ENTER key select track */
    vSendUopCmd(UOP_DIGEST, 0, 0, 0);
    return (UOP_OK);
  }

#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 fgCDDAResumeKey(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 fgCDDAStopKey(void) large
{
  BYTE bState = bSharedInfo(SI_PBC_STATE);
  BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);

#ifdef CDDA_NO_STOP_RESUME
  if (fgIsDiscPlay(bState))
  {
    vSendUopCmd(UOP_STOP, 0, 0, SV_STOP_FORCE);
    return (UOP_OK);
  }
#elif defined(PROG_NO_STOP_RESUME)
  if ((bSharedInfo(SI_USR_PBC_CTRL) == SV_PROGRAM) &&
      (fgIsDiscPlay(bState)))
  {
    vSendUopCmd(UOP_STOP, 0, 0, 0);
    vSendUopCmd(UOP_STOP, 0, 0, 0);
    /*
    vSendUopCmd(UOP_STOP, 0, 0, SV_STOP_FORCE);
    */
    return (UOP_OK);
  }
#endif

#if (STOP_RESUME_STYLE == STOP_RESUME_TWO_KEYS)
  if (bState == SV_STOP_RESUME)
  {
    //return (UOP_OK);
    // 20050401, CR00002256, show prohibit for non-supported keys
    return (UOP_FAIL);  
  }
#endif

  vSendUopCmd(UOP_STOP, 0, 0, 0);

  return (UOP_OK);
}

BOOL fgCDDANextKey(void) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bUsrMode = bSharedInfo(SI_USR_PBC_CTRL);
  BYTE bRepeatMode = bSharedInfo(SI_REPEAT_MODE);

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

  /* check if next track is valid */
#ifndef CDDA_LAST_TRACK_NEXT_STOP
  if (!fgIsRepeatMode(bRepeatMode))
  {
    if (fgISUsrSeqPlay(bUsrMode) && (bSharedInfo(SI_TRACK_NO) >= bSharedInfo(SI_TRACK_NS)))
    {
      return (UOP_FAIL);
    }
  #ifdef PLAYER_PROGRAM
    else if ((bUsrMode == SV_PROGRAM) && (bSharedInfo(SI_USR_PROGRAM_NO) >= bSharedInfo(SI_USR_PROGRAM_NS)))
    {
      vOsdShowError(SV_ERR_LIST_END_TRK, OSD_TIMEOUT_SHORT);
      return (UOP_OK);
    }
  #endif
  }
#endif /* CDDA_LAST_TRACK_NEXT_STOP */

  vSendUopCmd(UOP_NEXT, 0, 0, 0);

  return (UOP_OK);
}

BOOL fgCDDAPrevKey(void) large
{
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);
  BYTE bUsrMode = bSharedInfo(SI_USR_PBC_CTRL);
  BYTE bRepeatMode = bSharedInfo(SI_REPEAT_MODE);

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

#ifdef CDDA_SHUFFLE_NO_PREV
  if (bUsrMode == SV_SHUFFLE)
  {
    return (UOP_FAIL);
  }
#endif

  /* check if next track is valid */
#ifndef CDDA_FIRST_TRACK_PREV_STOP
  if (!fgIsRepeatMode(bRepeatMode))
  {
    if (fgISUsrSeqPlay(bUsrMode) && (bSharedInfo(SI_TRACK_NO) <= 1))
    {
      return (UOP_FAIL);
    }
  #ifdef PLAYER_PROGRAM
    else if ((bUsrMode == SV_PROGRAM) && (bSharedInfo(SI_USR_PROGRAM_NO) <= 1))
    {
      vOsdShowError(SV_ERR_LIST_HEAD_TRK, OSD_TIMEOUT_SHORT);
      return (UOP_OK);
    }
  #endif
  }
#endif /* CDDA_FIRST_TRACK_PREV_STOP */

  vSendUopCmd(UOP_PREVIOUS, CDDA_PREV_STYLE, CDDA_GOTOP_OFFSET, 0);

  return (UOP_OK);
}

BOOL fgCDDAA2BKey(void) large
{
  BYTE bUsrCtrl = bSharedInfo(SI_USR_PBC_CTRL);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

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

/* digest no repeat ab*/
  if (bUsrCtrl == SV_USR_DIGEST)
  {
    vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }

  /* CD-G does not support trick mode */
#ifdef CDG_SUPPORT
  if (bSharedInfo(SI_DISC_TYPE) == SV_CDG)
  {
    vOsdShowError(SV_ERR_DISC_NOT_SUPPORT, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#endif /* CDG_SUPPORT */

  vSendUopCmd(UOP_A_TO_B, 0, 0, 0);

  return (UOP_OK);
}

BOOL fgCDDAAudioKey(void) large
{
#if 0
  return (UOP_FAIL);
#else // normal routine
  BYTE bMode = bAdspCurrVocal();

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

  /* L/R/Stereo switch, not available for DTS-CD */
  if (bSharedInfo(SI_A_CODE_MODE) == SV_A_CODE_DTS)
  {
    return (UOP_FAIL);
  }
  else /* not DTS-CD */
  {
    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 */
  } /* not DTS-CD */

  return (UOP_OK);
#endif // normal routine
}

BOOL fgCDDADigestKey(void) large
{
  vSendUopCmd(UOP_DIGEST, 6, 0, 0); /* 6 seconds */

  return (UOP_OK);
}


#ifdef SIMPLE_ZOOM_MODE

#define CDDA_ZOOM_USED_MODE   6

static code BYTE pbCddaZoomMode[CDDA_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 fgCDDAZoomInKey(void) large
{
  BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);
  BYTE bZoom;
#ifdef SIMPLE_ZOOM_MODE
  BYTE bIdx;
#endif

#ifdef CDG_SUPPORT
  if (bDiscType != SV_CDG)
  {
    vOsdShowError(SV_ERR_DISC_NOT_SUPPORT, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#endif /* CDG_SUPPORT */

  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 < CDDA_ZOOM_USED_MODE; bIdx++)
    {
      if (pbCddaZoomMode[bIdx] > bZoom)
      {
        bZoom = pbCddaZoomMode[bIdx];
        break;
      }
    }
    
    if (bIdx == CDDA_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);
}

BOOL fgCDDAZoomOutKey(void) large
{
  BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);
  BYTE bZoom;
#ifdef SIMPLE_ZOOM_MODE
  BYTE bIdx;
#endif

#ifdef CDG_SUPPORT
  if (bDiscType != SV_CDG)
  {
    vOsdShowError(SV_ERR_DISC_NOT_SUPPORT, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
#endif /* CDG_SUPPORT */

  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 < CDDA_ZOOM_USED_MODE; bIdx++)
    {
      if (pbCddaZoomMode[bIdx] > bZoom)
      {
        bZoom = pbCddaZoomMode[bIdx];
        break;
      }
    }
    
    if (bIdx == CDDA_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
BOOL fgCDDAZoomUsrKey(void) large
{
  BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);

  #ifndef CDG_SUPPORT
  if (bDiscType != SV_CDG)
  {
    vOsdShowError(SV_ERR_DISC_NOT_SUPPORT, OSD_TIMEOUT_SHORT);
    return (UOP_OK);
  }
  #endif /* CDG_SUPPORT */

  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_BOOKMARK
BOOL fgCDDAMarkKey(void) large
{
  BYTE bUsrCtrl = bSharedInfo(SI_USR_PBC_CTRL);

  /* digest no bookmark */
  if (bUsrCtrl == SV_USR_DIGEST)
  {
    vOsdShowError(SV_ERR_NORMAL_PLAY_ONLY, OSD_TIMEOUT_SHORT);
  }
#ifdef CDG_SUPPORT
  else if (bSharedInfo(SI_DISC_TYPE) == SV_CDG)
  {
    vOsdShowError(SV_ERR_DISC_NOT_SUPPORT, OSD_TIMEOUT_SHORT);
  }
#endif /* CDG_SUPPORT */
  else
  {
#ifdef PLAYER_BOOKMARK
    vChangeInputState(INPUT_STATE_BOOKMARK, FALSE);
#endif
  }

  return (UOP_OK);
}
#endif /*#ifdef PLAYER_BOOKMARK */

#endif /* ifndef CDDA_USE_CDFS  */