//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/****************************************************************************\
*
*  Module Name    dalovl.c
*  Project        ATI Display Abstraction Layer
*  Device         Radeon (Win95/98 & WinNT 4.0/5.0)
*
*  Description    source file for Display Abstraction Layer 0.87
*                 contains functions for processing CWDDE Extensions
*
*  Copyright (c) 1998-2001 ATI Technologies Inc. (unpublished)
*
*  All rights reserved.  This notice is intended as a precaution against
*  inadvertent publication and does not imply publication or any waiver
*  of confidentiality.  The year included in the foregoing notice is the
*  year of creation of the work.
*
*  Refer to DAL Developers Guide & Programming Reference Rev 0.87 for usage
*
\****************************************************************************/

#include "dal.h"
#include "daldef.h"
#include "cwddedi.h"

/****************************Private*Routine*******************************\
*
* ULONG DALCWDDE_OverlayFlushData()
*
* Function queries all dirty overlay adjustment data and retuns the regsitry
* data via CWDDE to be written into the registry.
*
* Notes:
*
\**************************************************************************/

ULONG DALCWDDE_OverlayFlushData(
LPHW_DAL_EXTENSION lpHDE,
ULONG              ulDriverID,
SAVEDATA FAR      *lpSaveData)
{
  ULONG       i;
  BOOL        bYUVFormat;
  LPOVLADJUST lpAdjust;

  lpSaveData->ulSize = sizeof(SAVEDATA);
  lpSaveData->ulReturnSize = 0;

  bYUVFormat = TRUE;
  for (i = 0; i < DAL_OVERLAY_MAX_NUM_ADJUSTMENTS; i++)
  {
    lpAdjust = (LPOVLADJUST)&lpHDE->asOvlAdjust[i];

    // no need to save to the registry when an adjustment is needed to be 
    // reset at overlay allocation time.
    if (  (  DAL_OVLADJUST_SAVEREG_FLAG      & lpAdjust->ulFlags)
        &&(!(DAL_OVLADJUST_RESETATALLOC_FLAG & lpAdjust->ulFlags)))
    {
      lpGetOverlayRegName(lpSaveData->cStrName,
                          (LPUCHAR)NULL,
                          bYUVFormat,
                          lpAdjust->lpRegName);

      if (DAL_OVLADJUST_DISPDEVDEP_FLAG & lpAdjust->ulFlags)
      {
        lpSaveData->ulReturnSize = sizeof(LONG) * MAX_OBJECT_MAP;
      }
      else
      {
        lpSaveData->ulReturnSize = sizeof(LONG);
      }

      MOVEMEMORY((LPVOID)lpSaveData->ulBuffer,
                 (LPVOID)lpAdjust->lpAdjusts,
                 lpSaveData->ulReturnSize);
    
      lpAdjust->ulFlags &= ~DAL_OVLADJUST_SAVEREG_FLAG;

      return(CWDDE_OK);
    }
  }

  return(CWDDE_ERR_OUTOFRANGE);
}


/******************************Private*Routine*****************************\
*
* LPUCHAR lpGetOverlayRegName()
*
* This function construct registry name for an overlay adjustment
*
* PARAMETERS:
* lpBuf         buffer for the registry name to be stored
* lpDisplayName pointer of a display name.  If this pointer is valid, then
*               this function contructs default name; otherwise, it builds
*               name for adjustment values.
* bYUVFormat    TRUE indicates YUV overlay source format
* lpOverlayName pointer of a adjustment type name
*
* RETURN:
* lpBuf if there is no error.
* 
\**************************************************************************/

LPUCHAR lpGetOverlayRegName(LPUCHAR lpBuf,
                            LPUCHAR lpDisplayName,
                            BOOL    bYUVFormat,
                            LPUCHAR lpOverlayName)
{
    if (lpDisplayName && lpOverlayName &&
        (sizeof(DALREGKEY_DAL) +
         strlen(lpDisplayName) +
         sizeof(DALREGKEY_DEFAULT) +
         sizeof(DALREGKEY_OVERLAYYUV) +
         strlen(lpOverlayName)) <= MAX_REGISTRY_VALUENAME)
    {
        strcpy(lpBuf, DALREGKEY_DAL);
        strcat(lpBuf, (lpDisplayName ? lpDisplayName : ""));
        strcat(lpBuf, (lpDisplayName ? DALREGKEY_DEFAULT : ""));
        strcat(lpBuf, (bYUVFormat ? DALREGKEY_OVERLAYYUV : ""));
        strcat(lpBuf, lpOverlayName);
    }

    return lpBuf;
}


/******************************Private*Routine*****************************\
*
* LONG lGetOverlayDefaultPerDisplay()
* 
* This function retreives an overlay type default value from the registry.
* The default value is display dependent.
*
* PARAMETERS:
* lpHDE         DAL instance structure
* ulDisplayType bit vector of a display type
* lpReg         pointer of an overlay adjustment name
* bYUVFormat    TRUE indicates YUV overlay source format
* lDefault      returns this value if an error occurs
*
* RETURN:
* an overlay default value
* 
\**************************************************************************/

LONG lGetOverlayDefaultPerDisplay(LPHW_DAL_EXTENSION lpHDE,
                                  ULONG              ulDisplayType,
                                  LPUCHAR            lpReg,
                                  BOOL               bYUVFormat,
                                  LONG               lDefault)
{
  ULONG    i;
  ULONG    ulSize;
  ULONG    ulData;
  LPDEVGDO lpDisplay;
  UCHAR    aucRegName[MAX_REGISTRY_VALUENAME];

  //
  // get the registry name
  //
  i = ulFindDisplayIndex(lpHDE, ulDisplayType);
  if (MAX_NUMBER_DISPLAYS == i)
  {
    return lDefault;
  }

  lpDisplay = (LPDEVGDO)&lpHDE->aDisplays[i];
  lpGetOverlayRegName(aucRegName,
                      (LPUCHAR)lpDisplay->lpHWED->lpDisplayName,
                      bYUVFormat,
                      lpReg);

  // 
  ulSize = sizeof(ULONG);
  if ((DDLGetRegistryParameters(lpHDE->hDDL,
                                (LPUCHAR)&aucRegName[0],
                                (LPVOID)(&ulData),
                                (LPULONG)&ulSize) &&
      (ulSize == sizeof(ULONG))))
  {
    return (LONG)ulData;
  }

  return lDefault;
}


/******************************Private*Routine*****************************\
*
* ULONG ulGetOverlayPriorityDisplay()
*
* This function returns a display index from a display bit-vector.
* It prioritizes the display types and returns the highest available display
* index.
*
* PARAMETERS:
* ulDisplays  a display bit-vector
*
* RETURN:
* display index
* 
\**************************************************************************/

ULONG ulGetOverlayPriorityDisplay(ULONG ulDisplays)
{
  ULONG ulIndex;
  ULONG ulBitVector = HW_DISPLAY_TYPE_CRT;

  if (HW_DISPLAY_TYPE_LCD & ulDisplays)
  {
    ulBitVector = HW_DISPLAY_TYPE_LCD;
  }
  else if (HW_DISPLAY_TYPE_CV & ulDisplays)
  {
    ulBitVector = HW_DISPLAY_TYPE_CV;
  }
  else if (HW_DISPLAY_TYPE_TV & ulDisplays)
  {
    ulBitVector = HW_DISPLAY_TYPE_TV;
  }
  else if (HW_DISPLAY_TYPE_DFP & ulDisplays)
  {
    ulBitVector = HW_DISPLAY_TYPE_DFP;
  }
  else if (HW_DISPLAY_TYPE_DFP_EXTTMDS & ulDisplays)
  {
    ulBitVector = HW_DISPLAY_TYPE_DFP_EXTTMDS;
  }
  else if (HW_DISPLAY_TYPE_CRT & ulDisplays)
  {
    ulBitVector = HW_DISPLAY_TYPE_CRT;
  }
  else if (HW_DISPLAY_TYPE_CRT_2NDDAC & ulDisplays)
  {
    ulBitVector = HW_DISPLAY_TYPE_CRT_2NDDAC;
  }

  ulIndex       = 0;
  ulBitVector >>= 1;
  while (ulBitVector)
  {
    ulIndex++;
    ulBitVector >>= 1;
  }

  return ulIndex;
}


/******************************Private*Routine*****************************\
*
* VOID vBuildOverlaySettings()
*
* This function builds the overlay defaults and values based on the GCO
* and registry setting.
*
* PARAMETERS:
* lpHDE       DAL instance structure
*
* RETURN:
* none
* 
\**************************************************************************/

VOID vBuildOverlaySettings(LPHW_DAL_EXTENSION lpHDE)
{
  ULONG         i;
  LPDEVGCO      lpController;
  LPOVLADJUST   lpAdjust;
  UCHAR         aucRegName[MAX_REGISTRY_VALUENAME];
  LONG          lValue;
  ULONG         ulSize;

  lpController = (LPDEVGCO)&lpHDE->aControllers[0];   // sr - changed from 0 to 1.  Need to verify this for CE.

  // build up the adjustment table
  for (i = 0; i < DAL_OVERLAY_MAX_NUM_ADJUSTMENTS; i++)
  {
    lpAdjust = (LPOVLADJUST)&lpHDE->asOvlAdjust[i];
    lpAdjust->ulFlags = 0;

    switch (i)
    {
      case DAL_OVERLAY_ADJUSTTYPE_BRIGHTNESS:
      {
        if (  (GCO_HOOK_OVERLAY_GAMMA_ADJUSTMENT & lpController->lpHWED->ulFunctionHooks)
            &&(lpController->lpHWED->pfnGetOverlayGammaAdjustment)
            &&(lpController->lpHWED->pfnSetOverlayGammaAdjustment))
        {
          lpAdjust->ulFlags  |= DAL_OVLADJUST_SUPPORTED_FLAG;
          lpAdjust->ulFlags  |= DAL_OVLADJUST_DISPDEVDEP_FLAG;
          lpAdjust->ulDIIndex = CWDDEDI_CONTROLLER_OVERLAY_BRIGHTNESS;
          lpAdjust->lpDefault = lpHDE->alOverlayYUVDefaultBrightness;
          lpAdjust->lpAdjusts = lpHDE->alOverlayYUVBrightness;
          lpAdjust->lpRegName = (LPUCHAR)DALREGKEY_OVERLAYBRIGHTNESS;
          lpAdjust->pfnGet    = lpController->lpHWED->pfnGetOverlayGammaAdjustment;
          lpAdjust->pfnSet    = lpController->lpHWED->pfnSetOverlayGammaAdjustment;
          (*lpController->lpHWED->pfnGetOverlayGammaAdjustment)
                   (lpController->hGCO, (LPHW_ADJUSTMENT)&(lpAdjust->sGCODefault));
        }

        break;
      }

      case DAL_OVERLAY_ADJUSTTYPE_SATURATION:
      {
        if (  (GCO_HOOK_OVERLAY_SATURATION_ADJUSTMENT & lpController->lpHWED->ulFunctionHooks)
            &&(lpController->lpHWED->pfnGetOverlaySaturationAdjustment)
            &&(lpController->lpHWED->pfnSetOverlaySaturationAdjustment))
        {
          lpAdjust->ulFlags  |= DAL_OVLADJUST_SUPPORTED_FLAG;
          lpAdjust->ulFlags  |= DAL_OVLADJUST_DISPDEVDEP_FLAG;
          lpAdjust->ulDIIndex = CWDDEDI_CONTROLLER_OVERLAY_SATURATION;
          lpAdjust->lpDefault = lpHDE->alOverlayYUVDefaultSaturation;
          lpAdjust->lpAdjusts = lpHDE->alOverlayYUVSaturation;
          lpAdjust->lpRegName = (LPUCHAR)DALREGKEY_OVERLAYSATURATION;
          lpAdjust->pfnGet    = lpController->lpHWED->pfnGetOverlaySaturationAdjustment;
          lpAdjust->pfnSet    = lpController->lpHWED->pfnSetOverlaySaturationAdjustment;
          (*lpController->lpHWED->pfnGetOverlaySaturationAdjustment)
                   (lpController->hGCO, (LPHW_ADJUSTMENT)&(lpAdjust->sGCODefault));
        }

        break;
      }

      case DAL_OVERLAY_ADJUSTTYPE_CONTRAST:
      {
        if (  (GCO_HOOK_OVERLAY_CONTRAST_ADJUSTMENT & lpController->lpHWED->ulFunctionHooks)
            &&(lpController->lpHWED->pfnGetOverlayContrastAdjustment)
            &&(lpController->lpHWED->pfnSetOverlayContrastAdjustment))
        {
          lpAdjust->ulFlags  |= DAL_OVLADJUST_SUPPORTED_FLAG;
          lpAdjust->ulFlags  |= DAL_OVLADJUST_DISPDEVDEP_FLAG;
          lpAdjust->ulDIIndex = CWDDEDI_CONTROLLER_OVERLAY_CONTRAST;
          lpAdjust->lpDefault = lpHDE->alOverlayYUVDefaultContrast;
          lpAdjust->lpAdjusts = lpHDE->alOverlayYUVContrast;
          lpAdjust->lpRegName = (LPUCHAR)DALREGKEY_OVERLAYCONTRAST;
          lpAdjust->pfnGet    = lpController->lpHWED->pfnGetOverlayContrastAdjustment;
          lpAdjust->pfnSet    = lpController->lpHWED->pfnSetOverlayContrastAdjustment;
          (*lpController->lpHWED->pfnGetOverlayContrastAdjustment)
                   (lpController->hGCO, (LPHW_ADJUSTMENT)&(lpAdjust->sGCODefault));
        }

        break;
      }

      case DAL_OVERLAY_ADJUSTTYPE_HUE:
      {
        if (  (GCO_HOOK_OVERLAY_HUE_ADJUSTMENT & lpController->lpHWED->ulFunctionHooks)
            &&(lpController->lpHWED->pfnGetOverlayHueAdjustment)
            &&(lpController->lpHWED->pfnSetOverlayHueAdjustment))
        {
          lpAdjust->ulFlags  |= DAL_OVLADJUST_SUPPORTED_FLAG;
          lpAdjust->ulFlags  |= DAL_OVLADJUST_DISPDEVDEP_FLAG;
          lpAdjust->ulDIIndex = CWDDEDI_CONTROLLER_OVERLAY_HUE;
          lpAdjust->lpDefault = lpHDE->alOverlayYUVDefaultHue;
          lpAdjust->lpAdjusts = lpHDE->alOverlayYUVHue;
          lpAdjust->lpRegName = (LPUCHAR)DALREGKEY_OVERLAYHUE;
          lpAdjust->pfnGet    = lpController->lpHWED->pfnGetOverlayHueAdjustment;
          lpAdjust->pfnSet    = lpController->lpHWED->pfnSetOverlayHueAdjustment;
          (*lpController->lpHWED->pfnGetOverlayHueAdjustment)
                   (lpController->hGCO, (LPHW_ADJUSTMENT)&(lpAdjust->sGCODefault));
        }

        break;
      }

      case DAL_OVERLAY_ADJUSTTYPE_GAMMA:
      {
        if (  (GCO_HOOK_OVERLAY_COLOR_GAMMA_ADJUSTMENT & lpController->lpHWED->ulFunctionHooks)
            &&(lpController->lpHWED->pfnGetOverlayColorGammaAdjustment)
            &&(lpController->lpHWED->pfnSetOverlayColorGammaAdjustment))
        {
          lpAdjust->ulFlags  |= DAL_OVLADJUST_SUPPORTED_FLAG;
          lpAdjust->ulDIIndex = CWDDEDI_CONTROLLER_OVERLAY_GAMMA;
          lpAdjust->lpDefault = (LPLONG)&(lpAdjust->sGCODefault.lDefault);
          lpAdjust->lpAdjusts = (LPLONG)&(lpHDE->lOverlayYUVGamma);
          lpAdjust->lpRegName = (LPUCHAR)DALREGKEY_OVERLAYGAMMA;
          lpAdjust->pfnGet    = lpController->lpHWED->pfnGetOverlayColorGammaAdjustment;
          lpAdjust->pfnSet    = lpController->lpHWED->pfnSetOverlayColorGammaAdjustment;
          (*lpController->lpHWED->pfnGetOverlayColorGammaAdjustment)
                   (lpController->hGCO, (LPHW_ADJUSTMENT)&(lpAdjust->sGCODefault));
        }

        break;
      }

      case DAL_OVERLAY_ADJUSTTYPE_ALPHA:
      {
        if (  (GCO_HOOK2_OVERLAY_ALPHA_ADJUSTMENT & lpController->lpHWED->ulFunctionHooks2)
            &&(lpController->lpHWED->pfnGetOverlayAlphaAdjustment)
            &&(lpController->lpHWED->pfnSetOverlayAlphaAdjustment))
        {
          lpAdjust->ulFlags  |= DAL_OVLADJUST_SUPPORTED_FLAG;
          lpAdjust->ulFlags  |= DAL_OVLADJUST_RESETATALLOC_FLAG;
          lpAdjust->ulDIIndex = CWDDEDI_CONTROLLER_OVERLAY_ALPHA;
          lpAdjust->lpDefault = (LPLONG)&(lpAdjust->sGCODefault.lDefault);
          lpAdjust->lpAdjusts = (LPLONG)&(lpHDE->lOverlayYUVAlpha);
          lpAdjust->lpRegName = (LPUCHAR)DALREGKEY_OVERLAYALPHA;
          lpAdjust->pfnGet    = lpController->lpHWED->pfnGetOverlayAlphaAdjustment;
          lpAdjust->pfnSet    = lpController->lpHWED->pfnSetOverlayAlphaAdjustment;
          (*lpController->lpHWED->pfnGetOverlayAlphaAdjustment)
                   (lpController->hGCO, (LPHW_ADJUSTMENT)&(lpAdjust->sGCODefault));
        }

        break;
      }
    } 
  }

  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)
      {
        BOOL     bYUVFormat;
        ULONG    j;