VirtualBox

Changeset 75630 in vbox


Ignore:
Timestamp:
Nov 20, 2018 7:10:04 PM (6 years ago)
Author:
vboxsync
Message:

WDDM: Gallium Display Driver: code cleanup

Location:
trunk/src/VBox/Additions
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/3D/win/VBoxGL/GaDrvEnvKMT.cpp

    r75528 r75630  
    9191         * KMT specific helpers.
    9292         */
    93         int drvEnvKmtRenderCompose(uint32_t u32Cid,
    94                                    void *pvCommands,
    95                                    uint32_t cbCommands,
    96                                    ULONGLONG PresentHistoryToken);
     93        bool drvEnvKmtRenderCompose(uint32_t u32Cid,
     94                                    void *pvCommands,
     95                                    uint32_t cbCommands,
     96                                    ULONGLONG PresentHistoryToken);
    9797        D3DKMT_HANDLE drvEnvKmtContextHandle(uint32_t u32Cid);
    9898        D3DKMT_HANDLE drvEnvKmtSurfaceHandle(uint32_t u32Sid);
    … …  
    126126                                                    uint32_t cSizes,
    127127                                                    uint32_t *pu32Sid);
    128         static DECLCALLBACK(int) gaEnvSurfaceDestroy(void *pvEnv,
    129                                                      uint32_t u32Sid);
     128        static DECLCALLBACK(void) gaEnvSurfaceDestroy(void *pvEnv,
     129                                                      uint32_t u32Sid);
    130130        static DECLCALLBACK(int) gaEnvRender(void *pvEnv,
    131131                                             uint32_t u32Cid,
    … …  
    152152         * Internal.
    153153         */
    154         int doRender(uint32_t u32Cid, void *pvCommands, uint32_t cbCommands,
    155                      GAFENCEQUERY *pFenceQuery, ULONGLONG PresentHistoryToken, bool fPresentRedirected);
     154        bool doRender(uint32_t u32Cid, void *pvCommands, uint32_t cbCommands,
     155                      GAFENCEQUERY *pFenceQuery, ULONGLONG PresentHistoryToken, bool fPresentRedirected);
    156156};
    157157
    … …  
    175175
    176176
    177 /// @todo vboxDdi helpers must return NTSTATUS
    178 static NTSTATUS
     177/// @todo vboxDdi helpers must return a boof success indicator
     178static bool
    179179vboxDdiQueryAdapterInfo(GaKmtCallbacks *pKmtCallbacks,
    180180                        D3DKMT_HANDLE hAdapter,
    … …  
    182182                        uint32_t cbAdapterInfo)
    183183{
    184     NTSTATUS                  Status;
    185     D3DKMT_QUERYADAPTERINFO   kmtQAI;
    186 
    187     memset(&kmtQAI, 0, sizeof(kmtQAI));
    188     kmtQAI.hAdapter              = hAdapter;
    189     kmtQAI.Type                  = KMTQAITYPE_UMDRIVERPRIVATE;
    190     kmtQAI.pPrivateDriverData    = pAdapterInfo;
    191     kmtQAI.PrivateDriverDataSize = cbAdapterInfo;
    192 
    193     Status = pKmtCallbacks->d3dkmt->pfnD3DKMTQueryAdapterInfo(&kmtQAI);
    194     return Status;
     184    D3DKMT_QUERYADAPTERINFO QAI;
     185    memset(&QAI, 0, sizeof(QAI));
     186    QAI.hAdapter              = hAdapter;
     187    QAI.Type                  = KMTQAITYPE_UMDRIVERPRIVATE;
     188    QAI.pPrivateDriverData    = pAdapterInfo;
     189    QAI.PrivateDriverDataSize = cbAdapterInfo;
     190
     191    NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTQueryAdapterInfo(&QAI);
     192    return Status == STATUS_SUCCESS;
    195193}
    196194
    … …  
    201199    if (hDevice)
    202200    {
    203         D3DKMT_DESTROYDEVICE kmtDestroyDevice;
    204         memset(&kmtDestroyDevice, 0, sizeof(kmtDestroyDevice));
    205         kmtDestroyDevice.hDevice = hDevice;
    206         pKmtCallbacks->d3dkmt->pfnD3DKMTDestroyDevice(&kmtDestroyDevice);
    207     }
    208 }
    209 
    210 static NTSTATUS
     201        D3DKMT_DESTROYDEVICE DestroyDeviceData;
     202        memset(&DestroyDeviceData, 0, sizeof(DestroyDeviceData));
     203        DestroyDeviceData.hDevice = hDevice;
     204        pKmtCallbacks->d3dkmt->pfnD3DKMTDestroyDevice(&DestroyDeviceData);
     205    }
     206}
     207
     208static bool
    211209vboxDdiDeviceCreate(GaKmtCallbacks *pKmtCallbacks,
    212210                    D3DKMT_HANDLE *phDevice)
    213211{
    214     NTSTATUS                  Status;
    215     D3DKMT_CREATEDEVICE       kmtCreateDevice;
    216 
    217     memset(&kmtCreateDevice, 0, sizeof(kmtCreateDevice));
    218     kmtCreateDevice.hAdapter = pKmtCallbacks->hAdapter;
    219     // kmtCreateDevice.Flags = 0;
    220 
    221     Status = pKmtCallbacks->d3dkmt->pfnD3DKMTCreateDevice(&kmtCreateDevice);
     212    D3DKMT_CREATEDEVICE CreateDeviceData;
     213    memset(&CreateDeviceData, 0, sizeof(CreateDeviceData));
     214    CreateDeviceData.hAdapter = pKmtCallbacks->hAdapter;
     215    // CreateDeviceData.Flags = 0;
     216
     217    NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTCreateDevice(&CreateDeviceData);
    222218    if (Status == STATUS_SUCCESS)
    223219    {
    224         *phDevice = kmtCreateDevice.hDevice;
    225     }
    226     return Status;
    227 }
    228 
    229 static NTSTATUS
     220        *phDevice = CreateDeviceData.hDevice;
     221        return true;
     222    }
     223    return false;
     224}
     225
     226static bool
    230227vboxDdiContextGetId(GaKmtCallbacks *pKmtCallbacks,
    231228                    D3DKMT_HANDLE hContext,
    232229                    uint32_t *pu32Cid)
    233230{
    234     NTSTATUS                  Status;
    235     D3DKMT_ESCAPE             kmtEscape;
    236231    VBOXDISPIFESCAPE_GAGETCID data;
    237 
    238232    memset(&data, 0, sizeof(data));
    239233    data.EscapeHdr.escapeCode  = VBOXESC_GAGETCID;
    … …  
    244238     * have also set hDevice to a non-NULL value...
    245239     */
    246     memset(&kmtEscape, 0, sizeof(kmtEscape));
    247     kmtEscape.hAdapter              = pKmtCallbacks->hAdapter;
    248     kmtEscape.hDevice               = pKmtCallbacks->hDevice;
    249     kmtEscape.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
    250     // kmtEscape.Flags.HardwareAccess  = 0;
    251     kmtEscape.pPrivateDriverData    = &data;
    252     kmtEscape.PrivateDriverDataSize = sizeof(data);
    253     kmtEscape.hContext              = hContext;
    254 
    255     Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape);
     240    D3DKMT_ESCAPE EscapeData;
     241    memset(&EscapeData, 0, sizeof(EscapeData));
     242    EscapeData.hAdapter              = pKmtCallbacks->hAdapter;
     243    EscapeData.hDevice               = pKmtCallbacks->hDevice;
     244    EscapeData.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
     245    // EscapeData.Flags.HardwareAccess  = 0;
     246    EscapeData.pPrivateDriverData    = &data;
     247    EscapeData.PrivateDriverDataSize = sizeof(data);
     248    EscapeData.hContext              = hContext;
     249
     250    NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData);
    256251    if (Status == STATUS_SUCCESS)
    257252    {
    258253        *pu32Cid = data.u32Cid;
    259         return S_OK;
    260     }
    261     return E_FAIL;
     254        return true;
     255    }
     256    return false;
    262257}
    263258
    … …  
    268263    if (pContextInfo->hContext)
    269264    {
    270         D3DKMT_DESTROYCONTEXT kmtDestroyContext;
    271         memset(&kmtDestroyContext, 0, sizeof(kmtDestroyContext));
    272         kmtDestroyContext.hContext = pContextInfo->hContext;
    273         pKmtCallbacks->d3dkmt->pfnD3DKMTDestroyContext(&kmtDestroyContext);
    274     }
    275 }
    276 
    277 static HRESULT
     265        D3DKMT_DESTROYCONTEXT DestroyContextData;
     266        memset(&DestroyContextData, 0, sizeof(DestroyContextData));
     267        DestroyContextData.hContext = pContextInfo->hContext;
     268        pKmtCallbacks->d3dkmt->pfnD3DKMTDestroyContext(&DestroyContextData);
     269    }
     270}
     271
     272static bool
    278273vboxDdiContextCreate(GaKmtCallbacks *pKmtCallbacks,
    279274                     void *pvPrivateData, uint32_t cbPrivateData,
    280275                     GAWDDMCONTEXTINFO *pContextInfo)
    281276{
    282     NTSTATUS                  Status;
    283     D3DKMT_CREATECONTEXT      kmtCreateContext;
    284 
    285     memset(&kmtCreateContext, 0, sizeof(kmtCreateContext));
    286     kmtCreateContext.hDevice = pKmtCallbacks->hDevice;
    287     // kmtCreateContext.NodeOrdinal = 0;
    288     // kmtCreateContext.EngineAffinity = 0;
    289     // kmtCreateContext.Flags.Value = 0;
    290     kmtCreateContext.pPrivateDriverData = pvPrivateData;
    291     kmtCreateContext.PrivateDriverDataSize = cbPrivateData;
    292     kmtCreateContext.ClientHint = D3DKMT_CLIENTHINT_OPENGL;
    293 
    294     Status = pKmtCallbacks->d3dkmt->pfnD3DKMTCreateContext(&kmtCreateContext);
     277    D3DKMT_CREATECONTEXT CreateContextData;
     278    memset(&CreateContextData, 0, sizeof(CreateContextData));
     279    CreateContextData.hDevice = pKmtCallbacks->hDevice;
     280    // CreateContextData.NodeOrdinal = 0;
     281    // CreateContextData.EngineAffinity = 0;
     282    // CreateContextData.Flags.Value = 0;
     283    CreateContextData.pPrivateDriverData = pvPrivateData;
     284    CreateContextData.PrivateDriverDataSize = cbPrivateData;
     285    CreateContextData.ClientHint = D3DKMT_CLIENTHINT_OPENGL;
     286
     287    NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTCreateContext(&CreateContextData);
    295288    if (Status == STATUS_SUCCESS)
    296289    {
    297290        /* Query cid. */
    298291        uint32_t u32Cid = 0;
    299         Status = vboxDdiContextGetId(pKmtCallbacks, kmtCreateContext.hContext, &u32Cid);
    300         if (Status == STATUS_SUCCESS)
     292        bool fSuccess = vboxDdiContextGetId(pKmtCallbacks, CreateContextData.hContext, &u32Cid);
     293        if (fSuccess)
    301294        {
    302295            pContextInfo->Core.Key              = u32Cid;
    303             pContextInfo->hContext              = kmtCreateContext.hContext;
    304             pContextInfo->pCommandBuffer        = kmtCreateContext.pCommandBuffer;
    305             pContextInfo->CommandBufferSize     = kmtCreateContext.CommandBufferSize;
    306             pContextInfo->pAllocationList       = kmtCreateContext.pAllocationList;
    307             pContextInfo->AllocationListSize    = kmtCreateContext.AllocationListSize;
    308             pContextInfo->pPatchLocationList    = kmtCreateContext.pPatchLocationList;
    309             pContextInfo->PatchLocationListSize = kmtCreateContext.PatchLocationListSize;
    310         }
    311         else
    312         {
    313             vboxDdiContextDestroy(pKmtCallbacks, pContextInfo);
    314         }
    315     }
    316 
    317     return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL;
     296            pContextInfo->hContext              = CreateContextData.hContext;
     297            pContextInfo->pCommandBuffer        = CreateContextData.pCommandBuffer;
     298            pContextInfo->CommandBufferSize     = CreateContextData.CommandBufferSize;
     299            pContextInfo->pAllocationList       = CreateContextData.pAllocationList;
     300            pContextInfo->AllocationListSize    = CreateContextData.AllocationListSize;
     301            pContextInfo->pPatchLocationList    = CreateContextData.pPatchLocationList;
     302            pContextInfo->PatchLocationListSize = CreateContextData.PatchLocationListSize;
     303
     304            return true;
     305        }
     306
     307        vboxDdiContextDestroy(pKmtCallbacks, pContextInfo);
     308    }
     309
     310    return false;
    318311}
    319312
    … …  
    347340    GaDrvEnvKmt *pThis = (GaDrvEnvKmt *)pvEnv;
    348341
    349     VBOXWDDM_CREATECONTEXT_INFO privateData;
    350342    GAWDDMCONTEXTINFO *pContextInfo;
    351     HRESULT hr;
    352 
    353343    pContextInfo = (GAWDDMCONTEXTINFO *)malloc(sizeof(GAWDDMCONTEXTINFO));
    354344    if (!pContextInfo)
    355345        return (uint32_t)-1;
    356346
     347    VBOXWDDM_CREATECONTEXT_INFO privateData;
    357348    memset(&privateData, 0, sizeof(privateData));
    358     privateData.u32IfVersion   = 9;
    359     privateData.enmType        = VBOXWDDM_CONTEXT_TYPE_GA_3D;
     349    privateData.u32IfVersion       = 9;
     350    privateData.enmType            = VBOXWDDM_CONTEXT_TYPE_GA_3D;
    360351    privateData.u.vmsvga.u32Flags  = extended? VBOXWDDM_F_GA_CONTEXT_EXTENDED: 0;
    361352    privateData.u.vmsvga.u32Flags |= vgpu10? VBOXWDDM_F_GA_CONTEXT_VGPU10: 0;
    362353
    363     hr = vboxDdiContextCreate(&pThis->mKmtCallbacks,
    364                               &privateData, sizeof(privateData), pContextInfo);
    365     if (SUCCEEDED(hr))
     354    bool fSuccess = vboxDdiContextCreate(&pThis->mKmtCallbacks,
     355                                         &privateData, sizeof(privateData), pContextInfo);
     356    if (fSuccess)
    366357    {
    367358        if (RTAvlU32Insert(&pThis->mContextTree, &pContextInfo->Core))
    … …  
    375366
    376367    Assert(0);
    377 
    378368    free(pContextInfo);
    379369    return (uint32_t)-1;
    … …  
    392382        case SVGA3D_A1R5G5B5:       return D3DDDIFMT_A1R5G5B5;
    393383        case SVGA3D_LUMINANCE8_ALPHA8: return D3DDDIFMT_A8L8;
     384        case SVGA3D_R5G6B5:         return D3DDDIFMT_R5G6B5;
    394385        default: break;
    395386    }
    396387
    397388    Assert(0);
     389    VBoxDispMpLoggerLogF("WDDM: EnvKMT: unsupported surface format %d\n", format);
    398390    return D3DDDIFMT_UNKNOWN;
    399391}
    … …  
    408400    GaDrvEnvKmt *pThis = (GaDrvEnvKmt *)pvEnv;
    409401
    410     NTSTATUS                          Status;
    411402    D3DKMT_ESCAPE                     EscapeData;
    412403    VBOXDISPIFESCAPE_GASURFACEDEFINE *pData;
    … …  
    444435    // EscapeData.hContext              = 0;
    445436
    446     Status = pThis->mKmtCallbacks.d3dkmt->pfnD3DKMTEscape(&EscapeData);
     437    NTSTATUS Status = pThis->mKmtCallbacks.d3dkmt->pfnD3DKMTEscape(&EscapeData);
    447438    if (Status == STATUS_SUCCESS)
    448439    {
    … …  
    532523}
    533524
    534 /* static */ DECLCALLBACK(int)
     525/* static */ DECLCALLBACK(void)
    535526GaDrvEnvKmt::gaEnvSurfaceDestroy(void *pvEnv,
    536527                                 uint32_t u32Sid)
    … …  
    538529    GaDrvEnvKmt *pThis = (GaDrvEnvKmt *)pvEnv;
    539530
    540     NTSTATUS                          Status;
    541     D3DKMT_ESCAPE                     kmtEscape;
    542531    VBOXDISPIFESCAPE_GASURFACEDESTROY data;
    543 
    544532    memset(&data, 0, sizeof(data));
    545533    data.EscapeHdr.escapeCode  = VBOXESC_GASURFACEDESTROY;
    … …  
    547535    data.u32Sid                = u32Sid;
    548536
    549     memset(&kmtEscape, 0, sizeof(kmtEscape));
    550     kmtEscape.hAdapter              = pThis->mKmtCallbacks.hAdapter;
    551     kmtEscape.hDevice               = pThis->mKmtCallbacks.hDevice;
    552     kmtEscape.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
    553     kmtEscape.Flags.HardwareAccess  = 1;
    554     kmtEscape.pPrivateDriverData    = &data;
    555     kmtEscape.PrivateDriverDataSize = sizeof(data);
    556     // kmtEscape.hContext              = 0;
    557 
    558     Status = pThis->mKmtCallbacks.d3dkmt->pfnD3DKMTEscape(&kmtEscape);
     537    D3DKMT_ESCAPE EscapeData;
     538    memset(&EscapeData, 0, sizeof(EscapeData));
     539    EscapeData.hAdapter              = pThis->mKmtCallbacks.hAdapter;
     540    EscapeData.hDevice               = pThis->mKmtCallbacks.hDevice;
     541    EscapeData.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
     542    EscapeData.Flags.HardwareAccess  = 1;
     543    EscapeData.pPrivateDriverData    = &data;
     544    EscapeData.PrivateDriverDataSize = sizeof(data);
     545    // EscapeData.hContext              = 0;
     546
     547    NTSTATUS Status = pThis->mKmtCallbacks.d3dkmt->pfnD3DKMTEscape(&EscapeData);
    559548    Assert(Status == STATUS_SUCCESS);
    560549
    … …  
    575564        free(pSurfaceInfo);
    576565    }
    577 
    578     return (Status == STATUS_SUCCESS)? 0: -1;
    579566}
    580567
    … …  
    585572}
    586573
    587 static HRESULT
     574static bool
    588575vboxDdiFenceCreate(GaKmtCallbacks *pKmtCallbacks,
    589576                   GAWDDMCONTEXTINFO *pContextInfo,
    590577                   uint32_t *pu32FenceHandle)
    591578{
    592     NTSTATUS                       Status;
    593     D3DKMT_ESCAPE                  kmtEscape;
    594579    VBOXDISPIFESCAPE_GAFENCECREATE fenceCreate;
    595 
    596580    memset(&fenceCreate, 0, sizeof(fenceCreate));
    597581    fenceCreate.EscapeHdr.escapeCode  = VBOXESC_GAFENCECREATE;
    … …  
    601585     * have also set hDevice to a non-NULL value...
    602586     */
    603     memset(&kmtEscape, 0, sizeof(kmtEscape));
    604     kmtEscape.hAdapter              = pKmtCallbacks->hAdapter;
    605     kmtEscape.hDevice               = pKmtCallbacks->hDevice;
    606     kmtEscape.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
    607     // kmtEscape.Flags.HardwareAccess  = 0;
    608     kmtEscape.pPrivateDriverData    = &fenceCreate;
    609     kmtEscape.PrivateDriverDataSize = sizeof(fenceCreate);
    610     kmtEscape.hContext              = pContextInfo->hContext;
    611 
    612     Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape);
     587    D3DKMT_ESCAPE EscapeData;
     588    memset(&EscapeData, 0, sizeof(EscapeData));
     589    EscapeData.hAdapter              = pKmtCallbacks->hAdapter;
     590    EscapeData.hDevice               = pKmtCallbacks->hDevice;
     591    EscapeData.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
     592    // EscapeData.Flags.HardwareAccess  = 0;
     593    EscapeData.pPrivateDriverData    = &fenceCreate;
     594    EscapeData.PrivateDriverDataSize = sizeof(fenceCreate);
     595    EscapeData.hContext              = pContextInfo->hContext;
     596
     597    NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData);
    613598    if (Status == STATUS_SUCCESS)
    614599    {
    615600        *pu32FenceHandle = fenceCreate.u32FenceHandle;
    616     }
    617 
    618     Assert(Status == STATUS_SUCCESS);
    619     return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL;
    620 }
    621 
    622 static HRESULT
     601        return true;
     602    }
     603
     604    Assert(0);
     605    return false;
     606}
     607
     608static bool
    623609vboxDdiFenceQuery(GaKmtCallbacks *pKmtCallbacks,
    624610                  uint32_t u32FenceHandle,
    625611                  GAFENCEQUERY *pFenceQuery)
    626612{
    627     NTSTATUS                      Status;
    628     D3DKMT_ESCAPE                 kmtEscape;
    629613    VBOXDISPIFESCAPE_GAFENCEQUERY fenceQuery;
    630 
    631614    memset(&fenceQuery, 0, sizeof(fenceQuery));
    632615    fenceQuery.EscapeHdr.escapeCode  = VBOXESC_GAFENCEQUERY;
    … …  
    634617    fenceQuery.u32FenceHandle = u32FenceHandle;
    635618
    636     memset(&kmtEscape, 0, sizeof(kmtEscape));
    637     kmtEscape.hAdapter              = pKmtCallbacks->hAdapter;
    638     kmtEscape.hDevice               = pKmtCallbacks->hDevice;
    639     kmtEscape.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
    640     // kmtEscape.Flags.HardwareAccess  = 0;
    641     kmtEscape.pPrivateDriverData    = &fenceQuery;
    642     kmtEscape.PrivateDriverDataSize = sizeof(fenceQuery);
    643     kmtEscape.hContext              = 0;
    644 
    645     Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape);
     619    D3DKMT_ESCAPE EscapeData;
     620    memset(&EscapeData, 0, sizeof(EscapeData));
     621    EscapeData.hAdapter              = pKmtCallbacks->hAdapter;
     622    EscapeData.hDevice               = pKmtCallbacks->hDevice;
     623    EscapeData.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
     624    // EscapeData.Flags.HardwareAccess  = 0;
     625    EscapeData.pPrivateDriverData    = &fenceQuery;
     626    EscapeData.PrivateDriverDataSize = sizeof(fenceQuery);
     627    EscapeData.hContext              = 0;
     628
     629    NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData);
    646630    if (Status == STATUS_SUCCESS)
    647631    {
    … …  
    650634        pFenceQuery->u32ProcessedSeqNo = fenceQuery.u32ProcessedSeqNo;
    651635        pFenceQuery->u32FenceStatus    = fenceQuery.u32FenceStatus;
    652     }
    653 
    654     Assert(Status == STATUS_SUCCESS);
    655     return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL;
     636        return true;
     637    }
     638
     639    Assert(0);
     640    return false;
    656641}
    657642
    … …  
    669654    }
    670655
    671     HRESULT hr = vboxDdiFenceQuery(&pThis->mKmtCallbacks, u32FenceHandle, pFenceQuery);
    672     if (FAILED(hr))
    673         return -1;
    674 
    675     return 0;
    676 }
    677 
    678 static HRESULT
     656    bool fSuccess = vboxDdiFenceQuery(&pThis->mKmtCallbacks, u32FenceHandle, pFenceQuery);
     657    return fSuccess ? 0: -1;
     658}
     659
     660static bool
    679661vboxDdiFenceWait(GaKmtCallbacks *pKmtCallbacks,
    680662                 uint32_t u32FenceHandle,
    681663                 uint32_t u32TimeoutUS)
    682664{
    683     NTSTATUS                     Status;
    684     D3DKMT_ESCAPE                kmtEscape;
    685665    VBOXDISPIFESCAPE_GAFENCEWAIT fenceWait;
    686 
    687666    memset(&fenceWait, 0, sizeof(fenceWait));
    688667    fenceWait.EscapeHdr.escapeCode  = VBOXESC_GAFENCEWAIT;
    … …  
    691670    fenceWait.u32TimeoutUS = u32TimeoutUS;
    692671
    693     memset(&kmtEscape, 0, sizeof(kmtEscape));
    694     kmtEscape.hAdapter              = pKmtCallbacks->hAdapter;
    695     kmtEscape.hDevice               = pKmtCallbacks->hDevice;
    696     kmtEscape.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
    697     // kmtEscape.Flags.HardwareAccess  = 0;
    698     kmtEscape.pPrivateDriverData    = &fenceWait;
    699     kmtEscape.PrivateDriverDataSize = sizeof(fenceWait);
    700     kmtEscape.hContext              = 0;
    701 
    702     Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape);
     672    D3DKMT_ESCAPE EscapeData;
     673    memset(&EscapeData, 0, sizeof(EscapeData));
     674    EscapeData.hAdapter              = pKmtCallbacks->hAdapter;
     675    EscapeData.hDevice               = pKmtCallbacks->hDevice;
     676    EscapeData.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
     677    // EscapeData.Flags.HardwareAccess  = 0;
     678    EscapeData.pPrivateDriverData    = &fenceWait;
     679    EscapeData.PrivateDriverDataSize = sizeof(fenceWait);
     680    EscapeData.hContext              = 0;
     681
     682    NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData);
    703683    Assert(Status == STATUS_SUCCESS);
    704     return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL;
     684    return Status == STATUS_SUCCESS;
    705685}
    706686
    … …  
    715695        return 0;
    716696
    717     HRESULT hr = vboxDdiFenceWait(&pThis->mKmtCallbacks, u32FenceHandle, u32TimeoutUS);
    718     return SUCCEEDED(hr) ? 0 : -1;
    719 }
    720 
    721 static HRESULT
     697    bool fSuccess = vboxDdiFenceWait(&pThis->mKmtCallbacks, u32FenceHandle, u32TimeoutUS);
     698    return fSuccess ? 0 : -1;
     699}
     700
     701static bool
    722702vboxDdiFenceUnref(GaKmtCallbacks *pKmtCallbacks,
    723703                  uint32_t u32FenceHandle)
    724704{
    725     NTSTATUS                     Status;
    726     D3DKMT_ESCAPE                kmtEscape;
    727705    VBOXDISPIFESCAPE_GAFENCEUNREF fenceUnref;
    728 
    729706    memset(&fenceUnref, 0, sizeof(fenceUnref));
    730707    fenceUnref.EscapeHdr.escapeCode  = VBOXESC_GAFENCEUNREF;
    … …  
    732709    fenceUnref.u32FenceHandle = u32FenceHandle;
    733710
    734     memset(&kmtEscape, 0, sizeof(kmtEscape));
    735     kmtEscape.hAdapter              = pKmtCallbacks->hAdapter;
    736     kmtEscape.hDevice               = pKmtCallbacks->hDevice;
    737     kmtEscape.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
    738     // kmtEscape.Flags.HardwareAccess  = 0;
    739     kmtEscape.pPrivateDriverData    = &fenceUnref;
    740     kmtEscape.PrivateDriverDataSize = sizeof(fenceUnref);
    741     kmtEscape.hContext              = 0;
    742 
    743     Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape);
     711    D3DKMT_ESCAPE EscapeData;
     712    memset(&EscapeData, 0, sizeof(EscapeData));
     713    EscapeData.hAdapter              = pKmtCallbacks->hAdapter;
     714    EscapeData.hDevice               = pKmtCallbacks->hDevice;
     715    EscapeData.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
     716    // EscapeData.Flags.HardwareAccess  = 0;
     717    EscapeData.pPrivateDriverData    = &fenceUnref;
     718    EscapeData.PrivateDriverDataSize = sizeof(fenceUnref);
     719    EscapeData.hContext              = 0;
     720
     721    NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData);
    744722    Assert(Status == STATUS_SUCCESS);
    745     return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL;
     723    return Status == STATUS_SUCCESS;
    746724}
    747725
    … …  
    765743 * @param pu32Length  Size of commands which will fit in cbAvail bytes.
    766744 */
    767 static HRESULT
     745static bool
    768746vboxCalcCommandLength(const uint8_t *pu8Commands, uint32_t cbCommands, uint32_t cbAvail, uint32_t *pu32Length)
    769747{
    770     HRESULT hr = S_OK;
    771 
    772748    uint32_t u32Length = 0;
    773749    const uint8_t *pu8Src = pu8Commands;
    … …  
    779755        if (cbSrcLeft < sizeof(uint32_t))
    780756        {
    781             hr = E_INVALIDARG;
    782             break;
     757            return false;
    783758        }
    784759
    … …  
    791766            if (cbSrcLeft < sizeof(SVGA3dCmdHeader))
    792767            {
    793                 hr = E_INVALIDARG;
    794                 break;
     768                return false;
    795769            }
    796770
    … …  
    799773            if (cbCmd % sizeof(uint32_t) != 0)
    800774            {
    801                 hr = E_INVALIDARG;
    802                 break;
     775                return false;
    803776            }
    804777            if (cbSrcLeft < cbCmd)
    805778            {
    806                 hr = E_INVALIDARG;
    807                 break;
     779                return false;
    808780            }
    809781        }
    … …  
    813785             * because the SVGA gallium driver does not use them.
    814786             */
    815             hr = E_INVALIDARG;
    816             break;
     787            return false;
    817788        }
    818789
    … …  
    822793            {
    823794               /* No commands fit into the buffer. */
    824                hr = E_FAIL;
     795               return false;
    825796            }
    826797            break;
    … …  
    832803
    833804    *pu32Length = u32Length;
    834     return hr;
    835 }
    836 
    837 static HRESULT
     805    return true;
     806}
     807
     808static bool
    838809vboxDdiRender(GaKmtCallbacks *pKmtCallbacks,
    839810              GAWDDMCONTEXTINFO *pContextInfo, uint32_t u32FenceHandle, void *pvCommands, uint32_t cbCommands,
    840811              ULONGLONG PresentHistoryToken, bool fPresentRedirected)
    841812{
    842     HRESULT hr = S_OK;
    843     D3DKMT_RENDER kmtRender;
    844813    uint32_t cbLeft;
    845814    const uint8_t *pu8Src;
    846 
    847     // LogRel(("vboxDdiRender: cbCommands = %d, u32FenceHandle = %d\n", cbCommands, u32FenceHandle));
    848815
    849816    cbLeft = cbCommands;
    … …  
    856823        if (cbAvail <= sizeof(u32FenceHandle))
    857824        {
    858             hr = E_FAIL;
    859             break;
     825            return false;
    860826        }
    861827
    … …  
    878844
    879845            /* Get how much commands data will fit in the buffer. */
    880             hr = vboxCalcCommandLength(pu8Src, cbCommandChunk, cbAvail - sizeof(u32FenceHandle), &cbCommandChunk);
    881             if (hr != S_OK)
     846            if (!vboxCalcCommandLength(pu8Src, cbCommandChunk, cbAvail - sizeof(u32FenceHandle), &cbCommandChunk))
    882847            {
    883                 break;
     848                return false;
    884849            }
    885850
    … …  
    897862        cbLeft -= cbCommandChunk;
    898863
    899         memset(&kmtRender, 0, sizeof(kmtRender));
    900         kmtRender.hContext = pContextInfo->hContext;
    901         // kmtRender.CommandOffset = 0;
    902         kmtRender.CommandLength = cbToCopy;
    903         // kmtRender.AllocationCount = 0;
    904         // kmtRender.PatchLocationCount = 0;
    905         kmtRender.PresentHistoryToken = PresentHistoryToken;
    906         kmtRender.Flags.PresentRedirected = fPresentRedirected;
    907 
    908         NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTRender(&kmtRender);
     864        D3DKMT_RENDER RenderData;
     865        memset(&RenderData, 0, sizeof(RenderData));
     866        RenderData.hContext                = pContextInfo->hContext;
     867        // RenderData.CommandOffset           = 0;
     868        RenderData.CommandLength           = cbToCopy;
     869        // RenderData.AllocationCount         = 0;
     870        // RenderData.PatchLocationCount      = 0;
     871        RenderData.PresentHistoryToken     = PresentHistoryToken;
     872        RenderData.Flags.PresentRedirected = fPresentRedirected;
     873
     874        NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTRender(&RenderData);
    909875        Assert(Status == STATUS_SUCCESS);
    910876        if (Status != STATUS_SUCCESS)
    911877        {
    912             hr = E_FAIL;
    913             break;
    914         }
    915 
    916         pContextInfo->pCommandBuffer = kmtRender.pNewCommandBuffer;
    917         pContextInfo->CommandBufferSize = kmtRender.NewCommandBufferSize;
    918         pContextInfo->pAllocationList       = kmtRender.pNewAllocationList;
    919         pContextInfo->AllocationListSize    = kmtRender.NewAllocationListSize;
    920         pContextInfo->pPatchLocationList    = kmtRender.pNewPatchLocationList;
    921         pContextInfo->PatchLocationListSize = kmtRender.NewPatchLocationListSize;
     878            return false;
     879        }
     880
     881        pContextInfo->pCommandBuffer        = RenderData.pNewCommandBuffer;
     882        pContextInfo->CommandBufferSize     = RenderData.NewCommandBufferSize;
     883        pContextInfo->pAllocationList       = RenderData.pNewAllocationList;
     884        pContextInfo->AllocationListSize    = RenderData.NewAllocationListSize;
     885        pContextInfo->pPatchLocationList    = RenderData.pNewPatchLocationList;
     886        pContextInfo->PatchLocationListSize = RenderData.NewPatchLocationListSize;
    922887    } while (cbLeft);
    923888
    924     return hr;
    925 }
    926 
    927 /** @todo return bool */
    928 int GaDrvEnvKmt::doRender(uint32_t u32Cid, void *pvCommands, uint32_t cbCommands,
     889    return true;
     890}
     891
     892bool GaDrvEnvKmt::doRender(uint32_t u32Cid, void *pvCommands, uint32_t cbCommands,
    929893                          GAFENCEQUERY *pFenceQuery, ULONGLONG PresentHistoryToken, bool fPresentRedirected)
    930894{
    931     HRESULT hr = S_OK;
    932895    uint32_t u32FenceHandle;
    933896    GAWDDMCONTEXTINFO *pContextInfo = (GAWDDMCONTEXTINFO *)RTAvlU32Get(&mContextTree, u32Cid);
    934897    if (!pContextInfo)
    935         return -1;
    936 
     898        return false;
     899
     900    bool fSuccess = true;
    937901    u32FenceHandle = 0;
    938902    if (pFenceQuery)
    939903    {
    940         hr = vboxDdiFenceCreate(&mKmtCallbacks, pContextInfo, &u32FenceHandle);
    941     }
    942 
    943     if (SUCCEEDED(hr))
    944     {
    945         hr = vboxDdiRender(&mKmtCallbacks, pContextInfo, u32FenceHandle,
    946                            pvCommands, cbCommands, PresentHistoryToken, fPresentRedirected);
    947         if (SUCCEEDED(hr))
     904        fSuccess = vboxDdiFenceCreate(&mKmtCallbacks, pContextInfo, &u32FenceHandle);
     905    }
     906
     907    if (fSuccess)
     908    {
     909        fSuccess = vboxDdiRender(&mKmtCallbacks, pContextInfo, u32FenceHandle,
     910                                 pvCommands, cbCommands, PresentHistoryToken, fPresentRedirected);
     911        if (fSuccess)
    948912        {
    949913            if (pFenceQuery)
    950914            {
    951                 HRESULT hr2 = vboxDdiFenceQuery(&mKmtCallbacks, u32FenceHandle, pFenceQuery);
    952                 if (hr2 != S_OK)
     915                if (!vboxDdiFenceQuery(&mKmtCallbacks, u32FenceHandle, pFenceQuery))
    953916                {
    954917                    pFenceQuery->u32FenceStatus = GA_FENCE_STATUS_NULL;
    … …  
    957920        }
    958921    }
    959     return SUCCEEDED(hr)? 0: 1;
     922    return fSuccess;
    960923}
    961924
    … …  
    968931{
    969932    GaDrvEnvKmt *pThis = (GaDrvEnvKmt *)pvEnv;
    970     return pThis->doRender(u32Cid, pvCommands, cbCommands, pFenceQuery, 0, false);
    971 }
    972 
    973 int GaDrvEnvKmt::drvEnvKmtRenderCompose(uint32_t u32Cid,
    974                                         void *pvCommands,
    975                                         uint32_t cbCommands,
    976                                         ULONGLONG PresentHistoryToken)
     933    return pThis->doRender(u32Cid, pvCommands, cbCommands, pFenceQuery, 0, false) ? 1 : 0;
     934}
     935
     936bool GaDrvEnvKmt::drvEnvKmtRenderCompose(uint32_t u32Cid,
     937                                         void *pvCommands,
     938                                         uint32_t cbCommands,
     939                                         ULONGLONG PresentHistoryToken)
    977940{
    978941    return doRender(u32Cid, pvCommands, cbCommands, NULL, PresentHistoryToken, true);
    … …  
    980943
    981944
    982 static HRESULT
     945static bool
    983946vboxDdiRegionCreate(GaKmtCallbacks *pKmtCallbacks,
    984947                    uint32_t u32RegionSize,
    … …  
    986949                    void **ppvMap)
    987950{
    988     NTSTATUS                  Status;
    989     D3DKMT_ESCAPE             kmtEscape;
    990951    VBOXDISPIFESCAPE_GAREGION data;
    991 
    992952    memset(&data, 0, sizeof(data));
    993953    data.EscapeHdr.escapeCode  = VBOXESC_GAREGION;
    … …  
    998958    // data.u64UserAddress        = 0;
    999959
    1000     memset(&kmtEscape, 0, sizeof(kmtEscape));
    1001     kmtEscape.hAdapter              = pKmtCallbacks->hAdapter;
    1002     kmtEscape.hDevice               = pKmtCallbacks->hDevice;
    1003     kmtEscape.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
    1004     // kmtEscape.Flags.HardwareAccess  = 0;
    1005     kmtEscape.pPrivateDriverData    = &data;
    1006     kmtEscape.PrivateDriverDataSize = sizeof(data);
    1007     // kmtEscape.hContext              = 0;
    1008 
    1009     Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape);
     960    D3DKMT_ESCAPE EscapeData;
     961    memset(&EscapeData, 0, sizeof(EscapeData));
     962    EscapeData.hAdapter              = pKmtCallbacks->hAdapter;
     963    EscapeData.hDevice               = pKmtCallbacks->hDevice;
     964    EscapeData.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
     965    // EscapeData.Flags.HardwareAccess  = 0;
     966    EscapeData.pPrivateDriverData    = &data;
     967    EscapeData.PrivateDriverDataSize = sizeof(data);
     968    // EscapeData.hContext              = 0;
     969
     970    NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData);
    1010971    if (Status == STATUS_SUCCESS)
    1011972    {
    1012973        *pu32GmrId = data.u32GmrId;
    1013974        *ppvMap = (void *)(uintptr_t)data.u64UserAddress;
    1014     }
    1015     Assert(Status == STATUS_SUCCESS);
    1016     return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL;
     975        return true;
     976    }
     977
     978    Assert(0);
     979    return false;
    1017980}
    1018981
    … …  
    1025988    GaDrvEnvKmt *pThis = (GaDrvEnvKmt *)pvEnv;
    1026989
    1027     int ret;
    1028 
    1029990    if (pThis->mKmtCallbacks.hDevice)
    1030991    {
    1031992        /* That is a real device */
    1032         HRESULT hr = vboxDdiRegionCreate(&pThis->mKmtCallbacks, u32RegionSize, pu32GmrId, ppvMap);
    1033         ret = SUCCEEDED(hr)? 0: -1;
    1034     }
    1035     else
    1036     {
    1037         /* That is a fake device, created when WDDM adapter is initialized. */
    1038         *ppvMap = malloc(u32RegionSize);
    1039         if (*ppvMap != NULL)
    1040         {
    1041             *pu32GmrId = 0;
    1042             ret = 0;
    1043         }
    1044         else
    1045             ret = -1;
    1046     }
    1047 
    1048     return ret;
    1049 }
    1050 
    1051 static HRESULT
     993        bool fSuccess = vboxDdiRegionCreate(&pThis->mKmtCallbacks, u32RegionSize, pu32GmrId, ppvMap);
     994        return fSuccess ? 0: -1;
     995    }
     996
     997    /* That is a fake device, created when WDDM adapter is initialized. */
     998    *ppvMap = malloc(u32RegionSize);
     999    if (*ppvMap)
     1000    {
     1001        *pu32GmrId = 0;
     1002        return 0;
     1003    }
     1004
     1005    return -1;
     1006}
     1007
     1008static bool
    10521009vboxDdiRegionDestroy(GaKmtCallbacks *pKmtCallbacks,
    10531010                     uint32_t u32GmrId)
    10541011{
    1055     NTSTATUS                  Status;
    1056     D3DKMT_ESCAPE             kmtEscape;
    10571012    VBOXDISPIFESCAPE_GAREGION data;
    1058 
    10591013    memset(&data, 0, sizeof(data));
    10601014    data.EscapeHdr.escapeCode  = VBOXESC_GAREGION;
    … …  
    10651019    // data.u64UserAddress        = 0;
    10661020
    1067     memset(&kmtEscape, 0, sizeof(kmtEscape));
    1068     kmtEscape.hAdapter              = pKmtCallbacks->hAdapter;
    1069     kmtEscape.hDevice               = pKmtCallbacks->hDevice;
    1070     kmtEscape.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
    1071     // kmtEscape.Flags.HardwareAccess  = 0;
    1072     kmtEscape.pPrivateDriverData    = &data;
    1073     kmtEscape.PrivateDriverDataSize = sizeof(data);
    1074     // kmtEscape.hContext              = 0;
    1075 
    1076     Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&kmtEscape);
     1021    D3DKMT_ESCAPE EscapeData;
     1022    memset(&EscapeData, 0, sizeof(EscapeData));
     1023    EscapeData.hAdapter              = pKmtCallbacks->hAdapter;
     1024    EscapeData.hDevice               = pKmtCallbacks->hDevice;
     1025    EscapeData.Type                  = D3DKMT_ESCAPE_DRIVERPRIVATE;
     1026    // EscapeData.Flags.HardwareAccess  = 0;
     1027    EscapeData.pPrivateDriverData    = &data;
     1028    EscapeData.PrivateDriverDataSize = sizeof(data);
     1029    // EscapeData.hContext              = 0;
     1030
     1031    NTSTATUS Status = pKmtCallbacks->d3dkmt->pfnD3DKMTEscape(&EscapeData);
    10771032    Assert(Status == STATUS_SUCCESS);
    1078     return (Status == STATUS_SUCCESS) ? S_OK : E_FAIL;
     1033    return Status == STATUS_SUCCESS;
    10791034}
    10801035
    … …  
    11161071    NTSTATUS Status = vboxDispKmtOpenAdapter2(&mKmtCallbacks.hAdapter, &mKmtCallbacks.AdapterLuid);
    11171072    Assert(Status == STATUS_SUCCESS);
    1118 
    11191073    if (Status == STATUS_SUCCESS)
    11201074    {
    11211075        VBOXWDDM_QAI adapterInfo;
    1122         Status = vboxDdiQueryAdapterInfo(&mKmtCallbacks, mKmtCallbacks.hAdapter, &adapterInfo, sizeof(adapterInfo));
    1123         Assert(Status == STATUS_SUCCESS);
    1124 
    1125         if (Status == STATUS_SUCCESS)
    1126         {
    1127             Status = vboxDdiDeviceCreate(&mKmtCallbacks, &mKmtCallbacks.hDevice);
    1128             Assert(Status == STATUS_SUCCESS);
    1129 
    1130             if (Status == STATUS_SUCCESS)
     1076        bool fSuccess = vboxDdiQueryAdapterInfo(&mKmtCallbacks, mKmtCallbacks.hAdapter, &adapterInfo, sizeof(adapterInfo));
     1077        Assert(fSuccess);
     1078        if (fSuccess)
     1079        {
     1080            fSuccess = vboxDdiDeviceCreate(&mKmtCallbacks, &mKmtCallbacks.hDevice);
     1081            Assert(fSuccess);
     1082            if (fSuccess)
    11311083            {
    11321084                mHWInfo = adapterInfo.u.vmsvga.HWInfo;

  • trunk/src/VBox/Additions/3D/win/VBoxWddmUmHlp/VBoxWddmUmHlp.h

    r75556 r75630  
    8585DECLCALLBACK(D3DKMTFUNCTIONS const *) D3DKMTFunctions(void);
    8686
     87DECLCALLBACK(void) VBoxDispMpLoggerLogF(const char *pszString, ...);
    8788DECLCALLBACK(void) VBoxWddmUmLog(const char *pszString);
    8889

  • trunk/src/VBox/Additions/3D/win/include/VBoxGaDriver.h

    r75443 r75630  
    4646                                              uint32_t cSizes,
    4747                                              uint32_t *pu32Sid);
    48     DECLCALLBACKMEMBER(int, pfnSurfaceDestroy)(void *pvEnv,
    49                                                uint32_t u32Sid);
     48    DECLCALLBACKMEMBER(void, pfnSurfaceDestroy)(void *pvEnv,
     49                                                uint32_t u32Sid);
    5050    DECLCALLBACKMEMBER(int, pfnRender)(void *pvEnv,
    5151                                       uint32_t u32Cid,

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDrvEnvWddm.cpp

    r75443 r75630  
    237237}
    238238
    239 /* static */ DECLCALLBACK(int)
     239/* static */ DECLCALLBACK(void)
    240240GaDrvEnvWddm::gaEnvWddmSurfaceDestroy(void *pvEnv,
    241241                                      uint32_t u32Sid)
    … …  
    260260
    261261    hr = pThis->mWddmCallbacks.DeviceCallbacks.pfnEscapeCb(pThis->mWddmCallbacks.hAdapter, &ddiEscape);
    262     return SUCCEEDED(hr)? 0: -1;
     262    Assert(SUCCEEDED(hr));
    263263}
    264264

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDrvEnvWddm.h

    r75443 r75630  
    7070                                                        uint32_t cSizes,
    7171                                                        uint32_t *pu32Sid);
    72         static DECLCALLBACK(int) gaEnvWddmSurfaceDestroy(void *pvEnv,
    73                                                          uint32_t u32Sid);
     72        static DECLCALLBACK(void) gaEnvWddmSurfaceDestroy(void *pvEnv,
     73                                                          uint32_t u32Sid);
    7474        static DECLCALLBACK(int) gaEnvWddmRender(void *pvEnv,
    7575                                                 uint32_t u32Cid,
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