combine.c

mtk1389L latest sourcecode enjoy

    else
    {
      /* if is decoding, not allowed */
      return (FALSE);
    }
  }

  switch (bPbcState)
  {
    case SV_STOP:
      if (_bLastSyncUop == UOP_STOP)
      {
        /* clear _bLastSyncUop flag immediately */
        _bLastSyncUop = UOP_NONE;
        /* change to stop state due to previous UOP command */
        return (TRUE); /* allowed */
      }
      else if (fgIsUopUpdate() && (bSharedInfo(SI_UOP_RET_VAL) == SV_NO_ERROR))
      {
        /* any key changed to stop state */
        return (TRUE); /* allowed */
      }
      else if (_bLastPbcState == SV_PBC_INIT)
      {
        return (TRUE);
      }
      else
      {
        return (FALSE); /* not allowed */
      }

    case SV_STOP_RESUME:
    case SV_PAUSE:
    case SV_STEP:
    case SV_STEP_BACK:
    case SV_PTL_ERR:
    case SV_REGION_ERR:
    case SV_DISC_ERR:
    case SV_SET_TMP_PTL:
    case SV_PLAY:
    case SV_FF:
    case SV_SF:
    case SV_FR:
    case SV_SR:
    case SV_FREEZE:
    case SV_DIGEST9:
    case SV_DIGEST4:
    case SV_DIGEST:
    case SV_STILL:
      /* DVD/VCD is not allowed in still mode */
      return (FALSE);

    default:
      break; /* not determined */
  }

  return (FALSE); /* default is not allowed */
}
#endif /* PLAYER_STOP_SRV_STOP */

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void vShowInitState(BYTE bInitState) large
{
  BYTE bTmp;
  BYTE bDiscType = bSharedInfo(SI_DISC_TYPE);

  /* show or clear ICON/message first */
  vOsdShowInitState(bInitState);

  switch (bInitState)
  {
    case SV_LOADING_DISC:
#ifdef AUDIO_IN_EN
      if (fgIsAinPlay())
      {
        vClearPlayType();
      }
#endif /* AUDIO_IN_EN */
      break;

    case SV_TRAY_OPENING:
#ifdef MPEG4_CHROMA_ERROR_WORKAROUND
      // when traying out data disc,change overal MBL to 0x20 (default value)
      if(_bPrePlayType == PLAY_TYPE_ISO)
      {
        WriteDEC(0x3C, 0x20);  //overall MBL
      }
#endif      
#ifdef AUDIO_IN_EN
      if (fgIsAinPlay())
      {
        vClearPlayType();
      }
#endif /* AUDIO_IN_EN */
      /* the vPlayerReset() has been moved to eject key routine */
      //reset video when tray out
#ifdef RESET_VDO_TRAY_OUT
      vResetVdoPage();
#endif
#ifdef EEPROM_LASTMEM_EJECT_WR_BACK
      if (_rOsdStateCtx.fgLastMemWrBack == TRUE)
      {
        bTmp = bSharedInfo(SI_LASTMEM_NS);
        if (bTmp > 0)
        {
          vSendPeriCmd(MISC_CMD_EEPROM_SVC, EEPROM_CMD_WR_SLOT, bTmp - 1);
        }
        _rOsdStateCtx.fgLastMemWrBack = FALSE;
      }
#endif /* EEPROM_LASTMEM_EJECT_WR_BACK */
      break;

    case SV_TRAY_CLOSING:
      vClearPlayType();
#ifdef MT1379_MANUFACTURE_TEST
      vSetSharedInfo(SI_MANU_TEST_ST, 0);
#endif
      break;

    case SV_TRAY_ERROR:
      break;

    case SV_NO_DISC:
#ifdef AUDIO_IN_EN
      if (fgIsFuncAin())
      {
        vSetPlayType(SV_AUDIO_IN);
      }
#endif /* AUDIO_IN_EN */
      break;

    case SV_UNKNOWN_DISC:
      break;

    case SV_DISC_IDENTIFIED:
#ifdef EN_DISC_ID_CHK
      vSetDiscInitFlag(DISC_INIT_DISC_TYPE);
      if (fgIsDiscInitFinished())
      {
        vSendPeriCmd(MISC_CMD_EEPROM_SVC, EEPROM_CMD_CHK_DISC_ID, 0);
      }
#else
      /* always assume RISC notify disc type first */
      vSetPlayType(bDiscType);
      #ifdef MPEG4_CHROMA_ERROR_WORKAROUND  
          _bPrePlayType = _bPlayType;
          // when playing data disc,change overal MBL to 0x00 for chroma decode error and video BW
          if(_bPlayType == PLAY_TYPE_ISO)
          {
            WriteDEC(0x3C, 0x00);  //overall MBL
          }
      #endif
#endif
      break;

    default:
      break;
  }

  if (bInitState != SV_DISC_IDENTIFIED)
  {
    vAdspAudioTypeChange(bSharedInfo(SI_A_CODE_MODE), 0xff, bInitState);
  }

#ifdef AUDIO_IN_EN
  if (bInitState == SV_DISC_IDENTIFIED)
  {
    if (_bDiscLoadSt == DISC_LOAD_TOC)
    {
      _bDiscLoadSt = DISC_LOAD_IDENT;
    }
  }
  else if ((bInitState == SV_DISC_IDENTIFIED) || (bInitState == SV_DISC_IDENTIFIED))
  {
    if (_bDiscLoadSt >= DISC_LOAD_STARTUP)
    {
      _bDiscLoadSt = DISC_LOAD_IDENT;
    }
  }
#endif /* AUDIO_IN_EN */

#ifdef PLAYER_STOP_SRV_STOP
  if (bInitState == bSharedInfo(SI_INIT_STATE))
  {
    if (fgSrvStopCheck() == TRUE) /* for unknown disc */
    {
      _bUISrvStatus = PLAYER_SRV_STOP;
    }
  }
#endif /* PLAYER_STOP_SRV_STOP */
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void vShowPbcState(BYTE bPbcState) large
{
  BYTE bTmp;
  WORD wFileNo;

  switch (bPbcState)
  {
    case SV_STOP:
#ifdef PLAYER_FLMENU
      // prevent showing stop icon while beginning to repeat
      if (!fgIsIsoItemAV(bSharedInfo(SI_ISO_ITEM_TYPE)) && !fgFlCheckStatus(FL_STATUS_IN_JPEG))
#else
      vVfdMessageClr();
      vVfdRotate(VFD_DISC_LIGHT_OFF);
      vVfdMessage(VFD_MESSAGE_STOP);
      vVfdClrAudInfo();
      vVfdSymbol(VFD_SYM_STOP);
      if (!fgIsIsoItemAV(bSharedInfo(SI_ISO_ITEM_TYPE)))
#endif
      {
        vOsdShowPbcState(SV_STOP, 0, OSD_NO_DISAPPEAR);
      }
      vOsdDisplayChange(DISP_STOP, 0);
      break;

    case SV_STOP_RESUME:
      vVfdMessageClr();
      vVfdRotate(VFD_DISC_LIGHT_OFF);
#ifdef VFD_MESSAGE_HOLD
      vVfdMessage(VFD_MESSAGE_HOLD);
#else
      vVfdMessage(VFD_MESSAGE_STOP);
#endif
      vVfdClrAudInfo();
      vVfdSymbol(VFD_SYM_STOP);
      #if !defined(MT1379_MANUFACTURE_TEST)
      vOsdShowPbcState(SV_STOP_RESUME, 0, OSD_NO_DISAPPEAR);
      vOsdDisplayChange(DISP_STOP_RESUME, 0);
      #endif
      break;

    case SV_PLAY:
      if(fgIsIsoPlay())
      {
#if 0
        // show file no in VFD
        wFileNo = wIsoFileNo();
        wFileNo = wWRDToBCD(wFileNo + 1); /* from 1 ~ Ns */

#ifdef VFD_FLD_CH100
        vVfdWord(VFD_WORD_CH100, bHiByte(wFileNo), 0); /* note already in BCD */
#else
        vVfdWord(VFD_WORD_TT, bHiByte(wFileNo), 0); /* note already in BCD */
#endif  //VFD_FLD_CH100
        vVfdWord(VFD_WORD_CH, bLoByte(wFileNo), 1);
#endif
      }
      vOsdShowPbcState(SV_PLAY, 0, OSD_NO_DISAPPEAR);
      break;

    case SV_FF:
    case SV_SF:
    case SV_FR:
    case SV_SR:
      vOsdDisplayChange(DISP_TRICK, bPbcState);
      break;

    case SV_PAUSE:
#if 0   // 20050712, PL00001231, let PCD show same behavior as others.
      if (fgIsPcdPlay())
      {
        vOsdShowPbcState(SV_PAUSE, 0, OSD_TIMEOUT_SHORT);
      }
      else
#endif
      {
        vOsdShowPbcState(SV_PAUSE, 0, OSD_NO_DISAPPEAR);
      }
      break;

    case SV_STEP:
      vOsdShowPbcState(SV_STEP, 0, OSD_NO_DISAPPEAR);
      break;

    case SV_STEP_BACK:
      vOsdShowPbcState(SV_STEP_BACK, 0, OSD_NO_DISAPPEAR);
      break;

    case SV_FREEZE:
      break;

    case SV_STILL:
      vOsdShowPbcState(SV_STILL, 0, OSD_NO_DISAPPEAR);
      break;

    case SV_DIGEST9:
    case SV_DIGEST4:
    case SV_DIGEST:
      if(fgIsIsoPlay() || fgIsPcdPlay())
      {
        vVfdMessage(VFD_MESSAGE_DIGEST);
      }
      vOsdShowPbcState(bPbcState, 0, OSD_NO_DISAPPEAR);
      break;

    case SV_PTL_ERR:
    case SV_SET_TMP_PTL:
      /* clear status first */
      /* vOsdPosClear(OSD_POS_PLAY_STATUS); */
      /* call the password check function */
      if (fgIsDvdPlay() && (fgIsInputStateValid(INPUT_STATE_PASSWORD) == FALSE))
      {
        fgSetPlayPostKey(IR_PASSWORD);
      }
      break;

    case SV_REGION_ERR:
#ifndef EN_DISC_ID_CHK /* not define EN_DISC_ID_CHK */
      if (fgIsDvdPlay())
      {
        vClearPlayType();
        vOsdPosShow(OSD_POS_ERROR, OSD_MSG_WRONG_REGION, OSD_NO_DISAPPEAR);
        vOsdShowPbcState(SV_STOP, 0, OSD_NO_DISAPPEAR);
      }
#endif /* not define EN_DISC_ID_CHK */
      break;

    case SV_DISC_ERR:
      vOsdPosShow(OSD_POS_ERROR, OSD_MSG_DISC_ERROR, OSD_NO_DISAPPEAR);
      vOsdShowPbcState(SV_STOP, 0, OSD_NO_DISAPPEAR);
      break;

    default:
      break;
  }
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void vChangePbcState(BYTE bPbcState) large
{
  BYTE bTmp;

  /* for state change only */
  if (bPbcState == _bLastPbcState)
  {
    return;
  }

  switch (_bLastPbcState)
  {
    case SV_STOP:
    case SV_STOP_RESUME:
#if (STOP_RESUME_STYLE == STOP_RESUME_TWO_KEYS)
      if ((_bLastPbcState == SV_STOP_RESUME) ||
          (_bLastPbcState == SV_STOP))
      {
        vOsdPosClear(OSD_POS_STOP_MSG1);
        vOsdPosClear(OSD_POS_STOP_MSG2);
      }
#elif (STOP_RESUME_STYLE == STOP_RESUME_TWO_STOP)
      if (_bLastPbcState == SV_STOP_RESUME)
      {
        vOsdPosClear(OSD_POS_STOP_MSG1);
      }
#endif
      break;

    case SV_PLAY:
    case SV_FF:
    case SV_SF:
    case SV_FR:
    case SV_SR:
    case SV_PAUSE:
    case SV_STEP:
    case SV_STEP_BACK:
    case SV_FREEZE:
    case SV_STILL:
      /* fgIsDiscPlay() */
      break;

    case SV_DIGEST9:
    case SV_DIGEST4:
    case SV_DIGEST:
    case SV_PTL_ERR:
    case SV_REGION_ERR:
    case SV_DISC_ERR:
    case SV_SET_TMP_PTL:
      break;

    default:
      /* error? */
      break;
  }

  switch (bPbcState)
  {
    case SV_STOP:
    case SV_STOP_RESUME:
      vOsdCoreSetPlayStatus(OSD_SHOW_CLEAR, 0);
#ifdef STOP_CANCEL_USR_CTRL
      if (((fgIsIsoPlay() || fgIsPcdPlay()) == FALSE)
#ifdef SINGLE_STOP_KEEP_USR_CTRL
          && (bPbcState != SV_STOP_RESUME)
#endif
         )
      {
        bTmp = bSharedInfo(SI_USR_PBC_CTRL);

        if (bTmp == SV_PROGRAM)
        {
          vSendUopCmd(UOP_PROGRAM, SV_PROGRAM_STOP, 0, 0);
        }
        else if (bTmp == SV_SHUFFLE)
        {
          vSendUopCmd(UOP_SHUFFLE, SV_OFF, 0, 0);
        }
        else if (bTmp == SV_RANDOM)
        {
          vSendUopCmd(UOP_RANDOM, SV_OFF, 0, 0);
        }
      }
#endif /* STOP_CANCEL_USR_CTRL */
#ifdef STOP_RESUME_CANCEL_REPEAT
      if ((fgIsIsoPlay() || fgIsPcdPlay()) == FALSE)
      {
        bTmp = bSharedInfo(SI_REPEAT_MODE);

        if ((bTmp != SV_REPEAT_NONE) &&
            (bTmp != SV_REPEAT_ABNONE))
        {
          vSendUopCmd(UOP_REPEAT, SV_REPEAT_NONE, 0, 0);
        }
      }
#endif /* STOP_RESUME_CANCEL_REPEAT */
      break;

    case SV_PLAY:
    case SV_FF:
    case SV_SF:
    case SV_FR:
    case SV_SR:
    case SV_PAUSE:
    case SV_STEP:
    case SV_STEP_BACK:
    case SV_FREEZE:
    case SV_STILL:
      /* fgIsDiscPlay() */
      if (!fgIsDiscPlay(_bLastPbcState) && (_bLastPbcState != SV_PBC_INIT))
      {
        vStatusDispRecall();

        if (_bLastPbcState == SV_STOP)
        {
          /* if previous state is STOP, the time information may be incorrect! */
          if (fgIsDvdPlay())
          {
            vDVDShowTotalTimeMark();
          }
          else if (fgIsVcdPlay())
          {
            vVCDShowTotalTimeMark();
          }
        }
      }
      break;

    case SV_DIGEST9:
    case SV_DIGEST4:
    case SV_DIGEST:
    case SV_PTL_ERR:
    case SV_REGION_ERR:
    case SV_DISC_ERR:
    case SV_SET_TMP_PTL:
      break;

    default:
      /* error? */
      break;
  }

  /* to update VFD */
  vVfdUpdateTrick();

#ifdef PLAYER_STOP_SRV_STOP
  if (fgSrvStopCheck() == TRUE)
  {
    _bUISrvStatus = PLAYER_SRV_STOP;
  }
#endif

  _bLastPbcState = bPbcState;
}

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void vShowUsrPbcCtrl(BYTE bMode) large
{
  WORD wPos;

  if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_LEFT)
  {
    if (fgIsIsoPlay())
    {
      wPos = OSD_POS_ISO_REPEAT;
    }
    else
    {
      wPos = OSD_POS_REPEAT;
    }
  }
  else if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_RIGHT)
  {
    if (fgIsIsoPlay())
    {
      wPos = OSD_POS_ISO_REPEAT_LEFT;
    }
    else
    {
      wPos = OSD_POS_REPEAT_LEFT;
    }
  }

  switch (bMode)
  {
    case SV_REPEAT_NONE:
    case SV_REPEAT_ABNONE:
      vOsdPosClear(wPos);
      break;

    case SV_REPEAT_ALL:
      vOsdPosShow(wPos, OSD_MSG_ICON_RPT_ALL, OSD_NO_DISAPPEAR);
      break;

    case SV_REPEAT_TRACK:
    case SV_REPEAT_LIST:
      vOsdPosShow(wPos, OSD_MSG_ICON_RPT_TRK, OSD_NO_DISAPPEAR);
      break;

    case SV_REPEAT_TITLE:
      vOsdPosShow(wPos, OSD_MSG_ICON_RPT_TT, OSD_NO_DISAPPEAR);
      break;

    case SV_REPEAT_CHAPTER:
      vOsdPosShow(wPos, OSD_MSG_ICON_RPT_CH, OSD_NO_DISAPPEAR);
      break;