combine.c

MTK 1389E SOURCE CODE

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
static void vShowAudioBitrate(void) large
{
#ifdef AUDIO_IN_EN
  if (fgIsAinPlay())
  {
    vAINUpdateBitRate();
  }
#endif /* AUDIO_IN_EN */
#ifdef PLAYER_FLMENU
  if (fgIsIsoPlay())
  {
    vFlIpShowInfo(IP_INFO_BITRATE, 0,
                  bSharedInfo(SI_A_BITRATE0) + bSharedInfo(SI_A_BITRATE1) * 256);
  }
#endif
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
static void vShowAudioFreqBitLen(void) large
{
#ifdef AUDIO_IN_EN
  if (fgIsAinPlay())
  {
    vAINUpdateBitLen();
  }
#endif /* AUDIO_IN_EN */
}

/************************************************************************
     Function :
  Description : UOP return dispatch
    Parameter :
    Return    :
************************************************************************/
BYTE bHandleUopRet(BYTE bUopId, BYTE bUopRet) large
{
  BYTE bResult = UOP_UPDATE;

  /* if ((bUopId > UOP_LAST_GENERIC_UOP) || (bUopId < UOP_PLAYBACK_START)) */
  if ((bUopId > UOP_LAST_RISC_UOP) && (bUopId != UOP_NONE))
  {
    return (UOP_OK); /* not show ERROR */
  }

  /* clear last sync UOP flag here */
  if (bUopId == _bLastSyncUop)
  {
    /* check servo stop */
#ifdef PLAYER_STOP_SRV_STOP
    if (fgSrvStopCheck() == TRUE)
    {
      _bUISrvStatus = PLAYER_SRV_STOP;
    }
#endif

    _bLastSyncUop = UOP_NONE;
  }

  /* dispatch the UOP return */
  if ((bUopId >= UOP_SYSTEM_START) && (bUopId <= UOP_SYSTEM_MAX))
  {
    bResult = bCOMHandleUopRet(bUopId, bUopRet);
  }
  /* else if ((bUopId >= UOP_PLAYBACK_START) && (bUopId <= UOP_PLAYBACK_MAX)) */
  /* else if ((bUopId >= UOP_PLAYBACK_START) && (bUopId <= UOP_LAST_RISC_UOP)) */
  else if ((bUopId != UOP_NONE) && (bUopId <= UOP_LAST_RISC_UOP))
  {
#ifndef NEW_PLAY
    if (fgIsDvdPlay())
    {
      bResult = bDVDHandleUopRet(bUopId, bUopRet);
    }
#ifdef VCD_SUPPORT
    else if (fgIsVcdPlay())
    {
      bResult = bVCDHandleUopRet(bUopId, bUopRet);
    }
#endif
#ifdef SUPPORT_DATA_DISC
    else if (fgIsIsoPlay())
    {
      bResult = bISOHandleUopRet(bUopId, bUopRet);
    }
  #ifdef SUPPORT_PCD
    else if (fgIsPcdPlay())
    {
      bResult = bPCDHandleUopRet(bUopId, bUopRet);
    }
  #endif
#endif /* SUPPORT_DATA_DISC */
#ifndef CDDA_USE_CDFS
    else if (fgIsCddaPlay())
    {
      bResult = bCDDAHandleUopRet(bUopId, bUopRet);
    }
#endif
#ifdef AUDIO_IN_EN
    else if (fgIsAinPlay())
    {
      bResult = bAINHandleUopRet(bUopId, bUopRet);
    }
#endif
#else /* NEW_PLAY*/
  bResult = bDiscHandleUopRet(bUopId, bUopRet);
#endif
  }

  if (bResult == UOP_FAIL)
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
  }
  else /* UOP O.K. */
  {
    vOsdShowError(OSD_ERROR_CLEAR, 0);
  }

  return (bResult);
}

/************************************************************************
     Function :
  Description : Error return dispatch
    Parameter :
    Return    :
************************************************************************/
BYTE bHandleErrRet(BYTE bItem) large
{
  BYTE bRet = UOP_OK;

  switch (bItem)
  {
    case bSIItemIndex(SI_OSD_ERR_RET):
    {
      if (bSharedInfo(SI_OSD_ERR_RET) == SV_ERR_OSD_MEM_FULL)
      {
#ifdef RS232_WB_DEBUG
  DBGLogS(" mem full  \n");
#endif
        vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
      }
      break;
    }

    case bSIItemIndex(SI_UOP_ID):
    case bSIItemIndex(SI_UOP_RET_VAL):
    case bSIItemIndex(SI_UOP_SUB_ID):
    {
      bRet = bHandleUopRet(_rOsdStateCtx.bUopRetId, _rOsdStateCtx.bUopRetVal);
      break;
    }

    default:
      /* not a valid item, ignore it! */
      break;
  } /* switch (bItem) */

  if (bRet == UOP_FAIL)
  {
    vOsdShowError(SV_ERR_INVALID_OPERATION, OSD_TIMEOUT_SHORT);
  }
  else /* UOP O.K. */
  {
    vOsdShowError(OSD_ERROR_CLEAR, 0);
  }

  return (bRet);
}

/************************************************************************
     Function :
  Description : Share info update handle
    Parameter :
    Return    :
************************************************************************/
void vGroupPbcUpdateUsrCtrl(BYTE bItem) large
{
  BYTE bAuxCtrl = bSharedInfo(SI_USR_AUX_CTRL);
  BYTE bRepeatMode = bSharedInfo(SI_REPEAT_MODE);
  BYTE bUsrPbc = bSharedInfo(SI_USR_PBC_CTRL);

  switch (bItem)
  {
    case bSIItemIndex(SI_USR_AUX_CTRL):
    case bSIItemIndex(SI_REPEAT_MODE):
    case bSIItemIndex(SI_USR_PBC_CTRL):
    {
      if (fgShowAuxCtrl(bAuxCtrl))
      {
        break;
      }
#if 0   // enable show iso here because the code to show repeat in play_iso has been shrinked
      /* for ISO play, we do not need to show repeat mode and user control mode */
      if (fgIsIsoPlay()
#ifdef SUPPORT_PCD
        || fgIsPcdPlay()
#endif
        )
      {
        if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_LEFT)
        {
          vOsdPosClear(OSD_POS_ISO_REPEAT);
        }
        else if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_RIGHT)
        {
          vOsdPosClear(OSD_POS_ISO_REPEAT_LEFT);
        }
        break;
      }
#endif
      if (fgShowRepeatMode(bRepeatMode))
      {
        break;
      }
      vShowUsrPbcCtrl(bUsrPbc);
      break;
    }
  } /* switch (bItem) */

#if (defined(PLAYER_PROGRAM) || defined(PLAYER_DIGEST))
  if (bItem == bSIItemIndex(SI_USR_PBC_CTRL))
  {
    if (fgIsInputStateValid(INPUT_STATE_PROGRAM))
    {
      vSelMenuUsrPbcChange();
    }
  #ifdef PLAYER_DIGEST
    else if (fgIsInputStateValid(INPUT_STATE_DIGEST))
    {
      vDigestUsrPbcChange();
    }
  #endif
  }
#endif

  VfdShowUsrMode(bUsrPbc);
  VfdShowRepeatMode(bRepeatMode);
  VfdShowRepeatAB(bAuxCtrl);
}

/************************************************************************
     Function :
  Description : Share info update handle
    Parameter :
    Return    :
************************************************************************/
void vGroupPbcUpdate(BYTE bItem) large
{
  BYTE bTmp1, bTmp2;
#ifdef PLAYER_GOTO
  BYTE pbStr[] = { 0 };
#endif

  switch (bItem)
  {

 #ifdef MT1379_MANUFACTURE_TEST
    case bSIItemIndex(SI_MANU_TEST_ST):
    {
      vCheckTestStatus();
      _bPlayPostKey = IR_EJECT;
      return;
    }
#endif

    case bSIItemIndex(SI_INIT_STATE):
    {
      bTmp1 = bSharedInfo(SI_INIT_STATE);

      VfdShowInitStatus(bTmp1);
      vShowInitState(bTmp1);
      break;
    }

    case bSIItemIndex(SI_DISC_TYPE):
    {
      bTmp1 = bSharedInfo(SI_DISC_TYPE);
      VfdShowDiscType(bTmp1);
      vAdspAudioTypeChange(SV_A_CODE_NONE, bTmp1, SV_DISC_IDENTIFIED);
      /* vShowDiscType(bTmp); */ /* move to vSetPlayType() */
      if (fgIsInSetupMenu())
      {
        vSetupMenuClose();
      }
      break;
    }

    case bSIItemIndex(SI_UPGRADE_ST):
    {
      vUpgShowState(bSharedInfo(SI_UPGRADE_ST));
      return;
    }
  }

  if (fgIsNonPlay())
  {
#ifdef EN_DISC_ID_CHK
    if ((bItem == bSIItemIndex(SI_PBC_STATE)) &&
        fgIsDiscInitFlagSet(DISC_INIT_DISC_TYPE))
    {
      if ((bSharedInfo(SI_PBC_STATE) == SV_REGION_ERR) &&
          (bSharedInfo(SI_DISC_TYPE) == SV_DVD_VIDEO))
      {
        // reset init flag
        vResetDiscInitFlag();
        // clear play type
        if (!fgIsNonPlay())
        {
          vClearPlayType();
        }
        // clear OSD
        vOsdShowInitState(SV_DISC_IDENTIFIED);
        // sho error message
        vOsdPosShow(OSD_POS_ERROR, OSD_MSG_WRONG_REGION, OSD_NO_DISAPPEAR);
        vOsdShowPbcState(SV_STOP, 0, OSD_NO_DISAPPEAR);
      }
    }
#endif /* EN_DISC_ID_CHK */
    return; /* not a good method! */
  }

  switch (bItem)
  {
#ifdef KARAOKE_MIC_REC
    case bSIItemIndex(SI_REC_PROGRESS):
    {
      if (bEepromReadByte(MIC_SW_POS) == EV_ON)
      {
        vMicRecProgressUpdate();
      }

      break;
    }
    case bSIItemIndex(SI_AB_STATE):
    {
      if (bEepromReadByte(MIC_SW_POS) == EV_ON)
      {
        vMicRecStateChange(bSharedInfo(SI_AB_STATE));
      }

      break;
    }
#endif /* KARAOKE_MIC_REC */

    case bSIItemIndex(SI_PBC_SWITCH): /* only usefule for disc play startup */
    {
#ifdef VCD_SUPPORT
      if (fgIsVcdPlay())
      {
        bTmp1 = bSharedInfo(SI_PBC_SWITCH);

        VfdShowPbcSwitch(bTmp1 == SV_PBC_ON);
#if 0
        if (bTmp1 == SV_PBC_ON)
        {
          vOsdPosShow(OSD_POS_PBC_2, OSD_MSG_PBC_ON, OSD_TIMEOUT_SHORT);
        }
        else if (bTmp1 == SV_PBC_OFF)
        {
          vOsdPosShow(OSD_POS_PBC_2, OSD_MSG_PBC_OFF, OSD_TIMEOUT_SHORT);
        }
#endif

        if (bCurrRemainType() != OSD_SHOW_DISABLE)
        {
          bVcdCheckRemainShow(FALSE, bCurrRemainType());
        }
      }
#endif /* #ifdef VCD_SUPPORT */
      break;
    }

    case bSIItemIndex(SI_PBC_STATE):
    case bSIItemIndex(SI_PBC_SPEED):
    {
      bTmp1 = bSharedInfo(SI_PBC_STATE);

#ifdef PLAYER_GOTO
      if (fgIsInGoto())
      {
        if (fgChkGotoExit() == TRUE)
        {
          fgSetPlayPostKey(IR_GOTO);
        }
        else if (bTmp1 == SV_PLAY)
        {
          vGotoShowIcon(OSD_MSG_ICON_PLAY, pbStr);
        }
      }
#endif /* PLAYER_GOTO */

      vChangePbcState(bTmp1);
      vShowPbcState(bTmp1);
      vAdspPbcChange(bTmp1);
      break;
    }

    case bSIItemIndex(SI_USR_AUX_CTRL):
    case bSIItemIndex(SI_REPEAT_MODE):
    case bSIItemIndex(SI_USR_PBC_CTRL):
    {
      vGroupPbcUpdateUsrCtrl(bItem);
      break;
    }

#ifdef PLAYER_ZOOMIN_INDICATOR
    case bSIItemIndex(SI_ZOOM_OFST_X_HI):
    case bSIItemIndex(SI_ZOOM_OFST_X_LO):
    case bSIItemIndex(SI_ZOOM_OFST_Y_HI):
    case bSIItemIndex(SI_ZOOM_OFST_Y_LO):
    {
      if (fgIsZoomBrShow())
      {
        vZoomBrUpdate();
      }
      break;
    }
#endif /* PLAYER_ZOOMIN_INDICATOR */

    case bSIItemIndex(SI_ZOOM_SWITCH):
    {
      bTmp1 = bSharedInfo(SI_ZOOM_SWITCH);
      bTmp2 = bSharedInfo(SI_ISO_ITEM_TYPE);

#ifdef DDISC_FTYPE_JPEG_SUPPORT
      if (
#ifdef SUPPORT_PCD
        fgIsPcdPlay() ||
#endif
        (fgIsIsoPlay() && (fgFlCheckStatus(FL_STATUS_IN_JPEG))))
      {
        vOsdShowZoomPct(bTmp1);
        VfdShowZoom(TRUE);

        if ((bTmp1 == 0) && fgIsInputStateValid(INPUT_STATE_PCD_ZOOM))
        {
          /* need to escape zoom control mode */
          fgSetPlayPostKey(IR_ZOOM_IN);
          VfdShowZoom(FALSE);
        }
      }
      else
#endif
      {
#ifdef DDISC_FTYPE_JPEG_SUPPORT
        if ((fgIsIsoPlay() && (!fgFlCheckStatus(FL_STATUS_IN_JPEG))) &&
            fgIsInputStateValid(INPUT_STATE_PCD_ZOOM))
        {
          /* need to escape zoom control mode */
          fgSetPlayPostKey(IR_ZOOM_IN);
          VfdShowZoom(FALSE);
        }
        else
#endif
        {
          vOsdShowZoom(bTmp1);

#ifdef PLAYER_ZOOMIN_INDICATOR
          if ((bTmp1 >= SV_ZOOM_IN_MIN) &&
              (bTmp1 <= SV_ZOOM_IN_MAX))
          {
            if (fgIsZoomBrShow())
            {
              vZoomBrUpdate();
            }
            else
            {
              vZoomBrOn();
            }
          }
          else // not in zoom-in mode
          {
            if (fgIsZoomBrShow())
            {
              vZoomBrOff();
            }
          }
#endif /* PLAYER_ZOOMIN_INDICATOR */


          if ((bTmp1 == SV_ZOOM_OFF) || (bTmp1 >= SV_ZOOM_MODE_MAX))
          {
            VfdShowZoom(FALSE);
          }
          else
          {
            VfdShowZoom(TRUE);
          }
        }
      }
      break;
    }

    default:
      break;
  }
}

/************************************************************************
     Function :
  Description : Share info update handle
    Parameter :
    Return    :
************************************************************************/
void vGroupTimeUpdate(BYTE bItem) large
{
#ifdef KARAOKE_SCORING
  BOOL fgShow = FALSE;
  BOOL fgRmn2Sec = FALSE;
  BOOL fgRmnLast2Sec = FALSE;
  BYTE bKScore;
  #ifdef KARAOKE_SCORE_TEST
  BYTE pbStr[13];
  WORD wHit0;
  WORD wHit1;
  WORD wMiss;
  #else
  BYTE pbStr[4];
  #endif
#endif

  switch (bItem)
  {
    case bSIItemIndex(SI_TIME_SS):
    {
      vOsdDisplayChange(DISP_TIME_MARK, 0);
#ifdef KARAOKE_SCORING
      if (fgIsDvdPlay() && bSharedInfo(SI_DVD_DOM) == SV_VTSTT_DOM)
      {
        fgShow = TRUE;
        if (bSharedInfo(SI_TIME_CHAPTER_RMN_SS) <= 2)
        {
          fgRmn2Sec = TRUE;
          if (bSharedInfo(SI_TIME_CHAPTER_RMN_HH) == 0 &&
              bSharedInfo(SI_TIME_CHAPTER_RMN_MM) == 0)
            fgRmnLast2Sec = TRUE;
        }
      }
      else if (fgIsVcdPlay() || fgIsCddaPlay())
      {
        fgShow = TRUE;
        if (bSharedInfo(SI_TIME_TRACK_RMN_SS) <= 2)
        {
          fgRmn2Sec = TRUE;
          if (bSharedInfo(SI_TIME_TRACK_RMN_HH) == 0 &&
              bSharedInfo(SI_TIME_TRACK_RMN_MM) == 0)