surface.c File Reference

#include "framebufacc.h"

Include dependency graph for surface.c:

Go to the source code of this file.

Functions
BOOL	InitSurface (PPDEV ppdev, BOOL bForcemapping)
HSURF APIENTRY	DrvEnableSurface (IN DHPDEV dhpdev)
VOID APIENTRY	DrvDisableSurface (IN DHPDEV dhpdev)
BOOL APIENTRY	DrvAssertMode (IN DHPDEV dhpdev, IN BOOL bEnable)

Function Documentation

DrvAssertMode()

BOOL APIENTRY DrvAssertMode	(	IN DHPDEV	dhpdev,
		IN BOOL	bEnable
	)

Definition at line 270 of file surface.c.

{
   PPDEV ppdev = (PPDEV)dhpdev;
   ULONG ulTemp;
   BOOLEAN Result = TRUE;

   if (bEnable)
   {
      PVOID pRealVideoMem = ppdev->pRealVideoMem;

      /* Setup surface and remapping if it need it */
      if (!InitSurface(ppdev, FALSE))
      {
            Result = FALSE;
      }
      else
      {
            /* Check if we got same surface or not */
            if (pRealVideoMem != ppdev->pRealVideoMem)
            {
                PVOID pVideoMem= NULL;

                if (ppdev->pVideoMemCache == NULL)
                {
                    pVideoMem = ppdev->pRealVideoMem;
                }
                else
                {
                    pVideoMem = ppdev->pVideoMemCache;
                }

                Result = !EngModifySurface(ppdev->hSurfEng, ppdev->hDevEng,
                                           ppdev->dwHooks | HOOK_SYNCHRONIZE,
                                           0, (DHSURF)ppdev, pVideoMem,
                                           ppdev->ScreenDelta, NULL);
            }

            /* if the pRealVideoMem == ppdev->pRealVideoMem are 
             * the Result is then TRUE
             */
      }

   }
   else
   {
      /*
       * Call the miniport driver to reset the device to a known state.
       */

      Result = !EngDeviceIoControl(ppdev->hDriver, IOCTL_VIDEO_RESET_DEVICE,
                                 NULL, 0, NULL, 0, &ulTemp);
   }

   return Result;
}

DrvDisableSurface()

VOID APIENTRY DrvDisableSurface

(

IN DHPDEV

dhpdev

)

Definition at line 229 of file surface.c.

{
   DWORD ulTemp;
   VIDEO_MEMORY VideoMemory;
   PPDEV ppdev = (PPDEV)dhpdev;

   EngDeleteSurface(ppdev->hSurfEng);
   ppdev->hSurfEng = NULL;


   /* Free the video memory cache */
   if (ppdev->pVideoMemCache)
   {
        EngFreeMem(ppdev->pVideoMemCache);
   }

   /*
    * Unmap the framebuffer.
    */

   VideoMemory.RequestedVirtualAddress = ppdev->pRealVideoMem;
   EngDeviceIoControl(((PPDEV)dhpdev)->hDriver, IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
                      &VideoMemory, sizeof(VIDEO_MEMORY), NULL, 0, &ulTemp);

   ppdev->pRealVideoMem  = NULL;
   ppdev->pVideoMemCache = NULL;

}

DrvEnableSurface()

HSURF APIENTRY DrvEnableSurface

(

IN DHPDEV

dhpdev

)

Definition at line 143 of file surface.c.

{
   PPDEV ppdev = (PPDEV)dhpdev;
   HSURF hSurface;
   ULONG BitmapType;
   SIZEL ScreenSize;


   /* Setup surface and force the mapping */
   if (!InitSurface(ppdev, TRUE))
   {
       return FALSE;
   }

   /* Rest the desktop vitual position */
   ppdev->ScreenOffsetXY.x = 0;
   ppdev->ScreenOffsetXY.y = 0;


   switch (ppdev->BitsPerPixel)
   {
      case 8:
         IntSetPalette(dhpdev, ppdev->PaletteEntries, 0, 256);
         BitmapType = BMF_8BPP;
         break;

      case 16:
         BitmapType = BMF_16BPP;
         break;

      case 24:
         BitmapType = BMF_24BPP;
         break;

      case 32:
         BitmapType = BMF_32BPP;
         break;

      default:
         return FALSE;
   }

   ppdev->iDitherFormat = BitmapType;

   ScreenSize.cx = ppdev->ScreenWidth;
   ScreenSize.cy = ppdev->ScreenHeight;

   hSurface = (HSURF)EngCreateBitmap(ScreenSize, ppdev->ScreenDelta, BitmapType,
                                     (ppdev->ScreenDelta > 0) ? BMF_TOPDOWN : 0,
                                     ppdev->ScreenPtr);
   if (hSurface == NULL)
   {
      return FALSE;
   }

   /* Which api we hooking to */
   ppdev->dwHooks = HOOK_BITBLT | HOOK_COPYBITS | HOOK_FILLPATH | HOOK_TEXTOUT | HOOK_STROKEPATH | HOOK_LINETO ;

   /*
    * Associate the surface with our device.
    */

                
   if (!EngAssociateSurface(hSurface, ppdev->hDevEng, ppdev->dwHooks))
   {
      EngDeleteSurface(hSurface);
      return FALSE;
   }

   ppdev->hSurfEng = hSurface;

   return hSurface;
}

InitSurface()

BOOL InitSurface	(	PPDEV	ppdev,
		BOOL	bForcemapping
	)

Definition at line 25 of file surface.c.

{
   VIDEO_MEMORY VideoMemory;
   VIDEO_MEMORY_INFORMATION VideoMemoryInfo;
   ULONG returnedDataLength;
   ULONG RemappingNeeded = 0;
   ULONG PointerMaxWidth = 0;
   ULONG PointerMaxHeight = 0;

   /*
    * Set video mode of our adapter.
    */

   if (EngDeviceIoControl(ppdev->hDriver,
                          IOCTL_VIDEO_SET_CURRENT_MODE,
                          &(ppdev->ModeIndex),
                          sizeof(ULONG),
                          &RemappingNeeded,
                          sizeof(ULONG),
                          &returnedDataLength))
   {
      return FALSE;
   }

   /* Check if mapping is need it */
   if ((!bForcemapping) && 
       (!RemappingNeeded))
   {
       return TRUE;
   }
   

   /*
    * Map the framebuffer into our memory.
    */

   VideoMemory.RequestedVirtualAddress = NULL;
   if (EngDeviceIoControl(ppdev->hDriver, IOCTL_VIDEO_MAP_VIDEO_MEMORY,
                          &VideoMemory, sizeof(VIDEO_MEMORY),
                          &VideoMemoryInfo, sizeof(VIDEO_MEMORY_INFORMATION),
                          &returnedDataLength))
   {
      return FALSE;
   }

   /*
    * Save the real video memory
    */
    ppdev->pRealVideoMem = VideoMemoryInfo.FrameBufferBase;
    ppdev->VideoMemSize = VideoMemoryInfo.VideoRamLength;


   /*
    * Video memory cached
    *
    * We maby should only ask max 8MB as cached ?, think of the video ram length is 256MB 
    */

    ppdev->pVideoMemCache = NULL;
#ifdef EXPERIMENTAL_ACC_SUPPORT

   ppdev->pVideoMemCache = EngAllocMem(0, (ULONG)VideoMemoryInfo.VideoRamLength, ALLOC_TAG);
   if (ppdev->pVideoMemCache == NULL)
   {
        /* cached off for no avail system memory */
        ppdev->ScreenPtr = VideoMemoryInfo.FrameBufferBase;
   }
   else

#endif
   {
        /* cached on, system memory is avail */
        ppdev->ScreenPtr = ppdev->pRealVideoMem;
   }

   /* hw mouse pointer support */
   PointerMaxHeight = ppdev->PointerCapabilities.MaxHeight;
   PointerMaxWidth = ppdev->PointerCapabilities.MaxWidth * sizeof(ULONG);
   if (ppdev->PointerCapabilities.Flags & VIDEO_MODE_COLOR_POINTER)
   {
        PointerMaxWidth = (ppdev->PointerCapabilities.MaxWidth + 7) / 8;
   }

   ppdev->PointerAttributesSize = sizeof(VIDEO_POINTER_ATTRIBUTES) + ((sizeof(UCHAR) * PointerMaxWidth * PointerMaxHeight) << 1);

   ppdev->pPointerAttributes = EngAllocMem(0, ppdev->PointerAttributesSize, ALLOC_TAG);

   if (ppdev->pPointerAttributes != NULL)
   {
        ppdev->pPointerAttributes->Flags = ppdev->PointerCapabilities.Flags;
        ppdev->pPointerAttributes->WidthInBytes = PointerMaxWidth;
        ppdev->pPointerAttributes->Width = ppdev->PointerCapabilities.MaxWidth;
        ppdev->pPointerAttributes->Height = PointerMaxHeight;
        ppdev->pPointerAttributes->Column = 0;
        ppdev->pPointerAttributes->Row = 0;
        ppdev->pPointerAttributes->Enable = 0;
   }
   else
   {
       /* no hw mouse was avail */
       ppdev->PointerAttributesSize = 0;
   }

   return TRUE;
}

Referenced by DrvAssertMode(), and DrvEnableSurface().