dalmm.c

此代码为WCE5.0下显示器的源代码

//
// 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    dalmm.c
*  Project        ATI Display Abstraction Layer
*  Device         RageProPNP / Rage128 (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-2002 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"
#include "cwddemm.h"

/******************************Private*Routine******************************\
*
* BOOL bDetermineVCEngineIndex(...)
*
* This function validate the input capture engine ID.  It also translates
* the ID to internal array index.
*
* Parameters:
*   ulCaptureEngine - indicates which video capture engine (defined in cwddemm.h)
*   lpIndex         - returned value of corresponding array index
*
* Return:
*   TRUE            - ulCaptureEngine is valid
*   FALSE           - ulCaptureEngine is invalid
*
* Note:
*
\**************************************************************************/

BOOL bDetermineVCEngineIndex(
  ULONG   ulCaptureEngine,
  LPULONG lpIndex)
{
  DALASSERT((lpIndex != NULL), "bDetermineVCEngineIndex: NULL lpIndex pointer");

  if (MM_CAPTURE_ENGINE0 == ulCaptureEngine)
  {
    *lpIndex = 0;
    return TRUE;
  }
  else if (MM_CAPTURE_ENGINE1 == ulCaptureEngine)
  {
    *lpIndex = 1;
    return TRUE;
  }

  return FALSE;
}

/******************************Private*Routine******************************\
*
* ULONG ulValidateOverlayTheaterMode(...)
*
* This function validates requested overlay clone mode for the controller
*
* Return:
*   CWDDE_OK - on success
*
* Note:
*
\**************************************************************************/
ULONG ulValidateOverlayTheaterMode(LPHW_DAL_EXTENSION lpHDE,
                                   LPVOID             lpInput)
{
  ULONG                   ulReturn;
  ULONG                   ulController;
  ULONG                   ulDriverID;
  CWDDEMMCMD FAR          *lpMmCmd;
  MM_OVERLAYCLONEMODE FAR *lpMmOvlCloneMode;
  LPDEVGCO                lpController;
  LPDEVMODE_INFO          lpMI;
  DEVMODE_INFO            dmMode[MAX_NUMBER_CONTROLLERS];
  ULONG                   ulDisplayType[MAX_NUMBER_CONTROLLERS];
  ULONG                   ulDisplay[MAX_NUMBER_CONTROLLERS];
  ULONG                   i;

    
  ulReturn = CWDDE_OK;

  lpMmCmd = (CWDDEMMCMD FAR *)lpInput;

  if (lpMmCmd->ulSize != sizeof(CWDDEMMCMD) + sizeof(MM_OVERLAYCLONEMODE))
  {
    // specified input info size is invalid, fail

    ulReturn = CWDDE_ERR_BADINPUTSIZE;
    return ulReturn;

  }

  ulController = lpMmCmd->ulHandle;  // zero based controller index

  if (ulController >= lpHDE->ulControllersCount)
  {
    // specified controller index is invalid, fail

    ulReturn = CWDDE_ERR_BADINPUT;
    return ulReturn;

  }

  ulDriverID = lpMmCmd->ulDriverReserved;

  lpController = (LPDEVGCO) &lpHDE->aControllers[ulController];

  if ((lpController->ulFlags & GCO_MAPPED) &&
      (!(VECTORFROMINDEX(ulController) &
         lpHDE->aControllerMap[ulDriverID])))
  {
    // if the specified controller is active, but not with the driver
    // who is calling the DAL, fail the CWDDE call to ensure the caller
    // passes the CWDDE call to the driver whom owns the controller [GG]

    ulReturn = CWDDE_ERR_BADINPUT;
    return ulReturn;
  }

  lpMI = (LPDEVMODE_INFO)&dmMode[ulController];
  lpMmOvlCloneMode = (MM_OVERLAYCLONEMODE FAR *)&lpMmCmd[1];

  if (lpMmOvlCloneMode->ulFlags & CWDDEMM_OVERLAYCLONEMODE_FLAG_CURRENTVIEW)
  {
    // if this flag is set, function disregards the data in lpMmOvlCloneMode
    // structure and uses the current settings for the requested controller

    MOVEMEMORY(lpMI, (LPDEVMODE_INFO)&lpController->sModeInfo,
               sizeof(DEVMODE_INFO));
  }
  else
  {
    if ((lpMmOvlCloneMode->ulViewResolutionCx == 0) &&
        (lpMmOvlCloneMode->ulViewResolutionCy == 0) &&
        (lpMmOvlCloneMode->ulVerticalRefreshRate == 0) &&
        (lpMmOvlCloneMode->ulColorDepth == 0) &&
        (lpMmOvlCloneMode->ulFlags == 0))
    {
      // invalid input

      ulReturn = CWDDE_ERR_BADINPUT;
      return ulReturn;
    }
    
    if (lpMmOvlCloneMode->ulViewResolutionCx)
      lpMI->ulPelsWidth = lpMmOvlCloneMode->ulViewResolutionCx;
    else
    {
      // if ulViewResolutionCx is zero, use current horizontal view
      lpMI->ulPelsWidth = lpController->sModeInfo.ulPelsWidth;
    }

    if (lpMmOvlCloneMode->ulViewResolutionCy)
      lpMI->ulPelsHeight = lpMmOvlCloneMode->ulViewResolutionCy;
    else
    {
      // if ulViewResolutionCy is zero, use current vertical view
      lpMI->ulPelsHeight = lpController->sModeInfo.ulPelsHeight;
    }

    if (lpMmOvlCloneMode->ulVerticalRefreshRate)
      lpMI->ulDisplayFrequency = lpMmOvlCloneMode->ulVerticalRefreshRate;
    else
    {
      // if ulVerticalRefreshRate is zero, use current refresh rate
      lpMI->ulDisplayFrequency = lpController->sModeInfo.ulDisplayFrequency;
    }

    if (lpMmOvlCloneMode->ulColorDepth)
      lpMI->ulBitsPerPixel = lpMmOvlCloneMode->ulColorDepth;
    else
    {
      // if ulColorDepth is zero, use current bpp
      lpMI->ulBitsPerPixel = lpController->sModeInfo.ulBitsPerPixel;
    }
  }

  if ((lpMI->ulPelsWidth > lpHDE->aDriverData[ulDriverID].sMode.ulPelsWidth) ||
      (lpMI->ulPelsHeight >lpHDE->aDriverData[ulDriverID].sMode.ulPelsHeight) ||
      (lpMI->ulBitsPerPixel != lpHDE->aDriverData[ulDriverID].sMode.ulBitsPerPixel))
  {
    // requested view size exceeds the area of the drawing surface
    // or color depth is different

    ulReturn = CWDDE_ERR_BADINPUT;
    return ulReturn;
  }

  for (i = 0; i < lpHDE->ulControllersCount; i++)
  {
    // loop through all of the controllers to update
    // the displays to pass for this controller
    
    lpController = (LPDEVGCO) &lpHDE->aControllers[i];

    ulDisplay[i] = lpController->ulDisplays;
      
    // update the display types to pass for this controller
    ulDisplayType[i] = lpController->ulDisplayTypes;
  }

  if (!(bValidateMode(lpHDE,
                      (LPDEVMODE_INFO)&dmMode[0],
                      VECTORFROMINDEX(ulController),
                      (LPULONG)&ulDisplayType[0],
                      (LPULONG)&ulDisplay[0])))
  {
    // mode is not validated if no displays are connected to the
    // controller, because the controller is being disabled! [GG]

    // failed to validate the mode as requested by the CWDDE caller, so
    // the function fails.  DAL does not force the mode for CWDDE calls
    // because CWDDE client must be intelligent about setting exactly
    // what is wanted [GG]

    ulReturn = CWDDE_ERR_BADINPUT;
  }
  
  return(ulReturn);
}

/******************************Private*Routine******************************\
*
* ULONG ulSetOverlayTheaterMode(...)
*
* This function sets the requested overlay clone mode for the controller
*
* Return:
*   CWDDE_OK - on success
*
* Note:
*
\**************************************************************************/
ULONG ulSetOverlayTheaterMode(LPHW_DAL_EXTENSION lpHDE,
                              LPVOID             lpInput)
{
  ULONG                    ulReturn;
  ULONG                    ulController;
  LPDEVGCO                 lpController;
  CWDDEMMCMD FAR           *lpMmCmd;
  MM_OVERLAYCLONEMODE FAR  *lpMmOvlCloneMode;
  DEVMODE_INFO             ModeInfo;
  DRIVERDATA FAR           *lpDriverData;
  ULONG                    ulSaveFlags;

    
  ulReturn = ulValidateOverlayTheaterMode(lpHDE, lpInput);
  if (ulReturn == CWDDE_OK)
  {
    lpMmCmd = (CWDDEMMCMD FAR *)lpInput;

    ulController = lpMmCmd->ulHandle;  // zero based controller index

    lpController = (LPDEVGCO) &lpHDE->aControllers[ulController];

    if (lpController->ulFlags & GCO_OVERLAYTHEATERMODE)
    {
      // once the overlay clone mode has been already set, a call to reset overlay
      // clone mode is needed before a new set is requested

      ulReturn = CWDDE_ERR_FUNCTION_FAILED;
    }
    else
    {
      // lets see which mode requested
      lpMmOvlCloneMode = (MM_OVERLAYCLONEMODE FAR *)&lpMmCmd[1];

      if (lpMmOvlCloneMode->ulFlags & CWDDEMM_OVERLAYCLONEMODE_FLAG_CURRENTVIEW)
      {
        // if this flag is set, function disregards the data in lpMmOvlCloneMode
        // structure and uses the current settings for the requested controller

        ModeInfo.ulPelsWidth        = lpController->sModeInfo.ulPelsWidth;
        ModeInfo.ulPelsHeight       = lpController->sModeInfo.ulPelsHeight;
        ModeInfo.ulDisplayFrequency = lpController->sModeInfo.ulDisplayFrequency;
        ModeInfo.ulBitsPerPixel     = lpController->sModeInfo.ulBitsPerPixel;
      }
      else
      {
        if (lpMmOvlCloneMode->ulViewResolutionCx)
          ModeInfo.ulPelsWidth = lpMmOvlCloneMode->ulViewResolutionCx;
        else
        {
          // if ulViewResolutionCx is zero, use current horizontal view
          ModeInfo.ulPelsWidth = lpController->sModeInfo.ulPelsWidth;
        }

        if (lpMmOvlCloneMode->ulViewResolutionCy)
          ModeInfo.ulPelsHeight = lpMmOvlCloneMode->ulViewResolutionCy;
        else
        {
          // if ulViewResolutionCy is zero, use current vertical view
          ModeInfo.ulPelsHeight = lpController->sModeInfo.ulPelsHeight;
        }

        if (lpMmOvlCloneMode->ulVerticalRefreshRate)
          ModeInfo.ulDisplayFrequency = lpMmOvlCloneMode->ulVerticalRefreshRate;
        else
        {
          // if ulVerticalRefreshRate is zero, use current refresh rate
          ModeInfo.ulDisplayFrequency = lpController->sModeInfo.ulDisplayFrequency;
        }

        if (lpMmOvlCloneMode->ulColorDepth)
          ModeInfo.ulBitsPerPixel = lpMmOvlCloneMode->ulColorDepth;
        else
        {
          // if ulColorDepth is zero, use current bpp
          ModeInfo.ulBitsPerPixel = lpController->sModeInfo.ulBitsPerPixel;
        }
      }

      // CWDDE code needs to reset the controller before setting the mode
      // as vControllerResetMode reset some flags, save them !
      ulSaveFlags = lpController->ulFlags;

      vControllerResetMode(lpHDE, lpController);

      // drivers last 16bpp mode had the USE565 flag set, so the DAL will
      // preserve this color match for the next mode [GG] 04/01/99
      lpDriverData = (DRIVERDATA FAR *)&lpHDE->aDriverData[lpMmCmd->ulDriverReserved];
      ModeInfo.ulModeFlags = lpDriverData->sMode.ulModeFlags 
                           & (DEVMODEFLAG_USE565 | DEVMODEFLAG_USE4444);

      if (!(ulSaveFlags & GCO_VIEWSIZELOCKED))
      {
        lpController->siViewLock.cx = 0;
        lpController->siViewLock.cy = 0;
      }

      // program the view location for the mode

      lpController->sLastViewPosition.x = lpController->rtView.left;
      lpController->sLastViewPosition.y = lpController->rtView.top;

      lpController->rtView.left = 0;
      lpController->rtView.top = 0;
      lpController->rtView.right = ModeInfo.ulPelsWidth;
      lpController->rtView.bottom = ModeInfo.ulPelsHeight;

      // pan locking
      
      if (ulSaveFlags & GCO_PANLOCKED)
      {