VirtualBox

Changeset 33714 in vbox


Ignore:
Timestamp:
Nov 2, 2010 11:36:10 PM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
67340
Message:

wddm/3d: CrHgsmi cleanup, free resources correctly; 2D fixes

Location:
trunk
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/VBoxCrHgsmi.h

    r33656 r33714  
    3939#endif
    4040
     41#ifdef VBOX_CRHGSMI_WITH_D3DDEV
    4142typedef void * HVBOXCRHGSMI_CLIENT;
    4243
    … …  
    5455
    5556VBOXCRHGSMI_DECL(int) VBoxCrHgsmiInit(PVBOXCRHGSMI_CALLBACKS pCallbacks);
     57VBOXCRHGSMI_DECL(HVBOXCRHGSMI_CLIENT) VBoxCrHgsmiQueryClient();
     58#else
     59VBOXCRHGSMI_DECL(int) VBoxCrHgsmiInit();
     60VBOXCRHGSMI_DECL(PVBOXUHGSMI) VBoxCrHgsmiCreate();
     61VBOXCRHGSMI_DECL(void) VBoxCrHgsmiDestroy(PVBOXUHGSMI pHgsmi);
     62#endif
    5663VBOXCRHGSMI_DECL(int) VBoxCrHgsmiTerm();
    57 VBOXCRHGSMI_DECL(HVBOXCRHGSMI_CLIENT) VBoxCrHgsmiQueryClient();
    5864
    5965VBOXCRHGSMI_DECL(void) VBoxCrHgsmiLog(char * szString);

  • trunk/include/VBox/VBoxVideo.h

    r33575 r33714  
    740740            VBOXVHWA_OVERLAYFX desc;
    741741            VBOXVHWA_RECTL xUpdatedSrcMemRect;
     742            VBOXVHWA_RECTL xUpdatedDstMemRect;
    742743        } in;
    743744    } u;

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxCrHgsmi.cpp

    r33684 r33714  
    44#include "VBoxUhgsmiKmt.h"
    55
     6static VBOXDISPKMT_CALLBACKS g_VBoxCrHgsmiKmtCallbacks;
     7static int g_bVBoxKmtCallbacksInited = 0;
     8
     9#ifdef VBOX_CRHGSMI_WITH_D3DDEV
    610static VBOXCRHGSMI_CALLBACKS g_VBoxCrHgsmiCallbacks;
    711static HMODULE g_hVBoxCrHgsmiProvider = NULL;
    812static uint32_t g_cVBoxCrHgsmiProvider = 0;
    913
    10 static VBOXDISPKMT_CALLBACKS g_VBoxCrHgsmiKmtCallbacks;
    1114
    1215typedef VBOXWDDMDISP_DECL(int) FNVBOXDISPCRHGSMI_INIT(PVBOXCRHGSMI_CALLBACKS pCallbacks);
    … …  
    2528VBOXCRHGSMI_DECL(int) VBoxCrHgsmiInit(PVBOXCRHGSMI_CALLBACKS pCallbacks)
    2629{
    27     static int bKmtCallbacksInited = 0;
    28     if (!bKmtCallbacksInited)
     30    if (!g_bVBoxKmtCallbacksInited)
    2931    {
    3032        HRESULT hr = vboxDispKmtCallbacksInit(&g_VBoxCrHgsmiKmtCallbacks);
    3133        Assert(hr == S_OK);
    3234        if (hr == S_OK)
    33             bKmtCallbacksInited = 1;
     35            g_bVBoxKmtCallbacksInited = 1;
    3436        else
    35             bKmtCallbacksInited = -1;
    36     }
    37 
    38     Assert(bKmtCallbacksInited);
    39     if (bKmtCallbacksInited < 0)
     37            g_bVBoxKmtCallbacksInited = -1;
     38    }
     39
     40    Assert(g_bVBoxKmtCallbacksInited);
     41    if (g_bVBoxKmtCallbacksInited < 0)
    4042    {
    4143        Assert(0);
    … …  
    135137    return NULL;
    136138}
     139#else
     140VBOXCRHGSMI_DECL(int) VBoxCrHgsmiInit()
     141{
     142    if (!g_bVBoxKmtCallbacksInited)
     143    {
     144        HRESULT hr = vboxDispKmtCallbacksInit(&g_VBoxCrHgsmiKmtCallbacks);
     145        Assert(hr == S_OK);
     146        if (hr == S_OK)
     147            g_bVBoxKmtCallbacksInited = 1;
     148        else
     149            g_bVBoxKmtCallbacksInited = -1;
     150    }
     151
     152    Assert(g_bVBoxKmtCallbacksInited);
     153    if (g_bVBoxKmtCallbacksInited < 0)
     154    {
     155        Assert(0);
     156        return VERR_NOT_SUPPORTED;
     157    }
     158
     159    return VINF_SUCCESS;
     160}
     161
     162VBOXCRHGSMI_DECL(PVBOXUHGSMI) VBoxCrHgsmiCreate()
     163{
     164    PVBOXUHGSMI_PRIVATE_KMT pHgsmiGL = (PVBOXUHGSMI_PRIVATE_KMT)RTMemAllocZ(sizeof (*pHgsmiGL));
     165    if (pHgsmiGL)
     166    {
     167#if 0
     168        HRESULT hr = vboxUhgsmiKmtCreate(pHgsmiGL, TRUE /* bD3D tmp for injection thread*/);
     169#else
     170        HRESULT hr = vboxUhgsmiKmtEscCreate(pHgsmiGL, TRUE /* bD3D tmp for injection thread*/);
     171#endif
     172        Assert(hr == S_OK);
     173        if (hr == S_OK)
     174        {
     175            return &pHgsmiGL->BasePrivate.Base;
     176        }
     177        RTMemFree(pHgsmiGL);
     178    }
     179
     180    return NULL;
     181}
     182
     183VBOXCRHGSMI_DECL(void) VBoxCrHgsmiDestroy(PVBOXUHGSMI pHgsmi)
     184{
     185    PVBOXUHGSMI_PRIVATE_KMT pHgsmiGL = VBOXUHGSMIKMT_GET(pHgsmi);
     186    HRESULT hr = vboxUhgsmiKmtDestroy(pHgsmiGL);
     187    Assert(hr == S_OK);
     188    if (hr == S_OK)
     189    {
     190        RTMemFree(pHgsmiGL);
     191    }
     192}
     193#endif
    137194
    138195VBOXCRHGSMI_DECL(int) VBoxCrHgsmiTerm()
    139196{
    140     Assert(0);
    141197#if 0
    142198    PVBOXUHGSMI_PRIVATE_KMT pHgsmiGL = gt_pHgsmiGL;
    … …  
    151207        g_pfnVBoxDispCrHgsmiTerm();
    152208#endif
     209    if (g_bVBoxKmtCallbacksInited > 0)
     210    {
     211        vboxDispKmtCallbacksTerm(&g_VBoxCrHgsmiKmtCallbacks);
     212    }
    153213    return VINF_SUCCESS;
    154214}

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

    r33684 r33714  
    740740#ifdef VBOX_WITH_CRHGSMI
    741741static __declspec(thread) PVBOXUHGSMI_PRIVATE_BASE gt_pHgsmi = NULL;
    742 #endif
    743742
    744743VBOXWDDMDISP_DECL(int) VBoxDispCrHgsmiInit(PVBOXCRHGSMI_CALLBACKS pCallbacks)
    … …  
    786785}
    787786
    788 #ifdef VBOX_WITH_CRHGSMI
    789787static HRESULT vboxUhgsmiGlobalRetain()
    790788{
    … …  
    876874#define VBOXDISPCRHGSMI_SCOPE_SET_DEV(_pDev) do {} while(0)
    877875#define VBOXDISPCRHGSMI_SCOPE_SET_GLOBAL() do {} while(0)
     876
     877VBOXWDDMDISP_DECL(int) VBoxDispCrHgsmiInit(void*)
     878{
     879    return VERR_NOT_IMPLEMENTED;
     880}
     881
     882VBOXWDDMDISP_DECL(int) VBoxDispCrHgsmiTerm()
     883{
     884    return VERR_NOT_IMPLEMENTED;
     885}
     886
     887VBOXWDDMDISP_DECL(void*) VBoxDispCrHgsmiQueryClient()
     888{
     889    return NULL;
     890}
    878891#endif
    879892

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiBase.h

    r33241 r33714  
    3232{
    3333    VBOXUHGSMI Base;
     34#ifdef VBOX_CRHGSMI_WITH_D3DDEV
    3435    HVBOXCRHGSMI_CLIENT hClient;
     36#endif
    3537} VBOXUHGSMI_PRIVATE_BASE, *PVBOXUHGSMI_PRIVATE_BASE;
    3638

  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiKmt.cpp

    r33684 r33714  
    437437    pHgsmi->BasePrivate.Base.pfnBufferCreate = vboxUhgsmiKmtBufferCreate;
    438438    pHgsmi->BasePrivate.Base.pfnBufferSubmitAsynch = vboxUhgsmiKmtBufferSubmitAsynch;
     439#ifdef VBOX_CRHGSMI_WITH_D3DDEV
    439440    pHgsmi->BasePrivate.hClient = NULL;
     441#endif
    440442    return vboxUhgsmiKmtEngineCreate(pHgsmi, bD3D);
    441443}
    … …  
    445447    pHgsmi->BasePrivate.Base.pfnBufferCreate = vboxUhgsmiKmtEscBufferCreate;
    446448    pHgsmi->BasePrivate.Base.pfnBufferSubmitAsynch = vboxUhgsmiKmtEscBufferSubmitAsynch;
     449#ifdef VBOX_CRHGSMI_WITH_D3DDEV
    447450    pHgsmi->BasePrivate.hClient = NULL;
     451#endif
    448452    return vboxUhgsmiKmtEngineCreate(pHgsmi, bD3D);
    449453}

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.cpp

    r33540 r33714  
    920920}
    921921
     922static void vboxVhwaHlpOverlayListAdd(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay)
     923{
     924    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pOverlay->VidPnSourceId];
     925    KIRQL OldIrql;
     926    KeAcquireSpinLock(&pSource->OverlayListLock, &OldIrql);
     927    ASMAtomicIncU32(&pSource->cOverlays);
     928    InsertHeadList(&pSource->OverlayList, &pOverlay->ListEntry);
     929    KeReleaseSpinLock(&pSource->OverlayListLock, OldIrql);
     930}
     931
     932static void vboxVhwaHlpOverlayListRemove(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay)
     933{
     934    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pOverlay->VidPnSourceId];
     935    KIRQL OldIrql;
     936    KeAcquireSpinLock(&pSource->OverlayListLock, &OldIrql);
     937    ASMAtomicDecU32(&pSource->cOverlays);
     938    RemoveEntryList(&pOverlay->ListEntry);
     939    KeReleaseSpinLock(&pSource->OverlayListLock, OldIrql);
     940}
     941
    922942AssertCompile(sizeof (RECT) == sizeof (VBOXVHWA_RECTL));
    923943AssertCompile(RT_SIZEOFMEMB(RECT, left) == RT_SIZEOFMEMB(VBOXVHWA_RECTL, left));
    … …  
    930950AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(VBOXVHWA_RECTL, bottom));
    931951
    932 int vboxVhwaHlpOverlayUpdate(PVBOXWDDM_OVERLAY pOverlay, const DXGK_OVERLAYINFO *pOverlayInfo)
     952int vboxVhwaHlpOverlayUpdate(PVBOXWDDM_OVERLAY pOverlay, const DXGK_OVERLAYINFO *pOverlayInfo, RECT * pDstUpdateRect)
    933953{
    934954    PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pOverlayInfo->hAllocation;
    … …  
    9821002            if (pOurInfo->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_VALID)
    9831003            {
    984                 pBody->u.in.xUpdatedSrcMemValid = 1;
    9851004                if (pOurInfo->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_RECT_VALID)
    9861005                    pBody->u.in.xUpdatedSrcMemRect = *(VBOXVHWA_RECTL*)((void*)&pOurInfo->DirtyRegion.Rect);
    … …  
    9931012            }
    9941013
     1014            if (pDstUpdateRect)
     1015            {
     1016                pBody->u.in.xUpdatedDstMemRect = *(VBOXVHWA_RECTL*)((void*)pDstUpdateRect);
     1017            }
     1018
    9951019            /* we're not interested in completion, just send the command */
    9961020            vboxVhwaCommandSubmitAsynchAndComplete(pOverlay->pDevExt, pCmd);
    … …  
    10111035}
    10121036
     1037int vboxVhwaHlpOverlayUpdate(PVBOXWDDM_OVERLAY pOverlay, const DXGK_OVERLAYINFO *pOverlayInfo)
     1038{
     1039    return vboxVhwaHlpOverlayUpdate(pOverlay, pOverlayInfo, NULL);
     1040}
     1041
    10131042int vboxVhwaHlpOverlayDestroy(PVBOXWDDM_OVERLAY pOverlay)
    10141043{
    10151044    int rc = VINF_SUCCESS;
     1045
     1046    vboxVhwaHlpOverlayListRemove(pOverlay->pDevExt, pOverlay);
     1047
    10161048    for (uint32_t i = 0; i < pOverlay->pResource->cAllocations; ++i)
    10171049    {
    … …  
    10661098            pOverlay->pResource = pRc;
    10671099            pOverlay->VidPnSourceId = VidPnSourceId;
    1068             rc = vboxVhwaHlpOverlayUpdate(pOverlay, pOverlayInfo);
     1100
     1101            vboxVhwaHlpOverlayListAdd(pDevExt, pOverlay);
     1102#ifdef VBOXWDDM_RENDER_FROM_SHADOW
     1103            RECT DstRect;
     1104            vboxVhwaHlpOverlayDstRectGet(pDevExt, pOverlay, &DstRect);
     1105            NTSTATUS Status = vboxVdmaHlpUpdatePrimary(pDevExt, VidPnSourceId, &DstRect);
     1106            Assert(Status == STATUS_SUCCESS);
     1107            /* ignore primary update failure */
     1108            Status = STATUS_SUCCESS;
     1109#endif
     1110            rc = vboxVhwaHlpOverlayUpdate(pOverlay, pOverlayInfo, &DstRect);
    10691111            if (!RT_SUCCESS(rc))
    10701112            {
    … …  
    10891131    PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[VidPnSourceId];
    10901132    return !ASMAtomicReadU32(&pSource->cOverlays);
    1091 }
    1092 
    1093 void vboxVhwaHlpOverlayListAdd(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay)
    1094 {
    1095     PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pOverlay->VidPnSourceId];
    1096     KIRQL OldIrql;
    1097     KeAcquireSpinLock(&pSource->OverlayListLock, &OldIrql);
    1098     ASMAtomicIncU32(&pSource->cOverlays);
    1099     InsertHeadList(&pSource->OverlayList, &pOverlay->ListEntry);
    1100     KeReleaseSpinLock(&pSource->OverlayListLock, OldIrql);
    1101 }
    1102 
    1103 void vboxVhwaHlpOverlayListRemove(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay)
    1104 {
    1105     PVBOXWDDM_SOURCE pSource = &pDevExt->aSources[pOverlay->VidPnSourceId];
    1106     KIRQL OldIrql;
    1107     KeAcquireSpinLock(&pSource->OverlayListLock, &OldIrql);
    1108     ASMAtomicDecU32(&pSource->cOverlays);
    1109     RemoveEntryList(&pOverlay->ListEntry);
    1110     KeReleaseSpinLock(&pSource->OverlayListLock, OldIrql);
    11111133}
    11121134

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVhwa.h

    r32823 r33714  
    6464
    6565BOOLEAN vboxVhwaHlpOverlayListIsEmpty(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId);
    66 void vboxVhwaHlpOverlayListAdd(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay);
    67 void vboxVhwaHlpOverlayListRemove(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay);
     66//void vboxVhwaHlpOverlayListAdd(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay);
     67//void vboxVhwaHlpOverlayListRemove(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay);
    6868void vboxVhwaHlpOverlayDstRectUnion(PDEVICE_EXTENSION pDevExt, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, RECT *pRect);
    6969void vboxVhwaHlpOverlayDstRectGet(PDEVICE_EXTENSION pDevExt, PVBOXWDDM_OVERLAY pOverlay, RECT *pRect);

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVidPn.cpp

    r33540 r33714  
    533533    {
    534534        D3DKMDT_VIDPN_SOURCE_MODE *pNewVidPnSourceModeInfo;
     535        /* disable 24 bpp for now */
     536        if (pModes[i].BitsPerPlane == 24)
     537            continue;
     538
    535539        Status = pNewVidPnSourceModeSetInterface->pfnCreateNewModeInfo(hNewVidPnSourceModeSet, &pNewVidPnSourceModeInfo);
    536540        Assert(Status == STATUS_SUCCESS);

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

    r33711 r33714  
    43114311        if (RT_SUCCESS(rc))
    43124312        {
    4313             vboxVhwaHlpOverlayListAdd(pDevExt, pOverlay);
    4314 #ifdef VBOXWDDM_RENDER_FROM_SHADOW
    4315             RECT DstRect;
    4316             vboxVhwaHlpOverlayDstRectGet(pDevExt, pOverlay, &DstRect);
    4317             Status = vboxVdmaHlpUpdatePrimary(pDevExt, pCreateOverlay->VidPnSourceId, &DstRect);
    4318             Assert(Status == STATUS_SUCCESS);
    4319             /* ignore primary update failure */
    4320             Status = STATUS_SUCCESS;
    4321 #endif
    43224313            pCreateOverlay->hOverlay = pOverlay;
    43234314        }
    … …  
    51475138    PVBOXWDDM_OVERLAY pOverlay = (PVBOXWDDM_OVERLAY)hOverlay;
    51485139    Assert(pOverlay);
    5149     vboxVhwaHlpOverlayListRemove(pOverlay->pDevExt, pOverlay);
    51505140    int rc = vboxVhwaHlpOverlayDestroy(pOverlay);
    51515141    AssertRC(rc);

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp

    r33540 r33714  
    27392739
    27402740#ifdef VBOX_WITH_WDDM
    2741     if(pCmd->u.in.xUpdatedSrcMemValid)
     2741    if(pCmd->u.in.xUpdatedSrcMemRect.right)
    27422742    {
    27432743        QRect r = VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(&pCmd->u.in.xUpdatedSrcMemRect);
    27442744        pSrcSurf->updatedMem(&r);
     2745    }
     2746    if(pCmd->u.in.xUpdatedDstMemRect.right)
     2747    {
     2748        QRect r = VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(&pCmd->u.in.xUpdatedDstMemRect);
     2749        pDstSurf->updatedMem(&r);
    27452750    }
    27462751#endif

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_net.h

    r33540 r33714  
    106106} CRMultiBuffer;
    107107
     108#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
     109typedef struct CRVBOXHGSMI_CLIENT {
     110    struct VBOXUHGSMI *pHgsmi;
     111    struct VBOXUHGSMI_BUFFER *pCmdBuffer;
     112    struct VBOXUHGSMI_BUFFER *pHGBuffer;
     113    void *pvHGBuffer;
     114    struct CRBufferPool_t *bufpool;
     115} CRVBOXHGSMI_CLIENT, *PCRVBOXHGSMI_CLIENT;
     116#endif
    108117/**
    109118 * Chromium network connection (bidirectional).
    … …  
    224233#ifdef IN_GUEST
    225234    uint32_t u32InjectClientID;
     235# ifdef VBOX_WITH_CRHGSMI
     236#  ifndef VBOX_CRHGSMI_WITH_D3DDEV
     237    CRVBOXHGSMI_CLIENT HgsmiClient;
     238#  endif
     239# endif
    226240#endif
    227241    /* Used on host side to indicate that we are not allowed to store above pointers for later use

  • trunk/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c

    r33684 r33714  
    1616 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1717 */
    18 
    1918#ifdef RT_OS_WINDOWS
    2019    #include <windows.h>
    … …  
    226225
    227226#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
    228 typedef struct CRVBOXHGSMI_CLIENT {
    229     PVBOXUHGSMI pHgsmi;
    230     PVBOXUHGSMI_BUFFER pCmdBuffer;
    231     PVBOXUHGSMI_BUFFER pHGBuffer;
    232     void *pvHGBuffer;
    233     CRBufferPool *bufpool;
    234 } CRVBOXHGSMI_CLIENT, *PCRVBOXHGSMI_CLIENT;
    235227
    236228/* add sizeof header + page align */
    … …  
    243235#define CRVBOXHGSMI_BUF_OFFSET(_st2, _st1) ((uint32_t)(((uint8_t*)(_st2)) - ((uint8_t*)(_st1))))
    244236
     237static int _crVBoxHGSMIClientInit(PCRVBOXHGSMI_CLIENT pClient, PVBOXUHGSMI pHgsmi)
     238{
     239    int rc;
     240    pClient->pHgsmi = pHgsmi;
     241    rc = pHgsmi->pfnBufferCreate(pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(1),
     242                            VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT,
     243                            NULL,
     244                            &pClient->pCmdBuffer);
     245    AssertRC(rc);
     246    if (RT_SUCCESS(rc))
     247    {
     248        rc = pHgsmi->pfnBufferCreate(pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(1),
     249                                        VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT,
     250                                        NULL,
     251                                        &pClient->pHGBuffer);
     252        AssertRC(rc);
     253        if (RT_SUCCESS(rc))
     254        {
     255            pClient->pvHGBuffer = NULL;
     256            pClient->bufpool = crBufferPoolInit(16);
     257            return VINF_SUCCESS;
     258        }
     259        pClient->pCmdBuffer->pfnDestroy(pClient->pCmdBuffer);
     260    }
     261    pClient->pHgsmi = NULL;
     262    return rc;
     263}
     264
     265void _crVBoxHGSMIBufferFree(void *data)
     266{
     267    PVBOXUHGSMI_BUFFER pBuffer = (PVBOXUHGSMI_BUFFER)data;
     268    pBuffer->pfnDestroy(pBuffer);
     269}
     270
     271static int _crVBoxHGSMIClientTerm(PCRVBOXHGSMI_CLIENT pClient, PVBOXUHGSMI *ppHgsmi)
     272{
     273    if (pClient->bufpool)
     274        crBufferPoolCallbackFree(pClient->bufpool, _crVBoxHGSMIBufferFree);
     275    pClient->bufpool = NULL;
     276
     277    if (pClient->pHGBuffer)
     278    {
     279        pClient->pHGBuffer->pfnDestroy(pClient->pHGBuffer);
     280        pClient->pHGBuffer = NULL;
     281    }
     282
     283    if (pClient->pCmdBuffer)
     284    {
     285        pClient->pCmdBuffer->pfnDestroy(pClient->pCmdBuffer);
     286        pClient->pCmdBuffer = NULL;
     287    }
     288
     289    if (ppHgsmi)
     290    {
     291        *ppHgsmi = pClient->pHgsmi;
     292    }
     293    pClient->pHgsmi = NULL;
     294
     295    return VINF_SUCCESS;
     296}
     297
     298
     299#ifdef VBOX_CRHGSMI_WITH_D3DDEV
     300
     301DECLCALLBACK(HVBOXCRHGSMI_CLIENT) _crVBoxHGSMIClientCreate(PVBOXUHGSMI pHgsmi)
     302{
     303    PCRVBOXHGSMI_CLIENT pClient = crAlloc(sizeof (CRVBOXHGSMI_CLIENT));
     304
     305    if (pClient)
     306    {
     307        int rc = _crVBoxHGSMIClientInit(pClient, pHgsmi);
     308        AssertRC(rc);
     309        if (RT_SUCCESS(rc))
     310            return (HVBOXCRHGSMI_CLIENT)pClient;
     311
     312        crFree(pCLient);
     313    }
     314
     315    return NULL;
     316}
     317
     318DECLCALLBACK(void) _crVBoxHGSMIClientDestroy(HVBOXCRHGSMI_CLIENT hClient)
     319{
     320    PCRVBOXHGSMI_CLIENT pClient = (PCRVBOXHGSMI_CLIENT)hClient;
     321    _crVBoxHGSMIClientTerm(pClient, NULL);
     322    crFree(pClient);
     323}
     324#endif
     325
    245326DECLINLINE(PCRVBOXHGSMI_CLIENT) _crVBoxHGSMIClientGet(CRConnection *conn)
    246327{
     328#ifdef VBOX_CRHGSMI_WITH_D3DDEV
    247329    PCRVBOXHGSMI_CLIENT pClient = (PCRVBOXHGSMI_CLIENT)VBoxCrHgsmiQueryClient();
    248330    Assert(pClient);
    249331    return pClient;
     332#else
     333    if (conn->HgsmiClient.pHgsmi)
     334        return &conn->HgsmiClient;
     335    {
     336        PVBOXUHGSMI pHgsmi = VBoxCrHgsmiCreate();
     337        Assert(pHgsmi);
     338        if (pHgsmi)
     339        {
     340            int rc = _crVBoxHGSMIClientInit(&conn->HgsmiClient, pHgsmi);
     341            AssertRC(rc);
     342            if (RT_SUCCESS(rc))
     343            {
     344                Assert(conn->HgsmiClient.pHgsmi);
     345                return &conn->HgsmiClient;
     346            }
     347            VBoxCrHgsmiDestroy(pHgsmi);
     348        }
     349    }
     350    return NULL;
     351#endif
    250352}
    251353
    … …  
    13691471
    13701472#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
    1371 DECLCALLBACK(HVBOXCRHGSMI_CLIENT) _crVBoxHGSMIClientCreate(PVBOXUHGSMI pHgsmi)
    1372 {
    1373     PCRVBOXHGSMI_CLIENT pClient = crAlloc(sizeof (CRVBOXHGSMI_CLIENT));
    1374 
    1375     if (pClient)
     1473
     1474bool _crVBoxHGSMIInit()
     1475{
     1476#ifndef VBOX_CRHGSMI_WITH_D3DDEV
     1477    static
     1478#endif
     1479    int bHasHGSMI = -1;
     1480
     1481    if (bHasHGSMI < 0)
    13761482    {
    13771483        int rc;
    1378         pClient->pHgsmi = pHgsmi;
    1379         rc = pHgsmi->pfnBufferCreate(pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(1),
    1380                                 VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT,
    1381                                 NULL,
    1382                                 &pClient->pCmdBuffer);
    1383         AssertRC(rc);
    1384         if (RT_SUCCESS(rc))
    1385         {
    1386             rc = pHgsmi->pfnBufferCreate(pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(1),
    1387                                             VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT,
    1388                                             NULL,
    1389                                             &pClient->pHGBuffer);
    1390             AssertRC(rc);
    1391             if (RT_SUCCESS(rc))
    1392             {
    1393                 pClient->pvHGBuffer = NULL;
    1394                 pClient->bufpool = crBufferPoolInit(16);
    1395                 return (HVBOXCRHGSMI_CLIENT) pClient;
    1396             }
    1397             pClient->pCmdBuffer->pfnDestroy(pClient->pCmdBuffer);
    1398         }
    1399     }
    1400 
    1401     return NULL;
    1402 }
    1403 
    1404 DECLCALLBACK(void) _crVBoxHGSMIClientDestroy(HVBOXCRHGSMI_CLIENT hClient)
    1405 {
    1406     Assert(0);
    1407 
    1408     /* @todo */
    1409 }
    1410 
    1411 bool _crVBoxHGSMIInit()
    1412 {
    1413     int bHasHGSMI = -1;
    1414 
    1415     if (bHasHGSMI < 0)
    1416     {
    1417         int rc;
     1484#ifndef VBOX_CRHGSMI_WITH_D3DDEV
     1485        rc = VBoxCrHgsmiInit();
     1486#else
    14181487        VBOXCRHGSMI_CALLBACKS Callbacks;
    14191488        Callbacks.pfnClientCreate = _crVBoxHGSMIClientCreate;
    14201489        Callbacks.pfnClientDestroy = _crVBoxHGSMIClientDestroy;
    14211490        rc = VBoxCrHgsmiInit(&Callbacks);
     1491#endif
    14221492        AssertRC(rc);
    14231493        if (RT_SUCCESS(rc))
    … …  
    20042074static void crVBoxHGSMIDoDisconnect( CRConnection *conn )
    20052075{
     2076#ifndef VBOX_CRHGSMI_WITH_D3DDEV
     2077    if (conn->HgsmiClient.pHgsmi)
     2078    {
     2079        PVBOXUHGSMI pHgsmi;
     2080        _crVBoxHGSMIClientTerm(&conn->HgsmiClient, &pHgsmi);
     2081        Assert(pHgsmi);
     2082        VBoxCrHgsmiDestroy(pHgsmi);
     2083    }
     2084
     2085#endif
    20062086    crVBoxHGCMDoDisconnect(conn);
    20072087}
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