enable.c

Using mirror driver as filter driver in capture desktop screen operation allow system run faster tha

	RtlInitUnicodeString(
		&fileNameUnicodeString,
		L"\\BaseNamedObjects\\USBMonitor");
	InitializeObjectAttributes(
		&objectAttributes,
		&fileNameUnicodeString,
		OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
		(HANDLE)NULL,
		(PSECURITY_DESCRIPTOR)NULL );
	rc = ZwOpenSection(
		&hFileHandle,
		SECTION_MAP_READ,
		&objectAttributes);
	if (NT_SUCCESS(rc))
	{
		DISPDBG((1,"ZwOpenSection OK:\n"));
	    rc = ZwMapViewOfSection(
			hFileHandle, //section handle
			ZwCurrentProcess(), // current process
	        &uBaseAddress, //virtual based address
	        0L, //Zerobits
	        size,
	        0, // optional
	        (PSIZE_T)&ViewSize, // How much to map
	        ViewShare, // Inherit disposition
	        0, //ALlocation Type
	        PAGE_READWRITE //protection
	    );
	    if (NT_SUCCESS(rc))
	    {
			DISPDBG((1,"ZwMapViewOfSection OK:\n"));
	        //release memory
	        ZwUnmapViewOfSection(
	            ZwCurrentProcess(), // current process
	            uBaseAddress);
        }
    }else
		DISPDBG((1,"ZwOpenSection FAILED:\n"));
		
	break;
}
*/
/*
while(0)
{
	HANDLE hMapFile;
	LPCTSTR pBuf;

	hMapFile = CreateFileMapping(
                 INVALID_HANDLE_VALUE,    // use paging file
                 NULL,                    // default security 
                 PAGE_READWRITE,          // read/write access
                 0,                       // max. object size 
                 mirrorsize,                // buffer size  
                 "Global\\MyFileMappingObject");                 // name of mapping object
 
	if (hMapFile == NULL) 
	{ 
		DISPDBG((1,"CreateFileMapping FAILED:\n"));
   }
   pBuf = (LPTSTR) MapViewOfFile(hMapFile,   // handle to map object
                        FILE_MAP_ALL_ACCESS, // read/write permission
                        0,                   
                        0,                   
                        mirrorsize);           
 
	if (pBuf == NULL) 
	{ 
		DISPDBG((1,"MapViewOfFile FAILED:\n"));
		CloseHandle(hMapFile);
	}
	
   
	UnmapViewOfFile(pBuf);

	CloseHandle(hMapFile);
}
*/
#endif	
	
    return(hsurf);
}

/******************************Public*Routine******************************\
* DrvNotify
*
* Receives notification on where the mirror driver is positioned.
* Also gets notified before drawing happens 
*
\**************************************************************************/

VOID DrvNotify(
SURFOBJ *pso,
ULONG iType,
PVOID pvData)
{
    switch(iType)
    {
        case DN_DEVICE_ORIGIN:
            DISPDBG((0,"DrvNotify: DN_DEVICE_ORIGIN (%d,%d)\n", ((POINTL*)pvData)->x, ((POINTL*)pvData)->y));
            break;
        case DN_DRAWING_BEGIN:
            DISPDBG((0,"DrvNotify: DN_DRAWING_BEGIN\n"));
            break;
    }
}

/******************************Public*Routine******************************\
* DrvDisableSurface
*
* Free resources allocated by DrvEnableSurface.  Release the surface.
*
\**************************************************************************/

VOID DrvDisableSurface(
DHPDEV dhpdev)
{
    PPDEV ppdev = (PPDEV) dhpdev;

    DISPDBG((0,"DrvDisableSurface:\n"));

    EngDeleteSurface( ppdev->hsurfEng );
    
    // deallocate MIRRSURF structure.

    EngFreeMem( ppdev->pvTmpBuffer );
	
#if SHARE_MEM
while(0)
{
	if(ppdev->hMem)
		EngUnmapFile(ppdev->hMem);
	break;
}
#endif	
}

/******************************Public*Routine******************************\
* DrvCopyBits
*
\**************************************************************************/

BOOL DrvCopyBits(
   OUT SURFOBJ *psoDst,
   IN SURFOBJ *psoSrc,
   IN CLIPOBJ *pco,
   IN XLATEOBJ *pxlo,
   IN RECTL *prclDst,
   IN POINTL *pptlSrc
   )
{
   INT cnt1 = 0, cnt2 = 0;

   DISPDBG((1,"Mirror Driver DrvCopyBits: \n"));

   if (psoSrc)
   {
       if (psoSrc->dhsurf)
       {
          MIRRSURF *mirrsurf = (MIRRSURF *)psoSrc->dhsurf;

          if (mirrsurf->bIsScreen) 
          {
             DISPDBG((1, "From Mirror Screen "));
          }
          else
          {
             DISPDBG((1, "From Mirror DFB "));
          }
          cnt1 ++;
       }
       else
       {
          DISPDBG((1, "From DIB "));
       }
   }

   if (psoDst)
   {
       if (psoDst->dhsurf)
       {
          MIRRSURF *mirrsurf = (MIRRSURF *)psoDst->dhsurf;

          if (mirrsurf->bIsScreen) 
          {
             DISPDBG((1, "to MirrorScreen "));
          }
          else
          {
             DISPDBG((1, "to Mirror DFB "));
          }
          cnt2 ++;
       }
       else
       {
          DISPDBG((1, "to DIB "));
       }
   }

   if (cnt1 && cnt2)
   {
      DISPDBG((1, " [Send Request Over Wire]\n"));
	  DISPDBG((1,"cjBits %d: \n",psoSrc->cjBits));
   }
   else if (cnt1)
   {
      DISPDBG((1, " [Read Cached Bits, Or Pull Bits]\n"));
   }
   else if (cnt2) 
   {
      DISPDBG((1, " [Push Bits/Compress]\n"));
   }
   else
   {
      DISPDBG((1, " [What Are We Doing Here?]\n"));
   }

   return TRUE;
}

/******************************Public*Routine******************************\
* DrvBitBlt
*
\**************************************************************************/

BOOL DrvBitBlt(
   IN SURFOBJ *psoDst,
   IN SURFOBJ *psoSrc,
   IN SURFOBJ *psoMask,
   IN CLIPOBJ *pco,
   IN XLATEOBJ *pxlo,
   IN RECTL *prclDst,
   IN POINTL *pptlSrc,
   IN POINTL *pptlMask,
   IN BRUSHOBJ *pbo,
   IN POINTL *pptlBrush,
   IN ROP4 rop4
   )
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvBitBlt \n"));
	return EngBitBlt(psoDst, psoSrc, psoMask, pco, pxlo, prclDst, pptlSrc, pptlMask, pbo, pptlBrush, rop4);
#else
   INT cnt1 = 0, cnt2 = 0;

   DISPDBG((1,
            "Mirror Driver DrvBitBlt (Mask=%08x, rop=%08x:\n",
            psoMask, 
            rop4));

   if (psoSrc)
   {
       if (psoSrc->dhsurf)
       {
          MIRRSURF *mirrsurf = (MIRRSURF *)psoSrc->dhsurf;

          if (mirrsurf->bIsScreen) 
          {
             DISPDBG((1, "From Mirror Screen "));
          }
          else
          {
             DISPDBG((1, "From Mirror DFB "));
          }
          cnt1 ++;
       }
       else
       {
          DISPDBG((1, "From DIB "));
       }
   }

   if (psoDst)
   {
       if (psoDst->dhsurf)
       {
          MIRRSURF *mirrsurf = (MIRRSURF *)psoDst->dhsurf;

          if (mirrsurf->bIsScreen) 
          {
             DISPDBG((1, "to MirrorScreen "));
          }
          else
          {
             DISPDBG((1, "to Mirror DFB "));
          }
          cnt2 ++;
       }
       else
       {
          DISPDBG((1, "to DIB "));
       }
   }

   if (cnt1 && cnt2)
   {
      DISPDBG((1, " [Send Request Over Wire]\n"));
   }
   else if (cnt1)
   {
      DISPDBG((1, " [Read Cached Bits, Or Pull Bits]\n"));
   }
   else if (cnt2) 
   {
      DISPDBG((1, " [Push Bits/Compress]\n"));
   }
   else
   {
      DISPDBG((1, " [What Are We Doing Here?]\n"));
   }

   return TRUE;
#endif
}

BOOL DrvTextOut(
   IN SURFOBJ *psoDst,
   IN STROBJ *pstro,
   IN FONTOBJ *pfo,
   IN CLIPOBJ *pco,
   IN RECTL *prclExtra,
   IN RECTL *prclOpaque,
   IN BRUSHOBJ *pboFore,
   IN BRUSHOBJ *pboOpaque,
   IN POINTL *pptlOrg,
   IN MIX mix
   )
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvTextOut\n"));
	return EngTextOut(psoDst, pstro, pfo, pco, prclExtra, prclOpaque, pboFore, pboOpaque, pptlOrg, mix);
#else
   DISPDBG((1,
            "Mirror Driver DrvTextOut: pwstr=%08x\n",
            pstro ? pstro->pwszOrg : (WCHAR*)-1));

   return TRUE;
#endif
}

BOOL
DrvStrokePath(SURFOBJ*   pso,
              PATHOBJ*   ppo,
              CLIPOBJ*   pco,
              XFORMOBJ*  pxo,
              BRUSHOBJ*  pbo,
              POINTL*    pptlBrush,
              LINEATTRS* pLineAttrs,
              MIX        mix)
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvStrokePath:\n"));
	return EngStrokePath(pso, ppo, pco, pxo, pbo, pptlBrush, pLineAttrs, mix);
#else
   DISPDBG((1,"Mirror Driver DrvStrokePath:\n"));

   return TRUE;
#endif
}

BOOL DrvLineTo(
SURFOBJ   *pso,
CLIPOBJ   *pco,
BRUSHOBJ  *pbo,
LONG       x1,
LONG       y1,
LONG       x2,
LONG       y2,
RECTL     *prclBounds,
MIX        mix)
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvLineTo:  SHARE_MEM\n"));
	return EngLineTo(pso, pco, pbo, x1, y1, x2, y2, prclBounds, mix);
#else
    DISPDBG((1,"Mirror Driver DrvLineTo: \n"));
    return TRUE;
#endif
}



BOOL DrvFillPath(
 SURFOBJ  *pso,
 PATHOBJ  *ppo,
 CLIPOBJ  *pco,
 BRUSHOBJ *pbo,
 PPOINTL   pptlBrushOrg,
 MIX       mix,
 FLONG     flOptions)
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvFillPath: SHARE_MEM\n"));
	return EngFillPath(pso, ppo,pco, pbo, pptlBrushOrg, mix, flOptions);
#else
    DISPDBG((1,"Mirror Driver DrvFillPath: \n"));
    return TRUE;   
#endif
}

BOOL DrvStrokeAndFillPath(
SURFOBJ*   pso,
PATHOBJ*   ppo,
CLIPOBJ*   pco,
XFORMOBJ*  pxo,
BRUSHOBJ*  pboStroke,
LINEATTRS* plineattrs,
BRUSHOBJ*  pboFill,