bYUVFormat = TRUE;

        // Get overlay default
        for (j = 0; j < MAX_NUMBER_DISPLAYS; j++)
        {
          lpAdjust->lpDefault[j] = lpAdjust->sGCODefault.lDefault;

          ulSize = sizeof(LONG);  
          // get registry key
          lValue = lGetOverlayDefaultPerDisplay
                    (lpHDE, 1 << j, lpAdjust->lpRegName,
                     bYUVFormat, lpAdjust->sGCODefault.lDefault);
          if(  (lValue != lpAdjust->sGCODefault.lDefault)
             &&(lValue <= lpAdjust->sGCODefault.lMax)
             &&(lValue >= lpAdjust->sGCODefault.lMin)
             &&(lValue == ((lValue/lpAdjust->sGCODefault.lStep)*lpAdjust->sGCODefault.lStep)))
          {
            lpAdjust->lpDefault[j] = lValue;
          }
        }

        // Get overlay saved values
        lpGetOverlayRegName(aucRegName, (LPUCHAR)NULL, (BOOL)TRUE, lpAdjust->lpRegName);
    
        ulSize = sizeof(LONG) * MAX_OBJECT_MAP;
        if (!(DDLGetRegistryParameters(lpHDE->hDDL,
                                       (LPUCHAR)aucRegName,
                                       (LPVOID)(lpAdjust->lpAdjusts),
                                       (LPULONG) &ulSize) &&
             (ulSize == (sizeof(LONG) * MAX_OBJECT_MAP))))
        {
          ULONG    ulDisplay;

          for (j = 0; j < MAX_OBJECT_MAP; j++)
          {
            // get priority
            ulDisplay              = ulGetOverlayPriorityDisplay(j);
            lpAdjust->lpAdjusts[j] = lpAdjust->lpDefault[ulDisplay];
          }

          lpAdjust->ulFlags |= DAL_OVLADJUST_SAVEREG_FLAG;
        }
      }
      else
      {
        lpAdjust->lpAdjusts[0] = lpAdjust->sGCODefault.lDefault;
        lpAdjust->ulFlags     |= DAL_OVLADJUST_SAVEREG_FLAG;

        ulSize = sizeof(LONG);
        lpGetOverlayRegName((LPUCHAR)aucRegName,
                            (LPUCHAR)NULL,
                            (BOOL)TRUE,
                            (LPUCHAR)lpAdjust->lpRegName);

        if (DDLGetRegistryParameters(lpHDE->hDDL,
                                     (LPUCHAR)aucRegName,
                                     (LPVOID)(&lValue),
                                     (LPULONG) &ulSize) &&
          (ulSize == sizeof(LONG)))
        {
          if (  (lValue <= lpAdjust->sGCODefault.lMax)
              &&(lValue >= lpAdjust->sGCODefault.lMin)
              &&(lValue == ((lValue/lpAdjust->sGCODefault.lStep)*lpAdjust->sGCODefault.lStep)))
          {
            lpAdjust->lpAdjusts[0] = lValue;
            lpAdjust->ulFlags     &= ~DAL_OVLADJUST_SAVEREG_FLAG;
          }
        }
      }
    }
  }
}


/******************************Private*Routine*****************************\
*
* VOID vSetOverlayAdjust()
* 
* This function calls GCO to set an overlay adjustment.
*
* PARAMETERS:
* lpHDE         DAL handle
* lpController  pointer of a controller
* ulOvlAdjust   an overlay type
* lValue        an overlay value to be set
*
* RETURN:
* None
* 
\**************************************************************************/

VOID vSetOverlayAdjust
( LPHW_DAL_EXTENSION lpHDE,
  LPDEVGCO           lpController,
  ULONG              ulOvlAdjust,
  LONG               lValue)
{
  ULONG         ulIndex;
  LPOVLADJUST   lpAdjust;

  ulIndex = lpController->ulDisplayTypes & HW_DISPLAY_TYPES_MASK;

  lpAdjust = (LPOVLADJUST)&lpHDE->asOvlAdjust[ulOvlAdjust];
  if (!(DAL_OVLADJUST_SUPPORTED_FLAG & lpAdjust->ulFlags))
  {
    // not supported
    return;
  }

  if (lpController->ulControllerFlags & DAL_CONTROLLER_OVERLAY_RGB)
  {
    // RGB source - program default for now
    (*lpAdjust->pfnSet)(lpController->hGCO, lpAdjust->sGCODefault.lDefault);
  }
  else
  {
    (*lpAdjust->pfnSet)(lpController->hGCO, lValue);

    if (DAL_OVLADJUST_DISPDEVDEP_FLAG & lpAdjust->ulFlags)
    {
      if (lValue != lpAdjust->lpAdjusts[ulIndex])
      {
        lpAdjust->lpAdjusts[ulIndex] = lValue;
        lpAdjust->ulFlags           |= DAL_OVLADJUST_SAVEREG_FLAG;
      }
    }
    else
    {
      if (lValue != lpAdjust->lpAdjusts[0])
      {
        lpAdjust->lpAdjusts[0] = lValue;
        lpAdjust->ulFlags     |= DAL_OVLADJUST_SAVEREG_FLAG;
      }
    }
  }
}


/****************************Private*Routine*******************************\
*
* BOOL bValidateOvlAdjustValue
*
* This function assumes that controller supports the requested overlay
* adjustment.  It does not check for invalid adjustment function pointer.
*
\**************************************************************************/

BOOL bValidateOvlAdjustValue
( LPHW_DAL_EXTENSION lpHDE, 
  LPDEVGCO           lpController, 
  ULONG              ulOvlAdjust, 
  LONG               lData)
{
  LPOVLADJUST   lpAdjust;

  lpAdjust = (LPOVLADJUST)&lpHDE->asOvlAdjust[ulOvlAdjust];
  if (!(DAL_OVLADJUST_SUPPORTED_FLAG & lpAdjust->ulFlags))
  {
    // not supported
    return FALSE;
  }

  if(  (lData <= lpAdjust->sGCODefault.lMax)
     &&(lData >= lpAdjust->sGCODefault.lMin)
     &&(lData == ((lData/lpAdjust->sGCODefault.lStep)*lpAdjust->sGCODefault.lStep)))
  {
    return TRUE;
  }

  return FALSE;
}


/****************************Private*Routine*******************************\
*
* ULONG ulSetOverlayAdjustmentData
*
* This function sets the ovaley adjustment value
*
\**************************************************************************/
ULONG ulCWDDEDI_SetOverlayAdjustmentData
( LPHW_DAL_EXTENSION lpHDE, 
  LPDEVGCO           lpController, 
  ULONG              ulDIOvlAdjust, 
  LONG               lData)
{
  ULONG       i;
  LPOVLADJUST lpAdjust;

  // build up the adjustment table
  for (i = 0; i < DAL_OVERLAY_MAX_NUM_ADJUSTMENTS; i++)
  {
    lpAdjust = (LPOVLADJUST)&lpHDE->asOvlAdjust[i];
    if (  (lpAdjust->ulDIIndex == ulDIOvlAdjust)
        &&(DAL_OVLADJUST_SUPPORTED_FLAG & lpAdjust->ulFlags))
    {
      // found the adjustment
      break;
    }
  }

  if (i >= DAL_OVERLAY_MAX_NUM_ADJUSTMENTS)
  {
    // can't found the entry
    return CWDDE_ERR_UNSUPPORTED;
  }

  if (!bValidateOvlAdjustValue(lpHDE, lpController, i, lData))
  {
    return CWDDE_ERR_UNSUPPORTED;
  }

  vSetOverlayAdjust(lpHDE, lpController, i, lData);

  return CWDDE_OK;
}


/****************************Private*Routine*******************************\
*
* ULONG ulCWDDEDI_GetOverlayAdjustmentInfo
*
* This function returns the overlay adjustment info 
*
\**************************************************************************/

ULONG ulCWDDEDI_GetOverlayAdjustmentInfo
( LPHW_DAL_EXTENSION lpHDE, 
  LPDEVGCO           lpController, 
  ULONG              ulDIOvlAdjust, 
  LPHW_ADJUSTMENT    lpAdjustment)
{
  ULONG       i;
  LPOVLADJUST lpAdjust;

  // build up the adjustment table
  for (i = 0; i < DAL_OVERLAY_MAX_NUM_ADJUSTMENTS; i++)
  {
    lpAdjust = (LPOVLADJUST)&lpHDE->asOvlAdjust[i];
    if (  (lpAdjust->ulDIIndex == ulDIOvlAdjust)
        &&(DAL_OVLADJUST_SUPPORTED_FLAG & lpAdjust->ulFlags))
    {
      // found the adjustment
      break;
    }
  }

  if (i >= DAL_OVERLAY_MAX_NUM_ADJUSTMENTS)
  {
    // can't found the entry
    return CWDDE_ERR_UNSUPPORTED;
  }

  MOVEMEMORY((LPVOID)lpAdjustment,
             (LPVOID)&lpAdjust->sGCODefault,
             sizeof(HW_ADJUSTMENT));

  if (  (DAL_OVLADJUST_DISPDEVDEP_FLAG & lpAdjust->ulFlags)
      &&(!(DAL_CONTROLLER_OVERLAY_RGB & lpController->ulControllerFlags)))
  {
    ULONG ulIndex;

    ulIndex = ulGetOverlayPriorityDisplay
                    (lpController->ulDisplayTypes & HW_DISPLAY_TYPES_MASK);
    lpAdjustment->lDefault = lpAdjust->lpDefault[ulIndex];
  }

  return CWDDE_OK;
}


/****************************Private*Routine*******************************\
*
* ULONG ulCWDDEDI_GetOverlayAdjustmentData
*
* This function returns the current overlay adjustment value
*
\**************************************************************************/

ULONG ulCWDDEDI_GetOverlayAdjustmentData
( LPHW_DAL_EXTENSION lpHDE, 
  LPDEVGCO           lpController, 
  ULONG              ulDIOvlAdjust, 
  LPLONG             lpData)
{
  ULONG       i;
  ULONG       ulIndex;
  LPOVLADJUST lpAdjust;

  // build up the adjustment table
  for (i = 0; i < DAL_OVERLAY_MAX_NUM_ADJUSTMENTS; i++)
  {
    lpAdjust = (LPOVLADJUST)&lpHDE->asOvlAdjust[i];
    if (  (lpAdjust->ulDIIndex == ulDIOvlAdjust)
        &&(DAL_OVLADJUST_SUPPORTED_FLAG & lpAdjust->ulFlags))
    {
      // found the adjustment
      break;
    }
  }

  if (i >= DAL_OVERLAY_MAX_NUM_ADJUSTMENTS)
  {
    // can't found the entry
    return CWDDE_ERR_UNSUPPORTED;
  }

  if (DAL_CONTROLLER_OVERLAY_RGB & lpController->ulControllerFlags)
  {
    // return GCO default
    *lpData = lpAdjust->sGCODefault.lDefault;
    return CWDDE_OK;
  }

  ulIndex = 0;
  if (DAL_OVLADJUST_DISPDEVDEP_FLAG & lpAdjust->ulFlags)
  {
    ulIndex = lpController->ulDisplayTypes & HW_DISPLAY_TYPES_MASK;
  }

  *lpData = lpAdjust->lpAdjusts[ulIndex];

  return CWDDE_OK;
}


/****************************Private*Routine*******************************\
*
* VOID vHardwareUpdateOvlAdjusts
*
\**************************************************************************/

VOID vHardwareUpdateOvlAdjusts
( LPHW_DAL_EXTENSION lpHDE,
  LPDEVGCO           lpController) 
{
  ULONG       i;
  ULONG       ulIndex;
  LPOVLADJUST lpAdjust;

  if (!(DAL_CONTROLLER_OVERLAY_ALLOCATED & lpController->ulControllerFlags))
  {
    return;
  }

  ulIndex = lpController->ulDisplayTypes & HW_DISPLAY_TYPES_MASK;

  for (i = 0; i < DAL_OVERLAY_MAX_NUM_ADJUSTMENTS; i++)
  {
    lpAdjust = (LPOVLADJUST)&lpHDE->asOvlAdjust[i];
    if (DAL_OVLADJUST_SUPPORTED_FLAG & lpAdjust->ulFlags)
    {
      if (DAL_OVLADJUST_DISPDEVDEP_FLAG & lpAdjust->ulFlags)
      {
        vSetOverlayAdjust(lpHDE,
                          lpController,
                          i,
                          lpAdjust->lpAdjusts[ulIndex]);
      }
      else
      {
        vSetOverlayAdjust(lpHDE,
                          lpController,
                          i,
                          lpAdjust->lpAdjusts[0]);
      }
    }
  }
}


/****************************Private*Routine*******************************\
*
* ULONG ulCWDDEDI_GetOverlayInfo
*
\**************************************************************************/

ULONG ulCWDDEDI_GetOverlayInfo
( LPHW_DAL_EXTENSION lpHDE,
  ULONG              ulDriverID,
  DIOVERLAYINFO FAR *lpOvlInfo)
{
  ULONG         i;
  LPDEVGCO      lpController;

  ZEROMEMORY(lpOvlInfo, sizeof(DIOVERLAYINFO));

  lpOvlInfo->ulSize = sizeof(DIOVERLAYINFO);

  for (i = 0; i < MAX_NUMBER_CONTROLLERS; i++)
  {
    if (lpHDE->aControllerMap[ulDriverID] & VECTORFROMINDEX(i))
    {
      lpController = (LPDEVGCO)&lpHDE->aControllers[i];
      if (DAL_CONTROLLER_OVERLAY_ALLOCATED & lpController->ulControllerFlags)
      {
        if (DAL_CONTROLLER_OVERLAY_RGB & lpController->ulControllerFlags)
        {
          // no adjustment in RGB source right now

          lpOvlInfo->ulSourceType = CWDDEDI_OVERLAY_SOURCE_RGB;
        }
        else
        {
          ULONG       j;
          LPOVLADJUST lpAdjust;

          lpOvlInfo->ulSourceType = CWDDEDI_OVERLAY_SOURCE_YUV;

          for (j = 0; j < DAL_OVERLAY_MAX_NUM_ADJUSTMENTS; j++)
          {
            lpAdjust = (LPOVLADJUST)&lpHDE->asOvlAdjust[j];
            if (DAL_OVLADJUST_SUPPORTED_FLAG & lpAdjust->ulFlags)
            {
              lpOvlInfo->ulAdjustable |= VECTORFROMINDEX(lpAdjust->ulDIIndex);
            }
          }
        }

        lpOvlInfo->ulController = i;

        break;
      }
    }
  }

  return CWDDE_OK;
}