VirtualBox

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

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

(C) 2016
  • 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 62522 2016-07-22 19:17:25Z vboxsync $ */
2
3/** @file
4 * VBox XPDM Display driver
5 */
6
7/*
8 * Copyright (C) 2011-2016 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, MEM_ALLOC_TAG);
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 (uint8_t *)pDev->memInfo.VideoRamBase+pDev->layout.offDisplayInfo+sizeof(HGSMIHOSTFLAGS),
428 pDev->layout.cbDisplayInfo-sizeof(HGSMIHOSTFLAGS),
429 info.areaDisplay.offBase+pDev->layout.offDisplayInfo+sizeof(HGSMIHOSTFLAGS),
430 &g_hgsmiEnvDisp);
431
432 if (RT_SUCCESS(rc))
433 {
434 pDev->hgsmi.ctx.port = info.IOPortGuestCommand;
435 }
436 else
437 {
438 VBOX_WARNRC(rc);
439 pDev->hgsmi.bSupported = FALSE;
440 }
441 }
442
443 /* If we don't have HGSMI or doesn't have enough VRAM, setup layout without VBVA buffer and display info */
444 if (!pDev->hgsmi.bSupported)
445 {
446 VBOXDISPVRAMLAYOUT *vram = &pDev->layout;
447
448 pDev->iDevice = 0;
449
450 /* Setup a layout without both the VBVA buffer and the display information. */
451 vram->cbVRAM = pDev->memInfo.VideoRamLength;
452
453 vram->offFramebuffer = 0;
454 vram->cbFramebuffer = RT_ALIGN_32(pDev->memInfo.FrameBufferLength, 0x1000);
455
456 vram->offDDrawHeap = vram->offFramebuffer + vram->cbFramebuffer;
457 vram->cbDDrawHeap = vram->cbVRAM - vram->offDDrawHeap;
458
459 vram->offVBVABuffer = vram->offDDrawHeap + vram->cbDDrawHeap;
460 vram->cbVBVABuffer = 0;
461
462 vram->offDisplayInfo = vram->offVBVABuffer + vram->cbVBVABuffer;
463 vram->cbDisplayInfo = 0;
464 }
465
466 /* Update buffer layout in VBVA context info */
467 VBoxVBVASetupBufferContext(&pDev->vbvaCtx, pDev->layout.offVBVABuffer, pDev->layout.cbVBVABuffer);
468
469 LOG(("\n"
470 " cbVRAM=%#X\n"
471 " offFramebuffer=%#X cbFramebuffer=%#X\n"
472 " offDDrawHeap=%#X cbDDrawHeap=%#X\n"
473 " offVBVABuffer=%#X cbVBVABuffer=%#X\n"
474 " offDisplayInfo=%#X cbDisplayInfo=%#X\n",
475 pDev->layout.cbVRAM,
476 pDev->layout.offFramebuffer, pDev->layout.cbFramebuffer,
477 pDev->layout.offDDrawHeap, pDev->layout.cbDDrawHeap,
478 pDev->layout.offVBVABuffer, pDev->layout.cbVBVABuffer,
479 pDev->layout.offDisplayInfo, pDev->layout.cbDisplayInfo
480 ));
481
482 LOGF_LEAVE();
483 return VINF_SUCCESS;
484}
485
486void VBoxDispVBVAHostCommandComplete(PVBOXDISPDEV pDev, VBVAHOSTCMD *pCmd)
487{
488 pDev->hgsmi.mp.pfnCompletionHandler(pDev->hgsmi.mp.hContext, pCmd);
489}
490
491void vbvaReportDirtyRect(PVBOXDISPDEV pDev, RECTL *pRectOrig)
492{
493 if (pDev && pRectOrig)
494 {
495
496 LOG(("dirty rect: left %d, top: %d, width: %d, height: %d",
497 pRectOrig->left, pRectOrig->top,
498 pRectOrig->right - pRectOrig->left, pRectOrig->bottom - pRectOrig->top));
499
500 VBVACMDHDR hdr;
501 RECTL rect;
502
503 /* Ensure correct order. */
504 if (pRectOrig->left <= pRectOrig->right)
505 {
506 rect.left = pRectOrig->left;
507 rect.right = pRectOrig->right;
508 }
509 else
510 {
511 rect.left = pRectOrig->right;
512 rect.right = pRectOrig->left;
513 }
514
515 if (pRectOrig->top <= pRectOrig->bottom)
516 {
517 rect.top = pRectOrig->top;
518 rect.bottom = pRectOrig->bottom;
519 }
520 else
521 {
522 rect.top = pRectOrig->bottom;
523 rect.bottom = pRectOrig->top;
524 }
525
526 /* Clip the rectangle. */
527 rect.left = RT_CLAMP(rect.left, 0, (LONG)pDev->mode.ulWidth);
528 rect.top = RT_CLAMP(rect.top, 0, (LONG)pDev->mode.ulHeight);
529 rect.right = RT_CLAMP(rect.right, 0, (LONG)pDev->mode.ulWidth);
530 rect.bottom = RT_CLAMP(rect.bottom, 0, (LONG)pDev->mode.ulHeight);
531
532 /* If the rectangle is empty, still report it. */
533 if (rect.right < rect.left)
534 {
535 rect.right = rect.left;
536 }
537 if (rect.bottom < rect.top)
538 {
539 rect.bottom = rect.top;
540 }
541
542 hdr.x = (int16_t)(rect.left + pDev->orgDev.x);
543 hdr.y = (int16_t)(rect.top + pDev->orgDev.y);
544 hdr.w = (uint16_t)(rect.right - rect.left);
545 hdr.h = (uint16_t)(rect.bottom - rect.top);
546
547 VBoxVBVAWrite(&pDev->vbvaCtx, &pDev->hgsmi.ctx, &hdr, sizeof(hdr));
548 }
549}
550
551static void vbvaReportDirtyPath(PVBOXDISPDEV pDev, PATHOBJ *ppo)
552{
553 RECTFX rcfxBounds;
554 RECTL rclBounds;
555
556 PATHOBJ_vGetBounds(ppo, &rcfxBounds);
557
558 rclBounds.left = FXTOLFLOOR(rcfxBounds.xLeft);
559 rclBounds.right = FXTOLCEILING(rcfxBounds.xRight);
560 rclBounds.top = FXTOLFLOOR(rcfxBounds.yTop);
561 rclBounds.bottom = FXTOLCEILING(rcfxBounds.yBottom);
562
563 vbvaReportDirtyRect(pDev, &rclBounds);
564}
565
566static void vbvaReportDirtyClip(PVBOXDISPDEV pDev, CLIPOBJ *pco, RECTL *prcl)
567{
568 if (prcl)
569 {
570 vbvaReportDirtyRect(pDev, prcl);
571 }
572 else if (pco)
573 {
574 vbvaReportDirtyRect(pDev, &pco->rclBounds);
575 }
576}
577
578/*
579 * VBVA driver functions.
580 */
581
582void vbvaDrvLineTo(SURFOBJ *pso, CLIPOBJ *pco, BRUSHOBJ *pbo,
583 LONG x1, LONG y1, LONG x2, LONG y2, RECTL *prclBounds, MIX mix)
584{
585 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
586 vbvaReportDirtyClip(pDev, pco, prclBounds);
587}
588
589void vbvaDrvStrokePath(SURFOBJ *pso, PATHOBJ *ppo, CLIPOBJ *pco, XFORMOBJ *pxo,
590 BRUSHOBJ *pbo, POINTL *pptlBrushOrg, LINEATTRS *plineattrs, MIX mix)
591{
592 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
593 vbvaReportDirtyPath(pDev, ppo);
594}
595
596void vbvaDrvFillPath(SURFOBJ *pso, PATHOBJ *ppo, CLIPOBJ *pco, BRUSHOBJ *pbo, POINTL *pptlBrushOrg,
597 MIX mix, FLONG flOptions)
598{
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 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
606 vbvaReportDirtyClip(pDev, pco, NULL);
607}
608
609void vbvaDrvTextOut(SURFOBJ *pso, STROBJ *pstro, FONTOBJ *pfo, CLIPOBJ *pco,
610 RECTL *prclExtra, RECTL *prclOpaque, BRUSHOBJ *pboFore,
611 BRUSHOBJ *pboOpaque, POINTL *pptlOrg, MIX mix)
612{
613 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
614 vbvaReportDirtyClip(pDev, pco, prclOpaque? prclOpaque: &pstro->rclBkGround);
615}
616
617void vbvaDrvSaveScreenBits(SURFOBJ *pso, ULONG iMode, ULONG_PTR ident, RECTL *prcl)
618{
619 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
620
621 Assert(iMode == SS_RESTORE || iMode == SS_SAVE);
622 vbvaReportDirtyRect(pDev, prcl);
623}
624
625void vbvaDrvBitBlt(SURFOBJ *psoTrg, SURFOBJ *psoSrc, SURFOBJ *psoMask, CLIPOBJ *pco, XLATEOBJ *pxlo,
626 RECTL *prclTrg, POINTL *pptlSrc, POINTL *pptlMask, BRUSHOBJ *pbo, POINTL *pptlBrush,
627 ROP4 rop4)
628{
629 PVBOXDISPDEV pDev = (PVBOXDISPDEV)psoTrg->dhpdev;
630 vbvaReportDirtyClip(pDev, pco, prclTrg);
631}
632
633void vbvaDrvStretchBlt(SURFOBJ *psoDest, SURFOBJ *psoSrc, SURFOBJ *psoMask, CLIPOBJ *pco, XLATEOBJ *pxlo,
634 COLORADJUSTMENT *pca, POINTL *pptlHTOrg, RECTL *prclDest, RECTL *prclSrc,
635 POINTL *pptlMask, ULONG iMode)
636{
637 PVBOXDISPDEV pDev = (PVBOXDISPDEV)psoDest->dhpdev;
638 vbvaReportDirtyClip(pDev, pco, prclDest);
639}
640
641void vbvaDrvCopyBits(SURFOBJ *psoDest, SURFOBJ *psoSrc, CLIPOBJ *pco, XLATEOBJ *pxlo,
642 RECTL *prclDest, POINTL *pptlSrc)
643{
644 PVBOXDISPDEV pDev = (PVBOXDISPDEV)psoDest->dhpdev;
645 vbvaReportDirtyClip(pDev, pco, prclDest);
646}
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