static DECLCALLBACK(int) svcSaveState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM)
{
#ifndef UNIT_TEST
/* If there are any pending requests, they must be completed here. Since
* the service is single threaded, there could be only requests
* which the service itself has postponed.
*
* HGCM knows that the state is being saved and that the pfnComplete
* calls are just clean ups. These requests are saved by the VMMDev.
*
* When the state will be restored, these requests will be reissued
* by VMMDev. The service therefore must save state as if there were no
* pending request.
*/
LogRel2 (("svcSaveState: u32ClientID = %d\n", u32ClientID));
VBOXCLIPBOARDCLIENTDATA *pClient = (VBOXCLIPBOARDCLIENTDATA *)pvClient;
/* This field used to be the length. We're using it as a version field
with the high bit set. */
SSMR3PutU32 (pSSM, UINT32_C (0x80000002));
int rc = SSMR3PutStructEx (pSSM, pClient, sizeof(*pClient), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);
AssertRCReturn (rc, rc);
if (pClient->fAsync)
{
g_pHelpers->pfnCallComplete (pClient->async.callHandle, VINF_SUCCESS /* error code is not important here. */);
pClient->fAsync = false;
}
vboxSvcClipboardCompleteReadData (pClient, VINF_SUCCESS, 0);
#endif /* !UNIT_TEST */
return VINF_SUCCESS;
}
static DECLCALLBACK(int) svcSaveState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM)
{
#ifndef UNIT_TEST
/*
* When the state will be restored, pending requests will be reissued
* by VMMDev. The service therefore must save state as if there were no
* pending request.
* Pending requests, if any, will be completed in svcDisconnect.
*/
LogRel2 (("svcSaveState: u32ClientID = %d\n", u32ClientID));
VBOXCLIPBOARDCLIENTDATA *pClient = (VBOXCLIPBOARDCLIENTDATA *)pvClient;
/* This field used to be the length. We're using it as a version field
with the high bit set. */
SSMR3PutU32 (pSSM, UINT32_C (0x80000002));
int rc = SSMR3PutStructEx (pSSM, pClient, sizeof(*pClient), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);
AssertRCReturn (rc, rc);
#endif /* !UNIT_TEST */
return VINF_SUCCESS;
}
int vmsvga3dSaveExec(PVGASTATE pThis, PSSMHANDLE pSSM)
{
PVMSVGA3DSTATE pState = pThis->svga.p3dState;
AssertReturn(pState, VERR_NO_MEMORY);
int rc;
/* Save a copy of the generic 3d state first. */
rc = SSMR3PutStructEx(pSSM, pState, sizeof(*pState), 0, g_aVMSVGA3DSTATEFields, NULL);
AssertRCReturn(rc, rc);
#ifdef VMSVGA3D_OPENGL
/* Save the shared context. */
if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
{
rc = vmsvga3dSaveContext(pThis, pSSM, &pState->SharedCtx);
AssertRCReturn(rc, rc);
}
#endif
/* Save all active contexts. */
for (uint32_t i = 0; i < pState->cContexts; i++)
{
rc = vmsvga3dSaveContext(pThis, pSSM, pState->papContexts[i]);
AssertRCReturn(rc, rc);
}
/* Save all active surfaces. */
for (uint32_t sid = 0; sid < pState->cSurfaces; sid++)
{
PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
/* Save the id first. */
rc = SSMR3PutU32(pSSM, pSurface->id);
AssertRCReturn(rc, rc);
if (pSurface->id != SVGA3D_INVALID_ID)
{
/* Save a copy of the surface structure first. */
rc = SSMR3PutStructEx(pSSM, pSurface, sizeof(*pSurface), 0, g_aVMSVGA3DSURFACEFields, NULL);
AssertRCReturn(rc, rc);
/* Save the mip map level info. */
for (uint32_t face=0; face < pSurface->cFaces; face++)
{
for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
{
uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->pMipmapLevels[idx];
/* Save a copy of the mip map level struct. */
rc = SSMR3PutStructEx(pSSM, pMipmapLevel, sizeof(*pMipmapLevel), 0, g_aVMSVGA3DMIPMAPLEVELFields, NULL);
AssertRCReturn(rc, rc);
}
}
/* Save the mip map level data. */
for (uint32_t face=0; face < pSurface->cFaces; face++)
{
for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
{
uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->pMipmapLevels[idx];
Log(("Surface sid=%d: save mipmap level %d with %x bytes data.\n", sid, i, pMipmapLevel->cbSurface));
if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
{
if (pMipmapLevel->fDirty)
{
/* Data follows */
rc = SSMR3PutBool(pSSM, true);
AssertRCReturn(rc, rc);
Assert(pMipmapLevel->cbSurface);
rc = SSMR3PutMem(pSSM, pMipmapLevel->pSurfaceData, pMipmapLevel->cbSurface);
AssertRCReturn(rc, rc);
}
else
{
/* No data follows */
rc = SSMR3PutBool(pSSM, false);
AssertRCReturn(rc, rc);
}
}
else
{
#ifdef VMSVGA3D_DIRECT3D
void *pData;
bool fRenderTargetTexture = false;
bool fTexture = false;
bool fSkipSave = false;
HRESULT hr;
Assert(pMipmapLevel->cbSurface);
pData = RTMemAllocZ(pMipmapLevel->cbSurface);
AssertReturn(pData, VERR_NO_MEMORY);
switch (pSurface->enmD3DResType)
{
case VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE:
case VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE:
AssertFailed(); /// @todo
fSkipSave = true;
break;
case VMSVGA3D_D3DRESTYPE_SURFACE:
case VMSVGA3D_D3DRESTYPE_TEXTURE:
{
if (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
{
/** @todo unable to easily fetch depth surface data in d3d 9 */
fSkipSave = true;
break;
}
fTexture = (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE);
fRenderTargetTexture = fTexture && (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_RENDERTARGET);
D3DLOCKED_RECT LockedRect;
if (fTexture)
{
if (pSurface->bounce.pTexture)
{
if ( !pSurface->fDirty
&& fRenderTargetTexture
&& i == 0 /* only the first time */)
{
IDirect3DSurface9 *pSrc, *pDest;
/** @todo stricter checks for associated context */
uint32_t cid = pSurface->idAssociatedContext;
if ( cid >= pState->cContexts
|| pState->papContexts[cid]->id != cid)
{
Log(("vmsvga3dSaveExec invalid context id (%x - %x)!\n", cid, (cid >= pState->cContexts) ? -1 : pState->papContexts[cid]->id));
AssertFailedReturn(VERR_INVALID_PARAMETER);
}
PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
hr = pSurface->bounce.pTexture->GetSurfaceLevel(i, &pDest);
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
hr = pSurface->u.pTexture->GetSurfaceLevel(i, &pSrc);
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
hr = pContext->pDevice->GetRenderTargetData(pSrc, pDest);
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
pSrc->Release();
pDest->Release();
}
hr = pSurface->bounce.pTexture->LockRect(i, /* texture level */
&LockedRect,
NULL,
D3DLOCK_READONLY);
}
else
hr = pSurface->u.pTexture->LockRect(i, /* texture level */
&LockedRect,
NULL,
D3DLOCK_READONLY);
}
else
hr = pSurface->u.pSurface->LockRect(&LockedRect,
NULL,
D3DLOCK_READONLY);
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
/* Copy the data one line at a time in case the internal pitch is different. */
for (uint32_t j = 0; j < pMipmapLevel->cBlocksY; ++j)
{
uint8_t *pu8Dst = (uint8_t *)pData + j * pMipmapLevel->cbSurfacePitch;
const uint8_t *pu8Src = (uint8_t *)LockedRect.pBits + j * LockedRect.Pitch;
memcpy(pu8Dst, pu8Src, pMipmapLevel->cbSurfacePitch);
}
if (fTexture)
{
if (pSurface->bounce.pTexture)
{
hr = pSurface->bounce.pTexture->UnlockRect(i);
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
}
else
hr = pSurface->u.pTexture->UnlockRect(i);
}
else
hr = pSurface->u.pSurface->UnlockRect();
AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
break;
}
case VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER:
case VMSVGA3D_D3DRESTYPE_INDEX_BUFFER:
{
/* Current type of the buffer. */
const bool fVertex = (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER);
uint8_t *pD3DData;
if (fVertex)
hr = pSurface->u.pVertexBuffer->Lock(0, 0, (void **)&pD3DData, D3DLOCK_READONLY);
else
hr = pSurface->u.pIndexBuffer->Lock(0, 0, (void **)&pD3DData, D3DLOCK_READONLY);
AssertMsg(hr == D3D_OK, ("vmsvga3dSaveExec: Lock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));
memcpy(pData, pD3DData, pMipmapLevel->cbSurface);
if (fVertex)
hr = pSurface->u.pVertexBuffer->Unlock();
else
hr = pSurface->u.pIndexBuffer->Unlock();
AssertMsg(hr == D3D_OK, ("vmsvga3dSaveExec: Unlock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));
break;
}
default:
AssertFailed();
break;
}
if (!fSkipSave)
{
/* Data follows */
rc = SSMR3PutBool(pSSM, true);
AssertRCReturn(rc, rc);
/* And write the surface data. */
rc = SSMR3PutMem(pSSM, pData, pMipmapLevel->cbSurface);
AssertRCReturn(rc, rc);
}
else
{
/* No data follows */
rc = SSMR3PutBool(pSSM, false);
AssertRCReturn(rc, rc);
}
RTMemFree(pData);
#elif defined(VMSVGA3D_OPENGL)
void *pData = NULL;
PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
Assert(pMipmapLevel->cbSurface);
switch (pSurface->enmOGLResType)
{
default:
AssertFailed();
RT_FALL_THRU();
case VMSVGA3D_OGLRESTYPE_RENDERBUFFER:
/** @todo fetch data from the renderbuffer. Not used currently. */
/* No data follows */
rc = SSMR3PutBool(pSSM, false);
AssertRCReturn(rc, rc);
break;
case VMSVGA3D_OGLRESTYPE_TEXTURE:
{
GLint activeTexture;
pData = RTMemAllocZ(pMipmapLevel->cbSurface);
AssertReturn(pData, VERR_NO_MEMORY);
glGetIntegerv(GL_TEXTURE_BINDING_2D, &activeTexture);
VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
glBindTexture(GL_TEXTURE_2D, pSurface->oglId.texture);
VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
/* Set row length and alignment of the output data. */
VMSVGAPACKPARAMS SavedParams;
vmsvga3dOglSetPackParams(pState, pContext, pSurface, &SavedParams);
glGetTexImage(GL_TEXTURE_2D,
i,
pSurface->formatGL,
pSurface->typeGL,
pData);
VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
vmsvga3dOglRestorePackParams(pState, pContext, pSurface, &SavedParams);
/* Data follows */
rc = SSMR3PutBool(pSSM, true);
AssertRCReturn(rc, rc);
/* And write the surface data. */
rc = SSMR3PutMem(pSSM, pData, pMipmapLevel->cbSurface);
AssertRCReturn(rc, rc);
/* Restore the old active texture. */
glBindTexture(GL_TEXTURE_2D, activeTexture);
VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
break;
}
case VMSVGA3D_OGLRESTYPE_BUFFER:
{
uint8_t *pBufferData;
pState->ext.glBindBuffer(GL_ARRAY_BUFFER, pSurface->oglId.buffer);
VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
pBufferData = (uint8_t *)pState->ext.glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
Assert(pBufferData);
/* Data follows */
rc = SSMR3PutBool(pSSM, true);
AssertRCReturn(rc, rc);
/* And write the surface data. */
rc = SSMR3PutMem(pSSM, pBufferData, pMipmapLevel->cbSurface);
AssertRCReturn(rc, rc);
pState->ext.glUnmapBuffer(GL_ARRAY_BUFFER);
VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
pState->ext.glBindBuffer(GL_ARRAY_BUFFER, 0);
VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
}
}
if (pData)
RTMemFree(pData);
#else
#error "Unexpected 3d backend"
#endif
}
}
}
}
}
return VINF_SUCCESS;
}
static int vmsvga3dSaveContext(PVGASTATE pThis, PSSMHANDLE pSSM, PVMSVGA3DCONTEXT pContext)
{
PVMSVGA3DSTATE pState = pThis->svga.p3dState;
uint32_t cid = pContext->id;
/* Save the id first. */
int rc = SSMR3PutU32(pSSM, cid);
AssertRCReturn(rc, rc);
if (cid != SVGA3D_INVALID_ID)
{
/* Save a copy of the context structure first. */
rc = SSMR3PutStructEx(pSSM, pContext, sizeof(*pContext), 0, g_aVMSVGA3DCONTEXTFields, NULL);
AssertRCReturn(rc, rc);
/* Save all pixel shaders. */
for (uint32_t j = 0; j < pContext->cPixelShaders; j++)
{
PVMSVGA3DSHADER pShader = &pContext->paPixelShader[j];
/* Save the id first. */
rc = SSMR3PutU32(pSSM, pShader->id);
AssertRCReturn(rc, rc);
if (pShader->id != SVGA3D_INVALID_ID)
{
uint32_t cbData = pShader->cbData;
/* Save a copy of the shader struct. */
rc = SSMR3PutStructEx(pSSM, pShader, sizeof(*pShader), 0, g_aVMSVGA3DSHADERFields, NULL);
AssertRCReturn(rc, rc);
Log(("Save pixelshader shid=%d with %x bytes code.\n", pShader->id, cbData));
rc = SSMR3PutMem(pSSM, pShader->pShaderProgram, cbData);
AssertRCReturn(rc, rc);
}
}
/* Save all vertex shaders. */
for (uint32_t j = 0; j < pContext->cVertexShaders; j++)
{
PVMSVGA3DSHADER pShader = &pContext->paVertexShader[j];
/* Save the id first. */
rc = SSMR3PutU32(pSSM, pShader->id);
AssertRCReturn(rc, rc);
if (pShader->id != SVGA3D_INVALID_ID)
{
uint32_t cbData = pShader->cbData;
/* Save a copy of the shader struct. */
rc = SSMR3PutStructEx(pSSM, pShader, sizeof(*pShader), 0, g_aVMSVGA3DSHADERFields, NULL);
AssertRCReturn(rc, rc);
Log(("Save vertex shader shid=%d with %x bytes code.\n", pShader->id, cbData));
/* Fetch the shader code and save it. */
rc = SSMR3PutMem(pSSM, pShader->pShaderProgram, cbData);
AssertRCReturn(rc, rc);
}
}
/* Save pixel shader constants. */
for (uint32_t j = 0; j < pContext->state.cPixelShaderConst; j++)
{
rc = SSMR3PutStructEx(pSSM, &pContext->state.paPixelShaderConst[j], sizeof(pContext->state.paPixelShaderConst[j]), 0, g_aVMSVGASHADERCONSTFields, NULL);
AssertRCReturn(rc, rc);
}
/* Save vertex shader constants. */
for (uint32_t j = 0; j < pContext->state.cVertexShaderConst; j++)
{
rc = SSMR3PutStructEx(pSSM, &pContext->state.paVertexShaderConst[j], sizeof(pContext->state.paVertexShaderConst[j]), 0, g_aVMSVGASHADERCONSTFields, NULL);
AssertRCReturn(rc, rc);
}
/* Save texture stage and samplers state. */
/* Number of stages/samplers. */
rc = SSMR3PutU32(pSSM, RT_ELEMENTS(pContext->state.aTextureStates));
AssertRCReturn(rc, rc);
/* Number of texture states. */
rc = SSMR3PutU32(pSSM, RT_ELEMENTS(pContext->state.aTextureStates[0]));
AssertRCReturn(rc, rc);
for (uint32_t iStage = 0; iStage < RT_ELEMENTS(pContext->state.aTextureStates); ++iStage)
{
for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aTextureStates[0]); ++j)
{
SVGA3dTextureState *pTextureState = &pContext->state.aTextureStates[iStage][j];
SSMR3PutU32(pSSM, pTextureState->stage);
SSMR3PutU32(pSSM, pTextureState->name);
rc = SSMR3PutU32(pSSM, pTextureState->value);
AssertRCReturn(rc, rc);
}
}
/* Occlusion query. */
if (!VMSVGA3DQUERY_EXISTS(&pContext->occlusion))
{
pContext->occlusion.enmQueryState = VMSVGA3DQUERYSTATE_NULL;
}
switch (pContext->occlusion.enmQueryState)
{
case VMSVGA3DQUERYSTATE_BUILDING:
/* Stop collecting data. Fetch partial result. Save result. */
vmsvga3dOcclusionQueryEnd(pState, pContext);
RT_FALL_THRU();
case VMSVGA3DQUERYSTATE_ISSUED:
/* Fetch result. Save result. */
pContext->occlusion.u32QueryResult = 0;
vmsvga3dOcclusionQueryGetData(pState, pContext, &pContext->occlusion.u32QueryResult);
RT_FALL_THRU();
case VMSVGA3DQUERYSTATE_SIGNALED:
/* Save result. Nothing to do here. */
break;
default:
AssertFailed();
RT_FALL_THRU();
case VMSVGA3DQUERYSTATE_NULL:
pContext->occlusion.enmQueryState = VMSVGA3DQUERYSTATE_NULL;
pContext->occlusion.u32QueryResult = 0;
break;
}
rc = SSMR3PutStructEx(pSSM, &pContext->occlusion, sizeof(pContext->occlusion), 0, g_aVMSVGA3DQUERYFields, NULL);
AssertRCReturn(rc, rc);
}
return VINF_SUCCESS;
}
static int vmsvga3dSaveContext(PVGASTATE pThis, PSSMHANDLE pSSM, PVMSVGA3DCONTEXT pContext)
{
uint32_t cid = pContext->id;
/* Save the id first. */
int rc = SSMR3PutU32(pSSM, cid);
AssertRCReturn(rc, rc);
if (cid != SVGA3D_INVALID_ID)
{
/* Save a copy of the context structure first. */
rc = SSMR3PutStructEx(pSSM, pContext, sizeof(*pContext), 0, g_aVMSVGA3DCONTEXTFields, NULL);
AssertRCReturn(rc, rc);
/* Save all pixel shaders. */
for (uint32_t j = 0; j < pContext->cPixelShaders; j++)
{
PVMSVGA3DSHADER pShader = &pContext->paPixelShader[j];
/* Save the id first. */
rc = SSMR3PutU32(pSSM, pShader->id);
AssertRCReturn(rc, rc);
if (pShader->id != SVGA3D_INVALID_ID)
{
uint32_t cbData = pShader->cbData;
/* Save a copy of the shader struct. */
rc = SSMR3PutStructEx(pSSM, pShader, sizeof(*pShader), 0, g_aVMSVGA3DSHADERFields, NULL);
AssertRCReturn(rc, rc);
Log(("Save pixelshader shid=%d with %x bytes code.\n", pShader->id, cbData));
rc = SSMR3PutMem(pSSM, pShader->pShaderProgram, cbData);
AssertRCReturn(rc, rc);
}
}
/* Save all vertex shaders. */
for (uint32_t j = 0; j < pContext->cVertexShaders; j++)
{
PVMSVGA3DSHADER pShader = &pContext->paVertexShader[j];
/* Save the id first. */
rc = SSMR3PutU32(pSSM, pShader->id);
AssertRCReturn(rc, rc);
if (pShader->id != SVGA3D_INVALID_ID)
{
uint32_t cbData = pShader->cbData;
/* Save a copy of the shader struct. */
rc = SSMR3PutStructEx(pSSM, pShader, sizeof(*pShader), 0, g_aVMSVGA3DSHADERFields, NULL);
AssertRCReturn(rc, rc);
Log(("Save vertex shader shid=%d with %x bytes code.\n", pShader->id, cbData));
/* Fetch the shader code and save it. */
rc = SSMR3PutMem(pSSM, pShader->pShaderProgram, cbData);
AssertRCReturn(rc, rc);
}
}
/* Save pixel shader constants. */
for (uint32_t j = 0; j < pContext->state.cPixelShaderConst; j++)
{
rc = SSMR3PutStructEx(pSSM, &pContext->state.paPixelShaderConst[j], sizeof(pContext->state.paPixelShaderConst[j]), 0, g_aVMSVGASHADERCONSTFields, NULL);
AssertRCReturn(rc, rc);
}
/* Save vertex shader constants. */
for (uint32_t j = 0; j < pContext->state.cVertexShaderConst; j++)
{
rc = SSMR3PutStructEx(pSSM, &pContext->state.paVertexShaderConst[j], sizeof(pContext->state.paVertexShaderConst[j]), 0, g_aVMSVGASHADERCONSTFields, NULL);
AssertRCReturn(rc, rc);
}
}
return VINF_SUCCESS;
}
