VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispVBVA.cpp@ 63060

Last change on this file since 63060 was 63060, checked in by vboxsync, 8 years ago

GA/NT/Graphics: warnings - I'm so glad the compiler and I fully agree on what kind of code is hard to follow. It only throws a C4701, though. ;-)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 19.6 KB
Line 
1/* $Id: VBoxDispVBVA.cpp 63060 2016-08-05 20:33:05Z vboxsync $ */
2/** @file
3 * VBox XPDM Display driver
4 */
5
6/*
7 * Copyright (C) 2011-2016 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 "VBoxDisp.h"
19#include "VBoxDispMini.h"
20#include <VBox/HGSMI/HGSMIChSetup.h>
21
22#ifdef VBOX_VBVA_ADJUST_RECT
23static ULONG vbvaConvertPixel(BYTE *pu8PixelFrom, int cbPixelFrom, int cbPixelTo)
24{
25 BYTE r, g, b;
26 ULONG ulConvertedPixel = 0;
27
28 switch (cbPixelFrom)
29 {
30 case 4:
31 {
32 switch (cbPixelTo)
33 {
34 case 3:
35 {
36 memcpy (&ulConvertedPixel, pu8PixelFrom, 3);
37 } break;
38
39 case 2:
40 {
41 ulConvertedPixel = *(ULONG *)pu8PixelFrom;
42
43 r = (BYTE)(ulConvertedPixel >> 16);
44 g = (BYTE)(ulConvertedPixel >> 8);
45 b = (BYTE)(ulConvertedPixel);
46
47 ulConvertedPixel = ((r >> 3) << 11) + ((g >> 2) << 5) + (b >> 3);
48 } break;
49 }
50 } break;
51
52 case 3:
53 {
54 switch (cbPixelTo)
55 {
56 case 2:
57 {
58 memcpy (&ulConvertedPixel, pu8PixelFrom, 3);
59
60 r = (BYTE)(ulConvertedPixel >> 16);
61 g = (BYTE)(ulConvertedPixel >> 8);
62 b = (BYTE)(ulConvertedPixel);
63
64 ulConvertedPixel = ((r >> 3) << 11) + ((g >> 2) << 5) + (b >> 3);
65 } break;
66 }
67 } break;
68 }
69
70 return ulConvertedPixel;
71}
72
73BOOL vbvaFindChangedRect(SURFOBJ *psoDest, SURFOBJ *psoSrc, RECTL *prclDest, POINTL *pptlSrc)
74{
75 int x, y;
76 int fTopNonEqualFound;
77 int yTopmost;
78 int yBottommost;
79 int cbPixelSrc;
80 int cbPixelDest;
81 RECTL rclDest;
82 RECTL rclSrc;
83 BYTE *pu8Src;
84 BYTE *pu8Dest;
85
86 if (!prclDest || !pptlSrc)
87 {
88 return TRUE;
89 }
90
91 LOGF(("dest %d,%d %dx%d from %d,%d",
92 prclDest->left, prclDest->top, prclDest->right - prclDest->left, prclDest->bottom - prclDest->top,
93 pptlSrc->x, pptlSrc->y));
94
95 switch (psoDest->iBitmapFormat)
96 {
97 case BMF_16BPP: cbPixelDest = 2; break;
98 case BMF_24BPP: cbPixelDest = 3; break;
99 case BMF_32BPP: cbPixelDest = 4; break;
100 default: cbPixelDest = 0;
101 }
102
103 switch (psoSrc->iBitmapFormat)
104 {
105 case BMF_16BPP: cbPixelSrc = 2; break;
106 case BMF_24BPP: cbPixelSrc = 3; break;
107 case BMF_32BPP: cbPixelSrc = 4; break;
108 default: cbPixelSrc = 0;
109 }
110
111 if (cbPixelDest == 0 || cbPixelSrc == 0)
112 {
113 WARN(("unsupported pixel format src %d dst %d", psoDest->iBitmapFormat, psoSrc->iBitmapFormat));
114 return TRUE;
115 }
116
117 rclDest = *prclDest;
118
119 vrdpAdjustRect(psoDest, &rclDest);
120
121 pptlSrc->x += rclDest.left - prclDest->left;
122 pptlSrc->y += rclDest.top - prclDest->top;
123
124 *prclDest = rclDest;
125
126 if ( rclDest.right == rclDest.left
127 || rclDest.bottom == rclDest.top)
128 {
129 WARN(("empty dest rect: %d-%d, %d-%d", rclDest.left, rclDest.right, rclDest.top, rclDest.bottom));
130 return FALSE;
131 }
132
133 rclSrc.left = pptlSrc->x;
134 rclSrc.top = pptlSrc->y;
135 rclSrc.right = pptlSrc->x + (rclDest.right - rclDest.left);
136 rclSrc.bottom = pptlSrc->y + (rclDest.bottom - rclDest.top);
137 vrdpAdjustRect (psoSrc, &rclSrc);
138
139 if ( rclSrc.right == rclSrc.left
140 || rclSrc.bottom == rclSrc.top)
141 {
142 prclDest->right = prclDest->left;
143 prclDest->bottom = prclDest->top;
144
145 WARN(("empty src rect: %d-%d, %d-%d", rclSrc.left, rclSrc.right, rclSrc.top, rclSrc.bottom));
146 return FALSE;
147 }
148
149 Assert(pptlSrc->x == rclSrc.left);
150 Assert(pptlSrc->y == rclSrc.top);
151
152 /*
153 * Compare the content of the screen surface (psoDest) with the source surface (psoSrc).
154 * Update the prclDest with the rectangle that will be actually changed after
155 * copying the source bits to the screen.
156 */
157 pu8Src = (BYTE *)psoSrc->pvScan0 + psoSrc->lDelta * pptlSrc->y + cbPixelSrc * pptlSrc->x;
158 pu8Dest = (BYTE *)psoDest->pvScan0 + psoDest->lDelta * prclDest->top + cbPixelDest * prclDest->left;
159
160 /* Use the rclDest as the bounding rectangle for the changed area. */
161 rclDest.left = prclDest->right; /* +inf */
162 rclDest.right = prclDest->left; /* -inf */
163 rclDest.top = prclDest->bottom; /* +inf */
164 rclDest.bottom = prclDest->top; /* -inf */
165
166 fTopNonEqualFound = 0;
167 yTopmost = prclDest->top; /* inclusive */
168 yBottommost = prclDest->top - 1; /* inclusive */
169
170 for (y = prclDest->top; y < prclDest->bottom; y++)
171 {
172 int fLeftNonEqualFound = 0;
173
174 /* Init to an empty line. */
175 int xLeftmost = prclDest->left; /* inclusive */
176 int xRightmost = prclDest->left - 1; /* inclusive */
177
178 BYTE *pu8SrcLine = pu8Src;
179 BYTE *pu8DestLine = pu8Dest;
180
181 for (x = prclDest->left; x < prclDest->right; x++)
182 {
183 int fEqualPixels;
184
185 if (cbPixelSrc == cbPixelDest)
186 {
187 fEqualPixels = (memcmp (pu8SrcLine, pu8DestLine, cbPixelDest) == 0);
188 }
189 else
190 {
191 /* Convert larger pixel to the smaller pixel format. */
192 ULONG ulConvertedPixel;
193 if (cbPixelSrc > cbPixelDest)
194 {
195 /* Convert the source pixel to the destination pixel format. */
196 ulConvertedPixel = vbvaConvertPixel ( /*from*/ pu8SrcLine, cbPixelSrc,
197 /*to*/ cbPixelDest);
198 fEqualPixels = (memcmp (&ulConvertedPixel, pu8DestLine, cbPixelDest) == 0);
199 }
200 else
201 {
202 /* Convert the destination pixel to the source pixel format. */
203 ulConvertedPixel = vbvaConvertPixel ( /*from*/ pu8DestLine, cbPixelDest,
204 /*to*/ cbPixelSrc);
205 fEqualPixels = (memcmp (&ulConvertedPixel, pu8SrcLine, cbPixelSrc) == 0);
206 }
207 }
208
209 if (fEqualPixels)
210 {
211 /* Equal pixels. */
212 if (!fLeftNonEqualFound)
213 {
214 xLeftmost = x;
215 }
216 }
217 else
218 {
219 fLeftNonEqualFound = 1;
220 xRightmost = x;
221 }
222
223 pu8SrcLine += cbPixelSrc;
224 pu8DestLine += cbPixelDest;
225 }
226
227 /* min */
228 if (rclDest.left > xLeftmost)
229 {
230 rclDest.left = xLeftmost;
231 }
232
233 /* max */
234 if (rclDest.right < xRightmost)
235 {
236 rclDest.right = xRightmost;
237 }
238
239 if (xLeftmost > xRightmost) /* xRightmost is inclusive, so '>', not '>='. */
240 {
241 /* Empty line. */
242 if (!fTopNonEqualFound)
243 {
244 yTopmost = y;
245 }
246 }
247 else
248 {
249 fTopNonEqualFound = 1;
250 yBottommost = y;
251 }
252
253 pu8Src += psoSrc->lDelta;
254 pu8Dest += psoDest->lDelta;
255 }
256
257 /* min */
258 if (rclDest.top > yTopmost)
259 {
260 rclDest.top = yTopmost;
261 }
262
263 /* max */
264 if (rclDest.bottom < yBottommost)
265 {
266 rclDest.bottom = yBottommost;
267 }
268
269 /* rclDest was calculated with right-bottom inclusive.
270 * The following checks and the caller require exclusive coords.
271 */
272 rclDest.right++;
273 rclDest.bottom++;
274
275 LOG(("new dest %d,%d %dx%d from %d,%d",
276 rclDest.left, rclDest.top, rclDest.right - rclDest.left, rclDest.bottom - rclDest.top,
277 pptlSrc->x, pptlSrc->y));
278
279 /* Update the rectangle with the changed area. */
280 if ( rclDest.left >= rclDest.right
281 || rclDest.top >= rclDest.bottom)
282 {
283 /* Empty rect. */
284 LOG(("empty"));
285 prclDest->right = prclDest->left;
286 prclDest->bottom = prclDest->top;
287 return FALSE;
288 }
289
290 LOG(("not empty"));
291
292 pptlSrc->x += rclDest.left - prclDest->left;
293 pptlSrc->y += rclDest.top - prclDest->top;
294
295 *prclDest = rclDest;
296
297 return TRUE;
298}
299#endif /* VBOX_VBVA_ADJUST_RECT */
300
301static DECLCALLBACK(void *) hgsmiEnvAlloc(void *pvEnv, HGSMISIZE cb)
302{
303 NOREF(pvEnv);
304 return EngAllocMem(0, cb, MEM_ALLOC_TAG);
305}
306
307static DECLCALLBACK(void) hgsmiEnvFree(void *pvEnv, void *pv)
308{
309 NOREF(pvEnv);
310 EngFreeMem(pv);
311}
312
313static HGSMIENV g_hgsmiEnvDisp =
314{
315 NULL,
316 hgsmiEnvAlloc,
317 hgsmiEnvFree
318};
319
320int VBoxDispVBVAInit(PVBOXDISPDEV pDev)
321{
322 LOGF_ENTER();
323
324 /* Check if HGSMI is supported and obtain necessary info */
325 QUERYHGSMIRESULT info;
326 int rc = VBoxDispMPQueryHGSMIInfo(pDev->hDriver, &info);
327 if (RT_SUCCESS(rc))
328 {
329 HGSMIQUERYCALLBACKS callbacks;
330 rc = VBoxDispMPQueryHGSMICallbacks(pDev->hDriver, &callbacks);
331 if (RT_SUCCESS(rc))
332 {
333 HGSMIQUERYCPORTPROCS portProcs;
334 rc = VBoxDispMPHGSMIQueryPortProcs(pDev->hDriver, &portProcs);
335 if (RT_SUCCESS(rc))
336 {
337 pDev->hgsmi.bSupported = TRUE;
338
339 pDev->hgsmi.mp = callbacks;
340 pDev->vpAPI = portProcs;
341 }
342 }
343 }
344
345 if (pDev->hgsmi.bSupported)
346 {
347 HGSMIHANDLERENABLE HandlerReg;
348
349 memset(&HandlerReg, 0, sizeof(HandlerReg));
350 HandlerReg.u8Channel = HGSMI_CH_VBVA;
351 ULONG cbReturned;
352 DWORD dwrc = EngDeviceIoControl(pDev->hDriver, IOCTL_VIDEO_HGSMI_HANDLER_ENABLE, &HandlerReg, sizeof(HandlerReg),
353 0, NULL, &cbReturned);
354 VBOX_WARN_WINERR(dwrc);
355
356#ifdef VBOX_WITH_VIDEOHWACCEL
357 if (NO_ERROR == dwrc)
358 {
359 VBoxDispVHWAInit(pDev);
360 }
361#endif
362 }
363
364 /* Check if we have enough VRAM and update layout info.
365 * 0=Framebuffer(fixed)->DDrawHeap(all left vram)->VBVABuffer(64k..cbFramebuffer)->DisplayInfo(fixed)->=EndOfVRAM
366 */
367 if (pDev->hgsmi.bSupported)
368 {
369 ULONG cbAvailable;
370 VBOXDISPVRAMLAYOUT *vram = &pDev->layout;
371
372 pDev->iDevice = info.iDevice;
373
374 vram->cbVRAM = pDev->memInfo.VideoRamLength;
375
376 vram->offFramebuffer = 0;
377 vram->cbFramebuffer = RT_ALIGN_32(pDev->memInfo.FrameBufferLength, 0x1000);
378 cbAvailable = vram->cbVRAM - vram->cbFramebuffer;
379
380 if (cbAvailable <= info.u32DisplayInfoSize)
381 {
382 pDev->hgsmi.bSupported = FALSE;
383 }
384 else
385 {
386 vram->offDisplayInfo = vram->cbVRAM - info.u32DisplayInfoSize;
387 vram->cbDisplayInfo = info.u32DisplayInfoSize;
388 cbAvailable -= vram->cbDisplayInfo;
389
390 for (vram->cbVBVABuffer = vram->cbFramebuffer;
391 vram->cbVBVABuffer >= info.u32MinVBVABufferSize;
392 vram->cbVBVABuffer /= 2)
393 {
394 if (vram->cbVBVABuffer < cbAvailable)
395 {
396 break;
397 }
398 }
399
400 if (vram->cbVBVABuffer >= cbAvailable)
401 {
402 pDev->hgsmi.bSupported = FALSE;
403 }
404 else
405 {
406 vram->offDDrawHeap = vram->offFramebuffer + vram->cbFramebuffer;
407
408 cbAvailable -= vram->cbVBVABuffer;
409 vram->cbDDrawHeap = cbAvailable;
410
411 vram->offVBVABuffer = vram->offDDrawHeap + vram->cbDDrawHeap;
412 }
413 }
414 }
415
416 /* Setup HGSMI heap in the display information area.
417 * The area has some space reserved for HGSMI event flags in the beginning.
418 */
419 if (pDev->hgsmi.bSupported)
420 {
421 LOG(("offBase=%#x", info.areaDisplay.offBase));
422
423 rc = HGSMIHeapSetup(&pDev->hgsmi.ctx.heapCtx,
424 (uint8_t *)pDev->memInfo.VideoRamBase+pDev->layout.offDisplayInfo+sizeof(HGSMIHOSTFLAGS),
425 pDev->layout.cbDisplayInfo-sizeof(HGSMIHOSTFLAGS),
426 info.areaDisplay.offBase+pDev->layout.offDisplayInfo+sizeof(HGSMIHOSTFLAGS),
427 &g_hgsmiEnvDisp);
428
429 if (RT_SUCCESS(rc))
430 {
431 pDev->hgsmi.ctx.port = info.IOPortGuestCommand;
432 }
433 else
434 {
435 VBOX_WARNRC(rc);
436 pDev->hgsmi.bSupported = FALSE;
437 }
438 }
439
440 /* If we don't have HGSMI or doesn't have enough VRAM, setup layout without VBVA buffer and display info */
441 if (!pDev->hgsmi.bSupported)
442 {
443 VBOXDISPVRAMLAYOUT *vram = &pDev->layout;
444
445 pDev->iDevice = 0;
446
447 /* Setup a layout without both the VBVA buffer and the display information. */
448 vram->cbVRAM = pDev->memInfo.VideoRamLength;
449
450 vram->offFramebuffer = 0;
451 vram->cbFramebuffer = RT_ALIGN_32(pDev->memInfo.FrameBufferLength, 0x1000);
452
453 vram->offDDrawHeap = vram->offFramebuffer + vram->cbFramebuffer;
454 vram->cbDDrawHeap = vram->cbVRAM - vram->offDDrawHeap;
455
456 vram->offVBVABuffer = vram->offDDrawHeap + vram->cbDDrawHeap;
457 vram->cbVBVABuffer = 0;
458
459 vram->offDisplayInfo = vram->offVBVABuffer + vram->cbVBVABuffer;
460 vram->cbDisplayInfo = 0;
461 }
462
463 /* Update buffer layout in VBVA context info */
464 VBoxVBVASetupBufferContext(&pDev->vbvaCtx, pDev->layout.offVBVABuffer, pDev->layout.cbVBVABuffer);
465
466 LOG(("\n"
467 " cbVRAM=%#X\n"
468 " offFramebuffer=%#X cbFramebuffer=%#X\n"
469 " offDDrawHeap=%#X cbDDrawHeap=%#X\n"
470 " offVBVABuffer=%#X cbVBVABuffer=%#X\n"
471 " offDisplayInfo=%#X cbDisplayInfo=%#X\n",
472 pDev->layout.cbVRAM,
473 pDev->layout.offFramebuffer, pDev->layout.cbFramebuffer,
474 pDev->layout.offDDrawHeap, pDev->layout.cbDDrawHeap,
475 pDev->layout.offVBVABuffer, pDev->layout.cbVBVABuffer,
476 pDev->layout.offDisplayInfo, pDev->layout.cbDisplayInfo
477 ));
478
479 LOGF_LEAVE();
480 return VINF_SUCCESS;
481}
482
483void VBoxDispVBVAHostCommandComplete(PVBOXDISPDEV pDev, VBVAHOSTCMD *pCmd)
484{
485 pDev->hgsmi.mp.pfnCompletionHandler(pDev->hgsmi.mp.hContext, pCmd);
486}
487
488void vbvaReportDirtyRect(PVBOXDISPDEV pDev, RECTL *pRectOrig)
489{
490 if (pDev && pRectOrig)
491 {
492
493 LOG(("dirty rect: left %d, top: %d, width: %d, height: %d",
494 pRectOrig->left, pRectOrig->top,
495 pRectOrig->right - pRectOrig->left, pRectOrig->bottom - pRectOrig->top));
496
497 VBVACMDHDR hdr;
498 RECTL rect;
499
500 /* Ensure correct order. */
501 if (pRectOrig->left <= pRectOrig->right)
502 {
503 rect.left = pRectOrig->left;
504 rect.right = pRectOrig->right;
505 }
506 else
507 {
508 rect.left = pRectOrig->right;
509 rect.right = pRectOrig->left;
510 }
511
512 if (pRectOrig->top <= pRectOrig->bottom)
513 {
514 rect.top = pRectOrig->top;
515 rect.bottom = pRectOrig->bottom;
516 }
517 else
518 {
519 rect.top = pRectOrig->bottom;
520 rect.bottom = pRectOrig->top;
521 }
522
523 /* Clip the rectangle. */
524 rect.left = RT_CLAMP(rect.left, 0, (LONG)pDev->mode.ulWidth);
525 rect.top = RT_CLAMP(rect.top, 0, (LONG)pDev->mode.ulHeight);
526 rect.right = RT_CLAMP(rect.right, 0, (LONG)pDev->mode.ulWidth);
527 rect.bottom = RT_CLAMP(rect.bottom, 0, (LONG)pDev->mode.ulHeight);
528
529 /* If the rectangle is empty, still report it. */
530 if (rect.right < rect.left)
531 {
532 rect.right = rect.left;
533 }
534 if (rect.bottom < rect.top)
535 {
536 rect.bottom = rect.top;
537 }
538
539 hdr.x = (int16_t)(rect.left + pDev->orgDev.x);
540 hdr.y = (int16_t)(rect.top + pDev->orgDev.y);
541 hdr.w = (uint16_t)(rect.right - rect.left);
542 hdr.h = (uint16_t)(rect.bottom - rect.top);
543
544 VBoxVBVAWrite(&pDev->vbvaCtx, &pDev->hgsmi.ctx, &hdr, sizeof(hdr));
545 }
546}
547
548static void vbvaReportDirtyPath(PVBOXDISPDEV pDev, PATHOBJ *ppo)
549{
550 RECTFX rcfxBounds;
551 RECTL rclBounds;
552
553 PATHOBJ_vGetBounds(ppo, &rcfxBounds);
554
555 rclBounds.left = FXTOLFLOOR(rcfxBounds.xLeft);
556 rclBounds.right = FXTOLCEILING(rcfxBounds.xRight);
557 rclBounds.top = FXTOLFLOOR(rcfxBounds.yTop);
558 rclBounds.bottom = FXTOLCEILING(rcfxBounds.yBottom);
559
560 vbvaReportDirtyRect(pDev, &rclBounds);
561}
562
563static void vbvaReportDirtyClip(PVBOXDISPDEV pDev, CLIPOBJ *pco, RECTL *prcl)
564{
565 if (prcl)
566 {
567 vbvaReportDirtyRect(pDev, prcl);
568 }
569 else if (pco)
570 {
571 vbvaReportDirtyRect(pDev, &pco->rclBounds);
572 }
573}
574
575/*
576 * VBVA driver functions.
577 */
578
579void vbvaDrvLineTo(SURFOBJ *pso, CLIPOBJ *pco, BRUSHOBJ *pbo,
580 LONG x1, LONG y1, LONG x2, LONG y2, RECTL *prclBounds, MIX mix)
581{
582 RT_NOREF(pbo, x1, y1, x2, y2, mix);
583 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
584 vbvaReportDirtyClip(pDev, pco, prclBounds);
585}
586
587void vbvaDrvStrokePath(SURFOBJ *pso, PATHOBJ *ppo, CLIPOBJ *pco, XFORMOBJ *pxo,
588 BRUSHOBJ *pbo, POINTL *pptlBrushOrg, LINEATTRS *plineattrs, MIX mix)
589{
590 RT_NOREF(pco, pxo, pbo, pptlBrushOrg, plineattrs, mix);
591 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
592 vbvaReportDirtyPath(pDev, ppo);
593}
594
595void vbvaDrvFillPath(SURFOBJ *pso, PATHOBJ *ppo, CLIPOBJ *pco, BRUSHOBJ *pbo, POINTL *pptlBrushOrg,
596 MIX mix, FLONG flOptions)
597{
598 RT_NOREF(pco, pbo, pptlBrushOrg, mix, flOptions);
599 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
600 vbvaReportDirtyPath(pDev, ppo);
601}
602
603void vbvaDrvPaint(SURFOBJ *pso, CLIPOBJ *pco, BRUSHOBJ *pbo, POINTL *pptlBrushOrg, MIX mix)
604{
605 RT_NOREF(pbo, pptlBrushOrg, mix);
606 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
607 vbvaReportDirtyClip(pDev, pco, NULL);
608}
609
610void vbvaDrvTextOut(SURFOBJ *pso, STROBJ *pstro, FONTOBJ *pfo, CLIPOBJ *pco,
611 RECTL *prclExtra, RECTL *prclOpaque, BRUSHOBJ *pboFore,
612 BRUSHOBJ *pboOpaque, POINTL *pptlOrg, MIX mix)
613{
614 RT_NOREF(pfo, prclExtra, pboFore, pboOpaque, pptlOrg, mix);
615 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
616 vbvaReportDirtyClip(pDev, pco, prclOpaque ? prclOpaque : &pstro->rclBkGround);
617}
618
619void vbvaDrvSaveScreenBits(SURFOBJ *pso, ULONG iMode, ULONG_PTR ident, RECTL *prcl)
620{
621 RT_NOREF(iMode, ident);
622 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
623
624 Assert(iMode == SS_RESTORE || iMode == SS_SAVE);
625 vbvaReportDirtyRect(pDev, prcl);
626}
627
628void vbvaDrvBitBlt(SURFOBJ *psoTrg, SURFOBJ *psoSrc, SURFOBJ *psoMask, CLIPOBJ *pco, XLATEOBJ *pxlo,
629 RECTL *prclTrg, POINTL *pptlSrc, POINTL *pptlMask, BRUSHOBJ *pbo, POINTL *pptlBrush,
630 ROP4 rop4)
631{
632 RT_NOREF(psoSrc, psoMask, pxlo, pptlSrc, pptlMask, pbo, pptlBrush, rop4);
633 PVBOXDISPDEV pDev = (PVBOXDISPDEV)psoTrg->dhpdev;
634 vbvaReportDirtyClip(pDev, pco, prclTrg);
635}
636
637void vbvaDrvStretchBlt(SURFOBJ *psoDest, SURFOBJ *psoSrc, SURFOBJ *psoMask, CLIPOBJ *pco, XLATEOBJ *pxlo,
638 COLORADJUSTMENT *pca, POINTL *pptlHTOrg, RECTL *prclDest, RECTL *prclSrc,
639 POINTL *pptlMask, ULONG iMode)
640{
641 RT_NOREF(psoSrc, psoMask, pxlo, pca, pptlHTOrg, prclSrc, pptlMask, iMode);
642 PVBOXDISPDEV pDev = (PVBOXDISPDEV)psoDest->dhpdev;
643 vbvaReportDirtyClip(pDev, pco, prclDest);
644}
645
646void vbvaDrvCopyBits(SURFOBJ *psoDest, SURFOBJ *psoSrc, CLIPOBJ *pco, XLATEOBJ *pxlo, RECTL *prclDest, POINTL *pptlSrc)
647{
648 RT_NOREF(psoSrc, pxlo, pptlSrc);
649 PVBOXDISPDEV pDev = (PVBOXDISPDEV)psoDest->dhpdev;
650 vbvaReportDirtyClip(pDev, pco, prclDest);
651}
Note: See TracBrowser for help on using the repository browser.

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