VirtualBox

Changeset 63057 in vbox for trunk/src


Ignore:
Timestamp:
Aug 5, 2016 8:12:05 PM (9 years ago)
Author:
vboxsync
Message:

GA/NT/Graphics: warnings

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Video
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDriver.cpp

    r62522 r63057  
    500500                      HDEV  hdev, PWSTR pwszDeviceName, HANDLE hDriver)
    501501{
     502    RT_NOREF(hdev);
    502503    PVBOXDISPDEV pDev = NULL;
    503504    GDIINFO gdiInfo;
    … …  
    783784ULONG APIENTRY VBoxDispDrvDitherColor(DHPDEV dhpdev, ULONG iMode, ULONG rgb, ULONG *pul)
    784785{
     786    RT_NOREF(dhpdev, iMode, rgb, pul);
    785787    ULONG rc;
    786788    LOGF_ENTER();

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/common/VBoxMPUtils.h

    r63039 r63057  
    2020
    2121/*Sanity check*/
    22 #if defined(VBOX_XPDM_MINIPORT)==defined(VBOX_WDDM_MINIPORT)
    23 #error One of the VBOX_XPDM_MINIPORT or VBOX_WDDM_MINIPORT should be defined!
     22#if defined(VBOX_XPDM_MINIPORT) == defined(VBOX_WDDM_MINIPORT)
     23# error One of the VBOX_XPDM_MINIPORT or VBOX_WDDM_MINIPORT should be defined!
    2424#endif
    2525
    … …  
    2727#define LOG_GROUP LOG_GROUP_DRV_MINIPORT
    2828#include <VBox/log.h>
     29
    2930#define VBOX_VIDEO_LOG_NAME "VBoxMP"
    3031#ifdef VBOX_WDDM_MINIPORT
    … …  
    3435#endif
    3536#include "common/VBoxVideoLog.h"
     37
    3638#include <iprt/err.h>
    3739#include <iprt/assert.h>
    … …  
    4850# include <dderror.h>
    4951#endif
     52
     53
    5054
    5155/*Windows version identifier*/
    … …  
    6468
    6569RT_C_DECLS_BEGIN
    66 vboxWinVersion_t VBoxQueryWinVersion();
    67 uint32_t VBoxGetHeightReduction();
    68 bool VBoxLikesVideoMode(uint32_t display, uint32_t width, uint32_t height, uint32_t bpp);
    69 bool VBoxQueryDisplayRequest(uint32_t *xres, uint32_t *yres, uint32_t *bpp, uint32_t *pDisplayId);
    70 bool VBoxQueryHostWantsAbsolute();
    71 bool VBoxQueryPointerPos(uint16_t *pPosX, uint16_t *pPosY);
     70vboxWinVersion_t VBoxQueryWinVersion(void);
     71uint32_t VBoxGetHeightReduction(void);
     72bool     VBoxLikesVideoMode(uint32_t display, uint32_t width, uint32_t height, uint32_t bpp);
     73bool     VBoxQueryDisplayRequest(uint32_t *xres, uint32_t *yres, uint32_t *bpp, uint32_t *pDisplayId);
     74bool     VBoxQueryHostWantsAbsolute(void);
     75bool     VBoxQueryPointerPos(uint16_t *pPosX, uint16_t *pPosY);
    7276RT_C_DECLS_END
    7377
    74 #define VBE_DISPI_TOTAL_VIDEO_MEMORY_BYTES 4*_1M
    7578
    76 #define VBOXMP_WARN_VPS_NOBP(_vps)     \
    77 if ((_vps) != NO_ERROR)           \
    78 {                                 \
    79     WARN_NOBP(("vps(%#x)!=NO_ERROR", _vps)); \
    80 }
     79#define VBE_DISPI_TOTAL_VIDEO_MEMORY_BYTES (4*_1M)
    8180
    82 #define VBOXMP_WARN_VPS(_vps)     \
    83 if ((_vps) != NO_ERROR)           \
    84 {                                 \
    85     WARN(("vps(%#x)!=NO_ERROR", _vps)); \
    86 }
     81#define VBOXMP_WARN_VPS_NOBP(_vps) \
     82    if ((_vps) != NO_ERROR) \
     83    { \
     84        WARN_NOBP(("vps(%#x)!=NO_ERROR", _vps)); \
     85    } else do { } while (0)
     86
     87#define VBOXMP_WARN_VPS(_vps) \
     88    if ((_vps) != NO_ERROR) \
     89    { \
     90        WARN(("vps(%#x)!=NO_ERROR", _vps)); \
     91    } else do { } while (0)
    8792
    8893
    89 #define VBOXMP_CHECK_VPS_BREAK(_vps)    \
    90 if ((_vps) != NO_ERROR)                 \
    91 {                                       \
    92     break;                              \
    93 }
     94#define VBOXMP_CHECK_VPS_BREAK(_vps) \
     95    if ((_vps) != NO_ERROR) \
     96    { \
     97        break; \
     98    } else do { } while (0)
     99
    94100
    95101#ifdef DEBUG_misha
    96 /* specifies whether the vboxVDbgBreakF should break in the debugger
    97  * windbg seems to have some issues when there is a lot ( >~50) of sw breakpoints defined
    98  * to simplify things we just insert breaks for the case of intensive debugging WDDM driver*/
     102 /* specifies whether the vboxVDbgBreakF should break in the debugger
     103  * windbg seems to have some issues when there is a lot ( >~50) of sw breakpoints defined
     104  * to simplify things we just insert breaks for the case of intensive debugging WDDM driver*/
    99105extern int g_bVBoxVDbgBreakF;
    100106extern int g_bVBoxVDbgBreakFv;
    101 #define vboxVDbgBreakF() do { if (g_bVBoxVDbgBreakF) AssertBreakpoint(); } while (0)
    102 #define vboxVDbgBreakFv() do { if (g_bVBoxVDbgBreakFv) AssertBreakpoint(); } while (0)
     107# define vboxVDbgBreakF() do { if (g_bVBoxVDbgBreakF) AssertBreakpoint(); } while (0)
     108# define vboxVDbgBreakFv() do { if (g_bVBoxVDbgBreakFv) AssertBreakpoint(); } while (0)
    103109#else
    104 #define vboxVDbgBreakF() do { } while (0)
    105 #define vboxVDbgBreakFv() do { } while (0)
     110# define vboxVDbgBreakF() do { } while (0)
     111# define vboxVDbgBreakFv() do { } while (0)
    106112#endif
    107113
    108 #endif /*VBOXMPUTILS_H*/
     114#endif
     115

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCm.cpp

    r63053 r63057  
    436436        (PVOID*)&pUmEvent,
    437437        NULL);
    438     Assert(Status == STATUS_SUCCESS);
     438    AssertNtStatusSuccess(Status);
    439439    if (Status == STATUS_SUCCESS)
    440440    {
    … …  
    459459        {
    460460            Status = vboxVideoCmSessionCreateLocked(pMgr, &pSession, pUmEvent, pContext);
    461             Assert(Status == STATUS_SUCCESS);
     461            AssertNtStatusSuccess(Status);
    462462        }
    463463        else
    464464        {
    465465            /* Status = */vboxVideoCmSessionCtxAdd(pSession, pContext);
    466             /*Assert(Status == STATUS_SUCCESS);*/
     466            /*AssertNtStatusSuccess(Status);*/
    467467        }
    468468

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPCrUtil.cpp

    r62522 r63057  
    11/* $Id$ */
    2 
    32/** @file
    43 * VBox WDDM Miniport driver
    … …  
    7473DECLEXPORT(void) crDebug(const char *format, ... )
    7574{
    76 
     75    RT_NOREF(format);
    7776}
    7877
    … …  
    8079DECLEXPORT(void) crWarning(const char *format, ... )
    8180{
    82 
     81    RT_NOREF(format);
    8382}
    8483#endif
    … …  
    8685DECLEXPORT(void) crInfo(const char *format, ... )
    8786{
    88 
     87    RT_NOREF(format);
    8988}
    9089
    9190DECLEXPORT(void) crError(const char *format, ... )
    9291{
    93 
     92    RT_NOREF(format);
    9493}
    9594

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp

    r62522 r63057  
    11/* $Id$ */
    2 
    32/** @file
    43 * VBox WDDM Miniport driver
    … …  
    8382    {
    8483        NTSTATUS Status = vboxWddmHTableRealloc(pTbl, pTbl->cSize + RT_MAX(10, pTbl->cSize/4));
    85         Assert(Status == STATUS_SUCCESS);
     84        AssertNtStatusSuccess(Status);
    8685        if (Status != STATUS_SUCCESS)
    8786            return VBOXWDDM_HANDLE_INVALID;
    8887    }
    89     for (UINT i = pTbl->iNext2Search; ; ++i, i %= pTbl->cSize)
     88    for (UINT i = pTbl->iNext2Search; ; i = (i + 1) % pTbl->cSize)
    9089    {
    9190        Assert(i < pTbl->cSize);
    … …  
    10099        }
    101100    }
    102     Assert(0);
    103     return VBOXWDDM_HANDLE_INVALID;
     101    /* not reached */
    104102}
    105103
    … …  
    335333}
    336334
    337 static VOID vboxWddmSwapchainCtxRemoveLocked(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain)
     335static VOID vboxWddmSwapchainCtxRemoveLocked(PVBOXWDDM_CONTEXT pContext, PVBOXWDDM_SWAPCHAIN pSwapchain)
    338336{
    339337    Assert(pSwapchain->hSwapchainKm);
    340338    Assert(pSwapchain->pContext);
    341     void * pTst = vboxWddmHTableRemove(&pContext->Swapchains, pSwapchain->hSwapchainKm);
    342     Assert(pTst == pSwapchain);
     339    void *pvTst = vboxWddmHTableRemove(&pContext->Swapchains, pSwapchain->hSwapchainKm);
     340    Assert((PVBOXWDDM_SWAPCHAIN)pvTst == pSwapchain); NOREF(pvTst);
    343341    RemoveEntryList(&pSwapchain->DevExtListEntry);
    344342    pSwapchain->hSwapchainKm = NULL;
    … …  
    365363    VBOXWDDM_CTXLOCK_DATA
    366364    VBOXWDDM_CTXLOCK_LOCK(pDevExt);
    367     vboxWddmSwapchainCtxRemoveLocked(pDevExt, pContext, pSwapchain);
     365    vboxWddmSwapchainCtxRemoveLocked(pContext, pSwapchain);
    368366    VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
    369367}
    … …  
    384382
    385383        /* yes, we can call remove locked even when using iterator */
    386         vboxWddmSwapchainCtxRemoveLocked(pDevExt, pContext, pSwapchain);
     384        vboxWddmSwapchainCtxRemoveLocked(pContext, pSwapchain);
    387385
    388386        VBOXWDDM_CTXLOCK_UNLOCK(pDevExt);
    … …  
    397395
    398396/* process the swapchain info passed from user-mode display driver & synchronizes the driver state with it */
    399 NTSTATUS vboxWddmSwapchainCtxEscape(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext, PVBOXDISPIFESCAPE_SWAPCHAININFO pSwapchainInfo, UINT cbSize)
     397NTSTATUS vboxWddmSwapchainCtxEscape(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext,
     398                                    PVBOXDISPIFESCAPE_SWAPCHAININFO pSwapchainInfo, UINT cbSize)
    400399{
    401400    if (cbSize < RT_OFFSETOF(VBOXDISPIFESCAPE_SWAPCHAININFO, SwapchainInfo.ahAllocs[0]))
    … …  
    435434            if (VBOXWDDM_ARRAY_MAXELEMENTSU32(VBOXWDDM_ALLOCATION) < pSwapchainInfo->SwapchainInfo.cAllocs)
    436435            {
    437                 WARN(("number of allocations passed in too big (%d), max is (%d)", pSwapchainInfo->SwapchainInfo.cAllocs, VBOXWDDM_ARRAY_MAXELEMENTSU32(VBOXWDDM_ALLOCATION)));
     436                WARN(("number of allocations passed in too big (%d), max is (%d)",
     437                      pSwapchainInfo->SwapchainInfo.cAllocs, VBOXWDDM_ARRAY_MAXELEMENTSU32(VBOXWDDM_ALLOCATION)));
    438438                Status = STATUS_INVALID_PARAMETER;
    439439                break;
    440440            }
    441441
    442             apAlloc = (PVBOXWDDM_ALLOCATION *)vboxWddmMemAlloc(sizeof (PVBOXWDDM_ALLOCATION) * pSwapchainInfo->SwapchainInfo.cAllocs);
     442            apAlloc = (PVBOXWDDM_ALLOCATION *)vboxWddmMemAlloc(  sizeof(PVBOXWDDM_ALLOCATION)
     443                                                               * pSwapchainInfo->SwapchainInfo.cAllocs);
    443444            Assert(apAlloc);
    444445            if (!apAlloc)
    … …  
    470471        {
    471472            VBOXWDDM_CTXLOCK_LOCK(pDevExt);
    472             pSwapchain = (PVBOXWDDM_SWAPCHAIN)vboxWddmHTableGet(&pContext->Swapchains, (VBOXWDDM_HANDLE)pSwapchainInfo->SwapchainInfo.hSwapchainKm);
     473            pSwapchain = (PVBOXWDDM_SWAPCHAIN)vboxWddmHTableGet(&pContext->Swapchains,
     474                                                                (VBOXWDDM_HANDLE)pSwapchainInfo->SwapchainInfo.hSwapchainKm);
    473475            Assert(pSwapchain);
    474476            if (!pSwapchain)
    … …  
    497499
    498500            VBOXWDDM_CTXLOCK_LOCK(pDevExt);
    499             BOOLEAN bRc = vboxWddmSwapchainCtxAddLocked(pDevExt, pContext, pSwapchain);
    500             Assert(bRc);
     501            BOOLEAN fRc = vboxWddmSwapchainCtxAddLocked(pDevExt, pContext, pSwapchain);
     502            Assert(fRc); NOREF(fRc);
    501503        }
    502504        else
    … …  
    528530        else
    529531        {
    530             vboxWddmSwapchainCtxRemoveLocked(pDevExt, pContext, pSwapchain);
     532            vboxWddmSwapchainCtxRemoveLocked(pContext, pSwapchain);
    531533        }
    532534
    … …  
    545547        }
    546548
    547         Assert(Status == STATUS_SUCCESS);
     549        AssertNtStatusSuccess(Status);
    548550    } while (0);
    549551
    … …  
    557559NTSTATUS vboxWddmSwapchainCtxInit(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_CONTEXT pContext)
    558560{
     561    RT_NOREF(pDevExt);
    559562    NTSTATUS Status = vboxWddmHTableCreate(&pContext->Swapchains, 4);
    560563    if (!NT_SUCCESS(Status))
    … …  
    610613    NTSTATUS Status = STATUS_SUCCESS;
    611614    PWCHAR pSuffix;
    612     bool bFallback = false;
    613615    const WCHAR* pKeyPrefix;
    614616    UINT cbKeyPrefix;
    … …  
    693695        }
    694696
    695         NTSTATUS tmpStatus = ZwClose(hKey);
    696         Assert(tmpStatus == STATUS_SUCCESS);
     697        NTSTATUS rcNt2 = ZwClose(hKey);
     698        AssertNtStatusSuccess(rcNt2);
    697699    }
    698700    else
    … …  
    707709
    708710    Status = vboxWddmRegOpenKey(&hKey, VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY, GENERIC_READ);
    709     //Assert(Status == STATUS_SUCCESS);
     711    //AssertNtStatusSuccess(Status);
    710712    if (Status == STATUS_SUCCESS)
    711713    {
    … …  
    723725            RtlZeroMemory(&Buf, sizeof (Buf));
    724726            Status = ZwEnumerateKey(hKey, i, KeyBasicInformation, &Buf, sizeof (Buf), &ResultLength);
    725             Assert(Status == STATUS_SUCCESS);
     727            AssertNtStatusSuccess(Status);
    726728            /* we should not encounter STATUS_NO_MORE_ENTRIES here since this would mean we did not find our entry */
    727729            if (Status != STATUS_SUCCESS)
    … …  
    734736            memcpy(pSubBuf, VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY_SUBKEY, sizeof (VBOXWDDM_REG_DISPLAYSETTINGSVIDEOKEY_SUBKEY));
    735737            Status = vboxWddmRegOpenKey(&hSubKey, KeyBuf, GENERIC_READ);
    736             //Assert(Status == STATUS_SUCCESS);
     738            //AssertNtStatusSuccess(Status);
    737739            if (Status == STATUS_SUCCESS)
    738740            {
    … …  
    775777                }
    776778
    777                 NTSTATUS tmpStatus = ZwClose(hSubKey);
    778                 Assert(tmpStatus == STATUS_SUCCESS);
     779                NTSTATUS rcNt2 = ZwClose(hSubKey);
     780                AssertNtStatusSuccess(rcNt2);
    779781            }
    780782            else
    781783                break;
    782784        }
    783         NTSTATUS tmpStatus = ZwClose(hKey);
    784         Assert(tmpStatus == STATUS_SUCCESS);
     785        NTSTATUS rcNt2 = ZwClose(hKey);
     786        AssertNtStatusSuccess(rcNt2);
    785787    }
    786788
    … …  
    804806}
    805807
    806 NTSTATUS vboxWddmRegOpenDisplaySettingsKey(IN PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, OUT PHANDLE phKey)
     808NTSTATUS vboxWddmRegOpenDisplaySettingsKey(IN PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId,
     809                                           OUT PHANDLE phKey)
    807810{
    808811    WCHAR Buf[512];
    809812    ULONG cbBuf = sizeof(Buf);
    810813    NTSTATUS Status = vboxWddmRegQueryDisplaySettingsKeyName(pDevExt, VidPnSourceId, cbBuf, Buf, &cbBuf);
    811     Assert(Status == STATUS_SUCCESS);
     814    AssertNtStatusSuccess(Status);
    812815    if (Status == STATUS_SUCCESS)
    813816    {
    814817        Status = vboxWddmRegOpenKey(phKey, Buf, GENERIC_READ);
    815         Assert(Status == STATUS_SUCCESS);
     818        AssertNtStatusSuccess(Status);
    816819        if(Status == STATUS_SUCCESS)
    817820            return STATUS_SUCCESS;
    … …  
    829832    DWORD dwVal;
    830833    NTSTATUS Status = vboxWddmRegQueryValueDword(hKey, VBOXWDDM_REG_DISPLAYSETTINGS_ATTACH_RELX, &dwVal);
    831     Assert(Status == STATUS_SUCCESS);
     834    AssertNtStatusSuccess(Status);
    832835    if (Status == STATUS_SUCCESS)
    833836    {
    … …  
    842845    DWORD dwVal;
    843846    NTSTATUS Status = vboxWddmRegQueryValueDword(hKey, VBOXWDDM_REG_DISPLAYSETTINGS_ATTACH_RELY, &dwVal);
    844     Assert(Status == STATUS_SUCCESS);
     847    AssertNtStatusSuccess(Status);
    845848    if (Status == STATUS_SUCCESS)
    846849    {
    … …  
    856859    HANDLE hKey;
    857860    NTSTATUS Status = vboxWddmRegOpenDisplaySettingsKey(pDevExt, VidPnSourceId, &hKey);
    858     //Assert(Status == STATUS_SUCCESS);
     861    //AssertNtStatusSuccess(Status);
    859862    if (Status == STATUS_SUCCESS)
    860863    {
    861864        int x, y;
    862865        Status = vboxWddmRegDisplaySettingsQueryRelX(hKey, &x);
    863         Assert(Status == STATUS_SUCCESS);
     866        AssertNtStatusSuccess(Status);
    864867        if (Status == STATUS_SUCCESS)
    865868        {
    866869            Status = vboxWddmRegDisplaySettingsQueryRelY(hKey, &y);
    867             Assert(Status == STATUS_SUCCESS);
     870            AssertNtStatusSuccess(Status);
    868871            if (Status == STATUS_SUCCESS)
    869872            {
    … …  
    872875            }
    873876        }
    874         NTSTATUS tmpStatus = ZwClose(hKey);
    875         Assert(tmpStatus == STATUS_SUCCESS);
     877        NTSTATUS rcNt2 = ZwClose(hKey);
     878        AssertNtStatusSuccess(rcNt2);
    876879    }
    877880
    … …  
    914917        WARN(("vboxWddmRegSetValueDword failed, Status = 0x%x", Status));
    915918
    916     NTSTATUS tmpStatus = ZwClose(hKey);
    917     Assert(tmpStatus == STATUS_SUCCESS);
     919    NTSTATUS rcNt2 = ZwClose(hKey);
     920    AssertNtStatusSuccess(rcNt2);
    918921
    919922    return Status;
    … …  
    938941    }
    939942
    940     NTSTATUS tmpStatus = ZwClose(hKey);
    941     Assert(tmpStatus == STATUS_SUCCESS);
     943    NTSTATUS rcNt2 = ZwClose(hKey);
     944    AssertNtStatusSuccess(rcNt2);
    942945
    943946    return dwVal;
    … …  
    993996    ULONG cbVideoGuidBuf = sizeof (VideoGuidBuf);
    994997    NTSTATUS Status = vboxWddmRegQueryVideoGuidString(pDevExt ,cbVideoGuidBuf, VideoGuidBuf, &cbVideoGuidBuf);
    995     Assert(Status == STATUS_SUCCESS);
     998    AssertNtStatusSuccess(Status);
    996999    if (Status == STATUS_SUCCESS)
    9971000    {
    … …  
    11731176                (PVOID*)&pSynchEvent,
    11741177                NULL);
    1175         Assert(Status == STATUS_SUCCESS);
     1178        AssertNtStatusSuccess(Status);
    11761179        Assert(pSynchEvent);
    11771180    }
    … …  
    11821185        SIZE_T cbLength = pAlloc->cbData;
    11831186
    1184         PVBOXVIDEOCM_ALLOC_REF pAllocRef = (PVBOXVIDEOCM_ALLOC_REF)vboxWddmMemAllocZero(sizeof (*pAllocRef) + sizeof (PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(BaseVa, cbLength));
     1187        PVBOXVIDEOCM_ALLOC_REF pAllocRef;
     1188        pAllocRef = (PVBOXVIDEOCM_ALLOC_REF)vboxWddmMemAllocZero(  sizeof(*pAllocRef)
     1189                                                                 +   sizeof(PFN_NUMBER)
     1190                                                                   * ADDRESS_AND_SIZE_TO_SPAN_PAGES(BaseVa, cbLength));
    11851191        if (pAllocRef)
    11861192        {
    … …  
    12521258}
    12531259
    1254 NTSTATUS vboxVideoAMgrCtxAllocUnmap(PVBOXVIDEOCM_ALLOC_CONTEXT pContext, VBOXDISP_KMHANDLE hSesionHandle, PVBOXVIDEOCM_ALLOC *ppAlloc)
     1260NTSTATUS vboxVideoAMgrCtxAllocUnmap(PVBOXVIDEOCM_ALLOC_CONTEXT pContext, VBOXDISP_KMHANDLE hSesionHandle,
     1261                                    PVBOXVIDEOCM_ALLOC *ppAlloc)
    12551262{
    12561263    NTSTATUS Status = STATUS_SUCCESS;
    … …  
    12801287}
    12811288
    1282 static PVBOXVIDEOCM_ALLOC_REF vboxVideoAMgrCtxAllocRefAcquire(PVBOXVIDEOCM_ALLOC_CONTEXT pContext, VBOXDISP_KMHANDLE hSesionHandle)
     1289static PVBOXVIDEOCM_ALLOC_REF vboxVideoAMgrCtxAllocRefAcquire(PVBOXVIDEOCM_ALLOC_CONTEXT pContext,
     1290                                                              VBOXDISP_KMHANDLE hSesionHandle)
    12831291{
    12841292    ExAcquireFastMutex(&pContext->Mutex);
    … …  
    12941302    uint32_t cRefs = ASMAtomicDecU32(&pRef->cRefs);
    12951303    Assert(cRefs < UINT32_MAX/2);
    1296     Assert(cRefs >= 1); /* we do not do cleanup-on-zero here, instead we wait for the cRefs to reach 1 in vboxVideoAMgrCtxAllocUnmap before unmapping */
     1304    Assert(cRefs >= 1); /* we do not do cleanup-on-zero here, instead we wait for the cRefs to reach 1 in
     1305                           vboxVideoAMgrCtxAllocUnmap before unmapping */
     1306    NOREF(cRefs);
    12971307}
    12981308
    … …  
    13411351static DECLCALLBACK(VOID) vboxVideoAMgrAllocSubmitCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
    13421352{
     1353    RT_NOREF(pCmd);
    13431354    /* we should be called from our DPC routine */
    13441355    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
    … …  
    13661377
    13671378/* submits a set of chromium uhgsmi buffers to host for processing */
    1368 NTSTATUS vboxVideoAMgrCtxAllocSubmit(PVBOXMP_DEVEXT pDevExt, PVBOXVIDEOCM_ALLOC_CONTEXT pContext, UINT cBuffers, VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE *paBuffers)
     1379NTSTATUS vboxVideoAMgrCtxAllocSubmit(PVBOXMP_DEVEXT pDevExt, PVBOXVIDEOCM_ALLOC_CONTEXT pContext, UINT cBuffers,
     1380                                     VBOXWDDM_UHGSMI_BUFFER_UI_INFO_ESCAPE *paBuffers)
    13691381{
    13701382    /* ensure we do not overflow the 32bit buffer size value */
    13711383    if (VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(VBOXVDMACMD_CHROMIUM_CMD, aBuffers) < cBuffers)
    13721384    {
    1373         WARN(("number of buffers passed too big (%d), max is (%d)", cBuffers, VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(VBOXVDMACMD_CHROMIUM_CMD, aBuffers)));
     1385        WARN(("number of buffers passed too big (%d), max is (%d)",
     1386              cBuffers, VBOXWDDM_TRAILARRAY_MAXELEMENTSU32(VBOXVDMACMD_CHROMIUM_CMD, aBuffers)));
    13741387        return STATUS_INVALID_PARAMETER;
    13751388    }
    … …  
    14711484    ExInitializeFastMutex(&pMgr->Mutex);
    14721485    NTSTATUS Status = vboxWddmHTableCreate(&pMgr->AllocTable, 64);
    1473     Assert(Status == STATUS_SUCCESS);
     1486    AssertNtStatusSuccess(Status);
    14741487    if (Status == STATUS_SUCCESS)
    14751488    {
    14761489        Status = vboxMmInit(&pMgr->Mm, BYTES_TO_PAGES(cbData));
    1477         Assert(Status == STATUS_SUCCESS);
     1490        AssertNtStatusSuccess(Status);
    14781491        if (Status == STATUS_SUCCESS)
    14791492        {
    … …  
    15021515NTSTATUS vboxVideoAMgrDestroy(PVBOXMP_DEVEXT pDevExt, PVBOXVIDEOCM_ALLOC_MGR pMgr)
    15031516{
     1517    RT_NOREF(pDevExt);
    15041518    MmUnmapIoSpace(pMgr->pvData, pMgr->cbData);
    15051519    vboxMmTerm(&pMgr->Mm);
    … …  
    15151529        ExInitializeFastMutex(&pCtx->Mutex);
    15161530        Status = vboxWddmHTableCreate(&pCtx->AllocTable, 32);
    1517         Assert(Status == STATUS_SUCCESS);
     1531        AssertNtStatusSuccess(Status);
    15181532        if (Status == STATUS_SUCCESS)
    15191533        {
    … …  
    15431557
    15441558        Status = vboxVideoAMgrCtxAllocDestroy(pCtx, pRef->hSessionHandle);
    1545         Assert(Status == STATUS_SUCCESS);
     1559        AssertNtStatusSuccess(Status);
    15461560        if (Status != STATUS_SUCCESS)
    15471561            break;
    … …  
    15601574VOID vboxWddmSleep(uint32_t u32Val)
    15611575{
     1576    RT_NOREF(u32Val);
    15621577    LARGE_INTEGER Interval;
    15631578    Interval.QuadPart = -(int64_t) 2 /* ms */ * 10000;
    … …  
    16731688            vboxUmdDumpD3DCAPS9(pBuf->aBuf, &pBuf->Flags);
    16741689        }
     1690        default: break; /* Shuts up MSC. */
    16751691    }
    16761692
    … …  
    17071723}
    17081724
    1709 #define PVBOXWDDM_ALLOCATION_FROM_SHRCTREENODE(_p) ((PVBOXWDDM_ALLOCATION)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXWDDM_ALLOCATION, ShRcTreeEntry)))
     1725#define PVBOXWDDM_ALLOCATION_FROM_SHRCTREENODE(_p) \
     1726    ((PVBOXWDDM_ALLOCATION)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXWDDM_ALLOCATION, ShRcTreeEntry)))
     1727
    17101728PVBOXWDDM_ALLOCATION vboxShRcTreeGet(PVBOXMP_DEVEXT pDevExt, HANDLE hSharedRc)
    17111729{
    … …  
    17891807{
    17901808    int rc = VINF_SUCCESS;
    1791     PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
     1809    PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx,
     1810                                                               sizeof(VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
    17921811    if (pCmd)
    17931812    {
    … …  
    20332052)
    20342053{
     2054    RT_NOREF(Dpc, SystemArgument1, SystemArgument2);
    20352055    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)DeferredContext;
    20362056    Assert(!pDevExt->fVSyncInVBlank);
    … …  
    20712091
    20722092#ifdef VBOX_WDDM_WIN8
     2093
    20732094void vboxWddmDiInitDefault(DXGK_DISPLAY_INFORMATION *pInfo, PHYSICAL_ADDRESS PhAddr, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
    20742095{
    … …  
    21012122}
    21022123
    2103 void vboxWddmDmSetupDefaultVramLocation(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId, VBOXWDDM_SOURCE *paSources)
     2124void vboxWddmDmSetupDefaultVramLocation(PVBOXMP_DEVEXT pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID ModifiedVidPnSourceId,
     2125                                        VBOXWDDM_SOURCE *paSources)
    21042126{
    21052127    PVBOXWDDM_SOURCE pSource = &paSources[ModifiedVidPnSourceId];
    … …  
    21132135        pSource->u8SyncState &= ~VBOXWDDM_HGSYNC_F_SYNCED_LOCATION;
    21142136}
    2115 #endif
     2137
     2138#endif /* VBOX_WDDM_WIN8 */
     2139

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPRegistry.cpp

    r62522 r63057  
    2424    ULONG cbBuf = sizeof(Buf);
    2525    NTSTATUS Status = vboxWddmRegQueryDrvKeyName(pExt, cbBuf, Buf, &cbBuf);
    26     Assert(Status == STATUS_SUCCESS);
     26    AssertNtStatusSuccess(Status);
    2727    if (Status == STATUS_SUCCESS)
    2828    {
    2929        Status = vboxWddmRegOpenKey(pReg, Buf, GENERIC_READ | GENERIC_WRITE);
    30         Assert(Status == STATUS_SUCCESS);
     30        AssertNtStatusSuccess(Status);
    3131        if(Status == STATUS_SUCCESS)
    3232            return NO_ERROR;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVModes.cpp

    r62522 r63057  
    11/* $Id$ */
    2 
    32/** @file
    43 * VBox WDDM Miniport driver
    … …  
    311310     */
    312311    VBOXMPCMNREGISTRY Registry;
    313     int fPrefSet=0;
    314312    VP_STATUS vpRc;
    315313
    … …  
    614612        {
    615613            Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
    616             Assert(Status == STATUS_SUCCESS);
     614            AssertNtStatusSuccess(Status);
    617615            return STATUS_SUCCESS;
    618616        }

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.cpp

    r62522 r63057  
    847847static int vboxCmdVbvaFlush(PVBOXMP_DEVEXT pDevExt, HGSMIGUESTCOMMANDCONTEXT *pCtx, bool fBufferOverflow)
    848848{
     849    RT_NOREF(pDevExt);
     850
    849851    /* Issue the flush command. */
    850852    VBVACMDVBVAFLUSH *pFlush = (VBVACMDVBVAFLUSH*)VBoxHGSMIBufferAlloc(pCtx,
    851                                    sizeof (VBVACMDVBVAFLUSH),
    852                                    HGSMI_CH_VBVA,
    853                                    VBVA_CMDVBVA_FLUSH);
     853                                                                       sizeof(VBVACMDVBVAFLUSH),
     854                                                                       HGSMI_CH_VBVA,
     855                                                                       VBVA_CMDVBVA_FLUSH);
    854856    if (!pFlush)
    855857    {
    … …  
    918920                            0, /* IN ULONG MessageNumber */
    919921                            &bRet);
    920     Assert(Status == STATUS_SUCCESS);
     922    AssertNtStatusSuccess(Status);
    921923
    922924    if (pu32FenceSubmitted)
    … …  
    931933static DECLCALLBACK(void) voxCmdVbvaFlushCb(struct VBVAEXBUFFERCONTEXT *pCtx, PHGSMIGUESTCOMMANDCONTEXT pHGSMICtx, void *pvFlush)
    932934{
     935    NOREF(pCtx);
    933936    PVBOXMP_DEVEXT pDevExt = (PVBOXMP_DEVEXT)pvFlush;
    934937
    … …  
    13021305
    13031306int VBoxCmdVbvaConConnect(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva,
    1304         uint32_t crVersionMajor, uint32_t crVersionMinor,
    1305         uint32_t *pu32ClientID)
    1306 {
     1307                          uint32_t crVersionMajor, uint32_t crVersionMinor,
     1308                          uint32_t *pu32ClientID)
     1309{
     1310    RT_NOREF(pVbva);
    13071311    return vboxCmdVbvaConConnect(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, crVersionMajor, crVersionMinor, pu32ClientID);
    13081312}
    … …  
    13101314int VBoxCmdVbvaConDisconnect(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, uint32_t u32ClientID)
    13111315{
     1316    RT_NOREF(pVbva);
    13121317    return vboxCmdVbvaConDisconnect(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, u32ClientID);
    13131318}

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVdma.cpp

    r63053 r63057  
    133133    /* ensure the pipe is closed */
    134134    NTSTATUS Status = vboxVdmaPipeCltClose(pPipe);
    135     Assert(Status == STATUS_SUCCESS);
     135    AssertNtStatusSuccess(Status);
    136136
    137137    Assert(pPipe->enmState == VBOXVDMAPIPE_STATE_CLOSED);
    … …  
    170170        if (!bListEmpty)
    171171        {
    172             Assert(Status == STATUS_SUCCESS);
     172            AssertNtStatusSuccess(Status);
    173173            break;
    174174        }
    … …  
    177177        {
    178178            Status = KeWaitForSingleObject(&pPipe->Event, Executive, KernelMode, FALSE, NULL /* PLARGE_INTEGER Timeout */);
    179             Assert(Status == STATUS_SUCCESS);
     179            AssertNtStatusSuccess(Status);
    180180            if (Status != STATUS_SUCCESS)
    181181                break;
    … …  
    855855            Status = vboxVdmaGgDmaBltPerform(pDevExt, &pBlt->SrcAlloc.pAlloc->AllocData, &SrcRect,
    856856                    &pBlt->DstAlloc.pAlloc->AllocData, &pBlt->DstRects.UpdateRects.aRects[i]);
    857             Assert(Status == STATUS_SUCCESS);
     857            AssertNtStatusSuccess(Status);
    858858            if (Status != STATUS_SUCCESS)
    859859                return Status;
    … …  
    864864        Status = vboxVdmaGgDmaBltPerform(pDevExt, &pBlt->SrcAlloc.pAlloc->AllocData, &pBlt->SrcRect,
    865865                &pBlt->DstAlloc.pAlloc->AllocData, &pBlt->DstRects.ContextRect);
    866         Assert(Status == STATUS_SUCCESS);
     866        AssertNtStatusSuccess(Status);
    867867        if (Status != STATUS_SUCCESS)
    868868            return Status;
    … …  
    20462046            0, /* IN ULONG MessageNumber */
    20472047            &bNeedDps);
    2048     Assert(Status == STATUS_SUCCESS);
     2048    AssertNtStatusSuccess(Status);
    20492049    return Status;
    20502050}
    … …  
    20762076            0, /* IN ULONG MessageNumber */
    20772077            &bRc);
    2078     Assert(Status == STATUS_SUCCESS);
     2078    AssertNtStatusSuccess(Status);
    20792079    return Status;
    20802080}
    … …  
    21132113            0, /* IN ULONG MessageNumber */
    21142114            &bRet);
    2115     Assert(Status == STATUS_SUCCESS);
     2115    AssertNtStatusSuccess(Status);
    21162116    return Status;
    21172117}
    … …  
    21282128        vboxVdmaDdiCmdInit(pCmd, u32NodeOrdinal, u32FenceId, vboxVdmaDdiCmdCompletionCbFree, NULL);
    21292129        NTSTATUS Status = vboxVdmaDdiCmdCompleted(pDevExt, pCmd, enmComplType);
    2130         Assert(Status == STATUS_SUCCESS);
     2130        AssertNtStatusSuccess(Status);
    21312131        if (Status == STATUS_SUCCESS)
    21322132            return STATUS_SUCCESS;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVhwa.cpp

    r62522 r63057  
    5656}
    5757
    58 DECLINLINE(void) vbvaVhwaCommandRetain(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd)
     58DECLINLINE(void) vbvaVhwaCommandRetain(VBOXVHWACMD *pCmd)
    5959{
    6060    ASMAtomicIncU32(&pCmd->cRefs);
    … …  
    6262
    6363/* do not wait for completion */
    64 void vboxVhwaCommandSubmitAsynch(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext)
     64void vboxVhwaCommandSubmitAsynch(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void *pContext)
    6565{
    6666    pCmd->GuestVBVAReserved1 = (uintptr_t)pfnCompletion;
    6767    pCmd->GuestVBVAReserved2 = (uintptr_t)pContext;
    68     vbvaVhwaCommandRetain(pDevExt, pCmd);
     68    vbvaVhwaCommandRetain(pCmd);
    6969
    7070    VBoxHGSMIBufferSubmit(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx, pCmd);
    7171
    72     if(!(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH)
    73             || ((pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION)
    74                     && (pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED)))
     72    if(   !(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH)
     73       || (   (pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_NOCOMPLETION)
     74           && (pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH_RETURNED) ) )
    7575    {
    7676        /* the command is completed */
    … …  
    8383static DECLCALLBACK(void) vboxVhwaCompletionSetEvent(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD * pCmd, void * pvContext)
    8484{
     85    RT_NOREF(pDevExt,  pCmd);
    8586    RTSemEventSignal((RTSEMEVENT)pvContext);
    8687}
    … …  
    9596{
    9697    NTSTATUS Status = vboxWddmCallIsr(pDevExt);
    97     Assert(Status == STATUS_SUCCESS);
     98    AssertNtStatusSuccess(Status);
    9899}
    99100
    … …  
    184185
    185186#ifndef VBOXVHWA_WITH_SHGSMI
    186 static DECLCALLBACK(void) vboxVhwaCompletionFreeCmd(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD * pCmd, void * pContext)
    187 {
     187static DECLCALLBACK(void) vboxVhwaCompletionFreeCmd(PVBOXMP_DEVEXT pDevExt, VBOXVHWACMD *pCmd, void *pvContext)
     188{
     189    RT_NOREF(pvContext);
    188190    vboxVhwaCommandFree(pDevExt, pCmd);
    189191}
    … …  
    533535
    534536int vboxVhwaHlpPopulateSurInfo(VBOXVHWA_SURFACEDESC *pInfo, PVBOXWDDM_ALLOCATION pSurf,
    535         uint32_t fFlags, uint32_t cBackBuffers, uint32_t fSCaps,
    536         D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
    537 {
     537                               uint32_t fFlags, uint32_t cBackBuffers, uint32_t fSCaps,
     538                               D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId)
     539{
     540    RT_NOREF(VidPnSourceId);
    538541    memset(pInfo, 0, sizeof(VBOXVHWA_SURFACEDESC));
    539542

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVidPn.cpp

    r63051 r63057  
    20142014                    pNewVidPnSourceModeInfo, pContext))
    20152015            {
    2016                 Assert(Status == STATUS_SUCCESS);
     2016                AssertNtStatusSuccess(Status);
    20172017                if (Status == STATUS_SUCCESS)
    20182018                    pVidPnSourceModeSetInterface->pfnReleaseModeInfo(hNewVidPnSourceModeSet, pNextVidPnSourceModeInfo);
    … …  
    20692069                    pNewVidPnTargetModeInfo, pContext))
    20702070            {
    2071                 Assert(Status == STATUS_SUCCESS);
     2071                AssertNtStatusSuccess(Status);
    20722072                if (Status == STATUS_SUCCESS)
    20732073                    pVidPnTargetModeSetInterface->pfnReleaseModeInfo(hNewVidPnTargetModeSet, pNextVidPnTargetModeInfo);
    … …  
    21222122            D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId;
    21232123            Status = pVidPnTopologyInterface->pfnEnumPathTargetsFromSource(hVidPnTopology, VidPnSourceId, i, &VidPnTargetId);
    2124             Assert(Status == STATUS_SUCCESS);
     2124            AssertNtStatusSuccess(Status);
    21252125            if (Status == STATUS_SUCCESS)
    21262126            {
    … …  
    22942294    CONST DXGK_VIDPNTARGETMODESET_INTERFACE* pVidPnTargetModeSetInterface;
    22952295    NTSTATUS Status = pInfo->pVidPnInterface->pfnAcquireTargetModeSet(pInfo->hVidPn, VidPnTargetId, &hVidPnTargetModeSet, &pVidPnTargetModeSetInterface);
    2296     Assert(Status == STATUS_SUCCESS);
     2296    AssertNtStatusSuccess(Status);
    22972297    if (Status == STATUS_SUCCESS)
    22982298    {
    22992299        CONST D3DKMDT_VIDPN_TARGET_MODE* pPinnedVidPnTargetModeInfo;
    23002300        Status = pVidPnTargetModeSetInterface->pfnAcquirePinnedModeInfo(hVidPnTargetModeSet, &pPinnedVidPnTargetModeInfo);
    2301         Assert(Status == STATUS_SUCCESS);
     2301        AssertNtStatusSuccess(Status);
    23022302        if (Status == STATUS_SUCCESS)
    23032303        {
    … …  
    23512351                &hCurVidPnSourceModeSet,
    23522352                &pCurVidPnSourceModeSetInterface);
    2353     Assert(Status == STATUS_SUCCESS);
     2353    AssertNtStatusSuccess(Status);
    23542354    if (Status == STATUS_SUCCESS)
    23552355    {
    … …  
    23612361            Assert(pPinnedVidPnSourceModeInfo);
    23622362            Status = vboxVidPnCommitSourceMode(pDevExt, pPinnedVidPnSourceModeInfo, pAllocation, VidPnSourceId, paSources);
    2363             Assert(Status == STATUS_SUCCESS);
     2363            AssertNtStatusSuccess(Status);
    23642364            if (Status == STATUS_SUCCESS)
    23652365            {
    … …  
    23672367                CONST DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
    23682368                Status = pVidPnInterface->pfnGetTopology(hDesiredVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
    2369                 Assert(Status == STATUS_SUCCESS);
     2369                AssertNtStatusSuccess(Status);
    23702370                if (Status == STATUS_SUCCESS)
    23712371                {
    … …  
    23832383                    {
    23842384                        Status = TgtModeInfo.Status;
    2385                         Assert(Status == STATUS_SUCCESS);
     2385                        AssertNtStatusSuccess(Status);
    23862386                    }
    23872387                    else if (Status == STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY)
    … …  
    24032403        {
    24042404            Status = vboxVidPnCommitSourceMode(pDevExt, NULL, pAllocation, VidPnSourceId, paSources);
    2405             Assert(Status == STATUS_SUCCESS);
     2405            AssertNtStatusSuccess(Status);
    24062406        }
    24072407        else
    … …  
    29312931                        &hCurVidPnSourceModeSet,
    29322932                        &pCurVidPnSourceModeSetInterface);
    2933     Assert(Status == STATUS_SUCCESS);
     2933    AssertNtStatusSuccess(Status);
    29342934    if (Status == STATUS_SUCCESS)
    29352935    {
    … …  
    29822982                        &hCurVidPnSourceModeSet,
    29832983                        &pCurVidPnSourceModeSetInterface);
    2984     Assert(Status == STATUS_SUCCESS);
     2984    AssertNtStatusSuccess(Status);
    29852985    if (Status == STATUS_SUCCESS)
    29862986    {
    … …  
    29882988        Status = vboxVidPnEnumSourceModes(hCurVidPnSourceModeSet, pCurVidPnSourceModeSetInterface,
    29892989                vboxVidPnDumpSourceModeSetEnum, NULL);
    2990         Assert(Status == STATUS_SUCCESS);
     2990        AssertNtStatusSuccess(Status);
    29912991        if (Status != STATUS_SUCCESS)
    29922992        {
    … …  
    30243024                        &hCurVidPnTargetModeSet,
    30253025                        &pCurVidPnTargetModeSetInterface);
    3026     Assert(Status == STATUS_SUCCESS);
     3026    AssertNtStatusSuccess(Status);
    30273027    if (Status == STATUS_SUCCESS)
    30283028    {
    … …  
    30303030        Status = vboxVidPnEnumTargetModes(hCurVidPnTargetModeSet, pCurVidPnTargetModeSetInterface,
    30313031                vboxVidPnDumpTargetModeSetEnum, NULL);
    3032         Assert(Status == STATUS_SUCCESS);
     3032        AssertNtStatusSuccess(Status);
    30333033        if (Status != STATUS_SUCCESS)
    30343034        {
    … …  
    30553055                        &hCurVidPnTargetModeSet,
    30563056                        &pCurVidPnTargetModeSetInterface);
    3057     Assert(Status == STATUS_SUCCESS);
     3057    AssertNtStatusSuccess(Status);
    30583058    if (Status == STATUS_SUCCESS)
    30593059    {
    … …  
    31453145    const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
    31463146    NTSTATUS Status = pVidPnInterface->pfnGetTopology(hVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
    3147     Assert(Status == STATUS_SUCCESS);
     3147    AssertNtStatusSuccess(Status);
    31483148    if (Status == STATUS_SUCCESS)
    31493149    {
    31503150        Status = vboxVidPnEnumPaths(hVidPnTopology, pVidPnTopologyInterface,
    31513151                                        vboxVidPnDumpPathEnum, &CbData);
    3152         Assert(Status == STATUS_SUCCESS);
     3152        AssertNtStatusSuccess(Status);
    31533153    }
    31543154

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

    r63048 r63057  
    836836
    837837        NTSTATUS Status = vboxVideoAMgrCreate(pDevExt, &pDevExt->AllocMgr, offset, ulSize);
    838         Assert(Status == STATUS_SUCCESS);
     838        AssertNtStatusSuccess(Status);
    839839        if (Status != STATUS_SUCCESS)
    840840        {
    … …  
    10421042                                  RegKeyBuf,
    10431043                                  &cbRegKeyBuf);
    1044     Assert(Status == STATUS_SUCCESS);
     1044    AssertNtStatusSuccess(Status);
    10451045    if (Status == STATUS_SUCCESS)
    10461046    {
    … …  
    18581858                0, /* IN ULONG MessageNumber */
    18591859                &bRet);
    1860         Assert(Status == STATUS_SUCCESS); NOREF(Status);
     1860        AssertNtStatusSuccess(Status); NOREF(Status);
    18611861
    18621862    //    if (context.data.bNotifyDpc)
    … …  
    19011901            0, /* IN ULONG MessageNumber */
    19021902            &bRet);
    1903     Assert(Status == STATUS_SUCCESS); NOREF(Status);
     1903    AssertNtStatusSuccess(Status); NOREF(Status);
    19041904
    19051905//    if (context.data.bNotifyDpc)
    … …  
    32343234            0, /* IN ULONG MessageNumber */
    32353235            &bRet);
    3236     Assert(Status == STATUS_SUCCESS);
     3236    AssertNtStatusSuccess(Status);
    32373237    return Status;
    32383238}
    … …  
    35363536        {
    35373537            Status = vboxVdmaDdiCmdFenceComplete(pDevExt, pContext->NodeOrdinal, pSubmitCommand->SubmissionFenceId, DXGK_INTERRUPT_DMA_COMPLETED);
    3538             Assert(Status == STATUS_SUCCESS);
     3538            AssertNtStatusSuccess(Status);
    35393539            break;
    35403540        }
    … …  
    43924392                {
    43934393                    Status = vboxVideoAMgrCtxAllocSubmit(pDevExt, &pContext->AllocContext, pEscapeHdr->u32CmdSpecific, pSubmit->aBuffers);
    4394                     Assert(Status == STATUS_SUCCESS);
     4394                    AssertNtStatusSuccess(Status);
    43954395                }
    43964396                else
    … …  
    44164416                {
    44174417                    Status = vboxVideoAMgrCtxAllocCreate(&pContext->AllocContext, &pAlocate->Alloc);
    4418                     Assert(Status == STATUS_SUCCESS);
     4418                    AssertNtStatusSuccess(Status);
    44194419                }
    44204420                else
    … …  
    44394439                {
    44404440                    Status = vboxVideoAMgrCtxAllocDestroy(&pContext->AllocContext, pDealocate->hAlloc);
    4441                     Assert(Status == STATUS_SUCCESS);
     4441                    AssertNtStatusSuccess(Status);
    44424442                }
    44434443                else
    … …  
    46404640                PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
    46414641                Status = vboxWddmSwapchainCtxEscape(pDevExt, pContext, (PVBOXDISPIFESCAPE_SWAPCHAININFO)pEscapeHdr, pEscape->PrivateDriverDataSize);
    4642                 Assert(Status == STATUS_SUCCESS);
     4642                AssertNtStatusSuccess(Status);
    46434643                break;
    46444644            }
    … …  
    50835083            0, /* IN ULONG MessageNumber */
    50845084            &bRet);
    5085     Assert(Status == STATUS_SUCCESS);
     5085    AssertNtStatusSuccess(Status);
    50865086    if (Status == STATUS_SUCCESS)
    50875087    {
    … …  
    68396839                        {
    68406840                            Status = vboxWddmSwapchainCtxInit(pDevExt, pContext);
    6841                             Assert(Status == STATUS_SUCCESS);
     6841                            AssertNtStatusSuccess(Status);
    68426842                            if (Status == STATUS_SUCCESS)
    68436843                            {
    68446844                                pContext->enmType = VBOXWDDM_CONTEXT_TYPE_CUSTOM_3D;
    68456845                                Status = vboxVideoCmCtxAdd(&pDevice->pAdapter->CmMgr, &pContext->CmContext, (HANDLE)pInfo->hUmEvent, pInfo->u64UmInfo);
    6846                                 Assert(Status == STATUS_SUCCESS);
     6846                                AssertNtStatusSuccess(Status);
    68476847                                if (Status == STATUS_SUCCESS)
    68486848                                {
Note: See TracChangeset for help on using the changeset viewer.

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