VirtualBox

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

Last change on this file since 50482 was 50482, checked in by vboxsync, 11 years ago

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