VirtualBox

Changeset 42028 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Jul 5, 2012 3:22:55 PM (13 years ago)
Author:
vboxsync
Message:

wddm/crOpenGL: moreon kernel-based cr commands submission

Location:
trunk/src/VBox
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/Makefile.kmk

    r41636 r42028  
    9494 endif
    9595 
    96  VBoxVideoWddm_INCS       += ../../../include .. . ../../../../common/VBoxGuestLib $(VBOX_PATH_CROGL_INCLUDE) $(VBOX_PATH_CROGL_GENFILES)
     96 VBoxVideoWddm_INCS       += \
     97    ../../../include \
     98    .. \
     99    . \
     100    ../../../../common/VBoxGuestLib \
     101    $(VBOX_PATH_CROGL_INCLUDE) \
     102    $(VBOX_PATH_CROGL_GENFILES) \
     103    $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/packer
    97104 VBoxVideoWddm_LDFLAGS.x86 += /Entry:DriverEntry@8
    98105 VBoxVideoWddm_LDFLAGS.amd64 += /Entry:DriverEntry
    … …  
    114121        $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/HGSMIBase.cpp \
    115122        $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/Modesetting.cpp
     123 if defined(VBOX_WITH_CROGL) && defined(VBOX_WDDM_WITH_CRCMD)
     124   VBoxVideoWddm_SOURCES   += \
     125        $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/packer/pack_buffer.c \
     126        $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/packer/pack_bounds.c \
     127        $(VBOX_PATH_CROGL_GENFILES)/pack_bounds_swap.c \
     128        wddm/VBoxMPCrUtil.cpp
     129   VBoxVideoWddm_DEFS       + VBOX_WDDM_WITH_CRCMD
     130 endif
    116131 ifdef VBOXWDDM_WITH_VBVA
    117132  VBoxVideoWddm_SOURCES   += \

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

    r41485 r42028  
    2525#include <cr_protocol.h>
    2626
    27 # if 0
     27# ifdef VBOX_WDDM_WITH_CRCMD
    2828#  include <cr_pack.h>
    2929
    30 typedef struct PVBOXMP_SHGSMIPACKER
     30typedef struct VBOXMP_CRSHGSMICON_BUFDR
     31{
     32    uint32_t cbBuf;
     33    void *pvBuf;
     34} VBOXMP_CRSHGSMICON_BUFDR, *PVBOXMP_CRSHGSMICON_BUFDR;
     35
     36typedef struct VBOXMP_CRSHGSMICON_BUFDR_CACHE
     37{
     38    volatile PVBOXMP_CRSHGSMICON_BUFDR pBufDr;
     39} VBOXMP_CRSHGSMICON_BUFDR_CACHE, *PVBOXMP_CRSHGSMICON_BUFDR_CACHE;
     40
     41typedef struct VBOXMP_CRSHGSMICON
    3142{
    3243    PVBOXMP_DEVEXT pDevExt;
     44    PVBOXMP_CRCTLCON pCtlCon;
     45    uint32_t u32ClientID;
     46    VBOXMP_CRSHGSMICON_BUFDR_CACHE CmdDrCache;
     47    VBOXMP_CRSHGSMICON_BUFDR_CACHE WbDrCache;
     48} VBOXMP_CRSHGSMICON, *PVBOXMP_CRSHGSMICON;
     49
     50typedef struct VBOXMP_CRSHGSMIPACKER
     51{
     52    PVBOXMP_CRSHGSMICON pCon;
    3353    CRPackContext CrPacker;
    3454    CRPackBuffer CrBuffer;
    35 } PVBOXMP_SHGSMIPACKER, *PPVBOXMP_SHGSMIPACKER;
     55} VBOXMP_CRSHGSMIPACKER, *PVBOXMP_CRSHGSMIPACKER;
    3656
    3757static void* vboxMpCrShgsmiBufferAlloc(PVBOXMP_DEVEXT pDevExt, HGSMISIZE cbData)
    … …  
    4060}
    4161
     62static VBOXVIDEOOFFSET vboxMpCrShgsmiBufferOffset(PVBOXMP_DEVEXT pDevExt, void *pvBuffer)
     63{
     64    return HGSMIPointerToOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, (const HGSMIBUFFERHEADER *)pvBuffer);
     65}
     66
    4267static void vboxMpCrShgsmiBufferFree(PVBOXMP_DEVEXT pDevExt, void *pvBuffer)
    4368{
    … …  
    4570}
    4671
     72static void* vboxMpCrShgsmiConAlloc(PVBOXMP_CRSHGSMICON pCon, uint32_t cbBuffer)
     73{
     74    return vboxMpCrShgsmiBufferAlloc(pCon->pDevExt, cbBuffer);
     75}
     76
     77static VBOXVIDEOOFFSET vboxMpCrShgsmiConBufOffset(PVBOXMP_CRSHGSMICON pCon, void* pvBuffer)
     78{
     79    return vboxMpCrShgsmiBufferOffset(pCon->pDevExt, pvBuffer);
     80}
     81
     82
     83static void vboxMpCrShgsmiConFree(PVBOXMP_CRSHGSMICON pCon, void* pvBuffer)
     84{
     85    vboxMpCrShgsmiBufferFree(pCon->pDevExt, pvBuffer);
     86}
     87
     88#define VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) VBOXWDDM_ROUNDBOUND((VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[_cBuffers]))), 8)
     89#define VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(_pDr, _cBuffers, _type) ((_type*)(((uint8_t*)(_pDr)) + VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers)))
     90#define VBOXMP_CRSHGSMICON_DR_SIZE(_cBuffers, _cbCmdBuf) ( VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) + _cbCmdBuf)
     91
     92static int vboxMpCrShgsmiBufCacheBufReinit(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, PVBOXMP_CRSHGSMICON_BUFDR pDr, uint32_t cbRequested)
     93{
     94    if (pDr->cbBuf >= cbRequested)
     95        return VINF_SUCCESS;
     96
     97    if (pDr->pvBuf)
     98        vboxMpCrShgsmiConFree(pCon, pDr->pvBuf);
     99
     100    pDr->pvBuf = vboxMpCrShgsmiConAlloc(pCon, cbRequested);
     101    if (!pDr->pvBuf)
     102    {
     103        WARN(("vboxMpCrShgsmiConAlloc failed"));
     104        pDr->cbBuf = 0;
     105        return VERR_NO_MEMORY;
     106    }
     107
     108    pDr->cbBuf = cbRequested;
     109    return VINF_SUCCESS;
     110}
     111
     112static void vboxMpCrShgsmiBufCacheFree(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, PVBOXMP_CRSHGSMICON_BUFDR pDr)
     113{
     114    if (ASMAtomicCmpXchgPtr(&pCache->pBufDr, pDr, NULL))
     115        return;
     116
     117    /* the value is already cached, free the current one */
     118    vboxMpCrShgsmiConFree(pCon, pDr->pvBuf);
     119    vboxWddmMemFree(pDr);
     120}
     121
     122static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheGetAllocDr(PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
     123{
     124    PVBOXMP_CRSHGSMICON_BUFDR pBufDr = (PVBOXMP_CRSHGSMICON_BUFDR)ASMAtomicXchgPtr((void * volatile *)&pCache->pBufDr, NULL);
     125    if (!pBufDr)
     126    {
     127        pBufDr = (PVBOXMP_CRSHGSMICON_BUFDR)vboxWddmMemAllocZero(sizeof (*pBufDr));
     128        if (!pBufDr)
     129        {
     130            WARN(("vboxWddmMemAllocZero failed!"));
     131            return NULL;
     132        }
     133    }
     134    return pBufDr;
     135}
     136
     137static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAlloc(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
     138{
     139    PVBOXMP_CRSHGSMICON_BUFDR pBufDr = vboxMpCrShgsmiBufCacheGetAllocDr(pCache);
     140    int rc = vboxMpCrShgsmiBufCacheBufReinit(pCon, pCache, pBufDr, cbBuffer);
     141    if (RT_SUCCESS(rc))
     142        return pBufDr;
     143
     144    WARN(("vboxMpCrShgsmiBufCacheBufReinit failed, rc %d", rc));
     145
     146    vboxMpCrShgsmiBufCacheFree(pCon, pCache, pBufDr);
     147    return NULL;
     148}
     149
     150static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAllocAny(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
     151{
     152    PVBOXMP_CRSHGSMICON_BUFDR pBufDr = vboxMpCrShgsmiBufCacheGetAllocDr(pCache);
     153
     154    if (pBufDr->cbBuf)
     155        return pBufDr;
     156
     157    int rc = vboxMpCrShgsmiBufCacheBufReinit(pCon, pCache, pBufDr, cbBuffer);
     158    if (RT_SUCCESS(rc))
     159        return pBufDr;
     160
     161    WARN(("vboxMpCrShgsmiBufCacheBufReinit failed, rc %d", rc));
     162
     163    vboxMpCrShgsmiBufCacheFree(pCon, pCache, pBufDr);
     164    return NULL;
     165}
     166
     167
     168static int vboxMpCrShgsmiBufCacheInit(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
     169{
     170    memset(pCache, 0, sizeof (*pCache));
     171    return VINF_SUCCESS;
     172}
     173
     174static void vboxMpCrShgsmiBufCacheTerm(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
     175{
     176    if (pCache->pBufDr)
     177        vboxMpCrShgsmiBufCacheFree(pCon, pCache, pCache->pBufDr);
     178}
     179
     180static int vboxMpCrShgsmiConConnect(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_DEVEXT pDevExt, PVBOXMP_CRCTLCON pCrCtlCon)
     181{
     182    memset(pCon, 0, sizeof (*pCon));
     183    int rc = vboxMpCrShgsmiBufCacheInit(pCon, &pCon->CmdDrCache);
     184    if (RT_SUCCESS(rc))
     185    {
     186        rc = vboxMpCrShgsmiBufCacheInit(pCon, &pCon->WbDrCache);
     187        if (RT_SUCCESS(rc))
     188        {
     189            rc = VBoxMpCrCtlConConnect(pCrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pCon->u32ClientID);
     190            if (RT_SUCCESS(rc))
     191            {
     192                pCon->pDevExt = pDevExt;
     193                pCon->pCtlCon = pCrCtlCon;
     194                return VINF_SUCCESS;
     195            }
     196            else
     197            {
     198                WARN(("VBoxMpCrCtlConConnect failed rc %d", rc));
     199            }
     200            vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->WbDrCache);
     201        }
     202        else
     203        {
     204            WARN(("vboxMpCrShgsmiBufCacheInit2 failed rc %d", rc));
     205        }
     206        vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->CmdDrCache);
     207    }
     208    else
     209    {
     210        WARN(("vboxMpCrShgsmiBufCacheInit1 failed rc %d", rc));
     211    }
     212
     213    return rc;
     214}
     215
     216static int vboxMpCrShgsmiConDisconnect(PVBOXMP_CRSHGSMICON pCon)
     217{
     218    int rc = VBoxMpCrCtlConDisconnect(pCon->pCtlCon, pCon->u32ClientID);
     219    if (RT_FAILURE(rc))
     220    {
     221        WARN(("VBoxMpCrCtlConDisconnect failed rc %d", rc));
     222        return rc;
     223    }
     224
     225    vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->WbDrCache);
     226    vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->CmdDrCache);
     227
     228    return VINF_SUCCESS;
     229}
     230
     231typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMICON_SEND_COMPLETION(PVBOXMP_CRSHGSMICON pCon, void *pvRx, uint32_t cbRx, void *pvCtx);
     232typedef FNVBOXMP_CRSHGSMICON_SEND_COMPLETION *PFNVBOXMP_CRSHGSMICON_SEND_COMPLETION;
     233
     234typedef struct VBOXMP_CRSHGSMICON_SEND_COMPLETION
     235{
     236    PVBOXMP_CRSHGSMICON pCon;
     237    PFNVBOXMP_CRSHGSMICON_SEND_COMPLETION pvnCompletion;
     238    void *pvCompletion;
     239} VBOXMP_CRSHGSMICON_SEND_COMPLETION, *PVBOXMP_CRSHGSMICON_SEND_COMPLETION;
     240
     241static DECLCALLBACK(VOID) vboxMpCrShgsmiConSendAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
     242{
     243    /* we should be called from our DPC routine */
     244    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
     245
     246    PVBOXMP_CRSHGSMICON_SEND_COMPLETION pData = (PVBOXMP_CRSHGSMICON_SEND_COMPLETION)pvContext;
     247    PVBOXVDMACBUF_DR pDr = VBOXVDMACBUF_DR_FROM_DDI_CMD(pCmd);
     248    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
     249    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHROMIUM_CMD);
     250    UINT cBufs = pBody->cBuffers;
     251    /* the first one is a command buffer: obtain it and get the result */
     252
     253    /* if write back buffer is too small, issue read command.
     254     * we can use exactly the same command buffer for it */
     255    /* impl */
     256    Assert(0);
     257}
     258
     259static int vboxMpCrShgsmiConSendAsync(PVBOXMP_CRSHGSMICON pCon, void *pvTx, uint32_t cbTx, PFNVBOXMP_CRSHGSMICON_SEND_COMPLETION pfnCompletion, void *pvCompletion)
     260{
     261    const uint32_t cBuffers = 3;
     262    const uint32_t cbCmd = VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (CRVBOXHGSMIWRITEREAD));
     263    PVBOXMP_CRSHGSMICON_BUFDR pCmdDr = vboxMpCrShgsmiBufCacheAlloc(pCon, &pCon->CmdDrCache, cbCmd);
     264    if (!pCmdDr)
     265    {
     266        WARN(("vboxMpCrShgsmiBufCacheAlloc for cmd dr failed"));
     267        return VERR_NO_MEMORY;
     268    }
     269    PVBOXMP_CRSHGSMICON_BUFDR pWbDr = vboxMpCrShgsmiBufCacheAllocAny(pCon, &pCon->WbDrCache, 1000);
     270    if (!pWbDr)
     271    {
     272        WARN(("vboxMpCrShgsmiBufCacheAlloc for wb dr failed"));
     273        vboxMpCrShgsmiBufCacheFree(pCon, &pCon->CmdDrCache, pCmdDr);
     274        return VERR_NO_MEMORY;
     275    }
     276
     277    PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)pCmdDr->pvBuf;
     278    pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR;
     279    pDr->cbBuf = cbCmd;
     280    pDr->rc = VERR_NOT_IMPLEMENTED;
     281
     282    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
     283    pHdr->enmType = VBOXVDMACMD_TYPE_CHROMIUM_CMD;
     284    pHdr->u32CmdSpecific = 0;
     285    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHROMIUM_CMD);
     286    pBody->cBuffers = cBuffers;
     287    CRVBOXHGSMIWRITEREAD *pCmd = VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(pDr, cBuffers, CRVBOXHGSMIWRITEREAD);
     288    pCmd->hdr.result      = VERR_WRONG_ORDER;
     289    pCmd->hdr.u32ClientID = pCon->u32ClientID;
     290    pCmd->hdr.u32Function = SHCRGL_GUEST_FN_WRITE_READ;
     291    //    pCmd->hdr.u32Reserved = 0;
     292    pCmd->iBuffer = 1;
     293    pCmd->iWriteback = 2;
     294    pCmd->cbWriteback = 0;
     295
     296    VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[0];
     297    pBufCmd->offBuffer = vboxMpCrShgsmiConBufOffset(pCon, pCmd);
     298    pBufCmd->cbBuffer = sizeof (*pCmd);
     299    pBufCmd->u32GuestData = 0;
     300    pBufCmd->u64GuestData = (uint64_t)pCmdDr;
     301
     302    pBufCmd = &pBody->aBuffers[1];
     303    pBufCmd->offBuffer = vboxMpCrShgsmiConBufOffset(pCon, pvTx);
     304    pBufCmd->cbBuffer = cbTx;
     305    pBufCmd->u32GuestData = 0;
     306    pBufCmd->u64GuestData = 0;
     307
     308    pBufCmd = &pBody->aBuffers[2];
     309    pBufCmd->offBuffer = vboxMpCrShgsmiConBufOffset(pCon, pWbDr->pvBuf);
     310    pBufCmd->cbBuffer = pWbDr->cbBuf;
     311    pBufCmd->u32GuestData = 0;
     312    pBufCmd->u64GuestData = (uint64_t)pWbDr;
     313
     314    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
     315    PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);
     316    vboxVdmaDdiCmdInit(pDdiCmd, 0, 0, vboxMpCrShgsmiConSendAsyncCompletion, pDr);
     317    /* mark command as submitted & invisible for the dx runtime since dx did not originate it */
     318    vboxVdmaDdiCmdSubmittedNotDx(pDdiCmd);
     319    int rc = vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);
     320    if (RT_SUCCESS(rc))
     321    {
     322        return STATUS_SUCCESS;
     323    }
     324
     325    /* impl failure branch */
     326    Assert(0);
     327    return rc;
     328}
     329
     330static CRMessageOpcodes *
     331vboxMpCrPackerPrependHeader( CRPackBuffer *buf, unsigned int *len, unsigned int senderID )
     332{
     333    UINT num_opcodes;
     334    CRMessageOpcodes *hdr;
     335
     336    Assert(buf);
     337    Assert(buf->opcode_current < buf->opcode_start);
     338    Assert(buf->opcode_current >= buf->opcode_end);
     339    Assert(buf->data_current > buf->data_start);
     340    Assert(buf->data_current <= buf->data_end);
     341
     342    num_opcodes = (UINT)(buf->opcode_start - buf->opcode_current);
     343    hdr = (CRMessageOpcodes *)
     344        ( buf->data_start - ( ( num_opcodes + 3 ) & ~0x3 ) - sizeof(*hdr) );
     345
     346    Assert((void *) hdr >= buf->pack);
     347
     348    hdr->header.type = CR_MESSAGE_OPCODES;
     349    hdr->numOpcodes  = num_opcodes;
     350
     351    *len = (UINT)(buf->data_current - (unsigned char *) hdr);
     352
     353    return hdr;
     354}
     355
    47356static void vboxMpCrShgsmiPackerCbFlush(void *pvFlush)
    48357{
    49     PPVBOXMP_SHGSMIPACKER pPacker = (PPVBOXMP_SHGSMIPACKER)pvFlush;
     358    PVBOXMP_CRSHGSMIPACKER pPacker = (PVBOXMP_CRSHGSMIPACKER)pvFlush;
    50359
    51360    crPackReleaseBuffer(&pPacker->CrPacker);
    … …  
    65374}
    66375
    67 static int vboxMpCrShgsmiPackerInit(PPVBOXMP_SHGSMIPACKER pPacker, PVBOXMP_DEVEXT pDevExt)
     376int vboxMpCrShgsmiPackerInit(PVBOXMP_CRSHGSMIPACKER pPacker, PVBOXMP_CRSHGSMICON pCon)
    68377{
    69378    memset(pPacker, 0, sizeof (*pPacker));
    70379
    71     static const cbBuffer = 1000;
    72     void *pvBuffer = vboxMpCrShgsmiBufferAlloc(pDevExt, cbBuffer);
     380    static const HGSMISIZE cbBuffer = 1000;
     381    void *pvBuffer = vboxMpCrShgsmiConAlloc(pCon, cbBuffer);
    73382    if (!pvBuffer)
    74383    {
    75         WARN(("vboxMpCrShgsmiBufferAlloc failed"));
     384        WARN(("vboxMpCrShgsmiConAlloc failed"));
    76385        return VERR_NO_MEMORY;
    77386    }
     387    pPacker->pCon = pCon;
    78388    crPackInitBuffer(&pPacker->CrBuffer, pvBuffer, cbBuffer, cbBuffer);
    79389    crPackSetBuffer(&pPacker->CrPacker, &pPacker->CrBuffer);

  • trunk/src/VBox/GuestHost/OpenGL/glapi_parser/apiutil.py

    r30440 r42028  
    566566                return result
    567567        #endif
     568#enddef
     569
     570def MakeDeclarationStringWithContext(ctx_macro_prefix, params):
     571    """Same as MakeDeclarationString, but adds a context macro
     572    """
     573   
     574    n = len(params)
     575    if n == 0:
     576        return ctx_macro_prefix + '_ARGSINGLEDECL'
     577    else:
     578        result = MakeDeclarationString(params)
     579        return ctx_macro_prefix + '_ARGDECL ' + result
     580    #endif
    568581#enddef
    569582

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

    r41109 r42028  
    8080};
    8181
     82#if !defined(IN_RING0)
     83# define CR_PACKER_CONTEXT_ARGSINGLEDECL
     84# define CR_PACKER_CONTEXT_ARGDECL
     85# define CR_PACKER_CONTEXT_ARG
     86# define CR_PACKER_CONTEXT_ARGCTX(C)
     87# ifdef CHROMIUM_THREADSAFE
     88extern CRtsd _PackerTSD;
     89#  define CR_GET_PACKER_CONTEXT(C) CRPackContext *C = (CRPackContext *) crGetTSD(&_PackerTSD)
     90#  define CR_LOCK_PACKER_CONTEXT(PC) crLockMutex(&((PC)->mutex))
     91#  define CR_UNLOCK_PACKER_CONTEXT(PC) crUnlockMutex(&((PC)->mutex))
     92# else
     93extern DLLDATA(CRPackContext) cr_packer_globals;
     94#  define CR_GET_PACKER_CONTEXT(C) CRPackContext *C = &cr_packer_globals
     95#  define CR_LOCK_PACKER_CONTEXT(PC)
     96#  define CR_UNLOCK_PACKER_CONTEXT(PC)
     97# endif
     98#else /* if defined IN_RING0 */
     99# define CR_PACKER_CONTEXT_ARGSINGLEDECL CRPackContext *_pCtx
     100# define CR_PACKER_CONTEXT_ARGDECL CR_PACKER_CONTEXT_ARGSINGLEDECL,
     101# define CR_PACKER_CONTEXT_ARG _pCtx,
     102# define CR_PACKER_CONTEXT_ARGCTX(C) C,
     103# define CR_GET_PACKER_CONTEXT(C) CRPackContext *C = _pCtx
     104# define CR_LOCK_PACKER_CONTEXT(PC)
     105# define CR_UNLOCK_PACKER_CONTEXT(PC)
     106#endif
    82107
    83108extern DECLEXPORT(CRPackContext *) crPackNewContext(int swapping);
    … …  
    106131                                GLfloat *xmax, GLfloat *ymax, GLfloat *zmax);
    107132
    108 extern DECLEXPORT(void) crPackAppendBuffer( const CRPackBuffer *buffer );
    109 extern DECLEXPORT(void) crPackAppendBoundedBuffer( const CRPackBuffer *buffer, const CRrecti *bounds );
    110 extern DECLEXPORT(int) crPackCanHoldBuffer( const CRPackBuffer *buffer );
    111 extern DECLEXPORT(int) crPackCanHoldBoundedBuffer( const CRPackBuffer *buffer );
     133extern DECLEXPORT(void) crPackAppendBuffer( CR_PACKER_CONTEXT_ARGDECL const CRPackBuffer *buffer );
     134extern DECLEXPORT(void) crPackAppendBoundedBuffer( CR_PACKER_CONTEXT_ARGDECL const CRPackBuffer *buffer, const CRrecti *bounds );
     135extern DECLEXPORT(int) crPackCanHoldBuffer( CR_PACKER_CONTEXT_ARGDECL const CRPackBuffer *buffer );
     136extern DECLEXPORT(int) crPackCanHoldBoundedBuffer( CR_PACKER_CONTEXT_ARGDECL const CRPackBuffer *buffer );
    112137
    113138#if defined(LINUX) || defined(WINDOWS)
    … …  
    119144extern DECLEXPORT(void) crWriteSwappedDouble( void *buffer, double d );
    120145
    121 extern DECLEXPORT(void) *crPackAlloc( unsigned int len );
    122 extern DECLEXPORT(void) crHugePacket( CROpcode op, void *ptr );
    123 extern DECLEXPORT(void) crPackFree( void *ptr );
     146extern DECLEXPORT(void) *crPackAlloc( CR_PACKER_CONTEXT_ARGDECL unsigned int len );
     147extern DECLEXPORT(void) crHugePacket( CR_PACKER_CONTEXT_ARGDECL CROpcode op, void *ptr );
     148extern DECLEXPORT(void) crPackFree( CR_PACKER_CONTEXT_ARGDECL void *ptr );
    124149extern DECLEXPORT(void) crNetworkPointerWrite( CRNetworkPointer *, void * );
    125150
    … …  
    144169extern DECLEXPORT(void) crPackExpandMultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount, CRClientState *c );
    145170extern DECLEXPORT(void) crPackExpandMultiDrawElementsEXTSWAP( GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount, CRClientState *c );
    146 
    147 
    148 #ifdef CHROMIUM_THREADSAFE
    149 extern CRtsd _PackerTSD;
    150 #define CR_GET_PACKER_CONTEXT(C) CRPackContext *C = (CRPackContext *) crGetTSD(&_PackerTSD)
    151 #define CR_LOCK_PACKER_CONTEXT(PC) crLockMutex(&((PC)->mutex))
    152 #define CR_UNLOCK_PACKER_CONTEXT(PC) crUnlockMutex(&((PC)->mutex))
    153 #elif !defined IN_RING0
    154 extern DLLDATA(CRPackContext) cr_packer_globals;
    155 #define CR_GET_PACKER_CONTEXT(C) CRPackContext *C = &cr_packer_globals
    156 #define CR_LOCK_PACKER_CONTEXT(PC)
    157 #define CR_UNLOCK_PACKER_CONTEXT(PC)
    158 #endif
    159171
    160172

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_bounds.c

    r33475 r42028  
    99#include "cr_mem.h"
    1010
    11 void PACK_APIENTRY crPackBoundsInfoCR( const CRrecti *bounds, const GLbyte *payload, GLint len, GLint num_opcodes )
     11void PACK_APIENTRY crPackBoundsInfoCR( CR_PACKER_CONTEXT_ARGDECL const CRrecti *bounds, const GLbyte *payload, GLint len, GLint num_opcodes )
    1212{
    1313    CR_GET_PACKER_CONTEXT(pc);

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_buffer.c

    r41109 r42028  
    258258
    259259
    260 int crPackCanHoldBuffer( const CRPackBuffer *src )
     260int crPackCanHoldBuffer( CR_PACKER_CONTEXT_ARGDECL const CRPackBuffer *src )
    261261{
    262262        const int num_data = crPackNumData(src);
    … …  
    271271
    272272
    273 int crPackCanHoldBoundedBuffer( const CRPackBuffer *src )
     273int crPackCanHoldBoundedBuffer( CR_PACKER_CONTEXT_ARGDECL const CRPackBuffer *src )
    274274{
    275275        const int len_aligned = (src->data_current - src->opcode_current - 1 + 3) & ~3;
    … …  
    279279}
    280280
    281 void crPackAppendBuffer( const CRPackBuffer *src )
     281void crPackAppendBuffer( CR_PACKER_CONTEXT_ARGDECL const CRPackBuffer *src )
    282282{
    283283        CR_GET_PACKER_CONTEXT(pc);
    … …  
    294294        CRASSERT(pc->currentBuffer != src);
    295295
    296         if (!crPackCanHoldBuffer(src))
     296        if (!crPackCanHoldBuffer(CR_PACKER_CONTEXT_ARG src))
    297297        {
    298298                if (src->holds_BeginEnd)
    … …  
    326326
    327327void
    328 crPackAppendBoundedBuffer( const CRPackBuffer *src, const CRrecti *bounds )
     328crPackAppendBoundedBuffer( CR_PACKER_CONTEXT_ARGDECL const CRPackBuffer *src, const CRrecti *bounds )
    329329{
    330330        CR_GET_PACKER_CONTEXT(pc);
    … …  
    342342         */
    343343
    344         if ( !crPackCanHoldBoundedBuffer( src ) )
     344        if ( !crPackCanHoldBoundedBuffer( CR_PACKER_CONTEXT_ARG src ) )
    345345        {
    346346                if (src->holds_BeginEnd)
    … …  
    358358
    359359        if (pc->swapping)
    360                 crPackBoundsInfoCRSWAP( bounds, payload, length, num_opcodes );
     360                crPackBoundsInfoCRSWAP( CR_PACKER_CONTEXT_ARG bounds, payload, length, num_opcodes );
    361361        else
    362                 crPackBoundsInfoCR( bounds, payload, length, num_opcodes );
     362                crPackBoundsInfoCR( CR_PACKER_CONTEXT_ARG bounds, payload, length, num_opcodes );
    363363
    364364        pc->buffer.holds_BeginEnd |= src->holds_BeginEnd;
    … …  
    379379 * The command buffer _MUST_ then be transmitted by calling crHugePacket.
    380380 */
    381 void *crPackAlloc( unsigned int size )
     381void *crPackAlloc( CR_PACKER_CONTEXT_ARGDECL unsigned int size )
    382382{
    383383        CR_GET_PACKER_CONTEXT(pc);
    … …  
    467467 * Transmit a packet which was allocated with crPackAlloc.
    468468 */
    469 void crHugePacket( CROpcode opcode, void *packet )
     469void crHugePacket( CR_PACKER_CONTEXT_ARGDECL CROpcode opcode, void *packet )
    470470{
    471471        CR_GET_PACKER_CONTEXT(pc);
    … …  
    481481}
    482482
    483 void crPackFree( void *packet )
     483void crPackFree( CR_PACKER_CONTEXT_ARGDECL void *packet )
    484484{
    485485        CR_GET_PACKER_CONTEXT(pc);

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_header.py

    r15532 r42028  
    6060                        args.append(("writeback", "int *", 0))
    6161
    62                 print 'void PACK_APIENTRY crPack%s( %s );' % (func_name, apiutil.MakeDeclarationString(args))
    63                 print 'void PACK_APIENTRY crPack%sSWAP( %s );' % (func_name, apiutil.MakeDeclarationString(args))
     62                print 'void PACK_APIENTRY crPack%s( %s );' % (func_name, apiutil.MakeDeclarationStringWithContext('CR_PACKER_CONTEXT', args))
     63                print 'void PACK_APIENTRY crPack%sSWAP( %s );' % (func_name, apiutil.MakeDeclarationStringWithContext('CR_PACKER_CONTEXT', args))
    6464
    6565
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