VirtualBox

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

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

wddm: driver update w/o reboot working; dummy context creation in CreateDevice
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.8 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 | VBVA_F_ABSOFFSET;
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
121int vboxVbvaDestroy(PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva)
122{
123 int rc = VINF_SUCCESS;
124 /*rc = */VBoxUnmapAdapterMemory(pDevExt, (void**)&pVbva->pVBVA, pVbva->cbVBVA);
125/*
126 AssertRC(rc);
127 if (RT_SUCCESS(rc))
128*/
129 memset(pVbva, 0, sizeof(VBOXVBVAINFO));
130/*
131 else
132 drprintf((__FUNCTION__": VBoxUnmapAdapterMemory failed, rc (%d)\n", rc));
133*/
134 return rc;
135}
136
137/*
138 * Private operations.
139 */
140static uint32_t vboxHwBufferAvail (const VBVABUFFER *pVBVA)
141{
142 int32_t i32Diff = pVBVA->off32Data - pVBVA->off32Free;
143
144 return i32Diff > 0? i32Diff: pVBVA->cbData + i32Diff;
145}
146
147static void vboxHwBufferFlush (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva)
148{
149 /* Issue the flush command. */
150 void *p = vboxHGSMIBufferAlloc (pDevExt,
151 sizeof (VBVAFLUSH),
152 HGSMI_CH_VBVA,
153 VBVA_FLUSH);
154 Assert(p);
155 if (!p)
156 {
157 drprintf((__FUNCTION__":vboxHwBufferFlush: HGSMIHeapAlloc failed\n"));
158 }
159 else
160 {
161 VBVAFLUSH *pFlush = (VBVAFLUSH *)p;
162
163 pFlush->u32Reserved = 0;
164
165 vboxHGSMIBufferSubmit (pDevExt, p);
166
167 vboxHGSMIBufferFree (pDevExt, p);
168 }
169
170 return;
171}
172
173static void vboxHwBufferPlaceDataAt (VBVABUFFER *pVBVA, const void *p, uint32_t cb, uint32_t offset)
174{
175 uint32_t u32BytesTillBoundary = pVBVA->cbData - offset;
176 uint8_t *dst = &pVBVA->au8Data[offset];
177 int32_t i32Diff = cb - u32BytesTillBoundary;
178
179 if (i32Diff <= 0)
180 {
181 /* Chunk will not cross buffer boundary. */
182 memcpy (dst, p, cb);
183 }
184 else
185 {
186 /* Chunk crosses buffer boundary. */
187 memcpy (dst, p, u32BytesTillBoundary);
188 memcpy (&pVBVA->au8Data[0], (uint8_t *)p + u32BytesTillBoundary, i32Diff);
189 }
190
191 return;
192}
193
194BOOL vboxVbvaBufferBeginUpdate (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva)
195{
196 BOOL bRc = FALSE;
197
198 // DISPDBG((1, "VBoxDisp::vboxHwBufferBeginUpdate called flags = 0x%08X\n",
199 // ppdev->pVBVA? ppdev->pVBVA->u32HostEvents: -1));
200
201 if ( pVbva->pVBVA
202 && (pVbva->pVBVA->hostFlags.u32HostEvents & VBVA_F_MODE_ENABLED))
203 {
204 uint32_t indexRecordNext;
205
206 Assert (!pVbva->fHwBufferOverflow);
207 Assert (pVbva->pRecord == NULL);
208
209 indexRecordNext = (pVbva->pVBVA->indexRecordFree + 1) % VBVA_MAX_RECORDS;
210
211 if (indexRecordNext == pVbva->pVBVA->indexRecordFirst)
212 {
213 /* All slots in the records queue are used. */
214 vboxHwBufferFlush (pDevExt, pVbva);
215 }
216
217 if (indexRecordNext == pVbva->pVBVA->indexRecordFirst)
218 {
219// /* Even after flush there is no place. Fail the request. */
220// DISPDBG((1, "VBoxDisp::vboxHwBufferBeginUpdate no space in the queue of records!!! first %d, last %d\n",
221// ppdev->pVBVA->indexRecordFirst, ppdev->pVBVA->indexRecordFree));
222 }
223 else
224 {
225 /* Initialize the record. */
226 VBVARECORD *pRecord = &pVbva->pVBVA->aRecords[pVbva->pVBVA->indexRecordFree];
227
228 pRecord->cbRecord = VBVA_F_RECORD_PARTIAL;
229
230 pVbva->pVBVA->indexRecordFree = indexRecordNext;
231
232 // DISPDBG((1, "VBoxDisp::vboxHwBufferBeginUpdate indexRecordNext = %d\n", indexRecordNext));
233
234 /* Remember which record we are using. */
235 pVbva->pRecord = pRecord;
236
237 bRc = TRUE;
238 }
239 }
240
241 return bRc;
242}
243
244void vboxVbvaBufferEndUpdate (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva)
245{
246 VBVARECORD *pRecord;
247
248 // DISPDBG((1, "VBoxDisp::vboxHwBufferEndUpdate called\n"));
249
250 Assert(pVbva->pVBVA);
251
252 pRecord = pVbva->pRecord;
253 Assert (pRecord && (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL));
254
255 /* Mark the record completed. */
256 pRecord->cbRecord &= ~VBVA_F_RECORD_PARTIAL;
257
258 pVbva->fHwBufferOverflow = FALSE;
259 pVbva->pRecord = NULL;
260
261 return;
262}
263
264static int vboxHwBufferWrite (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva, const void *p, uint32_t cb)
265{
266 VBVARECORD *pRecord;
267 uint32_t cbHwBufferAvail;
268
269 uint32_t cbWritten = 0;
270
271 VBVABUFFER *pVBVA = pVbva->pVBVA;
272 Assert(pVBVA);
273
274 if (!pVBVA || pVbva->fHwBufferOverflow)
275 {
276 return VERR_INVALID_STATE;
277 }
278
279 Assert (pVBVA->indexRecordFirst != pVBVA->indexRecordFree);
280
281 pRecord = pVbva->pRecord;
282 Assert (pRecord && (pRecord->cbRecord & VBVA_F_RECORD_PARTIAL));
283
284// dfprintf((__FUNCTION__": VW %d\n", cb));
285
286 cbHwBufferAvail = vboxHwBufferAvail (pVBVA);
287
288 while (cb > 0)
289 {
290 uint32_t cbChunk = cb;
291
292 // DISPDBG((1, "VBoxDisp::vboxHwBufferWrite pVBVA->off32Free %d, pRecord->cbRecord 0x%08X, cbHwBufferAvail %d, cb %d, cbWritten %d\n",
293 // pVBVA->off32Free, pRecord->cbRecord, cbHwBufferAvail, cb, cbWritten));
294
295 if (cbChunk >= cbHwBufferAvail)
296 {
297 dfprintf((__FUNCTION__": 1) avail %d, chunk %d\n", cbHwBufferAvail, cbChunk));
298
299 vboxHwBufferFlush (pDevExt, pVbva);
300
301 cbHwBufferAvail = vboxHwBufferAvail (pVBVA);
302
303 if (cbChunk >= cbHwBufferAvail)
304 {
305 dprintf((__FUNCTION__": no place for %d bytes. Only %d bytes available after flush. Going to partial writes.\n",
306 cb, cbHwBufferAvail));
307
308 if (cbHwBufferAvail <= pVBVA->cbPartialWriteThreshold)
309 {
310 drprintf((__FUNCTION__": Buffer overflow!!!\n"));
311 pVbva->fHwBufferOverflow = TRUE;
312 Assert(FALSE);
313 return VERR_NO_MEMORY;
314 }
315
316 cbChunk = cbHwBufferAvail - pVBVA->cbPartialWriteThreshold;
317 }
318 }
319
320 Assert(cbChunk <= cb);
321 Assert(cbChunk <= vboxHwBufferAvail (pVBVA));
322
323 vboxHwBufferPlaceDataAt (pVbva->pVBVA, (uint8_t *)p + cbWritten, cbChunk, pVBVA->off32Free);
324
325 pVBVA->off32Free = (pVBVA->off32Free + cbChunk) % pVBVA->cbData;
326 pRecord->cbRecord += cbChunk;
327 cbHwBufferAvail -= cbChunk;
328
329 cb -= cbChunk;
330 cbWritten += cbChunk;
331 }
332
333 return VINF_SUCCESS;
334}
335
336/*
337 * Public writer to the hardware buffer.
338 */
339int vboxWrite (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva, const void *pv, uint32_t cb)
340{
341 return vboxHwBufferWrite (pDevExt, pVbva, pv, cb);
342}
343
344
345int vboxVbvaReportDirtyRect (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva, RECT *pRectOrig)
346{
347 VBVACMDHDR hdr;
348
349 RECT rect = *pRectOrig;
350
351 if (rect.left < 0) rect.left = 0;
352 if (rect.top < 0) rect.top = 0;
353// if (rect.right > (int)ppdev->cxScreen) rect.right = ppdev->cxScreen;
354// if (rect.bottom > (int)ppdev->cyScreen) rect.bottom = ppdev->cyScreen;
355
356 hdr.x = (int16_t)rect.left;
357 hdr.y = (int16_t)rect.top;
358 hdr.w = (uint16_t)(rect.right - rect.left);
359 hdr.h = (uint16_t)(rect.bottom - rect.top);
360
361// hdr.x += (int16_t)ppdev->ptlDevOrg.x;
362// hdr.y += (int16_t)ppdev->ptlDevOrg.y;
363
364 return vboxWrite (pDevExt, pVbva, &hdr, sizeof(hdr));
365}
366
367#ifdef VBOXVDMA_WITH_VBVA
368int vboxVbvaReportCmdOffset (PDEVICE_EXTENSION pDevExt, VBOXVBVAINFO *pVbva, uint32_t offCmd)
369{
370 VBOXVDMAVBVACMD cmd;
371 cmd.offCmd = offCmd;
372 return vboxWrite (pDevExt, pVbva, &cmd, sizeof(cmd));
373}
374#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