nonshow.c

mtk1389L latest sourcecode enjoy

  }
  else
  {
/*
  Add the else case by Bright_liu 2006/01/23, for CQ(PL00205233):
  when play MPEG file, press FF/FR or PAUSE to show the PBC state,
  then press the STOP to goto file menu, then play a MPEG file, 
  it will show the last PBC state in a short time then disappear.
*/
    vOsdPosClear(OSD_POS_PLAY_STATUS);
  }

  // 20050712, PL00000902, clear OSD_POS_NORMAL so that play status can display immediately.
  // Mark it by Bright_liu 2005/08/31, for CQ(PL00101092), It will clear the disc type information
  // vOsdPosClear(OSD_POS_NORMAL) ;
  
  // start show play status
  switch (bState)
  {
    case SV_PLAY:
    case SV_STILL:
    case SV_DIGEST9:
    case SV_DIGEST4:
    case SV_DIGEST:
      // show "BLANK" for PLAY state
      vOsdPosClear(OSD_POS_PLAY_STATUS);
#ifdef PLAYER_GOTO
      // megaa Goto
      if (fgIsInGoto())
      {
        pbStr[0] = 0;
        vGotoShowIcon(OSD_MSG_ICON_PLAY, pbStr);
      }
#endif
      return;

    default:
#ifdef SUPPORT_DATA_DISC
      if (fgIsIsoPlay())
        vGetPbcStateMsg(bFlGetFgPbcState(), bVal, &wMsgIndex, pbStr);
      else
#endif
        vGetPbcStateMsg(bState, bVal, &wMsgIndex, pbStr);
      break;
  }

#ifdef PLAYER_FLMENU
/*
  Add the follow code by Bright_liu 2006/01/23, for CQ(PL00205236)
  when play mp3, press IR_FR, then play JPG, the FR PBC OSD show.
*/
    if (fgFlCheckStatus(FL_STATUS_IN_JPEG))
    {
      if((bState == SV_FF) || (bState == SV_FR) )
      {
        wMsgIndex = 0;
      }
    }
#endif

  if (wMsgIndex != 0)
  {
#ifdef PLAYER_FLMENU
    if (fgFlCheckStatus(FL_STATUS_IN_MENU))
    {
      // tmp solution
      vFlIpShowInfo(IP_INFO_PBC, bVal, wMsgIndex);
      //vOsdPosShowArg(OSD_POS_FS_PBC, wMsgIndex, OSD_NO_DISAPPEAR, pbStr);
    }
    else
#endif /* PLAYER_FLMENU */
    {
      vOsdPosShowArg(OSD_POS_PLAY_STATUS, wMsgIndex, bTime, pbStr);
    }

#ifdef PLAYER_GOTO
    // megaa Goto
    if (fgIsInGoto())
    {
      vGotoShowIcon(wMsgIndex, pbStr);
    }
#endif
  }
}

#if 0
void vOsdShowPbcState(BYTE bState, BYTE bVal, BYTE bTime) large
{
  BYTE pbStr[5];
  WORD wMsgIndex = 0;
  WORD wMsg = 0;
  BYTE bPlayType = bOsdCoreCurrPlayType();
  BOOL fgFlMenuOn = fgFlCheckStatus(FL_STATUS_IN_MENU);

  if (bPlayType != OSD_SHOW_CLEAR)
  {
    if (bPlayType != OSD_SHOW_PLAY)
    {
      /* we must by pass user action here */
      if (fgIsTrickPlay(bState))
      {
        vOsdCoreSetPlayStatus(OSD_SHOW_TRICK, bTime);
      }
      else if ((bState == SV_PLAY) && (bPlayType == OSD_SHOW_TRICK))
      {
        /* clear play status first, this should be moved to vChangePbcState() */
        vOsdCoreSetPlayStatus(OSD_SHOW_CLEAR, 0);
      }
      else
      {
        return;
      }
    }
    else if (bState == SV_PLAY) /* && (bPlayType == OSD_SHOW_PLAY) */
    {
      return;
    }
    else
    {
      /* clear play status first */
      vOsdCoreSetPlayStatus(OSD_SHOW_CLEAR, 0);
    }
  }

  /* start show play status */

  pbStr[0] = 2;

  if ((bState == SV_FF) || (bState == SV_FR))
  {
    if (bVal == 0)
    {
      bState = SV_PLAY;
    }
    else
    {
      bVal = bHEXToBCD(bVal);
      if (BCD_HI(bVal) > 0)
      {
        pbStr[1] = BCD_HI(bVal) + '0';
      }
      else
      {
        pbStr[1] = ' ';
      }
      pbStr[2] = BCD_LO(bVal) + '0';
    }
  }
  else if ((bState == SV_SF) || (bState == SV_SR))
  {
    if (bVal == 0)
    {
      bState = SV_PLAY;
    }
    else
    {
      bVal = bHEXToBCD(bVal);
      if (BCD_HI(bVal) > 0)
      {
        pbStr[1] = BCD_HI(bVal) + '0';
        pbStr[2] = BCD_LO(bVal) + '0';
      }
      else
      {
        pbStr[1] = BCD_LO(bVal) + '0';
        pbStr[2] = ' ';
      }
    }
  }

  switch (bState)
  {
    case SV_PLAY:
    case SV_STILL:
    case SV_DIGEST9:
    case SV_DIGEST4:
    case SV_DIGEST:
      /* show "BLANK" for PLAY state */
      vOsdPosClear(OSD_POS_PLAY_STATUS);
#ifdef PLAYER_GOTO
      // megaa Goto
      if (fgIsInGoto())
      {
        pbStr[0] = 0;
        vGotoShowIcon(OSD_MSG_ICON_PLAY, pbStr);
      }
#endif
      return;

    case SV_STOP:
    case SV_STOP_RESUME:
      pbStr[0] = 0;
      wMsgIndex = fgFlMenuOn ? OSD_MSG_STOP : OSD_MSG_ICON_STOP;
      break;

    case SV_FF:
      wMsgIndex = fgFlMenuOn ? OSD_MSG_FFX : OSD_MSG_ICON_FFX;
      break;

    case SV_FR:
      wMsgIndex = fgFlMenuOn ? OSD_MSG_FRX : OSD_MSG_ICON_FRX;
      break;

    case SV_SF:
      wMsgIndex = fgFlMenuOn ? OSD_MSG_SFX : OSD_MSG_ICON_SFX;
      break;

    case SV_SR:
      wMsgIndex = fgFlMenuOn ? OSD_MSG_ICON_SRX : OSD_MSG_ICON_SRX;
      break;

    case SV_PAUSE:
      pbStr[0] = 0;
      wMsgIndex = fgFlMenuOn ? OSD_MSG_PAUSE : OSD_MSG_ICON_PAUSE;
      break;

    case SV_STEP:
      pbStr[0] = 0;
      wMsgIndex = fgFlMenuOn ? OSD_MSG_STEP : OSD_MSG_ICON_STEP;
      break;

    case SV_STEP_BACK:
      pbStr[0] = 0;
      wMsgIndex = fgFlMenuOn ? OSD_MSG_ICON_STEP_BACK : OSD_MSG_ICON_STEP_BACK;
      break;

    default:
      break;
  }

  if (wMsgIndex != 0)
  {
#ifdef PLAYER_FLMENU
    if (fgFlCheckStatus(FL_STATUS_IN_MENU))
    {
      vOsdPosShowArg(OSD_POS_FS_PBC, wMsgIndex, OSD_NO_DISAPPEAR, pbStr);
    }
    else
#endif /* PLAYER_FLMENU */
    {
      vOsdPosShowArg(OSD_POS_PLAY_STATUS, wMsgIndex, bTime, pbStr);
    }

#ifdef PLAYER_GOTO
    // megaa Goto
    if (fgIsInGoto())
    {
      vGotoShowIcon(wMsgIndex, pbStr);
    }
#endif
  }
}
#endif
static code WORD pwErrMsg[SV_ERR_MAX] = {
  0,                                /* 00: SV_NO_ERROR              */
  //OSD_MSG_ERR_INVALID_OPERATION,
  //OSD_MSG_ERR_INVALID_OPERATION,
  OSD_MSG_ERROR,                    /* 01: SV_ERR_GENERAL           */
  OSD_MSG_ERROR,                    /* 02: SV_ERR_INVALID_OPERATION */
  OSD_MSG_ERR_INPUT_INVALID,        /* 03: SV_ERR_INPUT_INVALID     */
  //OSD_MSG_ERR_DISC_NOT_SUPPORT,
  OSD_MSG_ERROR,                    /* 04: SV_ERR_DISC_NOT_SUPPORT  */
  OSD_MSG_ERR_PLAYBACK_ONLY,        /* 05: SV_ERR_PLAYBACK_ONLY     */
  OSD_MSG_ERR_STOP_ONLY,            /* 06: SV_ERR_STOP_ONLY         */
  OSD_MSG_ERR_PBC_ON_ONLY,          /* 07: SV_ERR_PBC_ON_ONLY       */
  OSD_MSG_ERR_PBC_OFF_ONLY,         /* 08: SV_ERR_PBC_OFF_ONLY      */
  OSD_MSG_ERR_NORMAL_PLAY_ONLY,     /* 09: SV_ERR_NORMAL_PLAY_ONLY  */
#if (defined(PLAYER_KARAOKE) || defined(USE_EXTERNAL_KARAOKE))
  OSD_MSG_ERR_KARA_ONLY,            /* 10: SV_ERR_KARA_ONLY         */
  OSD_MSG_ERR_NON_KARA_ONLY,        /* 11: SV_ERR_NON_KARA_ONLY     */
#else
  OSD_MSG_ERROR,                    /* 10: SV_ERR_KARA_ONLY         */
  OSD_MSG_ERROR,                    /* 11: SV_ERR_NON_KARA_ONLY     */
#endif
  OSD_MSG_ERR_OSD_MEM_FULL,         /* 12: SV_ERR_OSD_MEM_FULL      */
  OSD_MSG_ERROR,                    /* 13: SV_ERR_LIST_HEAD_TRK     */
  OSD_MSG_ERROR,                    /* 14: SV_ERR_LIST_END_TRK      */
  OSD_MSG_ERROR,                    /* 15: SV_ERR_LIST_HEAD_CH      */
  OSD_MSG_ERROR                     /* 16: SV_ERR_LIST_END_CH       */
};

// *********************************************************************
// Function : void vOsdShowError(BYTE bType, BYTE bTime)
// Description :
// Parameter :
// Return    : None
// Note      :
// *********************************************************************
void vOsdShowError(BYTE bType, BYTE bTime) large
{
  BYTE pbStr[4];

  if (bType == OSD_ERROR_CLEAR)
  {
    if (bSharedInfo(SH_OSD_TIMER_ERR_MSG) > 0)
    {
      vOsdPosClear(OSD_POS_ERROR);
      vSetSharedInfo(SH_OSD_TIMER_ERR_MSG, 0);
    }
    return;
  }
  else if (bType == OSD_ERROR_CODE)
  {
    pbStr[0] = 3;

    /* assume the error code in BCD format */
    if (bTime > 0x99)
    {
      return;
    }

    pbStr[1] = '0';
    pbStr[2] = BCD_HI(bTime) + '0';
    pbStr[3] = BCD_LO(bTime) + '0';

    vOsdPosShowArg(OSD_POS_AUD_CTRL, OSD_MSG_ERROR_CODE, OSD_NO_DISAPPEAR, pbStr);

    return;
  }
  else if (bType >= SV_ERR_MAX)
  {
    return;
  }
  else if (pwErrMsg[bType] == 0)
  {
    return;
  }

#ifdef SHOW_ERROR_TYPE_MSG
  vOsdPosShow(OSD_POS_ERROR, pwErrMsg[bType], bTime);
#else
  vOsdPosShow(OSD_POS_ERROR, OSD_MSG_ERROR, bTime);
#endif
  vSetSharedInfo(SH_OSD_TIMER_ERR_MSG, bTime);
}

// *********************************************************************
// Function : void vOsdShowTimeRemain2(BYTE bMin, BYTE bSec, BYTE bTime)
// Description :
// Parameter :
// Return    : None
// *********************************************************************
void vOsdShowTimeRemain2(BYTE bMin, BYTE bSec, BYTE bTime) large
{
  BYTE pbTime[5];

  vCheckTimeValid2(bMin, bSec);

  pbTime[0] = 4;
  pbTime[1] = BCD_HI(bMin) + '0';
  pbTime[2] = BCD_LO(bMin) + '0';
  pbTime[3] = BCD_HI(bSec) + '0';
  pbTime[4] = BCD_LO(bSec) + '0';

  if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_LEFT)
  {
    vOsdPosShowArg(OSD_POS_TIME_LEFT, OSD_MSG_TIME_LEFT_2, bTime, pbTime);
  }
  else if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_RIGHT)
  {
    vOsdPosShowArg(OSD_POS_TIME_RIGHT, OSD_MSG_TIME_RIGHT_2, bTime, pbTime);
  }
}

// *********************************************************************
// Function : void vOsdShowTimeRemain3(BYTE bHour, BYTE bMin, BYTE bSec, BYTE bTime)
// Description : show 0:00:00 message,
// Parameter :
// Return    : None
// *********************************************************************
void vOsdShowTimeRemain3(BYTE bHour, BYTE bMin, BYTE bSec, BYTE bTime) large
{
  BYTE pbTime[6];

  vCheckTimeValid3(bHour, bMin, bSec);

  pbTime[0] = 5;
  pbTime[1] = BCD_LO(bHour) + '0';
  pbTime[2] = BCD_HI(bMin) + '0';
  pbTime[3] = BCD_LO(bMin) + '0';
  pbTime[4] = BCD_HI(bSec) + '0';
  pbTime[5] = BCD_LO(bSec) + '0';

  if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_LEFT)
  {
    vOsdPosShowArg(OSD_POS_TIME_LEFT, OSD_MSG_TIME_LEFT_3, bTime, pbTime);
  }
  else if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_RIGHT)
  {
    vOsdPosShowArg(OSD_POS_TIME_RIGHT, OSD_MSG_TIME_RIGHT_3, bTime, pbTime);
  }
}

// *********************************************************************
// Function : void vOsdShowTimeClear(void)
// Description : show 0:00:00 message,
// Parameter :
// Return    : None
// *********************************************************************
void vOsdShowTimeClear(void) large
{
  if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_LEFT)
  {
    vOsdPosClear(OSD_POS_TIME_LEFT);
  }
  else if (_rOsdStateCtx.fgTimePos == OSD_SHOW_TIME_RIGHT)
  {
    vOsdPosClear(OSD_POS_TIME_RIGHT);
  }
}

// *********************************************************************
// Function : void vOsdShowSelect2(BYTE bNum, BYTE bType, BYTE bTime) large
// Description : show SELECT message,
// Parameter :
// Return    : None
// *********************************************************************
void vOsdShowSelect2(BYTE bNum, BYTE bType, BYTE bTime) large
{
  BYTE pbNum[3];
  BOOL fgHili;

  if (bType == OSD_SELECT_CLEAR)
  {
    vOsdClearInputField(OSD_POS_SELECT);
    vOsdPosClear(OSD_POS_SELECT);
    return;
  }
  else
  {