VirtualBox

Changeset 21939 in vbox for trunk/src/VBox/Additions/WINNT


Ignore:
Timestamp:
Aug 3, 2009 11:52:51 AM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
50619
Message:

Video Hw Accel: debugging & better color support (still debugging & perf enhancements needed)

Location:
trunk/src/VBox/Additions/WINNT/Graphics
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/dd.c

    r21611 r21939  
    4646#define VBOXVHWA_CAP(_pdev, _cap) ((_pdev)->vhwaInfo.caps & (_cap))
    4747static bool getDDHALInfo(PPDEV pDev, DD_HALINFO* pHALInfo);
    48 static DECLCALLBACK(void) vboxVHWAFreeCmdCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext);
    4948static DECLCALLBACK(void) vboxVHWASurfBltCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext);
    5049static DECLCALLBACK(void) vboxVHWASurfFlipCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext);
    … …  
    7675 *
    7776 */
     77
     78DD_HALINFO g_h2;
     79
    7880BOOL APIENTRY DrvGetDirectDrawInfo(
    7981    DHPDEV        dhpdev,
    … …  
    615617        DDPIXELFORMAT * pFormat = &lpSurfaceGlobal->ddpfSurface;
    616618
    617         if(lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    618         {
    619             lBpp = pDev->ulBitCount;
    620             lPitch = pDev->lDeltaScreen;
    621         }
    622         else
    623         {
    624             if (pFormat->dwFlags & DDPF_PALETTEINDEXED4)
    625             {
    626                 lBpp = 4;
    627                 lPitch = lpSurfaceGlobal->wWidth/2;
    628                 lPitch = (lPitch + 31) & ~31;
    629             }
    630             else
    631             if (pFormat->dwFlags & DDPF_PALETTEINDEXED8)
    632             {
    633                 lBpp = 8;
    634                 lPitch = lpSurfaceGlobal->wWidth;
    635                 lPitch = (lPitch + 31) & ~31;
    636             }
    637             else
    638             {
    639                 lBpp   = pFormat->dwRGBBitCount;
    640                 lPitch = lpSurfaceGlobal->wWidth*(lBpp/8);
    641             }
    642         }
    643 
    644         DISPDBG((0, "New surface (%d,%d)\n", lpSurfaceGlobal->wWidth, lpSurfaceGlobal->wHeight));
    645         DISPDBG((0, "BPP %d lPitch=%d\n", lBpp, lPitch));
    646 #if 1
    647         lpSurfaceGlobal->dwBlockSizeX   = lPitch;
    648         lpSurfaceGlobal->dwBlockSizeY   = lpSurfaceGlobal->wHeight;
    649         lpSurfaceGlobal->lPitch         = lPitch;
    650 #else
    651         lpSurfaceGlobal->dwBlockSizeX   = lPitch * lpSurfaceGlobal->wHeight;
    652         lpSurfaceGlobal->dwBlockSizeY   = 1;
    653         lpSurfaceGlobal->lPitch         = lPitch;
    654 #endif
    655 
    656 #if 1
    657         lpSurfaceDesc->lPitch   = lpSurfaceGlobal->lPitch;
    658         lpSurfaceDesc->dwFlags |= DDSD_PITCH;
    659 #endif
    660 
    661619        //
    662620        // Modify surface descriptions as appropriate and let Direct
    … …  
    683641            memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CREATE));
    684642
    685             rc = vboxVHWAFromDDSURFACEDESC(&pBody->u.in.SurfInfo, lpSurfaceDesc);
    686 
    687             pBody->u.in.SurfInfo.surfCaps = vboxVHWAFromDDSCAPS(lpSurfaceLocal->ddsCaps.dwCaps);
    688             pBody->u.in.SurfInfo.flags |= DDSD_CAPS;
    689 
    690             pBody->u.in.SurfInfo.height = lpSurfaceGlobal->wHeight;
    691             pBody->u.in.SurfInfo.width = lpSurfaceGlobal->wWidth;
    692             pBody->u.in.SurfInfo.flags |= DDSD_HEIGHT | DDSD_WIDTH;
    693 
    694             vboxVHWAFromDDPIXELFORMAT(&pBody->u.in.SurfInfo.PixelFormat, pFormat);
    695             pBody->u.in.SurfInfo.flags |= VBOXVHWA_SD_PIXELFORMAT;
     643            rc = vboxVHWAFromDDSURFACEDESC(&pBody->SurfInfo, lpSurfaceDesc);
     644
     645            pBody->SurfInfo.surfCaps = vboxVHWAFromDDSCAPS(lpSurfaceLocal->ddsCaps.dwCaps);
     646            pBody->SurfInfo.flags |= DDSD_CAPS;
     647
     648            pBody->SurfInfo.height = lpSurfaceGlobal->wHeight;
     649            pBody->SurfInfo.width = lpSurfaceGlobal->wWidth;
     650            pBody->SurfInfo.flags |= DDSD_HEIGHT | DDSD_WIDTH;
     651
     652            vboxVHWAFromDDPIXELFORMAT(&pBody->SurfInfo.PixelFormat, pFormat);
     653            pBody->SurfInfo.flags |= VBOXVHWA_SD_PIXELFORMAT;
    696654
    697655            if (lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    … …  
    708666            if(pDesc)
    709667            {
    710                 pDesc->cBitsPerPixel = lBpp;
    711668                vboxVHWACommandSubmit(pDev, pCmd);
    712669                Assert(pCmd->rc == VINF_SUCCESS);
    … …  
    715672                    pDesc->hHostHandle = pBody->u.out.hSurf;
    716673                    lpSurfaceGlobal->dwReserved1 = (ULONG_PTR)pDesc;
     674                    lPitch = pBody->SurfInfo.pitch;
     675                    lBpp = pBody->SurfInfo.bitsPerPixel;
     676                    pDesc->cBitsPerPixel = lBpp;
     677#if 0
     678                    lpSurfaceGlobal->dwBlockSizeX   = lPitch;
     679                    lpSurfaceGlobal->dwBlockSizeY   = lpSurfaceGlobal->wHeight;
     680                    lpSurfaceGlobal->lPitch         = lPitch;
     681#else
     682                    lpSurfaceGlobal->dwBlockSizeX   = lPitch * lpSurfaceGlobal->wHeight;
     683                    lpSurfaceGlobal->dwBlockSizeY   = 1;
     684                    lpSurfaceGlobal->lPitch         = lPitch;
     685#endif
     686#if 1
     687                    lpSurfaceDesc->lPitch   = lpSurfaceGlobal->lPitch;
     688                    lpSurfaceDesc->dwFlags |= DDSD_PITCH;
     689#endif
     690
    717691                    lpCreateSurface->ddRVal = DD_OK;
    718692                }
    … …  
    831805            memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_CANCREATE));
    832806
    833             rc = vboxVHWAFromDDSURFACEDESC(&pBody->u.in.SurfInfo, lpDDS);
     807            rc = vboxVHWAFromDDSURFACEDESC(&pBody->SurfInfo, lpDDS);
    834808            pBody->u.in.bIsDifferentPixelFormat = lpCanCreateSurface->bIsDifferentPixelFormat;
    835809
    … …  
    10291003        DD_SURFACE_GLOBAL*  lpSurfaceGlobal = lpSurfaceLocal->lpGbl;
    10301004        PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpSurfaceGlobal->dwReserved1;
    1031         VBOXVHWACMD* pCmd;
    1032         /* ensure we have host cmds processed to update pending blits and flips */
    1033         vboxVHWACommandCheckHostCmds(pDev);
    1034 
    1035     //    if(VBOXDD_CHECKFLAG(lpLock, DDLOCK_DONOTWAIT))
    1036         {
     1005        RECTL tmpRect, *pRect;
     1006
     1007        if(ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
     1008                || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr)
     1009                || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
     1010                || ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg))
     1011        {
     1012            /* ensure we have host cmds processed to update pending blits and flips */
     1013            vboxVHWACommandCheckHostCmds(pDev);
    10371014            if(ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
    1038                     || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
    1039                     || ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg)
    1040                     || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr))
     1015                        || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr)
     1016                        || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
     1017                        || ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg))
    10411018            {
    10421019                lpLock->ddRVal = DDERR_WASSTILLDRAWING;
    … …  
    10511028//        }
    10521029
    1053         pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_LOCK, sizeof(VBOXVHWACMD_SURF_LOCK));
    1054         if(pCmd)
    1055         {
    1056             VBOXVHWACMD_SURF_LOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK);
    1057             RECTL tmpRect, *pRect;
    1058             memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_LOCK));
    1059 
    1060             pBody->u.in.offSurface = (uint64_t)lpSurfaceGlobal->fpVidMem;
    1061 
    1062             if (lpLock->bHasRect)
     1030        if (lpLock->bHasRect)
     1031        {
     1032            pRect = &lpLock->rArea;
     1033        }
     1034        else
     1035        {
     1036            tmpRect.left=0;
     1037            tmpRect.top=0;
     1038            tmpRect.right=lpSurfaceGlobal->wWidth-1;
     1039            tmpRect.bottom=lpSurfaceGlobal->wHeight-1;
     1040            pRect = &tmpRect;
     1041        }
     1042
     1043        if(VBOXDD_CHECKFLAG(lpLock->dwFlags, DDLOCK_DISCARDCONTENTS))
     1044        {
     1045//            pBody->u.in.flags |= VBOXVHWA_LOCK_DISCARDCONTENTS;
     1046
     1047            vboxVHWARegionTrySubstitute(&pDesc->NonupdatedMemRegion, pRect);
     1048//                /* we're not interested in completion, just send the command */
     1049//                vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
     1050            vboxVHWARegionAdd(&pDesc->UpdatedMemRegion, pRect);
     1051            lpLock->ddRVal = DD_OK;
     1052        }
     1053        else if(!vboxVHWARegionIntersects(&pDesc->NonupdatedMemRegion, pRect))
     1054        {
     1055//                vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
     1056            vboxVHWARegionAdd(&pDesc->UpdatedMemRegion, pRect);
     1057            lpLock->ddRVal = DD_OK;
     1058        }
     1059        else
     1060        {
     1061            VBOXVHWACMD* pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_LOCK, sizeof(VBOXVHWACMD_SURF_LOCK));
     1062            if(pCmd)
    10631063            {
    1064                 DISPDBG((0, "%d,%d %dx%d\n", lpLock->rArea.left, lpLock->rArea.top, lpLock->rArea.right - lpLock->rArea.left, lpLock->rArea.bottom - lpLock->rArea.top));
    1065                 vboxVHWAFromRECTL(&pBody->u.in.rect, &lpLock->rArea);
     1064                VBOXVHWACMD_SURF_LOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK);
     1065                memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_LOCK));
     1066
     1067                pBody->u.in.offSurface = (uint64_t)lpSurfaceGlobal->fpVidMem;
     1068
     1069//            if (lpLock->bHasRect)
     1070//            {
     1071//                DISPDBG((0, "%d,%d %dx%d\n", lpLock->rArea.left, lpLock->rArea.top, lpLock->rArea.right - lpLock->rArea.left, lpLock->rArea.bottom - lpLock->rArea.top));
     1072//                vboxVHWAFromRECTL(&pBody->u.in.rect, &lpLock->rArea);
     1073//                pBody->u.in.rectValid = 1;
     1074//
     1075//            }
     1076//            else
     1077//            {
     1078//                pBody->u.in.rectValid = 0;
     1079//            }
     1080                Assert(pDesc->NonupdatedMemRegion.bValid);
     1081                vboxVHWAFromRECTL(&pBody->u.in.rect, &pDesc->NonupdatedMemRegion.Rect);
    10661082                pBody->u.in.rectValid = 1;
    10671083
    1068                 pRect = &lpLock->rArea;
    1069 
     1084                pBody->u.in.hSurf = pDesc->hHostHandle;
     1085
     1086                /* wait for the surface to be locked and memory buffer updated */
     1087                vboxVHWACommandSubmit(pDev, pCmd);
     1088                vboxVHWACommandFree(pDev, pCmd);
     1089                vboxVHWARegionClear(&pDesc->NonupdatedMemRegion);
     1090                lpLock->ddRVal = DD_OK;
    10701091            }
    10711092            else
    10721093            {
    1073                 pBody->u.in.rectValid = 0;
    1074 
    1075                 tmpRect.left=0;
    1076                 tmpRect.top=0;
    1077                 tmpRect.right=lpSurfaceGlobal->wWidth-1;
    1078                 tmpRect.bottom=lpSurfaceGlobal->wHeight-1;
    1079                 pRect = &tmpRect;
     1094                lpLock->ddRVal = DDERR_GENERIC;
    10801095            }
    1081 
    1082             pBody->u.in.hSurf = pDesc->hHostHandle;
    1083 
    1084             if(VBOXDD_CHECKFLAG(lpLock->dwFlags, DDLOCK_DISCARDCONTENTS))
    1085             {
    1086                 pBody->u.in.flags |= VBOXVHWA_LOCK_DISCARDCONTENTS;
    1087 
    1088                 if(vboxVHWARegionIncluded(&pDesc->DirtyRegion, pRect))
    1089                 {
    1090                     vboxVHWARegionClear(&pDesc->DirtyRegion);
    1091                 }
    1092 //            }
    1093 //            else if(vboxVHWARegionInterse)
    1094                 /* we're not interested in completion, just send the command */
    1095                 vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
    1096             }
    1097             else if(!vboxVHWARegionIntersects(&pDesc->DirtyRegion, pRect))
    1098             {
    1099                 vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
    1100             }
    1101             else
    1102             {
    1103                 /* wait for the surface to be locked and memory buffer updated */
    1104                 vboxVHWACommandSubmit(pDev, pCmd);
    1105                 vboxVHWACommandFree(pDev, pCmd);
    1106                 vboxVHWARegionClear(&pDesc->DirtyRegion);
    1107             }
    1108 
    1109             lpLock->ddRVal = DD_OK;
    1110         }
    1111         else
    1112         {
    1113             lpLock->ddRVal = DDERR_GENERIC;
    11141096        }
    11151097        return DDHAL_DRIVER_NOTHANDLED;
    … …  
    11741156        DD_SURFACE_GLOBAL*  lpSurfaceGlobal = lpSurfaceLocal->lpGbl;
    11751157        PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpSurfaceGlobal->dwReserved1;
    1176         VBOXVHWACMD* pCmd;
    11771158
    11781159        //TODO: hadle vrdp properly
    … …  
    11861167        }
    11871168
    1188         /* ensure we have host cmds processed to update pending blits and flips */
    1189         vboxVHWACommandCheckHostCmds(pDev);
    1190 
    1191         pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_UNLOCK, sizeof(VBOXVHWACMD_SURF_UNLOCK));
    1192     //    int rc = VERR_GENERAL_FAILURE;
    1193         if(pCmd)
    1194         {
    1195             VBOXVHWACMD_SURF_UNLOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK);
    1196             memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_UNLOCK));
    1197 
    1198             pBody->u.in.hSurf = pDesc->hHostHandle;
    1199 
    1200             vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
    1201 
    1202             lpUnlock->ddRVal = DD_OK;
    1203         }
    1204         else
    1205         {
    1206             lpUnlock->ddRVal = DDERR_GENERIC;
     1169//        /* ensure we have host cmds processed to update pending blits and flips */
     1170//        vboxVHWACommandCheckHostCmds(pDev);
     1171
     1172        if(lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_VISIBLE
     1173                || (
     1174                        !(lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_COMPLEX)
     1175                        && (
     1176                                lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE
     1177                                || (
     1178                                        (lpSurfaceLocal->ddsCaps.dwCaps & DDSCAPS_OVERLAY)
     1179                                        && !pDesc->bHidden
     1180                                    )
     1181                           )
     1182                   )
     1183          )
     1184        {
     1185            VBOXVHWACMD* pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_UNLOCK, sizeof(VBOXVHWACMD_SURF_UNLOCK));
     1186        //    int rc = VERR_GENERAL_FAILURE;
     1187            if(pCmd)
     1188            {
     1189                VBOXVHWACMD_SURF_UNLOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK);
     1190                memset(pBody, 0, sizeof(VBOXVHWACMD_SURF_UNLOCK));
     1191
     1192                pBody->u.in.hSurf = pDesc->hHostHandle;
     1193                if(pDesc->UpdatedMemRegion.bValid)
     1194                {
     1195                    pBody->u.in.xUpdatedMemValid = 1;
     1196                    vboxVHWAFromRECTL(&pBody->u.in.xUpdatedMemRect, &pDesc->UpdatedMemRegion.Rect);
     1197                    vboxVHWARegionClear(&pDesc->UpdatedMemRegion);
     1198                }
     1199
     1200                vboxVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
     1201
     1202                lpUnlock->ddRVal = DD_OK;
     1203            }
     1204            else
     1205            {
     1206                lpUnlock->ddRVal = DDERR_GENERIC;
     1207            }
    12071208        }
    12081209
    … …  
    13081309
    13091310            /* we're not interested in completion, just send the command */
    1310             vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
     1311            vboxVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
    13111312
    13121313            vboxVHWASurfDescFree(pDesc);
    … …  
    14061407
    14071408#ifdef VBOX_WITH_VIDEOHWACCEL
     1409#if 1
    14081410DWORD APIENTRY DdSetColorKey(PDD_SETCOLORKEYDATA  lpSetColorKey)
    14091411{
    … …  
    14281430        vboxVHWAFromDDCOLORKEY(&pBody->u.in.CKey, &lpSetColorKey->ckNew);
    14291431
    1430         vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
     1432        vboxVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
    14311433        lpSetColorKey->ddRVal = DD_OK;
    14321434    }
    … …  
    14821484            ASMAtomicIncU32(&pDestDesc->cPendingBltsDst);
    14831485
    1484             vboxVHWARegionAdd(&pDestDesc->DirtyRegion, &lpBlt->rDest);
     1486            vboxVHWARegionAdd(&pDestDesc->NonupdatedMemRegion, &lpBlt->rDest);
     1487            vboxVHWARegionTrySubstitute(&pDestDesc->UpdatedMemRegion, &lpBlt->rDest);
     1488
     1489            if(pSrcDesc->UpdatedMemRegion.bValid)
     1490            {
     1491                pBody->u.in.xUpdatedSrcMemValid = 1;
     1492                vboxVHWAFromRECTL(&pBody->u.in.xUpdatedSrcMemRect, &pSrcDesc->UpdatedMemRegion.Rect);
     1493                vboxVHWARegionClear(&pSrcDesc->UpdatedMemRegion);
     1494            }
     1495
    14851496            vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWASurfBltCompletion, NULL);
    14861497
    … …  
    15161527    DISPDBG((0, "%s\n", __FUNCTION__));
    15171528
    1518     /* ensure we have host cmds processed to update pending blits and flips */
    1519     vboxVHWACommandCheckHostCmds(pDev);
    1520 
    1521 //    if(VBOXDD_CHECKFLAG(lpLock, DDLOCK_DONOTWAIT))
    1522     {
    1523         if(
     1529    if(
    15241530//                ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
    15251531//                || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
    15261532//                ||
    1527                 ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsTarg)
    1528                 || ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsCurr)
    1529                 || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsTarg)
    1530                 || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsCurr))
     1533            ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsTarg)
     1534            || ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsCurr)
     1535            || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsTarg)
     1536            || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsCurr))
     1537    {
     1538        /* ensure we have host cmds processed to update pending blits and flips */
     1539        vboxVHWACommandCheckHostCmds(pDev);
     1540        if(
     1541    //                ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
     1542    //                || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
     1543    //                ||
     1544                    ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsTarg)
     1545                    || ASMAtomicUoReadU32(&pCurrDesc->cPendingFlipsCurr)
     1546                    || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsTarg)
     1547                    || ASMAtomicUoReadU32(&pTargDesc->cPendingFlipsCurr))
    15311548        {
    15321549            lpFlip->ddRVal = DDERR_WASSTILLDRAWING;
    … …  
    15341551        }
    15351552    }
     1553
    15361554
    15371555    pCmd = vboxVHWACommandCreate (pDev, VBOXVHWACMD_TYPE_SURF_FLIP, sizeof(VBOXVHWACMD_SURF_FLIP));
    … …  
    15561574        ASMAtomicIncU32(&pTargDesc->cPendingFlipsTarg);
    15571575
     1576        if(pTargDesc->UpdatedMemRegion.bValid)
     1577        {
     1578            pBody->u.in.xUpdatedTargMemValid = 1;
     1579            vboxVHWAFromRECTL(&pBody->u.in.xUpdatedTargMemRect, &pTargDesc->UpdatedMemRegion.Rect);
     1580            vboxVHWARegionClear(&pTargDesc->UpdatedMemRegion);
     1581        }
     1582
    15581583        vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWASurfFlipCompletion, NULL);
    15591584
    … …  
    15821607        DD_SURFACE_GLOBAL*  lpSurfaceGlobal = lpSurfaceLocal->lpGbl;
    15831608        PVBOXVHWASURFDESC pDesc = (PVBOXVHWASURFDESC)lpSurfaceGlobal->dwReserved1;
    1584 
    1585         /* ensure we have host cmds processed to update pending blits and flips */
    1586         vboxVHWACommandCheckHostCmds(pDev);
    15871609
    15881610        if(
    … …  
    15931615                    )
    15941616        {
    1595             lpGetBltStatus->ddRVal = DDERR_WASSTILLDRAWING;
     1617            /* ensure we have host cmds processed to update pending blits and flips */
     1618            vboxVHWACommandCheckHostCmds(pDev);
     1619
     1620            if(
     1621                        ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
     1622                        || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
     1623        //                || ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg)
     1624        //                || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr)
     1625                        )
     1626            {
     1627                lpGetBltStatus->ddRVal = DDERR_WASSTILLDRAWING;
     1628            }
     1629            else
     1630            {
     1631                lpGetBltStatus->ddRVal = DD_OK;
     1632            }
    15961633        }
    15971634        else
    … …  
    16121649
    16131650    DISPDBG((0, "%s\n", __FUNCTION__));
    1614 
    1615     /* ensure we have host cmds processed to update pending blits and flips */
    1616     vboxVHWACommandCheckHostCmds(pDev);
    16171651
    16181652    if(
    … …  
    16241658                )
    16251659    {
    1626         lpGetFlipStatus->ddRVal = DDERR_WASSTILLDRAWING;
     1660        /* ensure we have host cmds processed to update pending blits and flips */
     1661        vboxVHWACommandCheckHostCmds(pDev);
     1662
     1663        if(
     1664    //                ASMAtomicUoReadU32(&pDesc->cPendingBltsSrc)
     1665    //                || ASMAtomicUoReadU32(&pDesc->cPendingBltsDst)
     1666    //                ||
     1667                    ASMAtomicUoReadU32(&pDesc->cPendingFlipsTarg)
     1668                    || ASMAtomicUoReadU32(&pDesc->cPendingFlipsCurr)
     1669                    )
     1670        {
     1671            lpGetFlipStatus->ddRVal = DDERR_WASSTILLDRAWING;
     1672        }
     1673        else
     1674        {
     1675            lpGetFlipStatus->ddRVal = DD_OK;
     1676        }
    16271677    }
    16281678    else
    … …  
    16791729        pBody->u.in.yPos = lpSetOverlayPosition->lYPos;
    16801730
    1681         vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
     1731        vboxVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
    16821732        lpSetOverlayPosition->ddRVal = DD_OK;
    16831733    }
    … …  
    17281778        {
    17291779            pSrcDesc->bHidden = false;
     1780            if(pSrcDesc->UpdatedMemRegion.bValid)
     1781            {
     1782                pBody->u.in.xUpdatedSrcMemValid = 1;
     1783                vboxVHWAFromRECTL(&pBody->u.in.xUpdatedSrcMemRect, &pSrcDesc->UpdatedMemRegion.Rect);
     1784                vboxVHWARegionClear(&pSrcDesc->UpdatedMemRegion);
     1785            }
    17301786        }
    17311787
    … …  
    17381794        }
    17391795
    1740         vboxVHWACommandSubmitAsynch(pDev, pCmd, vboxVHWAFreeCmdCompletion, NULL);
     1796        vboxVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
    17411797        lpUpdateOverlay->ddRVal = DD_OK;
    17421798    }
    … …  
    17441800    return DDHAL_DRIVER_HANDLED;
    17451801}
     1802#else
     1803DWORD APIENTRY DdSetColorKey(PDD_SETCOLORKEYDATA  lpSetColorKey)
     1804{
     1805    DISPDBG((0, "%s\n", __FUNCTION__));
     1806    lpSetColorKey->ddRVal = DD_OK;
     1807    return DDHAL_DRIVER_HANDLED;
     1808}
     1809
     1810DWORD APIENTRY DdAddAttachedSurface(PDD_ADDATTACHEDSURFACEDATA  lpAddAttachedSurface)
     1811{
     1812    DISPDBG((0, "%s\n", __FUNCTION__));
     1813    lpAddAttachedSurface->ddRVal = DD_OK;
     1814    return DDHAL_DRIVER_HANDLED;
     1815}
     1816
     1817DWORD APIENTRY DdBlt(PDD_BLTDATA  lpBlt)
     1818{
     1819    DISPDBG((0, "%s\n", __FUNCTION__));
     1820    lpBlt->ddRVal = DD_OK;
     1821    return DDHAL_DRIVER_HANDLED;
     1822}
     1823
     1824//DWORD APIENTRY DdDestroySurface(PDD_DESTROYSURFACEDATA  lpDestroySurface)
     1825//{
     1826//    DISPDBG((0, "%s\n", __FUNCTION__));
     1827//    lpDestroySurface->ddRVal = DD_OK;
     1828//    return DDHAL_DRIVER_HANDLED;
     1829//}
     1830
     1831DWORD APIENTRY DdFlip(PDD_FLIPDATA  lpFlip)
     1832{
     1833    DISPDBG((0, "%s\n", __FUNCTION__));
     1834    lpFlip->ddRVal = DD_OK;
     1835    return DDHAL_DRIVER_HANDLED;
     1836}
     1837
     1838DWORD APIENTRY DdGetBltStatus(PDD_GETBLTSTATUSDATA  lpGetBltStatus)
     1839{
     1840    DISPDBG((0, "%s\n", __FUNCTION__));
     1841
     1842    if(lpGetBltStatus->dwFlags == DDGBS_CANBLT)
     1843    {
     1844        lpGetBltStatus->ddRVal = DD_OK;
     1845    }
     1846    else
     1847    {
     1848        lpGetBltStatus->ddRVal = DD_OK;
     1849    }
     1850
     1851    return DDHAL_DRIVER_HANDLED;
     1852}
     1853
     1854DWORD APIENTRY DdGetFlipStatus(PDD_GETFLIPSTATUSDATA  lpGetFlipStatus)
     1855{
     1856    DISPDBG((0, "%s\n", __FUNCTION__));
     1857    if(lpGetFlipStatus->dwFlags == DDGFS_CANFLIP)
     1858    {
     1859        lpGetFlipStatus->ddRVal = DD_OK;
     1860    }
     1861    else
     1862    {
     1863        lpGetFlipStatus->ddRVal = DD_OK;
     1864    }
     1865
     1866    return DDHAL_DRIVER_HANDLED;
     1867}
     1868
     1869DWORD APIENTRY DdSetOverlayPosition(PDD_SETOVERLAYPOSITIONDATA  lpSetOverlayPosition)
     1870{
     1871    DISPDBG((0, "%s\n", __FUNCTION__));
     1872
     1873    lpSetOverlayPosition->ddRVal = DD_OK;
     1874    return DDHAL_DRIVER_HANDLED;
     1875}
     1876
     1877DWORD APIENTRY DdUpdateOverlay(PDD_UPDATEOVERLAYDATA  lpUpdateOverlay)
     1878{
     1879    DISPDBG((0, "%s\n", __FUNCTION__));
     1880
     1881    lpUpdateOverlay->ddRVal = DD_OK;
     1882    return DDHAL_DRIVER_HANDLED;
     1883}
     1884
     1885#endif
    17461886
    17471887//-----------------------------------------------------------------------------
    … …  
    18131953static DWORD rops[DD_ROP_SPACE] = { 0 };
    18141954
     1955#if 1
    18151956static bool
    18161957getDDHALInfo(
    … …  
    18311972                     rops,
    18321973                     sizeof(ropListNT)/sizeof(ropListNT[0]));
     1974
     1975        //
     1976        // ROPS supported
     1977        //
     1978        for( i=0;i<DD_ROP_SPACE;i++ )
     1979        {
     1980            pHALInfo->ddCaps.dwRops[i] = rops[i];
     1981        }
    18331982    }
    18341983
    … …  
    18612010    // We need to flag we can run in windowed mode, otherwise we
    18622011    // might get restricted by apps to run in fullscreen only
    1863     pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_CANRENDERWINDOWED;
     2012//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_CANRENDERWINDOWED;
    18642013
    18652014    // Also permit surfaces wider than the display buffer.
    1866     pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_WIDESURFACES;
     2015//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_WIDESURFACES;
    18672016//#endif
    18682017
    … …  
    19312080    }
    19322081
    1933     if(VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT)
    1934             && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLTFOURCC))
    1935     {
    1936         pHALInfo->ddCaps.dwCaps |= DDCAPS_BLTFOURCC;
    1937 
    1938         // Enable copy blts between Four CC formats for DShow acceleration
    1939         pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_COPYFOURCC;
    1940     }
    1941 
    1942     if((VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT) || VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAY))
    1943             && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_COLORKEY))
     2082//    if(VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT)
     2083//            && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLTFOURCC))
     2084//    {
     2085//        pHALInfo->ddCaps.dwCaps |= DDCAPS_BLTFOURCC;
     2086//
     2087//        // Enable copy blts between Four CC formats for DShow acceleration
     2088//        pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_COPYFOURCC;
     2089//    }
     2090
     2091//    if((VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_BLT) || VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_OVERLAY))
     2092//            && VBOXVHWA_CAP(pDev, VBOXVHWA_CAPS_COLORKEY))
    19442093    {
    19452094        pHALInfo->ddCaps.dwCKeyCaps = vboxVHWAToDDCKEYCAPS(pDev->vhwaInfo.colorKeyCaps);
    … …  
    20552204//                                                  DDBD_8;
    20562205
    2057     //
    2058     // ROPS supported
    2059     //
    2060     for( i=0;i<DD_ROP_SPACE;i++ )
    2061     {
    2062         pHALInfo->ddCaps.dwRops[i] = rops[i];
    2063     }
    20642206
    20652207//Reenable:    // For DX5 and beyond we support this new informational callback.
    … …  
    20752217    return true;
    20762218} // getDDHALInfo
    2077 
    2078 static DECLCALLBACK(void) vboxVHWAFreeCmdCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext)
    2079 {
    2080     vboxVHWACommandFree(ppdev, pCmd);
    2081 }
     2219#else
     2220bool
     2221getDDHALInfo2(
     2222    PPDEV pDev,
     2223    DD_HALINFO* pHALInfo)
     2224{
     2225    int i;
     2226
     2227#if 0
     2228    /* TODO: only enable features supported by the host backend & host hw
     2229     * for now this just combines all caps we might use */
     2230
     2231    // Setup the ROPS we do.
     2232    setupRops( ropListNT,
     2233                 rops,
     2234                 sizeof(ropListNT)/sizeof(ropListNT[0]));
     2235
     2236    // The most basic DirectDraw functionality
     2237    pHALInfo->ddCaps.dwCaps |=   DDCAPS_BLT
     2238                                 | DDCAPS_BLTQUEUE
     2239                                 | DDCAPS_BLTCOLORFILL
     2240//                                | DDCAPS_READSCANLINE
     2241                                ;
     2242#endif
     2243    pHALInfo->ddCaps.ddsCaps.dwCaps |=   DDSCAPS_OFFSCREENPLAIN
     2244                                         | DDSCAPS_PRIMARYSURFACE
     2245                                         | DDSCAPS_FLIP;
     2246#if 0
     2247    pHALInfo->ddCaps.dwCaps |= DDCAPS_3D           |
     2248                               DDCAPS_BLTDEPTHFILL;
     2249
     2250    pHALInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_3DDEVICE |
     2251                                       DDSCAPS_ZBUFFER |
     2252                                       DDSCAPS_ALPHA;
     2253#endif
     2254    pHALInfo->ddCaps.dwCaps2 = 0;
     2255
     2256//#if DX7_TEXMANAGEMENT
     2257    // We need to set this bit up in order to be able to do
     2258    // out own texture management
     2259//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_CANMANAGETEXTURE;
     2260//#if DX8_DDI
     2261//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_CANMANAGERESOURCE;
     2262//#endif
     2263//#endif
     2264
     2265//#if DX8_DDI
     2266    // We need to flag we can run in windowed mode, otherwise we
     2267    // might get restricted by apps to run in fullscreen only
     2268    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_CANRENDERWINDOWED;
     2269//#endif
     2270
     2271//#if DX8_DDI
     2272    // We need to flag we support dynamic textures. That is , apps can
     2273        // lock with high frequency video memory textures without paying a
     2274        // penalty for it. Since on this sample driver we only support
     2275        // linear memory formats for textures we don't need to do anything
     2276        // else for this support. Otherwise we would have to keep two surfaces
     2277        // for textures created with the DDSCAPS2_HINTDYNAMIC hint in order
     2278        // to efficiently do the linear<->swizzled transformation or keep the
     2279        // texture permanantly in an unswizzled state.
     2280//        pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_DYNAMICTEXTURES;
     2281    #if DX9_DDI
     2282        // Notice that dynamic textures MUST be supported in order to instantiate a DX9 device
     2283    #endif // DX9_DDI
     2284//#endif
     2285
     2286//    pHALInfo->ddCaps.dwFXCaps = 0;
     2287
     2288    // P3RX can do:
     2289    // 1. Stretching/Shrinking
     2290    // 2. YUV->RGB conversion
     2291    // 3. Mirroring in X and Y
     2292    // 4. ColorKeying from a source color and a source color space
     2293    pHALInfo->ddCaps.dwCaps |=
     2294#if 0
     2295        DDCAPS_BLTSTRETCH
     2296                               | DDCAPS_BLTFOURCC
     2297                               |
     2298#endif
     2299                               DDCAPS_COLORKEY
     2300//                               | DDCAPS_CANBLTSYSMEM
     2301                               ;
     2302#if 0
     2303    // Special effects caps
     2304    pHALInfo->ddCaps.dwFXCaps |= DDFXCAPS_BLTSTRETCHY  |
     2305                                DDFXCAPS_BLTSTRETCHX  |
     2306                                DDFXCAPS_BLTSTRETCHYN |
     2307                                DDFXCAPS_BLTSTRETCHXN |
     2308                                DDFXCAPS_BLTSHRINKY   |
     2309                                DDFXCAPS_BLTSHRINKX   |
     2310                                DDFXCAPS_BLTSHRINKYN  |
     2311                                DDFXCAPS_BLTSHRINKXN;
     2312
     2313    // ColorKey caps
     2314    pHALInfo->ddCaps.dwCKeyCaps |= DDCKEYCAPS_SRCBLT         |
     2315                                  DDCKEYCAPS_SRCBLTCLRSPACE |
     2316                                  DDCKEYCAPS_DESTBLT        |
     2317                                  DDCKEYCAPS_DESTBLTCLRSPACE;
     2318#endif
     2319//    pHALInfo->ddCaps.dwSVBCaps = DDCAPS_BLT;
     2320
     2321//    // We can do a texture from sysmem to video mem.
     2322//    pHALInfo->ddCaps.dwSVBCKeyCaps |= DDCKEYCAPS_DESTBLT         |
     2323//                                     DDCKEYCAPS_DESTBLTCLRSPACE;
     2324    pHALInfo->ddCaps.dwSVBFXCaps = 0;
     2325
     2326//    // Fill in the sysmem->vidmem rops (only can copy);
     2327//    for( i=0;i<DD_ROP_SPACE;i++ )
     2328//    {
     2329//        pHALInfo->ddCaps.dwSVBRops[i] = rops[i];
     2330//    }
     2331#if 0
     2332    //mirroring with blitting
     2333    pHALInfo->ddCaps.dwFXCaps |= DDFXCAPS_BLTMIRRORUPDOWN  |
     2334                                DDFXCAPS_BLTMIRRORLEFTRIGHT;
     2335
     2336    pHALInfo->ddCaps.dwCKeyCaps |=  DDCKEYCAPS_SRCBLTCLRSPACEYUV;
     2337
     2338    pHALInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_TEXTURE;
     2339#endif
     2340//#if DX7_STEREO
     2341//    // Report the stereo capability back to runtime
     2342//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_STEREO;
     2343//    pHALInfo->ddCaps.dwSVCaps = DDSVCAPS_STEREOSEQUENTIAL;
     2344//#endif
     2345
     2346    // Z Buffer is only 16 Bits
     2347//    pHALInfo->ddCaps.dwZBufferBitDepths = DDBD_16;
     2348//    pHALInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_MIPMAP;
     2349
     2350        pHALInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_LOCALVIDMEM;
     2351
     2352    {
     2353//#ifdef SUPPORT_VIDEOPORT
     2354//        // We support 1 video port.  Must set CurrVideoPorts to 0
     2355//        // We can't do interleaved bobbing yet - maybe in the future.
     2356//        pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_VIDEOPORT            |
     2357//                                    DDCAPS2_CANBOBNONINTERLEAVED;
     2358//
     2359//        pHALInfo->ddCaps.dwMaxVideoPorts = 1;
     2360//        pHALInfo->ddCaps.dwCurrVideoPorts = 0;
     2361//
     2362//
     2363//#endif // SUPPORT_VIDEOPORT
     2364
     2365
     2366        {
     2367            // Overlay is free to use.
     2368            pHALInfo->ddCaps.dwMaxVisibleOverlays = 1;
     2369            pHALInfo->ddCaps.dwCurrVisibleOverlays = 0;
     2370
     2371            pHALInfo->ddCaps.dwCaps |=  DDCAPS_OVERLAY          |
     2372                                        DDCAPS_OVERLAYFOURCC    |
     2373                                        DDCAPS_OVERLAYSTRETCH   |
     2374                                        DDCAPS_COLORKEYHWASSIST |
     2375                                        DDCAPS_OVERLAYCANTCLIP;
     2376
     2377            pHALInfo->ddCaps.dwCKeyCaps |= DDCKEYCAPS_SRCOVERLAY           |
     2378                                           DDCKEYCAPS_SRCOVERLAYONEACTIVE  |
     2379                                           DDCKEYCAPS_SRCOVERLAYYUV        |
     2380                                           DDCKEYCAPS_DESTOVERLAY          |
     2381                                           DDCKEYCAPS_DESTOVERLAYONEACTIVE |
     2382                                           DDCKEYCAPS_DESTOVERLAYYUV;
     2383
     2384            pHALInfo->ddCaps.ddsCaps.dwCaps |= DDSCAPS_OVERLAY;
     2385
     2386            pHALInfo->ddCaps.dwFXCaps |= DDFXCAPS_OVERLAYSHRINKX   |
     2387                                         DDFXCAPS_OVERLAYSHRINKXN  |
     2388                                         DDFXCAPS_OVERLAYSHRINKY   |
     2389                                         DDFXCAPS_OVERLAYSHRINKYN  |
     2390                                         DDFXCAPS_OVERLAYSTRETCHX  |
     2391                                         DDFXCAPS_OVERLAYSTRETCHXN |
     2392                                         DDFXCAPS_OVERLAYSTRETCHY  |
     2393                                         DDFXCAPS_OVERLAYSTRETCHYN;
     2394
     2395            // Indicates that Perm3 has no stretch ratio limitation
     2396            pHALInfo->ddCaps.dwMinOverlayStretch = 1;
     2397            pHALInfo->ddCaps.dwMaxOverlayStretch = 32000;
     2398        }
     2399    }
     2400
     2401//#ifdef W95_DDRAW
     2402//#ifdef USE_DD_CONTROL_COLOR
     2403//    // Enable colour control asc brightness, contrast, gamma.
     2404//    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_COLORCONTROLPRIMARY;
     2405//#endif
     2406//#endif
     2407
     2408    // Also permit surfaces wider than the display buffer.
     2409    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_WIDESURFACES;
     2410#if 0
     2411    // Enable copy blts betweemn Four CC formats for DShow acceleration
     2412    pHALInfo->ddCaps.dwCaps2 |= DDCAPS2_COPYFOURCC;
     2413#endif
     2414    // Won't do Video-Sys mem Blits.
     2415    pHALInfo->ddCaps.dwVSBCaps = 0;
     2416    pHALInfo->ddCaps.dwVSBCKeyCaps = 0;
     2417    pHALInfo->ddCaps.dwVSBFXCaps = 0;
     2418    for( i=0;i<DD_ROP_SPACE;i++ )
     2419    {
     2420        pHALInfo->ddCaps.dwVSBRops[i] = 0;
     2421    }
     2422
     2423    // Won't do Sys-Sys mem Blits
     2424    pHALInfo->ddCaps.dwSSBCaps = 0;
     2425    pHALInfo->ddCaps.dwSSBCKeyCaps = 0;
     2426    pHALInfo->ddCaps.dwSSBFXCaps = 0;
     2427    for( i=0;i<DD_ROP_SPACE;i++ )
     2428    {
     2429        pHALInfo->ddCaps.dwSSBRops[i] = 0;
     2430    }
     2431
     2432    //
     2433    // bit depths supported for alpha and Z
     2434    //
     2435//    pHALInfo->ddCaps.dwAlphaBltConstBitDepths = DDBD_2 |
     2436//                                                DDBD_4 |
     2437//                                                DDBD_8;
     2438//
     2439//    pHALInfo->ddCaps.dwAlphaBltPixelBitDepths = DDBD_1 |
     2440//                                                DDBD_8;
     2441//    pHALInfo->ddCaps.dwAlphaBltSurfaceBitDepths = DDBD_1 |
     2442//                                                  DDBD_2 |
     2443//                                                  DDBD_4 |
     2444//                                                  DDBD_8;
     2445#if 0
     2446    // No alpha blending for overlays, so I'm not sure what these should be.
     2447    // Because we support 32bpp overlays, it's just that you can't use the
     2448    // alpha bits for blending. Pass.
     2449    pHALInfo->ddCaps.dwAlphaBltConstBitDepths = DDBD_2 |
     2450                                                DDBD_4 |
     2451                                                DDBD_8;
     2452
     2453    pHALInfo->ddCaps.dwAlphaBltPixelBitDepths = DDBD_1 |
     2454                                                DDBD_8;
     2455
     2456    pHALInfo->ddCaps.dwAlphaBltSurfaceBitDepths = DDBD_1 |
     2457                                                  DDBD_2 |
     2458                                                  DDBD_4 |
     2459                                                  DDBD_8;
     2460
     2461    //
     2462    // ROPS supported
     2463    //
     2464    for( i=0;i<DD_ROP_SPACE;i++ )
     2465    {
     2466        pHALInfo->ddCaps.dwRops[i] = rops[i];
     2467    }
     2468#endif
     2469//Reenable:    // For DX5 and beyond we support this new informational callback.
     2470//    pHALInfo->GetDriverInfo = DdGetDriverInfo;
     2471//    pHALInfo->dwFlags |= DDHALINFO_GETDRIVERINFOSET;
     2472//
     2473//#if DX8_DDI
     2474//    // Flag our support for a new class of GUIDs that may come through
     2475//    // GetDriverInfo for DX8 drivers. (This support will be compulsory)
     2476//    pHALInfo->dwFlags |= DDHALINFO_GETDRIVERINFO2;
     2477//#endif DX8_DDI
     2478
     2479    return true;
     2480} // getDDHALInfo
     2481
     2482#endif
    20822483
    20832484static DECLCALLBACK(void) vboxVHWASurfBltCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext)

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/driver.h

    r21611 r21939  
    110110    uint32_t cBitsPerPixel;
    111111    bool bHidden;
    112     VBOXVHWAREGION DirtyRegion;
     112    VBOXVHWAREGION UpdatedMemRegion;
     113    VBOXVHWAREGION NonupdatedMemRegion;
    113114}VBOXVHWASURFDESC, *PVBOXVHWASURFDESC;
    114115
    … …  
    307308void vboxVHWARegionInit(PVBOXVHWAREGION pReg);
    308309void vboxVHWARegionClear(PVBOXVHWAREGION pReg);
     310bool vboxVHWARegionValid(PVBOXVHWAREGION pReg);
     311void vboxVHWARegionTrySubstitute(PVBOXVHWAREGION pReg, const RECTL *pRect);
    309312
    310313VBOXVHWACMD* vboxVHWACommandCreate (PPDEV ppdev, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd);
    … …  
    314317void vboxVHWACommandSubmitAsynchByEvent (PPDEV ppdev, VBOXVHWACMD* pCmd, PEVENT pEvent);
    315318void vboxVHWACommandCheckHostCmds(PPDEV ppdev);
     319void vboxVHWACommandSubmitAsynchAndComplete (PPDEV ppdev, VBOXVHWACMD* pCmd);
    316320
    317321int vboxVHWAInitHostInfo1(PPDEV ppdev);

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/vbox.c

    r21609 r21939  
    782782
    783783    /* complete it asynchronously by setting event */
    784     pCmd->Flags |= VBOXVHWACMD_FLAG_ASYNCH_EVENT;
     784    pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT;
    785785    vboxHGSMIBufferSubmit (ppdev, pCmd);
    786786
    787     if(!(ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags)  & VBOXVHWACMD_FLAG_ASYNCH))
     787    if(!(ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags)  & VBOXVHWACMD_FLAG_HG_ASYNCH))
    788788    {
    789789        /* the command is completed */
    … …  
    800800    if(brc)
    801801    {
    802         pCmd->Flags = VBOXVHWACMD_FLAG_ASYNCH_IRQ;
     802        pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ;
    803803        vboxVHWACommandSubmitAsynchByEvent (ppdev, pCmd, pEvent);
    804804
    … …  
    822822    pCmd->GuestVBVAReserved2 = (uintptr_t)pContext;
    823823
    824     pCmd->Flags = 0;
    825824    vboxHGSMIBufferSubmit (ppdev, pCmd);
    826825
    827     if(!(pCmd->Flags  & VBOXVHWACMD_FLAG_ASYNCH))
     826    if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH))
    828827    {
    829828        /* the command is completed */
    830829        pfnCompletion(ppdev, pCmd, pContext);
     830    }
     831}
     832
     833static DECLCALLBACK(void) vboxVHWAFreeCmdCompletion(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext)
     834{
     835    vboxVHWACommandFree(ppdev, pCmd);
     836}
     837
     838void vboxVHWACommandSubmitAsynchAndComplete (PPDEV ppdev, VBOXVHWACMD* pCmd)
     839{
     840//    Assert(0);
     841    pCmd->GuestVBVAReserved1 = (uintptr_t)vboxVHWAFreeCmdCompletion;
     842
     843    pCmd->Flags |= VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION;
     844
     845    vboxHGSMIBufferSubmit (ppdev, pCmd);
     846
     847    if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH)
     848            || pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED)
     849    {
     850        /* the command is completed */
     851        vboxVHWAFreeCmdCompletion(ppdev, pCmd, NULL);
    831852    }
    832853}
    … …  
    919940    int rc = VINF_SUCCESS;
    920941
    921     if(pInfo)
     942    Assert(pInfo);
     943    if(!pInfo)
    922944        return VERR_OUT_OF_RESOURCES;
    923945

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp

    r21596 r21939  
    13271327        {
    13281328            /* schedule a DPC*/
    1329             BOOLEAN bResult = VideoPortQueueDpc(PrimaryExtension, VBoxVideoHGSMIDpc, NULL);
     1329            BOOLEAN bResult = VideoPortQueueDpc(PrimaryExtension, VBoxVideoHGSMIDpc, (PVOID)1);
    13301330            Assert(bResult);
    13311331        }
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette