play_cda.c

MTK 1389E SOURCE CODE

/**********************************************************************/
/***************    MTK CONFIDENTIAL & COPYRIGHTED     ****************/
/***************                                       ****************/
/***************  $Modtime:: 05/04/01 6:14p    $       ****************/
/***************  $Revision:: 2                $       ****************/
/***************                                       ****************/
/***************   Description :                       ****************/
/***************                                       ****************/
/***************       Company : MediaTek Inc.         ****************/
/***************    Programmer :                       ****************/
/**********************************************************************/

#define _PLAY_CDDA_C_

#pragma NOAREGS
#include "general.h"


#ifndef CDDA_USE_CDFS
// *********************************************************************
// Function : void vCDDAInit(BYTE bType) large
// Description : VCD play module initial
// Parameter : None
// Return    : None
// *********************************************************************
void vCDDAInit(BYTE bType) large
{
  vBookmarkReset();

#if (defined(USE_8032_AUTO_PLAY) && defined(CDDA_AUTO_PLAY))
  #ifdef CDDA_LAST_MEM
  vSendUopCmd(UOP_PLAY, SV_STOP_PLAY_CHK_LASTMEM, 0, 0);
  #else
  vSendUopCmd(UOP_PLAY, 0, 0, 0);
  #endif
#endif
}

// *********************************************************************
// Function : void vCDDAExit(void) large
// Description : CDDA play module exit
// Parameter : None
// Return    : None
// *********************************************************************
void vCDDAExit(void) large
{
}

/************************************************************************
     Function : void vOsdUpdate(void)
  Description : Update OSD/VFD
    Parameter : None
    Return    : None
************************************************************************/
BYTE bCDDAHandleUopRet(BYTE bUopId, BYTE bUopRet) large
{
  BYTE bRet = UOP_UPDATE;
  BYTE bTmp1, bTmp2;

  if (bUopRet != SV_NO_ERROR)
  {
    bRet = UOP_FAIL; /* show error */
  }
  else
  {
    bRet = UOP_UPDATE;
  }

  switch (bUopId)
  {
    case UOP_DIGITAL_BTN:
    case UOP_ARROW_BTN:
    {
      if (bUopRet == SV_NO_ERROR)
      {
        bRet = UOP_UPDATE; /* still allow update */
      }
      break;
    }

    /* normal playback */
    case UOP_RESUME:
    case UOP_RESUME_PLAY:
      if (bUopRet == SV_NO_ERROR)
      {
        VfdShowPlayInfo(VFD_INFO_CDDA_TRACK, 0, bSharedInfo(SI_TRACK_NO));
      }
      /* don't break here */
    case UOP_PLAY:
      if (bUopRet == SV_NO_ERROR)
      {
        vOsdShowPlayStatus(OSD_SHOW_PLAY, OSD_TIMEOUT_SHORT);
      }
      break;

    /* case UOP_PAUSE: */
    /* case UOP_STOP: */
    case UOP_NEXT:
      if (bUopRet == SV_NO_ERROR)
      {
        vOsdShowPlayStatus(OSD_SHOW_NEXT_TRK, OSD_TIMEOUT_SHORT);
      }
      break;

    case UOP_PREVIOUS:
      if (bUopRet == SV_NO_ERROR)
      {
        vOsdShowPlayStatus(OSD_SHOW_PREV_TRK, OSD_TIMEOUT_SHORT);
#ifdef KARAOKE_SCORING
        vAdspResetKScore();
#endif
      }
      break;

    case UOP_REPEAT:
      bTmp1 = bSharedInfo(SI_REPEAT_MODE);
      bTmp2 = bSharedInfo(SI_USR_AUX_CTRL);
      if ((bUopRet == SV_NO_ERROR) && (!fgISUsrSeqPlay(bTmp2)))
      {
        switch (bTmp1)
        {
          case SV_REPEAT_ALL:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_REPEAT_ALL, OSD_TIMEOUT_SHORT);
            break;

          case SV_REPEAT_TRACK:
          case SV_REPEAT_LIST:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_REPEAT_TRACK, OSD_TIMEOUT_SHORT);
            break;

          case SV_REPEAT_NONE:
          case SV_REPEAT_ABNONE:
            vOsdPosShow(OSD_POS_NORMAL, OSD_MSG_REPEAT_OFF, OSD_TIMEOUT_SHORT);
            break;

          default:
            break;
        } /* switch () */
      }
      break;

    /* trick mode control */
    /* case UOP_FORWARD: */
    /* case UOP_REVERSE: */
    /* case UOP_STEP: */
    /* case UOP_STEP_BACK: */
    /* case UOP_A_TO_B: */
    /* case UOP_FREEZE: */

    /* PBC control */
    /* case UOP_MENU_CALL: */
    /* case UOP_RETURN: */
    /* case UOP_CHANGE_ASTN: */
    /* case UOP_NEXT_ASTN: */
    /* case UOP_CHANGE_SPSTN: */
    /* case UOP_NEXT_SPSTN: */
    /* case UOP_SP_SWITCH: */
    /* case UOP_NEXT_SPSTN_NOSP: */
    /* case UOP_CHANGE_AGL: */
    /* case UOP_DEFAULT: */
    /* case UOP_TOP: */
    /* case UOP_GOUP: */
    /* case UOP_STILL_OFF: */
    /* case UOP_MEMORY_PLAY: */

    /* non-PBC control */
    /* case UOP_PBC_SWITCH: */
    /* case UOP_DIGEST: */
    /* 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: */
    /* case UOP_BOOKMARK: */
#ifdef PLAYER_BOOKMARK    
    case UOP_BOOKMARK:
      vBookmarkUpdate();
      break;
#endif 

    /* item play */
    /* case UOP_TIME_PLAY: */
    /* case UOP_TITLE_PLAY: */
    /* case UOP_PTT_PLAY: */
    case UOP_TRACK_PLAY:
      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);
}

BOOL fgCDDARemainKey(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
  bType++;

  bType = bCddaCheckRemainShow(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 fgCDDASearchKey(void) large
{
  BYTE bMode = bSharedInfo(SI_USR_PBC_CTRL);
  BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);
  BYTE bPbcState = bSharedInfo(SI_PBC_STATE);

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

#ifdef CDG_SUPPORT
  if (bDiscType == SV_CDG)
  {
    /* for CD-G, time search mode is not available */
    _rSearchStateCtx.bType = SEARCH_VCD_TRACK;
    vChangeInputState(INPUT_STATE_VCD_TRACK_SEARCH, FALSE);
  }
  else
#endif /* CDG_SUPPORT */
  {
    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 bCDDAGetRepeatType(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 fgCDDARepeatKey(void) large
{
  BYTE bUsrCtrl = bSharedInfo(SI_USR_PBC_CTRL);
  BYTE bRepeatType;

/* digest no repeat */
  if ((bUsrCtrl == SV_USR_DIGEST)
#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 = bCDDAGetRepeatType(bSharedInfo(SI_REPEAT_MODE));

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

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

  vSendUopCmd(UOP_REPEAT, bRepeatType, 0, 0);

  return (UOP_OK);
}


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

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

  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 < CDDA_FAST_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_FAST, bPbcSpeed, pbCDDAFastSpeedTbl[bPbcSpeed]);

  return (UOP_OK);
}

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

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

  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 < CDDA_FAST_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_REVERSE, SV_FAST, bPbcSpeed, pbCDDAFastSpeedTbl[bPbcSpeed]);

  return (UOP_OK);
}

BOOL fgCDDANumKey(void) large
{
  BYTE bMode = bSharedInfo(SI_USR_PBC_CTRL);

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