VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVbva.cpp@ 28800

Last change on this file since 28800 was 28800, checked in by vboxsync, 15 years ago

Automated rebranding to Oracle copyright/license strings via filemuncher
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.4 KB
Line 
1/** @file
2 *
3 * VirtualBox Windows Wddm guest video driver
4 *
5 * VBVA dirty rectangles calculations.
6 *
7 * Copyright (C) 2010 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#include "../VBoxVideo.h"
19#include "../Helper.h"
20
21static int vboxVBVAInformHost (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO * pVbva, BOOL bEnable)
22{
23 int rc = VERR_NO_MEMORY;
24 void *p = vboxHGSMIBufferAlloc (pDevExt,
25 sizeof (VBVAENABLE_EX),
26 HGSMI_CH_VBVA,
27 VBVA_ENABLE);
28 Assert(p);
29 if (!p)
30 {
31 drprintf((__FUNCTION__":vboxVBVAInformHost: HGSMIHeapAlloc failed\n"));
32 rc = VERR_NO_MEMORY;
33 }
34 else
35 {
36 VBVAENABLE_EX *pEnableEx = (VBVAENABLE_EX *)p;
37 pEnableEx->u32ScreenId = pVbva->srcId;
38
39 VBVAENABLE *pEnable = &pEnableEx->Base;
40 pEnable->u32Flags = bEnable? VBVA_F_ENABLE: VBVA_F_DISABLE;
41 pEnable->u32Flags |= VBVA_F_EXTENDED;
42 pEnable->u32Offset = (uint32_t)pVbva->offVBVA;
43 pEnable->i32Result = VERR_NOT_SUPPORTED;
44
45 vboxHGSMIBufferSubmit (pDevExt, p);
46
47 if (bEnable)
48 {
49 rc = pEnable->i32Result;
50 AssertRC(rc);
51 }
52 else
53 rc = VINF_SUCCESS;
54
55 vboxHGSMIBufferFree (pDevExt, p);
56 }
57 return rc;
58}
59
60/*
61 * Public hardware buffer methods.
62 */
63int vboxVbvaEnable (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva)
64{
65 VBVABUFFER *pVBVA = pVbva->pVBVA;
66
67// DISPDBG((1, "VBoxDisp::vboxVbvaEnable screen %p vbva off 0x%x\n", ppdev->pjScreen, ppdev->layout.offVBVABuffer));
68
69 pVBVA->hostFlags.u32HostEvents = 0;
70 pVBVA->hostFlags.u32SupportedOrders = 0;
71 pVBVA->off32Data = 0;
72 pVBVA->off32Free = 0;
73 RtlZeroMemory (pVBVA->aRecords, sizeof (pVBVA->aRecords));
74 pVBVA->indexRecordFirst = 0;
75 pVBVA->indexRecordFree = 0;
76 pVBVA->cbPartialWriteThreshold = 256;
77 pVBVA->cbData = pVbva->cbVBVA - sizeof (VBVABUFFER) + sizeof (pVBVA->au8Data);
78
79 pVbva->fHwBufferOverflow = FALSE;
80 pVbva->pRecord = NULL;
81
82 int rc = vboxVBVAInformHost (pDevExt, pVbva, TRUE);
83 AssertRC(rc);
84
85 if (!RT_SUCCESS(rc))
86 vboxVbvaDisable (pDevExt, pVbva);
87
88 return rc;
89}
90
91int vboxVbvaDisable (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva)
92{
93// DISPDBG((1, "VBoxDisp::vbvaDisable called.\n"));
94
95 pVbva->fHwBufferOverflow = FALSE;
96 pVbva->pRecord = NULL;
97// ppdev->pVBVA = NULL;
98
99 return vboxVBVAInformHost (pDevExt, pVbva, FALSE);
100}
101
102int vboxVbvaCreate(PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva, ULONG offBuffer, ULONG cbBuffer, D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId)
103{
104 memset(pVbva, 0, sizeof(VBOXVBVAINFO));
105 int rc = VBoxMapAdapterMemory (pDevExt,
106 (void**)&pVbva->pVBVA,
107 offBuffer,
108 cbBuffer);
109 AssertRC(rc);
110 if (RT_SUCCESS(rc))
111 {
112 Assert(pVbva->pVBVA);
113 pVbva->offVBVA = offBuffer;
114 pVbva->cbVBVA = cbBuffer;
115 pVbva->srcId = srcId;
116 }
117
118 return rc;
119}
120
121/*
122 * Private operations.
123 */
124static uint32_t vboxHwBufferAvail (const VBVABUFFER *pVBVA)
125{
126 int32_t i32Diff = pVBVA->off32Data - pVBVA->off32Free;
127
128 return i32Diff > 0? i32Diff: pVBVA->cbData + i32Diff;
129}
130
131static void vboxHwBufferFlush (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva)
132{
133 /* Issue the flush command. */
134 void *p = vboxHGSMIBufferAlloc (pDevExt,
135 sizeof (VBVAFLUSH),
136 HGSMI_CH_VBVA,
137 VBVA_FLUSH);
138 Assert(p);
139 if (!p)
140 {
141 drprintf((__FUNCTION__":vboxHwBufferFlush: HGSMIHeapAlloc failed\n"));
142 }
143 else
144 {
145 VBVAFLUSH *pFlush = (VBVAFLUSH *)p;
146
147 pFlush->u32Reserved = 0;
148
149 vboxHGSMIBufferSubmit (pDevExt, p);
150
151 vboxHGSMIBufferFree (pDevExt, p);
152 }
153
154 return;
155}
156
157static void vboxHwBufferPlaceDataAt (VBVABUFFER *pVBVA, const void *p, uint32_t cb, uint32_t offset)
158{
159 uint32_t u32BytesTillBoundary = pVBVA->cbData - offset;
160 uint8_t *dst = &pVBVA->au8Data[offset];
161 int32_t i32Diff = cb - u32BytesTillBoundary;
162
163 if (i32Diff <= 0)
164 {
165 /* Chunk will not cross buffer boundary. */
166 memcpy (dst, p, cb);
167 }
168 else
169 {
170 /* Chunk crosses buffer boundary. */
171 memcpy (dst, p, u32BytesTillBoundary);
172 memcpy (&pVBVA->au8Data[0], (uint8_t *)p + u32BytesTillBoundary, i32Diff);
173 }
174
175 return;
176}
177
178BOOL vboxVbvaBufferBeginUpdate (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva)
179{
180 BOOL bRc = FALSE;
181
182 // DISPDBG((1, "VBoxDisp::vboxHwBufferBeginUpdate called flags = 0x%08X\n",
183 // ppdev->pVBVA? ppdev->pVBVA->u32HostEvents: -1));
184
185 if ( pVbva->pVBVA
186 && (pVbva->pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_ENABLED))
187 {
188 uint32_t indexRecordNext;
189
190 Assert (!pVbva->fHwBufferOverflow);
191 Assert (pVbva->pRecord == NULL);
192
193 indexRecordNext = (pVbva->pVBVA->indexRecordFree + 1) % VBVA_MAX_RECORDS;
194
195 if (indexRecordNext == pVbva->pVBVA->indexRecordFirst)
196 {
197 /* All slots in the records queue are used. */
198 vboxHwBufferFlush (pDevExt, pVbva);
199 }
200
201 if (indexRecordNext == pVbva->pVBVA->indexRecordFirst)
202 {
203// /* Even after flush there is no place. Fail the request. */
204// DISPDBG((1, "VBoxDisp::vboxHwBufferBeginUpdate no space in the queue of records!!! first %d, last %d\n",
205// ppdev->pVBVA->indexRecordFirst, ppdev->pVBVA->indexRecordFree));
206 }
207 else
208 {
209 /* Initialize the record. */
210 VBVARECORD *pRecord = &pVbva->pVBVA->aRecords[pVbva->pVBVA->indexRecordFree];
211
212 pRecord->cbRecord = VBVA_F_RECORD_PARTIAL;
213
214 pVbva->pVBVA->indexRecordFree = indexRecordNext;
215
216 // DISPDBG((1, "VBoxDisp::vboxHwBufferBeginUpdate indexRecordNext = %d\n", indexRecordNext));
217
218 /* Remember which record we are using. */
219 pVbva->pRecord = pRecord;
220
221 bRc = TRUE;
222 }
223 }
224
225 return bRc;
226}
227
228void vboxVbvaBufferEndUpdate (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva)
229{
230 VBVARECORD *pRecord;
231
232 // DISPDBG((1, "VBoxDisp::vboxHwBufferEndUpdate called\n"));
233
234 Assert(pVbva->pVBVA);
235
236 pRecord = pVbva->pRecord;
237 Assert (pRecord && (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL));
238
239 /* Mark the record completed. */
240 pRecord->cbRecord &= ~VBVA_F_RECORD_PARTIAL;
241
242 pVbva->fHwBufferOverflow = FALSE;
243 pVbva->pRecord = NULL;
244
245 return;
246}
247
248static int vboxHwBufferWrite (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva, const void *p, uint32_t cb)
249{
250 VBVARECORD *pRecord;
251 uint32_t cbHwBufferAvail;
252
253 uint32_t cbWritten = 0;
254
255 VBVABUFFER *pVBVA = pVbva->pVBVA;
256 Assert(pVBVA);
257
258 if (!pVBVA || pVbva->fHwBufferOverflow)
259 {
260 return VERR_INVALID_STATE;
261 }
262
263 Assert (pVBVA->indexRecordFirst != pVBVA->indexRecordFree);
264
265 pRecord = pVbva->pRecord;
266 Assert (pRecord && (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL));
267
268 dfprintf((__FUNCTION__": VW %d\n", cb));
269
270 cbHwBufferAvail = vboxHwBufferAvail (pVBVA);
271
272 while (cb > 0)
273 {
274 uint32_t cbChunk = cb;
275
276 // DISPDBG((1, "VBoxDisp::vboxHwBufferWrite pVBVA->off32Free %d, pRecord->cbRecord 0x%08X, cbHwBufferAvail %d, cb %d, cbWritten %d\n",
277 // pVBVA->off32Free, pRecord->cbRecord, cbHwBufferAvail, cb, cbWritten));
278
279 if (cbChunk >= cbHwBufferAvail)
280 {
281 dfprintf((__FUNCTION__": 1) avail %d, chunk %d\n", cbHwBufferAvail, cbChunk));
282
283 vboxHwBufferFlush (pDevExt, pVbva);
284
285 cbHwBufferAvail = vboxHwBufferAvail (pVBVA);
286
287 if (cbChunk >= cbHwBufferAvail)
288 {
289 dprintf((__FUNCTION__": no place for %d bytes. Only %d bytes available after flush. Going to partial writes.\n",
290 cb, cbHwBufferAvail));
291
292 if (cbHwBufferAvail <= pVBVA->cbPartialWriteThreshold)
293 {
294 drprintf((__FUNCTION__": Buffer overflow!!!\n"));
295 pVbva->fHwBufferOverflow = TRUE;
296 Assert(FALSE);
297 return VERR_NO_MEMORY;
298 }
299
300 cbChunk = cbHwBufferAvail - pVBVA->cbPartialWriteThreshold;
301 }
302 }
303
304 Assert(cbChunk <= cb);
305 Assert(cbChunk <= vboxHwBufferAvail (pVBVA));
306
307 vboxHwBufferPlaceDataAt (pVbva->pVBVA, (uint8_t *)p + cbWritten, cbChunk, pVBVA->off32Free);
308
309 pVBVA->off32Free = (pVBVA->off32Free + cbChunk) % pVBVA->cbData;
310 pRecord->cbRecord += cbChunk;
311 cbHwBufferAvail -= cbChunk;
312
313 cb -= cbChunk;
314 cbWritten += cbChunk;
315 }
316
317 return VINF_SUCCESS;
318}
319
320/*
321 * Public writer to the hardware buffer.
322 */
323int vboxWrite (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva, const void *pv, uint32_t cb)
324{
325 return vboxHwBufferWrite (pDevExt, pVbva, pv, cb);
326}
327
328
329int vboxVbvaReportDirtyRect (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva, RECT *pRectOrig)
330{
331 VBVACMDHDR hdr;
332
333 RECT rect = *pRectOrig;
334
335 if (rect.left < 0) rect.left = 0;
336 if (rect.top < 0) rect.top = 0;
337// if (rect.right > (int)ppdev->cxScreen) rect.right = ppdev->cxScreen;
338// if (rect.bottom > (int)ppdev->cyScreen) rect.bottom = ppdev->cyScreen;
339
340 hdr.x = (int16_t)rect.left;
341 hdr.y = (int16_t)rect.top;
342 hdr.w = (uint16_t)(rect.right - rect.left);
343 hdr.h = (uint16_t)(rect.bottom - rect.top);
344
345// hdr.x += (int16_t)ppdev->ptlDevOrg.x;
346// hdr.y += (int16_t)ppdev->ptlDevOrg.y;
347
348 return vboxWrite (pDevExt, pVbva, &hdr, sizeof(hdr));
349}
350
351#ifdef VBOXVDMA_WITH_VBVA
352int vboxVbvaReportCmdOffset (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva, uint32_t offCmd)
353{
354 VBOXVDMAVBVACMD cmd;
355 cmd.offCmd = offCmd;
356 return vboxWrite (pDevExt, pVbva, &cmd, sizeof(cmd));
357}
358#endif
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette