VirtualBox

source: vbox/trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.cpp@ 60404

Last change on this file since 60404 was 58551, checked in by vboxsync, 9 years ago

DevVGA-SVGA3d.cpp: Applied patch for memory leak in vmsvga3dSurfaceStretchBlt from trivirt.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 23.3 KB
Line 
1/* $Id: DevVGA-SVGA3d.cpp 58551 2015-11-03 13:12:45Z vboxsync $ */
2/** @file
3 * DevSVGA3d - VMWare SVGA device, 3D parts - Common core code.
4 */
5
6/*
7 * Copyright (C) 2013-2015 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_DEV_VMSVGA
23#include <VBox/vmm/pdmdev.h>
24#include <VBox/err.h>
25#include <VBox/log.h>
26
27#include <iprt/assert.h>
28#include <iprt/mem.h>
29
30#include <VBox/vmm/pgm.h> /* required by DevVGA.h */
31#include <VBox/VBoxVideo.h> /* required by DevVGA.h */
32
33/* should go BEFORE any other DevVGA include to make all DevVGA.h config defines be visible */
34#include "DevVGA.h"
35
36#include "DevVGA-SVGA.h"
37#include "DevVGA-SVGA3d.h"
38#define VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS
39#include "DevVGA-SVGA3d-internal.h"
40
41
42
43/**
44 * Implements the SVGA_3D_CMD_SURFACE_DEFINE_V2 and SVGA_3D_CMD_SURFACE_DEFINE
45 * commands (fifo).
46 *
47 * @returns VBox status code (currently ignored).
48 * @param pThis The VGA device instance data.
49 * @param sid The ID of the surface to (re-)define.
50 * @param surfaceFlags .
51 * @param format .
52 * @param face .
53 * @param multisampleCount .
54 * @param autogenFilter .
55 * @param cMipLevels .
56 * @param paMipLevelSizes .
57 */
58int vmsvga3dSurfaceDefine(PVGASTATE pThis, uint32_t sid, uint32_t surfaceFlags, SVGA3dSurfaceFormat format,
59 SVGA3dSurfaceFace face[SVGA3D_MAX_SURFACE_FACES], uint32_t multisampleCount,
60 SVGA3dTextureFilter autogenFilter, uint32_t cMipLevels, SVGA3dSize *paMipLevelSizes)
61{
62 PVMSVGA3DSURFACE pSurface;
63 PVMSVGA3DSTATE pState = pThis->svga.p3dState;
64 AssertReturn(pState, VERR_NO_MEMORY);
65
66 Log(("vmsvga3dSurfaceDefine: sid=%x surfaceFlags=%x format=%s (%x) multiSampleCount=%d autogenFilter=%d, cMipLevels=%d size=(%d,%d,%d)\n",
67 sid, surfaceFlags, vmsvgaLookupEnum((int)format, &g_SVGA3dSurfaceFormat2String), format, multisampleCount, autogenFilter,
68 cMipLevels, paMipLevelSizes->width, paMipLevelSizes->height, paMipLevelSizes->depth));
69
70 AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
71 AssertReturn(cMipLevels >= 1, VERR_INVALID_PARAMETER);
72 /* Assuming all faces have the same nr of mipmaps. */
73 AssertReturn(!(surfaceFlags & SVGA3D_SURFACE_CUBEMAP) || cMipLevels == face[0].numMipLevels * 6, VERR_INVALID_PARAMETER);
74 AssertReturn((surfaceFlags & SVGA3D_SURFACE_CUBEMAP) || cMipLevels == face[0].numMipLevels, VERR_INVALID_PARAMETER);
75
76 if (sid >= pState->cSurfaces)
77 {
78 /* Grow the array. */
79 uint32_t cNew = RT_ALIGN(sid + 15, 16);
80 void *pvNew = RTMemRealloc(pState->papSurfaces, sizeof(pState->papSurfaces[0]) * cNew);
81 AssertReturn(pvNew, VERR_NO_MEMORY);
82 pState->papSurfaces = (PVMSVGA3DSURFACE *)pvNew;
83 while (pState->cSurfaces < cNew)
84 {
85 pSurface = (PVMSVGA3DSURFACE)RTMemAllocZ(sizeof(*pSurface));
86 AssertReturn(pSurface, VERR_NO_MEMORY);
87 pSurface->id = SVGA3D_INVALID_ID;
88 pState->papSurfaces[pState->cSurfaces++] = pSurface;
89 }
90 }
91 pSurface = pState->papSurfaces[sid];
92
93 /* If one already exists with this id, then destroy it now. */
94 if (pSurface->id != SVGA3D_INVALID_ID)
95 vmsvga3dSurfaceDestroy(pThis, sid);
96
97 RT_ZERO(*pSurface);
98 pSurface->id = sid;
99#ifdef VMSVGA3D_OPENGL
100 pSurface->idWeakContextAssociation = SVGA3D_INVALID_ID;
101#else
102 pSurface->idAssociatedContext = SVGA3D_INVALID_ID;
103#endif
104#ifdef VMSVGA3D_DIRECT3D
105 pSurface->hSharedObject = NULL;
106 pSurface->pSharedObjectTree = NULL;
107#else
108 pSurface->oglId.buffer = OPENGL_INVALID_ID;
109#endif
110
111 /* The surface type is sort of undefined now, even though the hints and format can help to clear that up.
112 * In some case we'll have to wait until the surface is used to create the D3D object.
113 */
114 switch (format)
115 {
116 case SVGA3D_Z_D32:
117 case SVGA3D_Z_D16:
118 case SVGA3D_Z_D24S8:
119 case SVGA3D_Z_D15S1:
120 case SVGA3D_Z_D24X8:
121 case SVGA3D_Z_DF16:
122 case SVGA3D_Z_DF24:
123 case SVGA3D_Z_D24S8_INT:
124 surfaceFlags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
125 break;
126
127 /* Texture compression formats */
128 case SVGA3D_DXT1:
129 case SVGA3D_DXT2:
130 case SVGA3D_DXT3:
131 case SVGA3D_DXT4:
132 case SVGA3D_DXT5:
133 /* Bump-map formats */
134 case SVGA3D_BUMPU8V8:
135 case SVGA3D_BUMPL6V5U5:
136 case SVGA3D_BUMPX8L8V8U8:
137 case SVGA3D_BUMPL8V8U8:
138 case SVGA3D_V8U8:
139 case SVGA3D_Q8W8V8U8:
140 case SVGA3D_CxV8U8:
141 case SVGA3D_X8L8V8U8:
142 case SVGA3D_A2W10V10U10:
143 case SVGA3D_V16U16:
144 /* Typical render target formats; we should allow render target buffers to be used as textures. */
145 case SVGA3D_X8R8G8B8:
146 case SVGA3D_A8R8G8B8:
147 case SVGA3D_R5G6B5:
148 case SVGA3D_X1R5G5B5:
149 case SVGA3D_A1R5G5B5:
150 case SVGA3D_A4R4G4B4:
151 surfaceFlags |= SVGA3D_SURFACE_HINT_TEXTURE;
152 break;
153
154 case SVGA3D_LUMINANCE8:
155 case SVGA3D_LUMINANCE4_ALPHA4:
156 case SVGA3D_LUMINANCE16:
157 case SVGA3D_LUMINANCE8_ALPHA8:
158 case SVGA3D_ARGB_S10E5: /* 16-bit floating-point ARGB */
159 case SVGA3D_ARGB_S23E8: /* 32-bit floating-point ARGB */
160 case SVGA3D_A2R10G10B10:
161 case SVGA3D_ALPHA8:
162 case SVGA3D_R_S10E5:
163 case SVGA3D_R_S23E8:
164 case SVGA3D_RG_S10E5:
165 case SVGA3D_RG_S23E8:
166 case SVGA3D_G16R16:
167 case SVGA3D_A16B16G16R16:
168 case SVGA3D_UYVY:
169 case SVGA3D_YUY2:
170 case SVGA3D_NV12:
171 case SVGA3D_AYUV:
172 case SVGA3D_BC4_UNORM:
173 case SVGA3D_BC5_UNORM:
174 break;
175
176 /*
177 * Any surface can be used as a buffer object, but SVGA3D_BUFFER is
178 * the most efficient format to use when creating new surfaces
179 * expressly for index or vertex data.
180 */
181 case SVGA3D_BUFFER:
182 break;
183
184 default:
185 break;
186 }
187
188 pSurface->flags = surfaceFlags;
189 pSurface->format = format;
190 memcpy(pSurface->faces, face, sizeof(pSurface->faces));
191 pSurface->cFaces = 1; /* check for cube maps later */
192 pSurface->multiSampleCount = multisampleCount;
193 pSurface->autogenFilter = autogenFilter;
194 Assert(autogenFilter != SVGA3D_TEX_FILTER_FLATCUBIC);
195 Assert(autogenFilter != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
196 pSurface->pMipmapLevels = (PVMSVGA3DMIPMAPLEVEL)RTMemAllocZ(cMipLevels * sizeof(VMSVGA3DMIPMAPLEVEL));
197 AssertReturn(pSurface->pMipmapLevels, VERR_NO_MEMORY);
198
199 for (uint32_t i=0; i < cMipLevels; i++)
200 pSurface->pMipmapLevels[i].size = paMipLevelSizes[i];
201
202 pSurface->cbBlock = vmsvga3dSurfaceFormatSize(format);
203
204#ifdef VMSVGA3D_DIRECT3D
205 /* Translate the format and usage flags to D3D. */
206 pSurface->formatD3D = vmsvga3dSurfaceFormat2D3D(format);
207 pSurface->multiSampleTypeD3D= vmsvga3dMultipeSampleCount2D3D(multisampleCount);
208 pSurface->fUsageD3D = 0;
209 if (surfaceFlags & SVGA3D_SURFACE_HINT_DYNAMIC)
210 pSurface->fUsageD3D |= D3DUSAGE_DYNAMIC;
211 if (surfaceFlags & SVGA3D_SURFACE_HINT_RENDERTARGET)
212 pSurface->fUsageD3D |= D3DUSAGE_RENDERTARGET;
213 if (surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
214 pSurface->fUsageD3D |= D3DUSAGE_DEPTHSTENCIL;
215 if (surfaceFlags & SVGA3D_SURFACE_HINT_WRITEONLY)
216 pSurface->fUsageD3D |= D3DUSAGE_WRITEONLY;
217 if (surfaceFlags & SVGA3D_SURFACE_AUTOGENMIPMAPS)
218 pSurface->fUsageD3D |= D3DUSAGE_AUTOGENMIPMAP;
219#else
220 vmsvga3dSurfaceFormat2OGL(pSurface, format);
221#endif
222
223 switch (surfaceFlags & (SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))
224 {
225 case SVGA3D_SURFACE_CUBEMAP:
226 Log(("SVGA3D_SURFACE_CUBEMAP\n"));
227 pSurface->cFaces = 6;
228 break;
229
230 case SVGA3D_SURFACE_HINT_INDEXBUFFER:
231 Log(("SVGA3D_SURFACE_HINT_INDEXBUFFER\n"));
232 /* else type unknown at this time; postpone buffer creation */
233 break;
234
235 case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
236 Log(("SVGA3D_SURFACE_HINT_VERTEXBUFFER\n"));
237 /* Type unknown at this time; postpone buffer creation */
238 break;
239
240 case SVGA3D_SURFACE_HINT_TEXTURE:
241 Log(("SVGA3D_SURFACE_HINT_TEXTURE\n"));
242 break;
243
244 case SVGA3D_SURFACE_HINT_RENDERTARGET:
245 Log(("SVGA3D_SURFACE_HINT_RENDERTARGET\n"));
246 break;
247
248 case SVGA3D_SURFACE_HINT_DEPTHSTENCIL:
249 Log(("SVGA3D_SURFACE_HINT_DEPTHSTENCIL\n"));
250 break;
251
252 default:
253 /* Unknown; decide later. */
254 break;
255 }
256
257 Assert(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface));
258
259 /* Allocate buffer to hold the surface data until we can move it into a D3D object */
260 for (uint32_t iFace=0; iFace < pSurface->cFaces; iFace++)
261 {
262 for (uint32_t i=0; i < pSurface->faces[iFace].numMipLevels; i++)
263 {
264 uint32_t idx = i + iFace * pSurface->faces[0].numMipLevels;
265
266 Log(("vmsvga3dSurfaceDefine: face %d mip level %d (%d,%d,%d)\n", iFace, i, pSurface->pMipmapLevels[idx].size.width, pSurface->pMipmapLevels[idx].size.height, pSurface->pMipmapLevels[idx].size.depth));
267 Log(("vmsvga3dSurfaceDefine: cbPitch=%x cbBlock=%x \n", pSurface->cbBlock * pSurface->pMipmapLevels[idx].size.width, pSurface->cbBlock));
268
269 pSurface->pMipmapLevels[idx].cbSurfacePitch = pSurface->cbBlock * pSurface->pMipmapLevels[idx].size.width;
270 pSurface->pMipmapLevels[idx].cbSurface = pSurface->pMipmapLevels[idx].cbSurfacePitch * pSurface->pMipmapLevels[idx].size.height * pSurface->pMipmapLevels[idx].size.depth;
271 pSurface->pMipmapLevels[idx].pSurfaceData = RTMemAllocZ(pSurface->pMipmapLevels[idx].cbSurface);
272 AssertReturn(pSurface->pMipmapLevels[idx].pSurfaceData, VERR_NO_MEMORY);
273 }
274 }
275 return VINF_SUCCESS;
276}
277
278
279/**
280 * Implements the SVGA_3D_CMD_SURFACE_DESTROY command (fifo).
281 *
282 * @returns VBox status code (currently ignored).
283 * @param pThis The VGA device instance data.
284 * @param sid The ID of the surface to destroy.
285 */
286int vmsvga3dSurfaceDestroy(PVGASTATE pThis, uint32_t sid)
287{
288 PVMSVGA3DSTATE pState = pThis->svga.p3dState;
289 AssertReturn(pState, VERR_NO_MEMORY);
290
291 if ( sid < pState->cSurfaces
292 && pState->papSurfaces[sid]->id == sid)
293 {
294 PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
295
296 Log(("vmsvga3dSurfaceDestroy id %x\n", sid));
297
298 /* Check all contexts if this surface is used as a render target or active texture. */
299 for (uint32_t cid = 0; cid < pState->cContexts; cid++)
300 {
301 PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
302 if (pContext->id == cid)
303 {
304 for (uint32_t i = 0; i < RT_ELEMENTS(pContext->aSidActiveTexture); i++)
305 if (pContext->aSidActiveTexture[i] == sid)
306 pContext->aSidActiveTexture[i] = SVGA3D_INVALID_ID;
307 if (pContext->sidRenderTarget == sid)
308 pContext->sidRenderTarget = SVGA3D_INVALID_ID;
309 }
310 }
311
312 vmsvga3dBackSurfaceDestroy(pState, pSurface);
313
314 if (pSurface->pMipmapLevels)
315 {
316 for (uint32_t face=0; face < pSurface->cFaces; face++)
317 {
318 for (uint32_t i=0; i < pSurface->faces[face].numMipLevels; i++)
319 {
320 uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
321 if (pSurface->pMipmapLevels[idx].pSurfaceData)
322 RTMemFree(pSurface->pMipmapLevels[idx].pSurfaceData);
323 }
324 }
325 RTMemFree(pSurface->pMipmapLevels);
326 }
327
328 memset(pSurface, 0, sizeof(*pSurface));
329 pSurface->id = SVGA3D_INVALID_ID;
330 }
331 else
332 AssertFailedReturn(VERR_INVALID_PARAMETER);
333
334 return VINF_SUCCESS;
335}
336
337
338/**
339 * Implements the SVGA_3D_CMD_SURFACE_STRETCHBLT command (fifo).
340 *
341 * @returns VBox status code (currently ignored).
342 * @param pThis The VGA device instance data.
343 * @param sid The ID of the surface to destroy.
344 */
345int vmsvga3dSurfaceStretchBlt(PVGASTATE pThis, SVGA3dSurfaceImageId const *pDstSfcImg, SVGA3dBox const *pDstBox,
346 SVGA3dSurfaceImageId const *pSrcSfcImg, SVGA3dBox const *pSrcBox, SVGA3dStretchBltMode enmMode)
347{
348 PVMSVGA3DSTATE pState = pThis->svga.p3dState;
349
350 AssertReturn(pState, VERR_NO_MEMORY);
351
352 uint32_t const sidSrc = pSrcSfcImg->sid;
353 Assert(sidSrc < SVGA3D_MAX_SURFACE_IDS);
354 AssertReturn(sidSrc < pState->cSurfaces, VERR_INVALID_PARAMETER);
355 PVMSVGA3DSURFACE pSrcSurface = pState->papSurfaces[sidSrc];
356 AssertReturn(pSrcSurface && pSrcSurface->id == sidSrc, VERR_INVALID_PARAMETER);
357
358 uint32_t const sidDst = pDstSfcImg->sid;
359 Assert(sidDst < SVGA3D_MAX_SURFACE_IDS);
360 AssertReturn(sidDst < pState->cSurfaces, VERR_INVALID_PARAMETER);
361 PVMSVGA3DSURFACE pDstSurface = pState->papSurfaces[sidDst];
362 AssertReturn(pDstSurface && pDstSurface->id == sidDst, VERR_INVALID_PARAMETER);
363
364 Assert(pSrcSfcImg->face == 0);
365 AssertReturn(pSrcSfcImg->mipmap < pSrcSurface->faces[0].numMipLevels, VERR_INVALID_PARAMETER);
366 Assert(pDstSfcImg->face == 0);
367 AssertReturn(pDstSfcImg->mipmap < pDstSurface->faces[0].numMipLevels, VERR_INVALID_PARAMETER);
368
369 PVMSVGA3DCONTEXT pContext;
370#ifdef VMSVGA3D_OPENGL
371 Log(("vmsvga3dSurfaceStretchBlt: src sid=%x (%d,%d)(%d,%d) dest sid=%x (%d,%d)(%d,%d) mode=%x\n",
372 sidSrc, pSrcBox->x, pSrcBox->y, pSrcBox->x + pSrcBox->w, pSrcBox->y + pSrcBox->h,
373 sidDst, pDstBox->x, pDstBox->y, pDstBox->x + pDstBox->w, pDstBox->y + pDstBox->h, enmMode));
374 pContext = &pState->SharedCtx;
375 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
376#else
377 Log(("vmsvga3dSurfaceStretchBlt: src sid=%x cid=%x (%d,%d)(%d,%d) dest sid=%x cid=%x (%d,%d)(%d,%d) mode=%x\n",
378 sidSrc, pSrcSurface->idAssociatedContext, pSrcBox->x, pSrcBox->y, pSrcBox->x + pSrcBox->w, pSrcBox->y + pSrcBox->h,
379 sidDst, pDstSurface->idAssociatedContext, pDstBox->x, pDstBox->y, pDstBox->x + pDstBox->w, pDstBox->y + pDstBox->h, enmMode));
380
381 /** @todo stricter checks for associated context */
382 uint32_t cid = pDstSurface->idAssociatedContext;
383 if (cid == SVGA3D_INVALID_ID)
384 cid = pSrcSurface->idAssociatedContext;
385
386 if ( cid >= pState->cContexts
387 || pState->papContexts[cid]->id != cid)
388 {
389 Log(("vmsvga3dSurfaceStretchBlt invalid context id!\n"));
390 AssertFailedReturn(VERR_INVALID_PARAMETER);
391 }
392 pContext = pState->papContexts[cid];
393#endif
394
395 int rc;
396 if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSrcSurface))
397 {
398 /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
399 Log(("vmsvga3dSurfaceStretchBlt: unknown src surface id=%x type=%d format=%d -> create texture\n", sidSrc, pSrcSurface->flags, pSrcSurface->format));
400 rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pSrcSurface);
401 AssertRCReturn(rc, rc);
402 }
403
404 if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pDstSurface))
405 {
406 /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
407 Log(("vmsvga3dSurfaceStretchBlt: unknown dest surface id=%x type=%d format=%d -> create texture\n", sidDst, pDstSurface->flags, pDstSurface->format));
408 rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pDstSurface);
409 AssertRCReturn(rc, rc);
410 }
411
412 return vmsvga3dBackSurfaceStretchBlt(pThis, pState,
413 pDstSurface, pDstSfcImg->mipmap, pDstBox,
414 pSrcSurface, pSrcSfcImg->mipmap, pSrcBox,
415 enmMode, pContext);
416}
417
418
419
420/**
421 * Implements the SVGA_3D_CMD_SURFACE_DMA command (fifo).
422 *
423 * @returns VBox status code (currently ignored).
424 * @param pThis The VGA device instance data.
425 * @param guest .
426 * @param host .
427 * @param transfer .
428 * @param cCopyBoxes .
429 * @param paBoxes .
430 */
431int vmsvga3dSurfaceDMA(PVGASTATE pThis, SVGA3dGuestImage guest, SVGA3dSurfaceImageId host, SVGA3dTransferType transfer,
432 uint32_t cCopyBoxes, SVGA3dCopyBox *paBoxes)
433{
434 int rc = VINF_SUCCESS;
435
436 PVMSVGA3DSTATE pState = pThis->svga.p3dState;
437 AssertReturn(pState, VERR_NO_MEMORY);
438
439 uint32_t sid = host.sid;
440 Assert(sid < SVGA3D_MAX_SURFACE_IDS);
441 AssertReturn(sid < pState->cSurfaces, VERR_INVALID_PARAMETER);
442 PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
443 AssertReturn(pSurface && pSurface->id == sid, VERR_INVALID_PARAMETER);
444
445 AssertMsg(host.face == 0, ("host.face=%#x\n", host.face));
446 AssertReturn(pSurface->faces[0].numMipLevels > host.mipmap, VERR_INVALID_PARAMETER);
447 PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->pMipmapLevels[host.mipmap];
448
449 if (pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE)
450 Log(("vmsvga3dSurfaceDMA TEXTURE guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", cCopyBoxes));
451 else
452 Log(("vmsvga3dSurfaceDMA guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", cCopyBoxes));
453
454 if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
455 {
456 /*
457 * Not realized in host hardware/library yet, we have to work with
458 * the copy of the data we've got in VMSVGA3DMIMAPLEVEL::pvSurfaceData.
459 */
460 AssertReturn(pSurface->pMipmapLevels[host.mipmap].pSurfaceData, VERR_INTERNAL_ERROR);
461
462 for (unsigned i = 0; i < cCopyBoxes; i++)
463 {
464 unsigned uDestOffset;
465 unsigned cbSrcPitch;
466 uint8_t *pBufferStart;
467
468 Log(("Copy box %d (%d,%d,%d)(%d,%d,%d) dest (%d,%d)\n", i, paBoxes[i].srcx, paBoxes[i].srcy, paBoxes[i].srcz, paBoxes[i].w, paBoxes[i].h, paBoxes[i].d, paBoxes[i].x, paBoxes[i].y));
469 /* Apparently we're supposed to clip it (gmr test sample) */
470 if (paBoxes[i].x + paBoxes[i].w > pMipLevel->size.width)
471 paBoxes[i].w = pMipLevel->size.width - paBoxes[i].x;
472 if (paBoxes[i].y + paBoxes[i].h > pMipLevel->size.height)
473 paBoxes[i].h = pMipLevel->size.height - paBoxes[i].y;
474 if (paBoxes[i].z + paBoxes[i].d > pMipLevel->size.depth)
475 paBoxes[i].d = pMipLevel->size.depth - paBoxes[i].z;
476
477 if ( !paBoxes[i].w
478 || !paBoxes[i].h
479 || !paBoxes[i].d
480 || paBoxes[i].x > pMipLevel->size.width
481 || paBoxes[i].y > pMipLevel->size.height
482 || paBoxes[i].z > pMipLevel->size.depth)
483 {
484 Log(("Empty box; skip\n"));
485 continue;
486 }
487
488 uDestOffset = paBoxes[i].x * pSurface->cbBlock + paBoxes[i].y * pMipLevel->cbSurfacePitch + paBoxes[i].z * pMipLevel->size.height * pMipLevel->cbSurfacePitch;
489 AssertReturn(uDestOffset + paBoxes[i].w * pSurface->cbBlock * paBoxes[i].h * paBoxes[i].d <= pMipLevel->cbSurface, VERR_INTERNAL_ERROR);
490
491 cbSrcPitch = (guest.pitch == 0) ? paBoxes[i].w * pSurface->cbBlock : guest.pitch;
492#ifdef MANUAL_FLIP_SURFACE_DATA
493 pBufferStart = (uint8_t *)pMipLevel->pSurfaceData
494 + paBoxes[i].x * pSurface->cbBlock
495 + pMipLevel->cbSurface - paBoxes[i].y * pMipLevel->cbSurfacePitch
496 - pMipLevel->cbSurfacePitch; /* flip image during copy */
497#else
498 pBufferStart = (uint8_t *)pMipLevel->pSurfaceData + uDestOffset;
499#endif
500 rc = vmsvgaGMRTransfer(pThis,
501 transfer,
502 pBufferStart,
503#ifdef MANUAL_FLIP_SURFACE_DATA
504 -(int32_t)pMipLevel->cbSurfacePitch,
505#else
506 (int32_t)pMipLevel->cbSurfacePitch,
507#endif
508 guest.ptr,
509 paBoxes[i].srcx * pSurface->cbBlock + (paBoxes[i].srcy + paBoxes[i].srcz * paBoxes[i].h) * cbSrcPitch,
510 cbSrcPitch,
511 paBoxes[i].w * pSurface->cbBlock,
512 paBoxes[i].d * paBoxes[i].h);
513
514 Log4(("first line:\n%.*Rhxd\n", pMipLevel->cbSurfacePitch, pMipLevel->pSurfaceData));
515
516 AssertRC(rc);
517 }
518 pSurface->pMipmapLevels[host.mipmap].fDirty = true;
519 pSurface->fDirty = true;
520 }
521 else
522 {
523 /*
524 * Because of the clipping below, we're doing a little more
525 * here before calling the backend specific code.
526 */
527#ifdef VMSVGA3D_DIRECT3D
528 /* Flush the drawing pipeline for this surface as it could be used in a shared context. */
529 vmsvga3dSurfaceFlush(pThis, pSurface);
530 PVMSVGA3DCONTEXT pContext = NULL;
531
532#else /* VMSVGA3D_OPENGL */
533 PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
534 VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
535#endif
536
537 for (unsigned i = 0; i < cCopyBoxes; i++)
538 {
539 /* Apparently we're supposed to clip it (gmr test sample) */
540 if (paBoxes[i].x + paBoxes[i].w > pMipLevel->size.width)
541 paBoxes[i].w = pMipLevel->size.width - paBoxes[i].x;
542 if (paBoxes[i].y + paBoxes[i].h > pMipLevel->size.height)
543 paBoxes[i].h = pMipLevel->size.height - paBoxes[i].y;
544 if (paBoxes[i].z + paBoxes[i].d > pMipLevel->size.depth)
545 paBoxes[i].d = pMipLevel->size.depth - paBoxes[i].z;
546
547 Assert((paBoxes[i].d == 1 || paBoxes[i].d == 0) && paBoxes[i].z == 0);
548
549 if ( !paBoxes[i].w
550 || !paBoxes[i].h
551 || paBoxes[i].x > pMipLevel->size.width
552 || paBoxes[i].y > pMipLevel->size.height)
553 {
554 Log(("Empty box; skip\n"));
555 continue;
556 }
557
558 Log(("Copy box %d (%d,%d,%d)(%d,%d,%d) dest (%d,%d)\n", i, paBoxes[i].srcx, paBoxes[i].srcy, paBoxes[i].srcz, paBoxes[i].w, paBoxes[i].h, paBoxes[i].d, paBoxes[i].x, paBoxes[i].y));
559
560 uint32_t cbSrcPitch = (guest.pitch == 0) ? paBoxes[i].w * pSurface->cbBlock : guest.pitch;
561 rc = vmsvga3dBackSurfaceDMACopyBox(pThis, pState, pSurface, host.mipmap, guest.ptr, cbSrcPitch, transfer,
562 &paBoxes[i], pContext, rc, i);
563 }
564 }
565
566 return rc;
567}
568
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use