VirtualBox

Changeset 82090 in vbox for trunk


Ignore:
Timestamp:
Nov 21, 2019 10:29:30 PM (5 years ago)
Author:
vboxsync
Message:

Devices/Graphics: use helpers to resolve surface and context ids; log the ids as decimal values.

Location:
trunk/src/VBox/Devices/Graphics
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-info.cpp

    r82089 r82090  
    345345                                        /** @todo stricter checks for associated context */
    346346                                        uint32_t cid = pSurface->idAssociatedContext;
    347                                         if (   cid >= pState->cContexts
    348                                             || pState->papContexts[cid]->id != cid)
    349                                         {
    350                                             Log(("vmsvga3dSurfaceUpdateHeapBuffers: invalid context id (%x - %x)!\n", cid, (cid >= pState->cContexts) ? -1 : pState->papContexts[cid]->id));
    351                                             AssertFailedReturn(VERR_INVALID_PARAMETER);
    352                                         }
    353                                         PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
     347                                        PVMSVGA3DCONTEXT pContext;
     348                                        int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     349                                        AssertRCReturn(rc, rc);
    354350
    355351                                        IDirect3DSurface9 *pDst = NULL;
  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-internal.h

    r82063 r82090  
    12251225DECLINLINE(int) vmsvga3dContextFromCid(PVMSVGA3DSTATE pState, uint32_t cid, PVMSVGA3DCONTEXT *ppContext)
    12261226{
    1227     /** @todo stricter checks for associated context */
    12281227    AssertReturn(cid < pState->cContexts, VERR_INVALID_PARAMETER);
    12291228    PVMSVGA3DCONTEXT const pContext = pState->papContexts[cid];
     
    12331232        return VINF_SUCCESS;
    12341233    }
    1235     LogRelMax(64, ("VMSVGA: unknown cid=%d (%s cid=%d)\n", cid, pContext ? "expected" : "null", pContext ? pContext->id : -1));
     1234    LogRelMax(64, ("VMSVGA: unknown cid=%u (%s cid=%u)\n", cid, pContext ? "expected" : "null", pContext ? pContext->id : -1));
    12361235    return VERR_INVALID_PARAMETER;
    12371236}
     
    12461245        return VINF_SUCCESS;
    12471246    }
    1248     LogRelMax(64, ("VMSVGA: unknown sid=%d (%s sid=%d)\n", sid, pSurface ? "expected" : "null", pSurface ? pSurface->id : -1));
     1247    LogRelMax(64, ("VMSVGA: unknown sid=%u (%s sid=%u)\n", sid, pSurface ? "expected" : "null", pSurface ? pSurface->id : -1));
    12491248    return VERR_INVALID_PARAMETER;
    12501249}
  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-ogl.cpp

    r82089 r82090  
    21812181    RT_NOREF(idAssociatedContext);
    21822182
    2183     LogFunc(("sid=%x\n", pSurface->id));
     2183    LogFunc(("sid=%u\n", pSurface->id));
    21842184
    21852185    uint32_t const numMipLevels = pSurface->faces[0].numMipLevels;
     
    29672967    pSurface->autogenFilter = filter;
    29682968
    2969     LogFunc(("sid=%x filter=%d\n", sid, filter));
     2969    LogFunc(("sid=%u filter=%d\n", sid, filter));
    29702970
    29712971    cid = SVGA3D_INVALID_ID;
     
    34433443int vmsvga3dSetTransform(PVGASTATE pThis, uint32_t cid, SVGA3dTransformType type, float matrix[16])
    34443444{
    3445     PVMSVGA3DCONTEXT      pContext;
    34463445    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    34473446    AssertReturn(pState, VERR_NO_MEMORY);
    34483447    bool                  fModelViewChanged = false;
    34493448
    3450     Log(("vmsvga3dSetTransform cid=%x %s\n", cid, vmsvgaTransformToString(type)));
    3451 
    3452     if (    cid >= pState->cContexts
    3453         ||  pState->papContexts[cid]->id != cid)
    3454     {
    3455         Log(("vmsvga3dSetTransform invalid context id!\n"));
    3456         return VERR_INVALID_PARAMETER;
    3457     }
     3449    Log(("vmsvga3dSetTransform cid=%u %s\n", cid, vmsvgaTransformToString(type)));
    34583450
    34593451    ASSERT_GUEST_RETURN((unsigned)type < SVGA3D_TRANSFORM_MAX, VERR_INVALID_PARAMETER);
    34603452
    3461     pContext = pState->papContexts[cid];
     3453    PVMSVGA3DCONTEXT pContext;
     3454    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     3455    AssertRCReturn(rc, rc);
     3456
    34623457    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    34633458
     
    34863481    case SVGA3D_TRANSFORM_PROJECTION:
    34873482    {
    3488         int rc = ShaderTransformProjection(pContext->state.RectViewPort.w, pContext->state.RectViewPort.h, matrix, false /* fPretransformed */);
     3483        rc = ShaderTransformProjection(pContext->state.RectViewPort.w, pContext->state.RectViewPort.h, matrix, false /* fPretransformed */);
    34893484        AssertRCReturn(rc, rc);
    34903485        break;
     
    35543549int vmsvga3dSetZRange(PVGASTATE pThis, uint32_t cid, SVGA3dZRange zRange)
    35553550{
    3556     PVMSVGA3DCONTEXT      pContext;
    35573551    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    35583552    AssertReturn(pState, VERR_NO_MEMORY);
    35593553
    3560     Log(("vmsvga3dSetZRange cid=%x min=%d max=%d\n", cid, (uint32_t)(zRange.min * 100.0), (uint32_t)(zRange.max * 100.0)));
    3561 
    3562     if (    cid >= pState->cContexts
    3563         ||  pState->papContexts[cid]->id != cid)
    3564     {
    3565         Log(("vmsvga3dSetZRange invalid context id!\n"));
    3566         return VERR_INVALID_PARAMETER;
    3567     }
    3568     pContext = pState->papContexts[cid];
     3554    Log(("vmsvga3dSetZRange cid=%u min=%d max=%d\n", cid, (uint32_t)(zRange.min * 100.0), (uint32_t)(zRange.max * 100.0)));
     3555
     3556    PVMSVGA3DCONTEXT pContext;
     3557    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     3558    AssertRCReturn(rc, rc);
     3559
    35693560    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    35703561
     
    36973688{
    36983689    uint32_t                    val = UINT32_MAX; /* Shut up MSC. */
    3699     PVMSVGA3DCONTEXT            pContext;
    37003690    PVMSVGA3DSTATE              pState = pThis->svga.p3dState;
    37013691    AssertReturn(pState, VERR_NO_MEMORY);
    37023692
    3703     Log(("vmsvga3dSetRenderState cid=%x cRenderStates=%d\n", cid, cRenderStates));
    3704 
    3705     if (    cid >= pState->cContexts
    3706         ||  pState->papContexts[cid]->id != cid)
    3707     {
    3708         Log(("vmsvga3dSetRenderState invalid context id!\n"));
    3709         return VERR_INVALID_PARAMETER;
    3710     }
    3711 
    3712     pContext = pState->papContexts[cid];
     3693    Log(("vmsvga3dSetRenderState cid=%u cRenderStates=%d\n", cid, cRenderStates));
     3694
     3695    PVMSVGA3DCONTEXT pContext;
     3696    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     3697    AssertRCReturn(rc, rc);
     3698
    37133699    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    37143700
     
    37163702    {
    37173703        GLenum enableCap = ~(GLenum)0;
    3718         Log(("vmsvga3dSetRenderState: cid=%x state=%s (%d) val=%x\n", cid, vmsvga3dGetRenderStateName(pRenderState[i].state), pRenderState[i].state, pRenderState[i].uintValue));
     3704        Log(("vmsvga3dSetRenderState: cid=%u state=%s (%d) val=%x\n", cid, vmsvga3dGetRenderStateName(pRenderState[i].state), pRenderState[i].state, pRenderState[i].uintValue));
    37193705        /* Save the render state for vm state saving. */
    37203706        ASSERT_GUEST_RETURN((unsigned)pRenderState[i].state < SVGA3D_RS_MAX, VERR_INVALID_PARAMETER);
     
    39983984            }
    39993985
    4000             int rc = vmsvga3dSetRenderState(pThis, cid, 2, renderstate);
     3986            rc = vmsvga3dSetRenderState(pThis, cid, 2, renderstate);
    40013987            AssertRCReturn(rc, rc);
    40023988
     
    41694155            }
    41704156
    4171             int rc = vmsvga3dSetRenderState(pThis, cid, RT_ELEMENTS(renderstate), renderstate);
     4157            rc = vmsvga3dSetRenderState(pThis, cid, RT_ELEMENTS(renderstate), renderstate);
    41724158            AssertRCReturn(rc, rc);
    41734159
     
    45714557    AssertReturn((unsigned)type < SVGA3D_RT_MAX, VERR_INVALID_PARAMETER);
    45724558
    4573     LogFunc(("cid=%x type=%x sid=%x\n", cid, type, target.sid));
     4559    LogFunc(("cid=%u type=%x sid=%u\n", cid, type, target.sid));
    45744560
    45754561    PVMSVGA3DCONTEXT pContext;
     
    49214907#endif
    49224908
    4923         LogFunc(("cid=%x stage=%d type=%s (%x) val=%x\n",
     4909        LogFunc(("cid=%u stage=%d type=%s (%x) val=%x\n",
    49244910                 cid, pTextureState[i].stage, vmsvga3dTextureStateToString(pTextureState[i].name), pTextureState[i].name, pTextureState[i].value));
    49254911
     
    49964982            uint32_t const sid = pTextureState[i].value;
    49974983
    4998             Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture sid=%x replacing sid=%x\n",
     4984            Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture sid=%u replacing sid=%u\n",
    49994985                 currentStage, sid, pContext->aSidActiveTextures[currentStage]));
    50004986
     
    50285014                    AssertRCReturn(rc, rc);
    50295015
    5030                     Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture sid=%x (%d,%d) replacing sid=%x\n",
     5016                    Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture sid=%u (%d,%d) replacing sid=%u\n",
    50315017                         currentStage, sid, pSurface->pMipmapLevels[0].mipmapSize.width,
    50325018                         pSurface->pMipmapLevels[0].mipmapSize.height, pContext->aSidActiveTextures[currentStage]));
     
    52355221    AssertReturn(pState, VERR_NO_MEMORY);
    52365222
    5237     LogFunc(("cid=%x face %d\n", cid, face));
     5223    LogFunc(("cid=%u face %d\n", cid, face));
    52385224
    52395225    PVMSVGA3DCONTEXT pContext;
     
    52845270    AssertReturn(pState, VERR_NO_MEMORY);
    52855271
    5286     LogFunc(("vmsvga3dSetLightData cid=%x index=%d type=%d\n", cid, index, pData->type));
     5272    LogFunc(("vmsvga3dSetLightData cid=%u index=%d type=%d\n", cid, index, pData->type));
    52875273
    52885274    PVMSVGA3DCONTEXT pContext;
     
    54615447    AssertReturn(pState, VERR_NO_MEMORY);
    54625448
    5463     LogFunc(("cid=%x %d -> %d\n", cid, index, enabled));
     5449    LogFunc(("cid=%u %d -> %d\n", cid, index, enabled));
    54645450
    54655451    PVMSVGA3DCONTEXT pContext;
     
    54945480int vmsvga3dSetViewPort(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect)
    54955481{
    5496     PVMSVGA3DCONTEXT      pContext;
    54975482    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    54985483    AssertReturn(pState, VERR_NO_MEMORY);
    54995484
    5500     Log(("vmsvga3dSetViewPort cid=%x (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
    5501 
    5502     if (    cid >= pState->cContexts
    5503         ||  pState->papContexts[cid]->id != cid)
    5504     {
    5505         Log(("vmsvga3dSetViewPort invalid context id!\n"));
    5506         return VERR_INVALID_PARAMETER;
    5507     }
    5508     pContext = pState->papContexts[cid];
     5485    Log(("vmsvga3dSetViewPort cid=%u (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
     5486
     5487    PVMSVGA3DCONTEXT pContext;
     5488    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     5489    AssertRCReturn(rc, rc);
     5490
    55095491    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    55105492
     
    55405522int vmsvga3dSetClipPlane(PVGASTATE pThis, uint32_t cid,  uint32_t index, float plane[4])
    55415523{
    5542     PVMSVGA3DCONTEXT      pContext;
    55435524    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    55445525    AssertReturn(pState, VERR_NO_MEMORY);
    55455526    double                oglPlane[4];
    55465527
    5547     Log(("vmsvga3dSetClipPlane cid=%x %d (%d,%d)(%d,%d)\n", cid, index, (unsigned)(plane[0] * 100.0), (unsigned)(plane[1] * 100.0), (unsigned)(plane[2] * 100.0), (unsigned)(plane[3] * 100.0)));
     5528    Log(("vmsvga3dSetClipPlane cid=%u %d (%d,%d)(%d,%d)\n", cid, index, (unsigned)(plane[0] * 100.0), (unsigned)(plane[1] * 100.0), (unsigned)(plane[2] * 100.0), (unsigned)(plane[3] * 100.0)));
    55485529    AssertReturn(index < SVGA3D_CLIPPLANE_MAX, VERR_INVALID_PARAMETER);
    55495530
    5550     if (    cid >= pState->cContexts
    5551         ||  pState->papContexts[cid]->id != cid)
    5552     {
    5553         Log(("vmsvga3dSetClipPlane invalid context id!\n"));
    5554         return VERR_INVALID_PARAMETER;
    5555     }
    5556     pContext = pState->papContexts[cid];
     5531    PVMSVGA3DCONTEXT pContext;
     5532    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     5533    AssertRCReturn(rc, rc);
     5534
    55575535    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    55585536
     
    55755553int vmsvga3dSetScissorRect(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect)
    55765554{
    5577     PVMSVGA3DCONTEXT      pContext;
    55785555    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    55795556    AssertReturn(pState, VERR_NO_MEMORY);
    55805557
    5581     Log(("vmsvga3dSetScissorRect cid=%x (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
    5582 
    5583     if (    cid >= pState->cContexts
    5584         ||  pState->papContexts[cid]->id != cid)
    5585     {
    5586         Log(("vmsvga3dSetScissorRect invalid context id!\n"));
    5587         return VERR_INVALID_PARAMETER;
    5588     }
    5589     pContext = pState->papContexts[cid];
     5558    Log(("vmsvga3dSetScissorRect cid=%u (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
     5559
     5560    PVMSVGA3DCONTEXT pContext;
     5561    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     5562    AssertRCReturn(rc, rc);
     5563
    55905564    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    55915565
     
    56135587{
    56145588    GLbitfield            mask = 0;
    5615     PVMSVGA3DCONTEXT      pContext;
    56165589    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    56175590    AssertReturn(pState, VERR_NO_MEMORY);
    56185591    GLboolean             fDepthWriteEnabled = GL_FALSE;
    56195592
    5620     Log(("vmsvga3dCommandClear cid=%x clearFlag=%x color=%x depth=%d stencil=%x cRects=%d\n", cid, clearFlag, color, (uint32_t)(depth * 100.0), stencil, cRects));
    5621 
    5622     if (    cid >= pState->cContexts
    5623         ||  pState->papContexts[cid]->id != cid)
    5624     {
    5625         Log(("vmsvga3dCommandClear invalid context id!\n"));
    5626         return VERR_INVALID_PARAMETER;
    5627     }
    5628     pContext = pState->papContexts[cid];
     5593    Log(("vmsvga3dCommandClear cid=%u clearFlag=%x color=%x depth=%d stencil=%x cRects=%d\n", cid, clearFlag, color, (uint32_t)(depth * 100.0), stencil, cRects));
     5594
     5595    PVMSVGA3DCONTEXT pContext;
     5596    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     5597    AssertRCReturn(rc, rc);
     5598
    56295599    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    56305600
     
    58665836{
    58675837    PVMSVGA3DSTATE      pState = pThis->svga.p3dState;
    5868     unsigned            sidVertex = pVertexDecl[0].array.surfaceId;
     5838    unsigned const      sidVertex = pVertexDecl[0].array.surfaceId;
     5839
    58695840    PVMSVGA3DSURFACE    pVertexSurface;
    5870 
    5871     AssertReturn(sidVertex < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
    5872     AssertReturn(sidVertex < pState->cSurfaces && pState->papSurfaces[sidVertex]->id == sidVertex, VERR_INVALID_PARAMETER);
    5873 
    5874     pVertexSurface = pState->papSurfaces[sidVertex];
    5875     Log(("vmsvga3dDrawPrimitives: vertex surface %x\n", sidVertex));
     5841    int rc = vmsvga3dSurfaceFromSid(pState, sidVertex, &pVertexSurface);
     5842    AssertRCReturn(rc, rc);
     5843
     5844    Log(("vmsvga3dDrawPrimitives: vertex surface sid=%u\n", sidVertex));
    58765845
    58775846    /* Create and/or bind the vertex buffer. */
     
    59215890        Log(("vmsvga3dDrawPrimitives: array index %d type=%s (%d) method=%s (%d) usage=%s (%d) usageIndex=%d stride=%d offset=%d\n", index, vmsvgaDeclType2String(pVertexDecl[iVertex].identity.type), pVertexDecl[iVertex].identity.type, vmsvgaDeclMethod2String(pVertexDecl[iVertex].identity.method), pVertexDecl[iVertex].identity.method, vmsvgaDeclUsage2String(pVertexDecl[iVertex].identity.usage), pVertexDecl[iVertex].identity.usage, pVertexDecl[iVertex].identity.usageIndex, pVertexDecl[iVertex].array.stride, pVertexDecl[iVertex].array.offset));
    59225891
    5923         int rc = vmsvga3dVertexDecl2OGL(pVertexDecl[iVertex].identity, size, type, normalized);
     5892        rc = vmsvga3dVertexDecl2OGL(pVertexDecl[iVertex].identity, size, type, normalized);
    59245893        AssertRCReturn(rc, rc);
    59255894
     
    61316100                           SVGA3dVertexDivisor *pVertexDivisor)
    61326101{
    6133     RT_NOREF(pVertexDivisor);
    61346102    PVMSVGA3DSTATE               pState = pThis->svga.p3dState;
    61356103    AssertReturn(pState, VERR_INTERNAL_ERROR);
    6136     PVMSVGA3DCONTEXT             pContext;
    6137     int                          rc = VERR_NOT_IMPLEMENTED;
    61386104    uint32_t                     iCurrentVertex;
    61396105
    6140     Log(("vmsvga3dDrawPrimitives cid=%x numVertexDecls=%d numRanges=%d, cVertexDivisor=%d\n", cid, numVertexDecls, numRanges, cVertexDivisor));
     6106    Log(("vmsvga3dDrawPrimitives cid=%u numVertexDecls=%d numRanges=%d, cVertexDivisor=%d\n", cid, numVertexDecls, numRanges, cVertexDivisor));
    61416107
    61426108    /* Caller already check these, but it cannot hurt to check again... */
     
    61486114        pVertexDivisor = NULL; /* Be sure. */
    61496115
    6150     if (    cid >= pState->cContexts
    6151         ||  pState->papContexts[cid]->id != cid)
    6152     {
    6153         Log(("vmsvga3dDrawPrimitives invalid context id!\n"));
    6154         return VERR_INVALID_PARAMETER;
    6155     }
    6156     pContext = pState->papContexts[cid];
     6116    PVMSVGA3DCONTEXT pContext;
     6117    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     6118    AssertRCReturn(rc, rc);
     6119
    61576120    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    61586121
     
    62856248    {
    62866249        GLenum           modeDraw;
    6287         unsigned         sidIndex  = pRange[iPrimitive].indexArray.surfaceId;
     6250        unsigned const   sidIndex  = pRange[iPrimitive].indexArray.surfaceId;
    62886251        PVMSVGA3DSURFACE pIndexSurface = NULL;
    62896252        unsigned         cVertices;
     
    63016264            AssertMsg(pRange[iPrimitive].indexWidth == sizeof(uint32_t) || pRange[iPrimitive].indexWidth == sizeof(uint16_t), ("Unsupported primitive width %d\n", pRange[iPrimitive].indexWidth));
    63026265
    6303             if (    sidIndex >= SVGA3D_MAX_SURFACE_IDS
    6304                 ||  sidIndex >= pState->cSurfaces
    6305                 ||  pState->papSurfaces[sidIndex]->id != sidIndex)
     6266            rc = vmsvga3dSurfaceFromSid(pState, sidIndex, &pIndexSurface);
     6267            if (RT_FAILURE(rc))
    63066268            {
    6307                 Assert(sidIndex < SVGA3D_MAX_SURFACE_IDS);
    6308                 Assert(sidIndex < pState->cSurfaces && pState->papSurfaces[sidIndex]->id == sidIndex);
    6309                 rc = VERR_INVALID_PARAMETER;
     6269                AssertRC(rc);
    63106270                goto internal_error;
    63116271            }
    6312             pIndexSurface = pState->papSurfaces[sidIndex];
    6313             Log(("vmsvga3dDrawPrimitives: index surface %x\n", sidIndex));
     6272
     6273            Log(("vmsvga3dDrawPrimitives: index surface sid=%u\n", sidIndex));
    63146274
    63156275            if (pIndexSurface->oglId.buffer == OPENGL_INVALID_ID)
     
    64736433
    64746434            AssertMsg(pTexture->oglId.texture == (GLuint)activeTexture,
    6475                       ("%x vs %x unit %d (active unit %d) sid=%x\n", pTexture->oglId.texture, activeTexture, i,
     6435                      ("%d vs %d unit %d (active unit %d) sid=%u\n", pTexture->oglId.texture, activeTexture, i,
    64766436                       activeTextureUnit - GL_TEXTURE0, pContext->aSidActiveTextures[i]));
    64776437        }
     
    65076467int vmsvga3dShaderDefine(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData)
    65086468{
    6509     PVMSVGA3DCONTEXT      pContext;
    65106469    PVMSVGA3DSHADER       pShader;
    65116470    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    65126471    AssertReturn(pState, VERR_NO_MEMORY);
    6513     int                   rc;
    6514 
    6515     Log(("vmsvga3dShaderDefine cid=%x shid=%d type=%s cbData=0x%x\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", cbData));
     6472
     6473    Log(("vmsvga3dShaderDefine cid=%u shid=%d type=%s cbData=0x%x\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", cbData));
    65166474    Log3(("shader code:\n%.*Rhxd\n", cbData, pShaderData));
    65176475
    6518     if (    cid >= pState->cContexts
    6519         ||  pState->papContexts[cid]->id != cid)
    6520     {
    6521         Log(("vmsvga3dShaderDefine invalid context id!\n"));
    6522         return VERR_INVALID_PARAMETER;
    6523     }
    6524     pContext = pState->papContexts[cid];
     6476    PVMSVGA3DCONTEXT pContext;
     6477    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     6478    AssertRCReturn(rc, rc);
     6479
    65256480    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    65266481
     
    66106565int vmsvga3dShaderDestroy(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
    66116566{
    6612     PVMSVGA3DCONTEXT      pContext;
    66136567    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    66146568    AssertReturn(pState, VERR_NO_MEMORY);
    66156569    PVMSVGA3DSHADER       pShader = NULL;
    6616     int                   rc;
    6617 
    6618     Log(("vmsvga3dShaderDestroy cid=%x shid=%d type=%s\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL"));
    6619 
    6620     if (    cid >= pState->cContexts
    6621         ||  pState->papContexts[cid]->id != cid)
    6622     {
    6623         Log(("vmsvga3dShaderDestroy invalid context id!\n"));
    6624         return VERR_INVALID_PARAMETER;
    6625     }
    6626     pContext = pState->papContexts[cid];
     6570
     6571    Log(("vmsvga3dShaderDestroy cid=%u shid=%d type=%s\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL"));
     6572
     6573    PVMSVGA3DCONTEXT pContext;
     6574    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     6575    AssertRCReturn(rc, rc);
     6576
    66276577    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    66286578
     
    66686618    int                 rc;
    66696619
    6670     Log(("vmsvga3dShaderSet cid=%x type=%s shid=%d\n", cid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", shid));
    6671 
    6672     if (   !pContext
    6673         && cid < pState->cContexts
    6674         && pState->papContexts[cid]->id == cid)
    6675         pContext = pState->papContexts[cid];
    6676     else if (!pContext)
    6677     {
    6678         AssertMsgFailed(("cid=%#x cContexts=%#x\n", cid, pState->cContexts));
    6679         Log(("vmsvga3dShaderSet invalid context id!\n"));
    6680         return VERR_INVALID_PARAMETER;
    6681     }
     6620    Log(("vmsvga3dShaderSet cid=%u type=%s shid=%d\n", cid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", shid));
     6621
     6622    if (!pContext)
     6623    {
     6624        rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     6625        AssertRCReturn(rc, rc);
     6626    }
     6627
    66826628    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    66836629
     
    67396685int vmsvga3dShaderSetConst(PVGASTATE pThis, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
    67406686{
    6741     PVMSVGA3DCONTEXT      pContext;
    67426687    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    67436688    AssertReturn(pState, VERR_NO_MEMORY);
    6744     int                   rc;
    6745 
    6746     Log(("vmsvga3dShaderSetConst cid=%x reg=%x type=%s cregs=%d ctype=%x\n", cid, reg, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", cRegisters, ctype));
    6747 
    6748     if (    cid >= pState->cContexts
    6749         ||  pState->papContexts[cid]->id != cid)
    6750     {
    6751         Log(("vmsvga3dShaderSetConst invalid context id!\n"));
    6752         return VERR_INVALID_PARAMETER;
    6753     }
    6754     pContext = pState->papContexts[cid];
     6689
     6690    Log(("vmsvga3dShaderSetConst cid=%u reg=%x type=%s cregs=%d ctype=%x\n", cid, reg, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", cRegisters, ctype));
     6691
     6692    PVMSVGA3DCONTEXT pContext;
     6693    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     6694    AssertRCReturn(rc, rc);
     6695
    67556696    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    67566697
  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-savedstate.cpp

    r82048 r82090  
    458458                AssertRCReturn(rc, rc);
    459459
    460                 Log(("Surface sid=%x: load mipmap level %d with %x bytes data (present=%d).\n", sid, j, pMipmapLevel->cbSurface, fDataPresent));
     460                Log(("Surface sid=%u: load mipmap level %d with %x bytes data (present=%d).\n", sid, j, pMipmapLevel->cbSurface, fDataPresent));
    461461
    462462                if (fDataPresent)
     
    701701                    PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->pMipmapLevels[idx];
    702702
    703                     Log(("Surface sid=%d: save mipmap level %d with %x bytes data.\n", sid, i, pMipmapLevel->cbSurface));
     703                    Log(("Surface sid=%u: save mipmap level %d with %x bytes data.\n", sid, i, pMipmapLevel->cbSurface));
    704704
    705705                    if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
     
    769769                                        /** @todo stricter checks for associated context */
    770770                                        uint32_t cid = pSurface->idAssociatedContext;
    771                                         if (    cid >= pState->cContexts
    772                                             ||  pState->papContexts[cid]->id != cid)
    773                                         {
    774                                             Log(("vmsvga3dSaveExec invalid context id (%x - %x)!\n", cid, (cid >= pState->cContexts) ? -1 : pState->papContexts[cid]->id));
    775                                             AssertFailedReturn(VERR_INVALID_PARAMETER);
    776                                         }
    777                                         PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
     771
     772                                        PVMSVGA3DCONTEXT pContext;
     773                                        rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     774                                        AssertRCReturn(rc, rc);
    778775
    779776                                        hr = pSurface->bounce.pTexture->GetSurfaceLevel(i, &pDest);
  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win.cpp

    r82089 r82090  
    13151315        return VINF_SUCCESS;
    13161316
    1317     LogFunc(("track usage of sid=%x (cid=%d) for cid=%d, pQuery %p\n", pSurface->id, pSurface->idAssociatedContext, pContext->id, pSurface->pQuery));
     1317    LogFunc(("track usage of sid=%u (cid=%u) for cid=%u, pQuery %p\n", pSurface->id, pSurface->idAssociatedContext, pContext->id, pSurface->pQuery));
    13181318
    13191319    if (pSurface->idQueryContext == pContext->id)
     
    13571357static int vmsvga3dSurfaceTrackUsageById(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t sid)
    13581358{
    1359     Assert(sid < SVGA3D_MAX_SURFACE_IDS);
    1360     AssertReturn(sid < pState->cSurfaces, VERR_INVALID_PARAMETER);
    1361     PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
    1362     AssertReturn(pSurface && pSurface->id == sid, VERR_INVALID_PARAMETER);
     1359    PVMSVGA3DSURFACE pSurface;
     1360    int rc = vmsvga3dSurfaceFromSid(pState, sid, &pSurface);
     1361    AssertRCReturn(rc, rc);
    13631362
    13641363    return vmsvga3dSurfaceTrackUsage(pState, pContext, pSurface);
     
    13791378    Assert(pSurface->pSharedObjectTree);
    13801379
    1381     Log(("vmsvga3dSurfaceFlush: wait for draw to finish (sid=%x)\n", pSurface->id));
     1380    Log(("vmsvga3dSurfaceFlush: wait for draw to finish (sid=%u)\n", pSurface->id));
    13821381    while (true)
    13831382    {
     
    14251424            || pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
    14261425        {
    1427             LogFunc(("using texture sid=%x created for another context (%d vs %d)\n",
     1426            LogFunc(("using texture sid=%u created for another context (%d vs %d)\n",
    14281427                     pSurface->id, pSurface->idAssociatedContext, pContext->id));
    14291428
     
    14351434        else
    14361435        {
    1437             AssertMsgFailed(("surface sid=%x created for another context (%d vs %d)\n",
     1436            AssertMsgFailed(("surface sid=%u created for another context (%d vs %d)\n",
    14381437                            pSurface->id, pSurface->idAssociatedContext, pContext->id));
    14391438        }
     
    15121511        AssertRCReturn(rc, rc);
    15131512
    1514         LogFunc(("sid=%x type=%x format=%d -> create dest texture\n", sidDest, pSurfaceDest->surfaceFlags, pSurfaceDest->format));
     1513        LogFunc(("sid=%u type=%x format=%d -> create dest texture\n", sidDest, pSurfaceDest->surfaceFlags, pSurfaceDest->format));
    15151514        rc = vmsvga3dBackCreateTexture(pState, pContextSrc, cidSrc, pSurfaceDest);
    15161515        AssertRCReturn(rc, rc);
     
    15691568            RectDest.bottom = clipBox.y + clipBox.h;   /* exclusive */
    15701569
    1571             LogFunc(("StretchRect copy src sid=%x face=%d mipmap=%d (%d,%d)(%d,%d) to dest sid=%x face=%d mipmap=%d (%d,%d)\n", sidSrc, src.face, src.mipmap, RectSrc.left, RectSrc.top, RectSrc.right, RectSrc.bottom, sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
     1570            LogFunc(("StretchRect copy src sid=%u face=%d mipmap=%d (%d,%d)(%d,%d) to dest sid=%u face=%d mipmap=%d (%d,%d)\n", sidSrc, src.face, src.mipmap, RectSrc.left, RectSrc.top, RectSrc.right, RectSrc.bottom, sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
    15721571
    15731572            if (    sidSrc == sidDest
     
    17241723            RectDest.bottom = clipBox.y + clipBox.h;   /* exclusive */
    17251724
    1726             LogFunc(("(manual) copy sid=%x face=%d mipmap=%d (%d,%d)(%d,%d) to sid=%x face=%d mipmap=%d (%d,%d)\n",
     1725            LogFunc(("(manual) copy sid=%u face=%d mipmap=%d (%d,%d)(%d,%d) to sid=%u face=%d mipmap=%d (%d,%d)\n",
    17271726                     sidSrc, src.face, src.mipmap, RectSrc.left, RectSrc.top, RectSrc.right, RectSrc.bottom,
    17281727                     sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
     
    18351834    HRESULT hr;
    18361835
    1837     LogFunc(("sid=%x\n", pSurface->id));
     1836    LogFunc(("sid=%u\n", pSurface->id));
    18381837
    18391838    Assert(pSurface->hSharedObject == NULL);
     
    24012400        AssertMsgReturn(hr == D3D_OK, ("LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
    24022401
    2403         LogFunc(("Lock sid=%x %s(bounce=%d) memory for rectangle (%d,%d)(%d,%d)\n",
     2402        LogFunc(("Lock sid=%u %s(bounce=%d) memory for rectangle (%d,%d)(%d,%d)\n",
    24042403                 pSurface->id, fTexture ? "TEXTURE " : "", RT_BOOL(pSurface->bounce.pTexture),
    24052404                 Rect.left, Rect.top, Rect.right, Rect.bottom));
     
    25152514{
    25162515    PVMSVGA3DSTATE      pState = pThis->svga.p3dState;
    2517     PVMSVGA3DSURFACE    pSurface;
    2518     int                 rc = VINF_SUCCESS;
    25192516    HRESULT             hr;
    25202517
    2521     AssertReturn(pState, VERR_NO_MEMORY);
    2522     AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
    2523     AssertReturn(sid < pState->cSurfaces && pState->papSurfaces[sid]->id == sid, VERR_INVALID_PARAMETER);
    2524 
    2525     pSurface = pState->papSurfaces[sid];
     2518    PVMSVGA3DSURFACE pSurface;
     2519    int rc = vmsvga3dSurfaceFromSid(pState, sid, &pSurface);
     2520    AssertRCReturn(rc, rc);
    25262521    AssertReturn(pSurface->idAssociatedContext != SVGA3D_INVALID_ID, VERR_INTERNAL_ERROR);
    25272522
     
    25302525    pSurface->autogenFilter = filter;
    25312526
    2532     Log(("vmsvga3dGenerateMipmaps: sid=%x filter=%d\n", sid, filter));
     2527    Log(("vmsvga3dGenerateMipmaps: sid=%u filter=%d\n", sid, filter));
    25332528
    25342529    if (!pSurface->u.pSurface)
    25352530    {
    2536         PVMSVGA3DCONTEXT    pContext;
    2537         uint32_t            cid;
    2538 
    25392531        /** @todo stricter checks for associated context */
    2540         cid = pSurface->idAssociatedContext;
    2541 
    2542         if (    cid >= pState->cContexts
    2543             ||  pState->papContexts[cid]->id != cid)
    2544         {
    2545             Log(("vmsvga3dGenerateMipmaps invalid context id!\n"));
    2546             return VERR_INVALID_PARAMETER;
    2547         }
    2548         pContext = pState->papContexts[cid];
     2532        uint32_t const cid = pSurface->idAssociatedContext;
     2533
     2534        PVMSVGA3DCONTEXT pContext;
     2535        rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     2536        AssertRCReturn(rc, rc);
    25492537
    25502538        /* Unknown surface type; turn it into a texture. */
    2551         LogFunc(("unknown src surface sid=%x type=%d format=%d -> create texture\n", sid, pSurface->surfaceFlags, pSurface->format));
     2539        LogFunc(("unknown src surface sid=%u type=%d format=%d -> create texture\n", sid, pSurface->surfaceFlags, pSurface->format));
    25522540        rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
    25532541        AssertRCReturn(rc, rc);
     
    26972685                int rc;
    26982686
    2699                 LogFunc(("Remove all dependencies for surface sid=%x\n", sid));
     2687                LogFunc(("Remove all dependencies for surface sid=%u\n", sid));
    27002688
    27012689                uint32_t            surfaceFlags = pSurface->surfaceFlags;
     
    27402728                if (pSharedSurface)
    27412729                {
    2742                     LogFunc(("Remove shared dependency for surface sid=%x\n", sid));
     2730                    LogFunc(("Remove shared dependency for surface sid=%u\n", sid));
    27432731
    27442732                    switch (pSurface->enmD3DResType)
     
    28562844                    &&  pSurface->u.pSurface)
    28572845                {
    2858                     Log(("vmsvga3dChangeMode: sync back data of surface sid=%x (fDirty=%d)\n", sid, pSurface->fDirty));
     2846                    Log(("vmsvga3dChangeMode: sync back data of surface sid=%u (fDirty=%d)\n", sid, pSurface->fDirty));
    28592847
    28602848                    /* Reallocate our surface memory buffers. */
     
    30773065    D3DTRANSFORMSTATETYPE d3dState;
    30783066    HRESULT               hr;
    3079     PVMSVGA3DCONTEXT      pContext;
    30803067    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    30813068    AssertReturn(pState, VERR_NO_MEMORY);
     
    30853072    ASSERT_GUEST_RETURN((unsigned)type < SVGA3D_TRANSFORM_MAX, VERR_INVALID_PARAMETER);
    30863073
    3087     if (    cid >= pState->cContexts
    3088         ||  pState->papContexts[cid]->id != cid)
    3089     {
    3090         Log(("vmsvga3dSetTransform invalid context id!\n"));
    3091         return VERR_INVALID_PARAMETER;
    3092     }
    3093     pContext = pState->papContexts[cid];
     3074    PVMSVGA3DCONTEXT pContext;
     3075    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     3076    AssertRCReturn(rc, rc);
    30943077
    30953078    switch (type)
     
    31613144    D3DVIEWPORT9          viewport;
    31623145    HRESULT               hr;
    3163     PVMSVGA3DCONTEXT      pContext;
    31643146    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    31653147    AssertReturn(pState, VERR_NO_MEMORY);
     
    31673149    Log(("vmsvga3dSetZRange %x min=%d max=%d\n", cid, (uint32_t)(zRange.min * 100.0), (uint32_t)(zRange.max * 100.0)));
    31683150
    3169     if (    cid >= pState->cContexts
    3170         ||  pState->papContexts[cid]->id != cid)
    3171     {
    3172         Log(("vmsvga3dSetZRange invalid context id!\n"));
    3173         return VERR_INVALID_PARAMETER;
    3174     }
    3175     pContext = pState->papContexts[cid];
     3151    PVMSVGA3DCONTEXT pContext;
     3152    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     3153    AssertRCReturn(rc, rc);
     3154
    31763155    pContext->state.zRange = zRange;
    31773156    pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_ZRANGE;
     
    32373216    DWORD                       val = 0; /* Shut up MSC */
    32383217    HRESULT                     hr;
    3239     PVMSVGA3DCONTEXT            pContext;
    32403218    PVMSVGA3DSTATE              pState = pThis->svga.p3dState;
    32413219    AssertReturn(pState, VERR_NO_MEMORY);
    32423220
    3243     Log(("vmsvga3dSetRenderState cid=%x cRenderStates=%d\n", cid, cRenderStates));
    3244 
    3245     if (    cid >= pState->cContexts
    3246         ||  pState->papContexts[cid]->id != cid)
    3247     {
    3248         Log(("vmsvga3dSetRenderState invalid context id!\n"));
    3249         return VERR_INVALID_PARAMETER;
    3250     }
    3251     pContext = pState->papContexts[cid];
     3221    Log(("vmsvga3dSetRenderState cid=%u cRenderStates=%d\n", cid, cRenderStates));
     3222
     3223    PVMSVGA3DCONTEXT pContext;
     3224    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     3225    AssertRCReturn(rc, rc);
    32523226
    32533227    for (unsigned i = 0; i < cRenderStates; i++)
     
    39173891    AssertReturn((unsigned)type < SVGA3D_RT_MAX, VERR_INVALID_PARAMETER);
    39183892
    3919     LogFunc(("cid=%x type=%x sid=%x face=%u mipmap=%u\n", cid, type, target.sid, target.face, target.mipmap));
     3893    LogFunc(("cid=%u type=%x sid=%u face=%u mipmap=%u\n", cid, type, target.sid, target.face, target.mipmap));
    39203894
    39213895    PVMSVGA3DCONTEXT pContext;
     
    41274101            if (!pRenderTarget->u.pTexture)
    41284102            {
    4129                 LogFunc(("Create texture to be used as render target; sid=%x type=%d format=%d -> create texture\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
     4103                LogFunc(("Create texture to be used as render target; sid=%u type=%d format=%d -> create texture\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
    41304104                int rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pRenderTarget);
    41314105                AssertRCReturn(rc, rc);
     
    43454319    for (unsigned i = 0; i < cTextureStates; i++)
    43464320    {
    4347         LogFunc(("cid=%x stage=%d type=%s (%x) val=%x\n", cid, pTextureState[i].stage, vmsvga3dTextureStateToString(pTextureState[i].name), pTextureState[i].name, pTextureState[i].value));
     4321        LogFunc(("cid=%u stage=%d type=%s (%x) val=%x\n", cid, pTextureState[i].stage, vmsvga3dTextureStateToString(pTextureState[i].name), pTextureState[i].name, pTextureState[i].value));
    43484322
    43494323        if (pTextureState[i].name == SVGA3D_TS_BIND_TEXTURE)
     
    43554329            if (RT_UNLIKELY(idxSampler >= SVGA3D_MAX_SAMPLERS))
    43564330            {
    4357                 AssertMsgFailed(("pTextureState[%d]: SVGA3D_TS_BIND_TEXTURE idxSampler=%d, sid=%x\n", i, idxSampler, sid));
     4331                AssertMsgFailed(("pTextureState[%d]: SVGA3D_TS_BIND_TEXTURE idxSampler=%d, sid=%u\n", i, idxSampler, sid));
    43584332                continue;
    43594333            }
     
    43764350                AssertRCReturn(rc, rc);
    43774351
    4378                 LogFunc(("SVGA3D_TS_BIND_TEXTURE: bind idxSampler=%d, texture sid=%x (%d,%d)\n", idxSampler, sid, pSurface->pMipmapLevels[0].mipmapSize.width, pSurface->pMipmapLevels[0].mipmapSize.height));
     4352                LogFunc(("SVGA3D_TS_BIND_TEXTURE: bind idxSampler=%d, texture sid=%u (%d,%d)\n", idxSampler, sid, pSurface->pMipmapLevels[0].mipmapSize.width, pSurface->pMipmapLevels[0].mipmapSize.height));
    43794353
    43804354                if (!pSurface->u.pTexture)
     
    43974371                if (pSurface->idAssociatedContext != cid)
    43984372                {
    4399                     LogFunc(("Using texture sid=%x created for another context (%d vs %d)\n", sid, pSurface->idAssociatedContext, cid));
     4373                    LogFunc(("Using texture sid=%u created for another context (%d vs %d)\n", sid, pSurface->idAssociatedContext, cid));
    44004374
    44014375                    PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pState, pContext, pSurface);
     
    46244598    AssertReturn(pState, VERR_NO_MEMORY);
    46254599
    4626     LogFunc(("cid=%x face %d\n", cid, face));
     4600    LogFunc(("cid=%u face %d\n", cid, face));
    46274601
    46284602    PVMSVGA3DCONTEXT      pContext;
     
    49304904        pVertexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_NONE;
    49314905
    4932         LogFunc(("index -> vertex buffer sid=%x\n", pVertexSurface->id));
     4906        LogFunc(("index -> vertex buffer sid=%u\n", pVertexSurface->id));
    49334907    }
    49344908
     
    49364910    if (!pVertexSurface->u.pVertexBuffer)
    49374911    {
    4938         LogFunc(("Create vertex buffer sid=%x fDirty=%d\n", pVertexSurface->id, pVertexSurface->fDirty));
     4912        LogFunc(("Create vertex buffer sid=%u fDirty=%d\n", pVertexSurface->id, pVertexSurface->fDirty));
    49394913
    49404914        const DWORD Usage = D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY; /* possible severe performance penalty otherwise (according to d3d debug output */
     
    49854959        pIndexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_NONE;
    49864960
    4987         LogFunc(("vertex -> index buffer sid=%x\n", pIndexSurface->id));
     4961        LogFunc(("vertex -> index buffer sid=%u\n", pIndexSurface->id));
    49884962    }
    49894963
     
    50935067    RT_ZERO(aIndexSurfaces);
    50945068
    5095     LogFunc(("cid=%x numVertexDecls=%d numRanges=%d, cVertexDivisor=%d\n", cid, numVertexDecls, numRanges, cVertexDivisor));
     5069    LogFunc(("cid=%u numVertexDecls=%d numRanges=%d, cVertexDivisor=%d\n", cid, numVertexDecls, numRanges, cVertexDivisor));
    50965070
    50975071    AssertReturn(numVertexDecls && numVertexDecls <= SVGA3D_MAX_VERTEX_ARRAYS, VERR_INVALID_PARAMETER);
     
    51525126        AssertRCBreak(rc);
    51535127
    5154         LogFunc(("SetStreamSource vertex sid=%x stream %d min offset=%d stride=%d\n",
     5128        LogFunc(("SetStreamSource vertex sid=%u stream %d min offset=%d stride=%d\n",
    51555129                 pVertexSurface->id, iCurrentStreamId, uVertexMinOffset, strideVertex));
    51565130
     
    52425216            aIndexSurfaces[iPrimitive] = pIndexSurface;
    52435217
    5244             Log(("vmsvga3dDrawPrimitives: index sid=%x\n", sidIndex));
     5218            Log(("vmsvga3dDrawPrimitives: index sid=%u\n", sidIndex));
    52455219
    52465220            rc = vmsvga3dDrawPrimitivesSyncIndexBuffer(pContext, pIndexSurface, pRange[iPrimitive].indexWidth);
     
    53845358    HRESULT               hr;
    53855359    RECT                  rect;
    5386     PVMSVGA3DCONTEXT      pContext;
    53875360    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    53885361    AssertReturn(pState, VERR_NO_MEMORY);
     
    53905363    Log(("vmsvga3dSetScissorRect %x (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
    53915364
    5392     if (    cid >= pState->cContexts
    5393         ||  pState->papContexts[cid]->id != cid)
    5394     {
    5395         Log(("vmsvga3dSetScissorRect invalid context id!\n"));
    5396         return VERR_INVALID_PARAMETER;
    5397     }
    5398     pContext = pState->papContexts[cid];
     5365    PVMSVGA3DCONTEXT pContext;
     5366    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     5367    AssertRCReturn(rc, rc);
    53995368
    54005369    /* Store for vm state save/restore. */
     
    54175386{
    54185387    HRESULT               hr;
    5419     PVMSVGA3DCONTEXT      pContext;
    54205388    PVMSVGA3DSHADER       pShader;
    54215389    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
     
    54435411#endif
    54445412
    5445     if (    cid >= pState->cContexts
    5446         ||  pState->papContexts[cid]->id != cid)
    5447     {
    5448         Log(("vmsvga3dShaderDefine invalid context id!\n"));
    5449         return VERR_INVALID_PARAMETER;
    5450     }
    5451     pContext = pState->papContexts[cid];
     5413    PVMSVGA3DCONTEXT pContext;
     5414    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     5415    AssertRCReturn(rc, rc);
    54525416
    54535417    AssertReturn(shid < SVGA3D_MAX_SHADER_IDS, VERR_INVALID_PARAMETER);
     
    55605524int vmsvga3dShaderDestroy(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
    55615525{
    5562     PVMSVGA3DCONTEXT      pContext;
    55635526    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    55645527    AssertReturn(pState, VERR_NO_MEMORY);
     
    55675530    Log(("vmsvga3dShaderDestroy %x shid=%x type=%s\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL"));
    55685531
    5569     if (    cid >= pState->cContexts
    5570         ||  pState->papContexts[cid]->id != cid)
    5571     {
    5572         Log(("vmsvga3dShaderDestroy invalid context id!\n"));
    5573         return VERR_INVALID_PARAMETER;
    5574     }
    5575     pContext = pState->papContexts[cid];
     5532    PVMSVGA3DCONTEXT pContext;
     5533    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     5534    AssertRCReturn(rc, rc);
    55765535
    55775536    if (type == SVGA3D_SHADERTYPE_VS)
     
    56185577
    56195578    NOREF(pContext);
    5620     if (    cid >= pState->cContexts
    5621         ||  pState->papContexts[cid]->id != cid)
    5622     {
    5623         Log(("vmsvga3dShaderSet invalid context id!\n"));
    5624         return VERR_INVALID_PARAMETER;
    5625     }
    5626     pContext = pState->papContexts[cid];
     5579    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     5580    AssertRCReturn(rc, rc);
    56275581
    56285582    if (type == SVGA3D_SHADERTYPE_VS)
     
    56845638{
    56855639    HRESULT               hr;
    5686     PVMSVGA3DCONTEXT      pContext;
    56875640    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
    56885641    AssertReturn(pState, VERR_NO_MEMORY);
     
    56905643    Log(("vmsvga3dShaderSetConst %x reg=%x type=%s ctype=%x\n", cid, reg, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", ctype));
    56915644
    5692     if (    cid >= pState->cContexts
    5693         ||  pState->papContexts[cid]->id != cid)
    5694     {
    5695         Log(("vmsvga3dShaderSetConst invalid context id!\n"));
    5696         return VERR_INVALID_PARAMETER;
    5697     }
    5698     pContext = pState->papContexts[cid];
     5645    PVMSVGA3DCONTEXT pContext;
     5646    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     5647    AssertRCReturn(rc, rc);
    56995648
    57005649    for (uint32_t i = 0; i < cRegisters; i++)
  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.cpp

    r82089 r82090  
    6464    AssertReturn(pState, VERR_NO_MEMORY);
    6565
    66     Log(("vmsvga3dSurfaceDefine: sid=%x surfaceFlags=%x format=%s (%x) multiSampleCount=%d autogenFilter=%d, cMipLevels=%d size=(%d,%d,%d)\n",
     66    Log(("vmsvga3dSurfaceDefine: sid=%u surfaceFlags=%x format=%s (%x) multiSampleCount=%d autogenFilter=%d, cMipLevels=%d size=(%d,%d,%d)\n",
    6767         sid, surfaceFlags, vmsvgaLookupEnum((int)format, &g_SVGA3dSurfaceFormat2String), format, multisampleCount, autogenFilter,
    6868         cMipLevels, paMipLevelSizes->width, paMipLevelSizes->height, paMipLevelSizes->depth));
     
    342342    AssertRCReturn(rc, rc);
    343343
    344     LogFunc(("sid=%x\n", sid));
     344    LogFunc(("sid=%u\n", sid));
    345345
    346346    /* Check all contexts if this surface is used as a render target or active texture. */
     
    412412    PVMSVGA3DCONTEXT pContext;
    413413#ifdef VMSVGA3D_OPENGL
    414     LogFunc(("src sid=%x (%d,%d)(%d,%d) dest sid=%x (%d,%d)(%d,%d) mode=%x\n",
     414    LogFunc(("src sid=%u (%d,%d)(%d,%d) dest sid=%u (%d,%d)(%d,%d) mode=%x\n",
    415415         sidSrc, pSrcBox->x, pSrcBox->y, pSrcBox->x + pSrcBox->w, pSrcBox->y + pSrcBox->h,
    416416         sidDst, pDstBox->x, pDstBox->y, pDstBox->x + pDstBox->w, pDstBox->y + pDstBox->h, enmMode));
     
    418418    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    419419#else
    420     LogFunc(("src sid=%x cid=%x (%d,%d)(%d,%d) dest sid=%x cid=%x (%d,%d)(%d,%d) mode=%x\n",
     420    LogFunc(("src sid=%u cid=%u (%d,%d)(%d,%d) dest sid=%u cid=%u (%d,%d)(%d,%d) mode=%x\n",
    421421         sidSrc, pSrcSurface->idAssociatedContext, pSrcBox->x, pSrcBox->y, pSrcBox->x + pSrcBox->w, pSrcBox->y + pSrcBox->h,
    422422         sidDst, pDstSurface->idAssociatedContext, pDstBox->x, pDstBox->y, pDstBox->x + pDstBox->w, pDstBox->y + pDstBox->h, enmMode));
     
    436436    {
    437437        /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
    438         LogFunc(("unknown src sid=%x type=%d format=%d -> create texture\n", sidSrc, pSrcSurface->surfaceFlags, pSrcSurface->format));
     438        LogFunc(("unknown src sid=%u type=%d format=%d -> create texture\n", sidSrc, pSrcSurface->surfaceFlags, pSrcSurface->format));
    439439        rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pSrcSurface);
    440440        AssertRCReturn(rc, rc);
     
    444444    {
    445445        /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
    446         LogFunc(("unknown dest sid=%x type=%d format=%d -> create texture\n", sidDst, pDstSurface->surfaceFlags, pDstSurface->format));
     446        LogFunc(("unknown dest sid=%u type=%d format=%d -> create texture\n", sidDst, pDstSurface->surfaceFlags, pDstSurface->format));
    447447        rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pDstSurface);
    448448        AssertRCReturn(rc, rc);
     
    489489    AssertRCReturn(rc, rc);
    490490
    491     LogFunc(("%sguestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n",
     491    LogFunc(("%sguestptr gmr=%x offset=%x pitch=%x host sid=%u face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n",
    492492             (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE) ? "TEXTURE " : "",
    493493             guest.ptr.gmrId, guest.ptr.offset, guest.pitch,
     
    696696    AssertReturn(pState, VERR_NO_MEMORY);
    697697
    698     LogFunc(("cid=%x type=%d\n", cid, type));
     698    LogFunc(("cid=%u type=%d\n", cid, type));
    699699
    700700    PVMSVGA3DCONTEXT pContext;
     
    731731    AssertReturn(pState, VERR_NO_MEMORY);
    732732
    733     LogFunc(("cid=%x type=%d guestResult %d:0x%x\n", cid, type, guestResult.gmrId, guestResult.offset));
     733    LogFunc(("cid=%u type=%d guestResult %d:0x%x\n", cid, type, guestResult.gmrId, guestResult.offset));
    734734
    735735    PVMSVGA3DCONTEXT pContext;
     
    761761    AssertReturn(pState, VERR_NO_MEMORY);
    762762
    763     LogFunc(("cid=%x type=%d guestResult GMR%d:0x%x\n", cid, type, guestResult.gmrId, guestResult.offset));
     763    LogFunc(("cid=%u type=%d guestResult GMR%d:0x%x\n", cid, type, guestResult.gmrId, guestResult.offset));
    764764
    765765    PVMSVGA3DCONTEXT pContext;
     
    812812{
    813813    /* Requires SVGA_FIFO_CAP_SCREEN_OBJECT support */
    814     LogFunc(("dest=%d (%d,%d)(%d,%d) sid=%x (face=%d, mipmap=%d) (%d,%d)(%d,%d) cRects=%d\n",
     814    LogFunc(("dest=%d (%d,%d)(%d,%d) sid=%u (face=%d, mipmap=%d) (%d,%d)(%d,%d) cRects=%d\n",
    815815             idDstScreen, destRect.left, destRect.top, destRect.right, destRect.bottom, src.sid, src.face, src.mipmap,
    816816             srcRect.left, srcRect.top, srcRect.right, srcRect.bottom, cRects));
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