dalmm.c

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

        // controller was pan locked
        lpController->rtLastPanLock.top    = lpController->rtPanLock.top;
        lpController->rtLastPanLock.left   = lpController->rtPanLock.left;
        lpController->rtLastPanLock.bottom = lpController->rtPanLock.bottom;
        lpController->rtLastPanLock.right  = lpController->rtPanLock.right;
      }
      else
      {
        lpController->rtLastPanLock.top    = 0;
        lpController->rtLastPanLock.left   = 0;
        lpController->rtLastPanLock.bottom = 0;
        lpController->rtLastPanLock.right  = 0;
      }

      lpController->rtPanLock.top = 0;
      lpController->rtPanLock.left = 0;
      lpController->rtPanLock.bottom = 0;
      lpController->rtPanLock.right = 0;

      // Flag to call DDLPre/PostModeChange.  Should reset it after set mode call.
      // besides set GCO_OVERLAYTHEATERMODE as well
      lpController->ulFlags |= (GCO_CALLDDLPPMODECHANGE | GCO_OVERLAYTHEATERMODE);

      vControllerSetMode(lpHDE,
                         (LPDEVMODE_INFO)&ModeInfo,
                         lpController,
                         lpController->ulDisplays,
                         lpController->ulOffset,
                         lpController->ulPitch);

      // Reset DDLPre/PostModeChange flag
      lpController->ulFlags &= ~GCO_CALLDDLPPMODECHANGE;

    }
  }

  return (ulReturn);
}

/******************************Private*Routine******************************\
*
* ULONG ulResetOverlayTheaterMode(...)
*
* This function restores previous mode on the requested controller
*
* Return:
*   CWDDE_OK - on success
*
* Note:
*
\**************************************************************************/
ULONG ulResetOverlayTheaterMode(LPHW_DAL_EXTENSION lpHDE,
                                LPVOID             lpInput)
{
  ULONG                    ulReturn;
  ULONG                    ulController;
  LPDEVGCO                 lpController;
  CWDDEMMCMD FAR           *lpMmCmd;
  DEVMODE_INFO             ModeInfo;
  DRIVERDATA FAR           *lpDriverData;
  ULONG                    ulOffset;
  GCO_QUERY_STRUCTURE      sQueryGCO;
    
  lpMmCmd = (CWDDEMMCMD FAR *)lpInput;

  if (lpMmCmd->ulSize != sizeof(CWDDEMMCMD))
  {
    // 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;

  }

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

  if ((lpController->ulFlags & GCO_MAPPED) &&
      (!(VECTORFROMINDEX(ulController) &
         lpHDE->aControllerMap[lpMmCmd->ulDriverReserved])))
  {
    // 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;
  }

  if (lpController->ulFlags & GCO_OVERLAYTHEATERMODE)
  {
    // only need to do something if the overlay clone mode has been set

    ulReturn = CWDDE_OK;

    ModeInfo.ulModeFlags        = lpController->sLastModeInfo.ulModeFlags;
    ModeInfo.ulPelsWidth        = lpController->sLastModeInfo.ulPelsWidth;
    ModeInfo.ulPelsHeight       = lpController->sLastModeInfo.ulPelsHeight;
    ModeInfo.ulDisplayFrequency = lpController->sLastModeInfo.ulDisplayFrequency;
    ModeInfo.ulBitsPerPixel     = lpController->sLastModeInfo.ulBitsPerPixel;

    lpDriverData = (DRIVERDATA FAR *)&lpHDE->aDriverData[lpMmCmd->ulDriverReserved];

    // CWDDE code needs to reset the controller before setting the
    // mode.  vControllerSetMode may have the side effect of resetting one
    // or more controllers as they are disabled when no displays are active
    // on them. [GG]

    vControllerResetMode(lpHDE, lpController);

    if ((lpController->siViewLock.cx != 0) || (lpController->siViewLock.cy != 0))
      lpController->ulFlags |= GCO_VIEWSIZELOCKED;

    // restore the view location for the mode

    lpController->rtView.left = lpController->sLastViewPosition.x;
    lpController->rtView.top = lpController->sLastViewPosition.y;
    lpController->rtView.right = lpController->rtView.left + ModeInfo.ulPelsWidth;
    lpController->rtView.bottom = lpController->rtView.top + ModeInfo.ulPelsHeight;

    // restore pan locking flag

    if ((lpController->rtLastPanLock.left != 0)   ||
        (lpController->rtLastPanLock.top != 0)    ||
        (lpController->rtLastPanLock.bottom != 0) ||
        (lpController->rtLastPanLock.right != 0))
    {
      // a pan locking rectangle had been specified, code can safely assume
      // that the View position is within the pan lock rectangle which is
      // in the drawing surface, as the parameters were validated earlier.

      lpController->ulFlags |= GCO_PANLOCKED;

      lpController->rtPanLock.top = lpController->rtLastPanLock.top;
      lpController->rtPanLock.left = lpController->rtLastPanLock.left;
      lpController->rtPanLock.bottom = lpController->rtLastPanLock.bottom;
      lpController->rtPanLock.right = lpController->rtLastPanLock.right;

    }
    else
    {
      lpController->ulFlags &= ~GCO_PANLOCKED;

      lpController->rtPanLock.top = 0;
      lpController->rtPanLock.left = 0;
      lpController->rtPanLock.bottom = lpDriverData->sMode.ulPelsHeight;
      lpController->rtPanLock.right = lpDriverData->sMode.ulPelsWidth;
    }
    
    if (GCO_HOOK2_SETDISPLAYXYPOS & lpController->lpHWED->ulFunctionHooks2)
    {
      ulOffset = lpController->ulOffset;
    }
    else
    {
      //determine if we are in tiled memory case
      // get the pertinent info from the GCO
      ZEROMEMORY((LPGCO_QUERY_STRUCTURE) &sQueryGCO, sizeof(GCO_QUERY_STRUCTURE));
      (*lpController->lpHWED->pfnGetInfo)
                    (lpController->hGCO, lpController->ulController,
                    (LPGCO_QUERY_STRUCTURE) &sQueryGCO);

      if (sQueryGCO.ulFlags & GCO_QUERY_STRUCTURE_FLAGS_TILEENABLED) 
      {
        ulOffset = ulCalculateOffsetFromCoordinatesInTiledMemory(
            lpController->rtView.left, lpController->rtView.top ,
            (ModeInfo.ulBitsPerPixel >> 3),lpController->ulPitch,
            sQueryGCO.ulTileWidthBytes ,  sQueryGCO.ulTileHeightLines);
      }
      else
      {
        ulOffset = (lpController->rtView.top * lpController->ulPitch) +
                    lpController->rtView.left;

        ulOffset *= (ModeInfo.ulBitsPerPixel >> 3);
      }

      //  adjust on RGB boundary for 24 bpp case
      if (lpDriverData->sMode.ulBitsPerPixel == 24)
        ulOffset  = (ulOffset / 24) * 24;

      ulOffset += lpDriverData->ulOffset;
    }

    // Flag to call DDLPre/PostModeChange.  Should reset it after set mode call.
    lpController->ulFlags |= GCO_CALLDDLPPMODECHANGE;

    vControllerSetMode(lpHDE,
                       (LPDEVMODE_INFO)&ModeInfo,
                       lpController,
                       lpController->ulDisplays,
                       ulOffset,
                       lpController->ulPitch);

    // Reset DDLPre/PostModeChange flag
    // besides reset GCO_OVERLAYTHEATERMODE as well

    lpController->ulFlags &= ~(GCO_CALLDDLPPMODECHANGE | GCO_OVERLAYTHEATERMODE);

  }
  else
    ulReturn = CWDDE_ERR_FUNCTION_FAILED;

  return (ulReturn);
}

/******************************Public*Routine******************************\
*
* BOOL DALCWDDE_MM()
*
* Processes the Multi Media Common Windows Display Driver Extensions (Display Interface)
* function calls
*
* Note:
*
\**************************************************************************/

ULONG DALCWDDE_MM(
  HDAL   hDAL,
  LPVOID lpInput,
  ULONG  ulInputSize,
  LPVOID lpOutput,
  ULONG  ulOutputSize,
  LPLONG lpInfoSize)
{
  LPHW_DAL_EXTENSION  lpHDE;
  CWDDEMMCMD FAR      *lpMmCmd;
  ULONG               ulReturn;

  DALDEBUG((DALDBG_ENTRY_EXIT, "DALCWDDE_MM - Entry"));

  // grab the structure for the DAL out of the DDL's handle to it
  lpHDE = (LPHW_DAL_EXTENSION)hDAL;
  ulReturn = (ULONG)CWDDEMM_OK;

  if (ulInputSize < sizeof(CWDDEMMCMD))
  {
    // size of the input structure is smaller than the size of the CWDDE
    // command block and hence the DAL cannot process the call.

    ulReturn = (ULONG)CWDDEMM_ERR_BADINPUTSIZE;
    goto DALCWDDEMM_Return;
  }

  lpMmCmd = (CWDDEMMCMD FAR *)lpInput;

  if (lpMmCmd->ulDriverReserved >= MAX_NUMBER_CONTROLLERS)
  {
    // caller provided an invalid value for the DriverID in the reserved
    // field of the CWDDE command block, hence fail the call.

    ulReturn = (ULONG)CWDDEMM_ERR_BADINPUT;
    goto DALCWDDEMM_Return;
  }

  switch(lpMmCmd->ulEscape32)
  {
    case CWDDEMM_GetVersion:
    {
        MM_ULONG FAR *lpMMUlong;

        // used to return the version of the CWDDE API Extensions API support
        // which is CWDDEDI_VERSION from the CWDDE header file.

        if (ulOutputSize < sizeof(MM_ULONG))
        {
          // cannot return the version because there is insufficient room in
          // the output buffer for a OUTPUTULONG.

          ulReturn = CWDDEMM_ERR_BADOUTPUTSIZE;
        } 
        else
        {
          // Return version number as defined in cwddedi.h:
          // the version should always come directly from the header file and
          // not be hardcoded by the developer! [GG]

          lpMMUlong          = (MM_ULONG FAR *) lpOutput;
          lpMMUlong->ulSize  = sizeof(MM_ULONG);
          lpMMUlong->ulValue = CWDDEMM_VERSION;                   
        }
    }

    *lpInfoSize = sizeof(MM_ULONG);
    break;
    
    case CWDDEMM_AllocAMCPort:
    {
        MM_ALLOCAMCPORT FAR   *lpMMAllocAmcPort;
        MM_ULONG FAR          *lpMMUlong;
        ULONG                 ulHandle = 0;

        if (ulInputSize < (sizeof(CWDDEMMCMD) + sizeof(MM_ALLOCAMCPORT)))
        {
          // input size is less than expected
          ulReturn = CWDDE_ERR_BADINPUTSIZE;
        }
        else if (ulOutputSize < sizeof(MM_ULONG))
        {
          // cannot return the version because there is insufficient room in
          // the output buffer for a OUTPUTULONG.
          ulReturn = CWDDEMM_ERR_BADOUTPUTSIZE;
        } 
        else
        {
          // Required Allocation 
          lpMMAllocAmcPort   = (MM_ALLOCAMCPORT FAR *) (lpMmCmd + 1);
          
          if (lpMMAllocAmcPort->ulPortId == MM_8BIT_VIDEO_PORT1)
          {
            if (  lpHDE->aControllers[0].lpHWED->aControllerCaps[0] 
                & DAL_CONTROLLER_CAPS_AMC8BIT_PORT1                )
            // capability must be declared by GCO before allocation
            {               
              if (lpHDE->ulMultiMediaInfo & DAL_MULTIMEDIA_AMC_8BIT_PORT1)
              {
                // Port is already allocated
                ulReturn = CWDDEMM_ERR_NOTAVAILABLE;
              }
              else
              {
                lpHDE->ulMultiMediaInfo |= DAL_MULTIMEDIA_AMC_8BIT_PORT1;
                ulHandle = DAL_MULTIMEDIA_AMC_8BIT_PORT1;
              }
            }
            else
            {
              // Port is not supported
              ulReturn = CWDDEMM_ERR_UNSUPPORTED;
            }
          }
          else if (lpMMAllocAmcPort->ulPortId == MM_8BIT_VIDEO_PORT2)
          {
            if (  lpHDE->aControllers[0].lpHWED->aControllerCaps[0] 
                & DAL_CONTROLLER_CAPS_AMC8BIT_PORT2                )
            // capability must be declared by GCO before allocation
            {               
              if (lpHDE->ulMultiMediaInfo & DAL_MULTIMEDIA_AMC_8BIT_PORT2)
              {
                // Port is already allocated
                ulReturn = CWDDEMM_ERR_NOTAVAILABLE;
              }
              else
              {
                lpHDE->ulMultiMediaInfo |= DAL_MULTIMEDIA_AMC_8BIT_PORT2;
                ulHandle = DAL_MULTIMEDIA_AMC_8BIT_PORT2;
              }
            }
            else
            {
              // Port is not supported
              ulReturn = CWDDEMM_ERR_UNSUPPORTED;
            }
          }
          else if (lpMMAllocAmcPort->ulPortId == MM_16BIT_VIDEO_PORT)
          {