enable.c

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

POINTL*    pptlBrushOrg,
MIX        mixFill,
FLONG      flOptions)
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvStrokeAndFillPath: SHARE_MEM\n"));
	return EngStrokeAndFillPath(pso,ppo,pco,pxo,pboStroke,plineattrs,pboFill,pptlBrushOrg,mixFill,flOptions);
#else
    DISPDBG((1,"Mirror Driver DrvStrokeAndFillPath: \n"));
    return TRUE;
#endif
}

BOOL DrvTransparentBlt(
SURFOBJ*    psoDst,
SURFOBJ*    psoSrc,
CLIPOBJ*    pco,
XLATEOBJ*   pxlo,
RECTL*      prclDst,
RECTL*      prclSrc,
ULONG       iTransColor,
ULONG       ulReserved)
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvTransparentBlt: SHARE_MEM\n"));
	return EngTransparentBlt(psoDst, psoSrc, pco, pxlo, prclDst, prclSrc, iTransColor, ulReserved);
#else
    DISPDBG((1,"Mirror Driver DrvTransparentBlt: \n"));
    return TRUE;
#endif	
}


BOOL DrvAlphaBlend(
SURFOBJ*            psoDst,
SURFOBJ*            psoSrc,
CLIPOBJ*            pco,
XLATEOBJ*           pxlo,
RECTL*              prclDst,
RECTL*              prclSrc,
BLENDOBJ*           pBlendObj)
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvAlphaBlend: SHARE_MEM\n"));
	return EngAlphaBlend(psoDst, psoSrc, pco, pxlo, prclDst, prclSrc, pBlendObj);
#else
    DISPDBG((1,"Mirror Driver DrvAlphaBlend: \n"));
    return TRUE;
#endif
}

BOOL DrvGradientFill(
SURFOBJ*            pso,
CLIPOBJ*            pco,
XLATEOBJ*           pxlo,
TRIVERTEX*          pVertex,
ULONG               nVertex,
PVOID               pMesh,
ULONG               nMesh,
RECTL*              prclExtents,
POINTL*             pptlDitherOrg,
ULONG               ulMode)
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvGradientFill: SHARE_MEM\n"));
	return EngGradientFill(pso, pco, pxlo, pVertex, nVertex, pMesh, nMesh, prclExtents, pptlDitherOrg, ulMode);
#else
    DISPDBG((1,"Mirror Driver DrvGradientFill: \n"));
    return TRUE;
#endif
}

BOOL DrvStretchBlt(
SURFOBJ*            psoDst,
SURFOBJ*            psoSrc,
SURFOBJ*            psoMsk,
CLIPOBJ*            pco,
XLATEOBJ*           pxlo,
COLORADJUSTMENT*    pca,
POINTL*             pptlHTOrg,
RECTL*              prclDst,
RECTL*              prclSrc,
POINTL*             pptlMsk,
ULONG               iMode)
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvStretchBlt: SHARE_MEM\n"));
	return EngStretchBlt(psoDst, psoSrc, psoMsk, pco, pxlo, pca, pptlHTOrg, prclDst, prclSrc, pptlMsk, iMode);
#else
    DISPDBG((1,"Mirror Driver DrvStretchBlt: \n"));
    return TRUE;
#endif
}

BOOL DrvStretchBltROP(
SURFOBJ         *psoTrg,
SURFOBJ         *psoSrc,
SURFOBJ         *psoMask,
CLIPOBJ         *pco,
XLATEOBJ        *pxlo,
COLORADJUSTMENT *pca,
POINTL          *pptlBrushOrg,
RECTL           *prclTrg,
RECTL           *prclSrc,
POINTL          *pptlMask,
ULONG            iMode,
BRUSHOBJ        *pbo,
ROP4            rop4)
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvStretchBltROP: SHARE_MEM\n"));
	return EngStretchBltROP(psoTrg,psoSrc,psoMask,pco,pxlo,pca,pptlBrushOrg,prclTrg,prclSrc,pptlMask,iMode,pbo,rop4);
#else
    DISPDBG((1,"Mirror Driver DrvStretchBltROP: \n"));
    return TRUE; 
#endif
}

BOOL DrvPlgBlt(
SURFOBJ         *psoTrg,
SURFOBJ         *psoSrc,
SURFOBJ         *psoMsk,
CLIPOBJ         *pco,
XLATEOBJ        *pxlo,
COLORADJUSTMENT *pca,
POINTL          *pptlBrushOrg,
POINTFIX        *pptfx,
RECTL           *prcl,
POINTL          *pptl,
ULONG            iMode)
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvPlgBlt: SHARE_MEM\n"));
	return EngPlgBlt(psoTrg,psoSrc,psoMsk,pco,pxlo,pca,pptlBrushOrg,pptfx,prcl,pptl,iMode);
#else
    DISPDBG((1,"Mirror Driver DrvPlgBlt: \n"));
    return TRUE;
#endif
}

HBITMAP DrvCreateDeviceBitmap(
   IN DHPDEV dhpdev,
   IN SIZEL sizl,
   IN ULONG iFormat
   )
{
#if SHARE_MEM
	DISPDBG((1,"Mirror Driver DrvCreateDeviceBitmap: \n"));
	return NULL;
#else
   HBITMAP hbm;
   MIRRSURF *mirrsurf;
   ULONG mirrorsize;
   DHSURF dhsurf;
   ULONG stride;
   HSURF hsurf;

   PPDEV ppdev = (PPDEV) dhpdev;
   
   DISPDBG((1,"CreateDeviceBitmap:\n"));
   
   if (iFormat == BMF_1BPP || iFormat == BMF_4BPP)
   {
      return NULL;
   }

   // DWORD align each stride
   stride = (sizl.cx*(iFormat/8)+3);
   stride -= stride % 4;
   
   mirrorsize = (int)(sizeof(MIRRSURF) + stride * sizl.cy);

   mirrsurf = (MIRRSURF *) EngAllocMem(FL_ZERO_MEMORY,
                                       mirrorsize,
                                       0x4D495252);
   if (!mirrsurf) {
        RIP("DISP DrvCreateDeviceBitmap failed EngAllocMem\n");
        return(FALSE);
   }
                                       
   dhsurf = (DHSURF) mirrsurf;

   hsurf = (HSURF) EngCreateDeviceBitmap(dhsurf,
                                 sizl,
                                 iFormat);

   if (hsurf == (HSURF) 0)
   {
       RIP("DISP DrvCreateDeviceBitmap failed EngCreateBitmap\n");
       return(FALSE);
   }

   if (!EngAssociateSurface(hsurf, 
                            ppdev->hdevEng, 
                            flGlobalHooks))
   {
       RIP("DISP DrvCreateDeviceBitmap failed EngAssociateSurface\n");
       EngDeleteSurface(hsurf);
       return(FALSE);
   }
  
   mirrsurf->cx = sizl.cx;
   mirrsurf->cy = sizl.cy;
   mirrsurf->lDelta = stride;
   mirrsurf->ulBitCount = iFormat;
   mirrsurf->bIsScreen = FALSE;
  
   return((HBITMAP)hsurf);
  #endif
   
}

VOID DrvDeleteDeviceBitmap(
   IN DHSURF dhsurf
   )
{
#if SHARE_MEM
	DISPDBG((1, "DeleteDeviceBitmap: SHARE_MEM\n"));
#else
   MIRRSURF *mirrsurf;
   
   DISPDBG((1, "DeleteDeviceBitmap:\n"));

   mirrsurf = (MIRRSURF *) dhsurf;

   EngFreeMem((PVOID) mirrsurf);
#endif
}

#if (NTDDI_VERSION >= NTDDI_VISTA)
LONG
DrvRenderHint(DHPDEV dhpdev,
              ULONG  NotifyCode,
              SIZE_T Length,
              PVOID  Data)
{
    PPDEV ppdev = (PPDEV) dhpdev;
    PDRH_APIBITMAPDATA pData = (PDRH_APIBITMAPDATA)Data;

    if (NotifyCode == DRH_APIBITMAP)
    {
        DISPDBG((1, "DrvRenderHint(API Render: %08x, %lx)\n", pData->pso, pData->b));
    }

    return TRUE;
}
#endif

/******************************Public*Routine******************************\
* DrvAssertMode
*
* Enable/Disable the given device.
*
\**************************************************************************/

DrvAssertMode(DHPDEV  dhpdev,
              BOOL    bEnable)
{
    PPDEV ppdev = (PPDEV) dhpdev;

    DISPDBG((0, "DrvAssertMode(%lx, %lx)\n", dhpdev, bEnable));

    return TRUE;

}// DrvAssertMode()

/******************************Public*Routine******************************\
* DrvEscape
*
* We only handle WNDOBJ_SETUP escape. 
*
\**************************************************************************/

typedef struct _WndObjENUMRECTS
{
  ULONG c;
  RECTL arcl[100];
} WNDOBJENUMRECTS;

VOID
vDumpWndObjRgn(WNDOBJ *pwo)
{
    ULONG ulRet;

    ulRet = WNDOBJ_cEnumStart(pwo, CT_RECTANGLES, CD_RIGHTDOWN, 100);

    if (ulRet != 0xFFFFFFFF)
    {
        BOOL bMore;
        ULONG i;
        WNDOBJENUMRECTS enumRects;

        do
        {
          bMore = WNDOBJ_bEnum(pwo, sizeof(enumRects), &enumRects.c);

          for (i = 0; i < enumRects.c; i++)
          {
              DISPDBG((0,"\nWNDOBJ_rect:[%d,%d][%d,%d]",
                          enumRects.arcl[i].left,
                          enumRects.arcl[i].top,
                          enumRects.arcl[i].right,
                          enumRects.arcl[i].bottom));

          }
        } while (bMore);
    }
}

VOID
WndObjCallback(WNDOBJ *pwo,
               FLONG fl)
{
    if (fl & (WOC_RGN_CLIENT_DELTA |
              WOC_RGN_CLIENT |
              WOC_RGN_SURFACE_DELTA |
              WOC_RGN_SURFACE |
              WOC_CHANGED |
              WOC_DELETE |
              WOC_DRAWN |
              WOC_SPRITE_OVERLAP |
              WOC_SPRITE_NO_OVERLAP
#if (NTDDI_VERSION >= NTDDI_VISTA)
              | WOC_RGN_SPRITE
#endif 
              ))
    {
        DISPDBG((0,"WndObjCallback: "));

        if (fl & WOC_RGN_CLIENT_DELTA) 
            DISPDBG((0,"WOC_RGN_CLIENT_DELTA "));
        if (fl & WOC_RGN_CLIENT) 
            DISPDBG((0,"WOC_RGN_CLIENT "));
        if (fl & WOC_RGN_SURFACE_DELTA) 
            DISPDBG((1,"WOC_RGN_SURFACE_DELTA "));
        if (fl & WOC_RGN_SURFACE) 
            DISPDBG((1,"WOC_RGN_SURFACE "));
        if (fl & WOC_CHANGED) 
            DISPDBG((1,"WOC_CHANGED "));
        if (fl & WOC_DELETE) 
            DISPDBG((0,"WOC_DELETE "));
        if (fl & WOC_DRAWN) 
            DISPDBG((1,"WOC_DRAWN "));
        if (fl & WOC_SPRITE_OVERLAP) 
            DISPDBG((0,"WOC_SPRITE_OVERLAP "));
        if (fl & WOC_SPRITE_NO_OVERLAP)
            DISPDBG((0,"WOC_SPRITE_NO_OVERLAP "));
#if (NTDDI_VERSION >= NTDDI_VISTA)
        if (fl & WOC_RGN_SPRITE)
        {
            DISPDBG((0,"WOC_RGN_SPRITE "));
            vDumpWndObjRgn(pwo);
        }
#endif
        DISPDBG((0,"\n"));
    }
}

ULONG
DrvEscape(SURFOBJ *pso,
          ULONG iEsc,
          ULONG cjIn,
          PVOID pvIn,
          ULONG cjOut,
          PVOID pvOut)
{
#ifndef SHARE_MEM
	DISPDBG((0,"DrvEscape\n"));
	return 0;
#else
    ULONG ulRet = 0;

    if (pso->dhsurf)
    {

        if (iEsc == WNDOBJ_SETUP)
        {
            WNDOBJ *pwo = NULL;

            DISPDBG((0,"Attempt to create WndObj\n"));

            pwo = EngCreateWnd(pso,
                               *(HWND*)pvIn,
                               WndObjCallback,
                               WO_DRAW_NOTIFY |
                               WO_RGN_CLIENT |
                               WO_RGN_CLIENT_DELTA |
                               WO_RGN_WINDOW |
                               WO_SPRITE_NOTIFY
#if (NTDDI_VERSION >= NTDDI_VISTA)
                               | WO_RGN_SPRITE
#endif
                               ,
                               0);
            if (pwo != NULL)
            {
                DISPDBG((0,"WndObj creat success\n"));
                ulRet = 1;
            }
        }
    }

    return ulRet;
#endif
}