osdcore.c

是MTK公司新出来的DVD方案

// *********************************************************************
BOOL fgOsdCoreChgColDis(WORD wPosIndex, BYTE bWB) large
{
  BOOL fgChange;
  uOsdLayer1Status uTmp1;
  uOsdLayer2Status uTmp2;

  fgChange = FALSE;
  uTmp1.Byte = bSharedInfo(SH_OSD_LAYER1_STATUS);
  uTmp2.Byte = bSharedInfo(SH_OSD_LAYER2_STATUS);

  if (fgIsLayer2(wPosIndex))
  {
    if (!fgIsInSetupMenu())
    {
      fgChange = TRUE;
    }

    if (bWB == pbWbLayer2[0])
    {
      uTmp2.Bit.Wb1Hili = FALSE;
    }
    else if (bWB == pbWbLayer2[1])
    {
      uTmp2.Bit.Wb2Hili = FALSE;
    }
    else if (bWB == pbWbLayer2[2])
    {
      uTmp2.Bit.Wb3Hili = FALSE;
    }
    else if (bWB == pbWbLayer2[3])
    {
      uTmp2.Bit.Wb4Hili = FALSE;
    }

    vSetSharedInfo(SH_OSD_LAYER2_STATUS, uTmp2.Byte);
  }
  else if (fgIsLayer1(wPosIndex))
  {
    /* the hili disable is done in layer refresh */
    if (bWB == pbWbLayer1[0])
    {
      uTmp1.Bit.Wb1Hili = FALSE;
      if (!(uTmp2.Bit.Line1 || fgIsInSetupMenu()))
      {
        fgChange = TRUE;
      }
    }
    else if (bWB == pbWbLayer1[1])
    {
      uTmp1.Bit.Wb2Hili = FALSE;
      if (!(uTmp2.Bit.Line2 || fgIsInSetupMenu()))
      {
        fgChange = TRUE;
      }
    }
    else if (bWB == pbWbLayer1[2])
    {
      uTmp1.Bit.Wb3Hili = FALSE;
      if (!(uTmp2.Bit.Line3 || fgIsInSetupMenu()))
      {
        fgChange = TRUE;
      }
    }
    else if (bWB == pbWbLayer1[3])
    {
      uTmp1.Bit.Wb4Hili = FALSE;
      if (!(uTmp2.Bit.Line4 || fgIsInSetupMenu()))
      {
        fgChange = TRUE;
      }
    }

    vSetSharedInfo(SH_OSD_LAYER1_STATUS, uTmp1.Byte);
  }
  else
  {
    fgChange = TRUE;
  }

  return (fgChange);
}

// *********************************************************************
// Function : BYTE bOsdCoreCurrPlayType(void)
// Description :
// Parameter :
// Return    : None
// *********************************************************************
BYTE bOsdCoreCurrPlayType(void) large
{
  if (_rOsdStateCtx.fgPlayShow == TRUE)
  {
    return (_rOsdStateCtx.bPlayType);
  }
  else
  {
    return (OSD_SHOW_CLEAR);
  }
}

// *********************************************************************
// Function : void vOsdCoreSetPlayStatus(BYTE bStatus, BYTE bTime)
// Description :
// Parameter :
// Return    : None
// *********************************************************************
void vOsdCoreSetPlayStatus(BYTE bStatus, BYTE bTime) large
{
  if (bStatus == OSD_SHOW_CLEAR)
  {
    _rOsdStateCtx.fgPlayShow = FALSE;
    _rOsdStateCtx.bPlayType = OSD_SHOW_PLAY;
    vSetSharedInfo(SH_OSD_TIMER_PLAY_STATUS, 0);
  }
  else
  {
    _rOsdStateCtx.fgPlayShow = TRUE;
    _rOsdStateCtx.bPlayType = bStatus;
    vSetSharedInfo(SH_OSD_TIMER_PLAY_STATUS, bTime);
  }
}

// *********************************************************************
// Function : void vOsdCoreSetAudioStatus(BYTE bStatus, BYTE bTime)
// Description :
// Parameter :
// Return    : None
// *********************************************************************
void vOsdCoreSetAudioStatus(BYTE bStatus, BYTE bTime) large
{
  if (bStatus == OSD_AUDIO_SHOW_CLEAR)
  {
    _rOsdStateCtx.bAudioStatus = OSD_AUDIO_SHOW_NORMAL;
    _rOsdStateCtx.fgAudioStatusRecall = FALSE;
    vSetSharedInfo(SH_OSD_TIMER_AUDIO_CTRL, 0);
  }
  else
  {
    if ((_rOsdStateCtx.bAudioStatus == OSD_AUDIO_SHOW_MUTE) &&
        (bStatus != OSD_AUDIO_SHOW_MUTE))
    {
      /* don't chnage status */
      _rOsdStateCtx.fgAudioStatusRecall = TRUE;
      vSetSharedInfo(SH_OSD_TIMER_AUDIO_CTRL, bTime);
    }
    else
    {
      _rOsdStateCtx.bAudioStatus = bStatus;
      _rOsdStateCtx.fgAudioStatusRecall = FALSE;
      vSetSharedInfo(SH_OSD_TIMER_AUDIO_CTRL, 0);
    }
  }
}

// *********************************************************************
// Function : void vOsdShowMode(BYTE bMode)
// Description :
// Parameter :
// Return    : None
// *********************************************************************
void vOsdShowWb(BYTE bMode) large
{
  BYTE i, bTmp;
  BYTE bSavedMode, bCurrMode;

  bCurrMode = bSharedInfo(SH_OSD_WB_MODE);
  bSavedMode = bSharedInfo(SH_OSD_WB_SAVED);

  if (bCurrMode == bMode)
  {
    return;
  }

  if (bMode == OSD_WB_RESTORE)
  {
    if (fgIsInSetupMenu())
    {
      bMode = bCurrMode;
    }
    else /* not in setup menu */
    {
      if (bSavedMode == OSD_WB_NONE)
      {
        /* error! */
        bMode = OSD_WB_NORMAL;
      }
      else if (bSavedMode == bCurrMode)
      {
        vSetSharedInfo(SH_OSD_WB_SAVED, OSD_WB_NONE);
        return;
      }
      else
      {
        bMode = bSavedMode;
        vSetSharedInfo(SH_OSD_WB_MODE, bMode);
        vSetSharedInfo(SH_OSD_WB_SAVED, OSD_WB_NONE);
      }
    } /* not in setup menu */
  }
  else if (fgIsStDispWbMode(bMode))
  {
    if ((bCurrMode == OSD_WB_FULL_SCR) ||
        (bCurrMode == OSD_WB_USER))
    {
      // do it in OSD_WB_RESTORE
      return;
    }
  }

  switch (bMode)
  {
    case OSD_WB_RESET:
    {
      for(i=0; i < WB_LAYER1_NS; i++)
      {
        if (pbWbLayer1[i] != WB_NORMAL_VOL)
        {
          vClearWB(pbWbLayer1[i]);
        }
      }
      for(i=0; i < WB_LAYER2_NS; i++)
      {
        vClearWB(pbWbLayer2[i]);
      }
      for (i = 0; i < OSD_TIMER_MAX; i++)
      {
        vSetSharedInfo(SH_OSD_TIMER_START + i, 0);
      }

      /* clear input state */
      if (!fgIsInSetupMenu())
      {
        vChgColDis();
        vHideHL(HL_1);
        vHideHL(HL_2);
      }

      /* delete WB */
/*      
      for(i=0; i < WB_FULL_SCR_NS; i++)
      {
        vDeleteWB(pbWbFullScr[i]);
      }
*/      

      /* enable and disable WB */
      vDisableWB(WB_OVERLAY_MSG1);
/*      
      vDisableWB(WB_OVERLAY_MSG2);
      vDisableWB(WB_OVERLAY_MSG3);
      vDisableWB(WB_OVERLAY_MSG4);
*/      

      /* turn off static display WB */
      if (WB_ST_DISP_NS > 1) // assume the last one is null WB
      {
        for(i=0; i < WB_ST_DISP_NS-1; i++)
        {
          vDeleteWB(pbWbStaticDisp[i]);
        }
      }

      if (!fgIsInSetupMenu())
      {
        vEnableWB(WB_NORMAL_HEAD1);
        vEnableWB(WB_NORMAL_HEAD2);
        vEnableWB(WB_NORMAL_PBC1);
        vEnableWB(WB_NORMAL_PBC2);
        vEnableWB(WB_NORMAL_VOL);
      }

      /* set initial status */
      vSetSharedInfo(SH_OSD_LAYER1_WB, 0x7f);
      vSetSharedInfo(SH_OSD_LAYER1_STATUS, 0x00);
      vSetSharedInfo(SH_OSD_LAYER2_WB, 0x00);
      vSetSharedInfo(SH_OSD_LAYER2_STATUS, 0x00);

      /* set OSD wb mode */
      vSetSharedInfo(SH_OSD_WB_MODE, OSD_WB_NORMAL);
      vSetSharedInfo(SH_OSD_WB_SAVED, OSD_WB_NONE);

      /* set hili color */
      vSetHLCol(HL_1, HL1_NORMAL_COL);
      vSetHLCol(HL_2, HL1_NORMAL_COL);
      break;
    } /* OSD_WB_RESET */

    case OSD_WB_CLEAR:
    {
      /* clear layer 1 only */
      for(i=0; i < WB_LAYER1_NS; i++)
      {
        if (pbWbLayer1[i] != WB_NORMAL_VOL)
        {
          vClearWB(pbWbLayer1[i]);
        }
      }
      vSetSharedInfo(SH_OSD_TIMER_PLAY_STATUS, 0);
      vSetSharedInfo(SH_OSD_LAYER1_STATUS, 0x00);
      break;
    } /* OSD_WB_CLEAR */

#if 0
    case OSD_WB_CLEAR_ALL:
    {
      for(i=0; i < WB_LAYER1_NS; i++)
      {
        if (pbWbLayer1[i] != WB_NORMAL_VOL)
        {
          vClearWB(pbWbLayer1[i]);
        }
      }
      for(i=0; i < WB_LAYER2_NS; i++)
      {
        vClearWB(pbWbLayer2[i]);
      }
      for (i = 0; i < OSD_TIMER_MAX; i++)
      {
        vSetSharedInfo(SH_OSD_TIMER_START + i, 0);
      }

      vSetSharedInfo(SH_OSD_LAYER1_STATUS, 0x00);
      vSetSharedInfo(SH_OSD_LAYER2_STATUS, 0x00);
      vOsdCoreLayer2Refresh();
      vOsdCoreLayer1Refresh();
      break;
    } /* OSD_WB_CLEAR_ALL */
#endif

    case OSD_WB_DISABLE:
    {
      for (i=0; i < WB_LAYER1_NS; i++)
      {
        vDisableWB(pbWbLayer1[i]);
      }
      for (i=0; i < WB_LAYER2_NS; i++)
      {
        vDisableWB(pbWbLayer2[i]);
      }
      for (i=0; i < WB_FSMENU_NS; i++)
      {
        vDisableWB(pbWbFsMenu[i]);
      }
/*
      for(i=0; i < WB_FULL_SCR_NS; i++)
      {
        vDisableWB(pbWbFullScr[i]);
      }
*/      

      /* turn off static display WB */
      if (WB_ST_DISP_NS > 1) // assume the last one is null WB
      {
        for(i=0; i < WB_ST_DISP_NS-1; i++)
        {
          vDeleteWB(pbWbStaticDisp[i]);
        }
      }

      break;
    } /* OSD_WB_SETUP */

    case OSD_WB_NORMAL:
    case OSD_WB_ZOOM_BR:
    case OSD_WB_SPECTRUM:
    {
      /*
      for(i=0; i < WB_FULL_SCR_NS; i++)
      {
        vDeleteWB(pbWbFullScr[i]);
      }
      */

      /* no need to check fgIsInSetupMenu() here */
      bTmp = bSharedInfo(SH_OSD_LAYER1_WB);
      for(i=0; i < WB_LAYER1_NS; i++) /* not include FSMENU WB */
      {
        if (bTmp & 0x01)
        {
          vEnableWB(pbWbLayer1[i]);
        }

        bTmp >>= 1;
      }

      bMode = bRecallStDispWB();

      /* enable FSMENU WB */
#ifdef SUPPORT_DATA_DISC
      if (fgIsIsoPlay()
  #ifdef SUPPORT_PCD
        || fgIsPcdPlay()
  #endif
        )
      {
        #ifdef PLAYER_FLMENU
          vFlRecover();
        #else
          vFsMenuRecoverMenus();
        #endif
      }
#endif

      bTmp = bSharedInfo(SH_OSD_LAYER2_WB);
      for(i=0; i < WB_LAYER2_NS; i++)
      {
        if (bTmp & 0x01)
        {
          vEnableWB(pbWbLayer2[i]);
        }
        bTmp >>= 1;
      }

      vSetSharedInfo(SH_OSD_WB_MODE, bMode);
      break;
    } /* OSD_WB_NORMAL */

    case OSD_WB_FULL_SCR:
    {
      for(i=0; i < WB_LAYER1_NS; i++)
      {
        vDisableWB(pbWbLayer1[i]);
      }
      for(i=0; i < WB_LAYER2_NS; i++)
      {
        vDisableWB(pbWbLayer2[i]);
      }

      /* turn off non-overlay display WB */
      if (WB_ST_DISP_NS > 1) // assume the last one is null WB
      {
        for(i=0; i < WB_ST_DISP_NS-1; i++)
        {
          vDeleteWB(pbWbStaticDisp[i]);
        }
      }

      for (i=0; i < WB_FSMENU_NS; i++)
      {
        vDisableWB(pbWbFsMenu[i]);
      }

      /*
      for(i=0; i < WB_FULL_SCR_NS; i++)
      {
        vEnableWB(pbWbFullScr[i]);
      }
      */
      vSetSharedInfo(SH_OSD_WB_MODE, bMode);
      if (fgIsStDispWbMode(bCurrMode))
      {
        vSetSharedInfo(SH_OSD_WB_SAVED, bCurrMode);
      }
      break;
    } /* OSD_WB_FULL_SCR */

    case OSD_WB_USER:
    {
      /* turn off non-overlay display WB */
      if (WB_ST_DISP_NS > 1) // assume the last one is null WB
      {
        for(i=0; i < WB_ST_DISP_NS-1; i++)
        {
          vDeleteWB(pbWbStaticDisp[i]);
        }
      }

      vSetSharedInfo(SH_OSD_WB_MODE, bMode);
      if (fgIsStDispWbMode(bCurrMode))
      {
        vSetSharedInfo(SH_OSD_WB_SAVED, bCurrMode);
      }
      break;
    } /* OSD_WB_USER */

    /* TODO: add layer 1 status recall */

    default:
      break;
  }
}

#ifdef POS_CLEAR_DISABLE_WB
// *********************************************************************
// Function : void vOsdCoreLayer1WbRestore(BYTE bWb)
// Description :
// Parameter :
// Return    : None
// *********************************************************************
void vOsdCoreLayer1WbRestore(BYTE bWb) large
{
  BYTE bIdx;
  BYTE bCnt;

  switch (bWb)
  {
    case WB_NORMAL_HEAD1:
      bIdx = 0x00;
      break;

    case WB_NORMAL_HEAD2:
      bIdx = 0x01;
      break;

    case WB_NORMAL_PBC1:
      bIdx = 0x02;
      break;

    case WB_NORMAL_PBC2:
      bIdx = 0x03;
      break;

    case WB_NORMAL_VOL:
      vEnableWB(WB_NORMAL_VOL);
      return;

    default:
      return;
  } /* switch (bWb) */

  bIdx = (0x01 << bIdx);
  bCnt = bSharedInfo(SH_OSD_LAYER1_WB);

  if ((!fgIsInSetupMenu()) && (!fgIsScrSaverOn()) &&
      (bSharedInfo(SH_OSD_WB_MODE) != OSD_WB_FULL_SCR) && (bCnt & bIdx))
  {
    vEnableWB(bWb);
  }
}
#endif /* POS_CLEAR_DISABLE_WB */

/************************************************************************
     Function :
  Description :
    Parameter :
    Return    :
************************************************************************/
void vOsdCoreTimer(void) large
{
  if (_rOsdCore.fgRefreshNow == TRUE)
  {
    _rOsdCore.fgRefreshNow = FALSE;
    vOsdCoreRefresh(FALSE); /* no timer count */
    vSetLayer2Change(FALSE);
  }
}