VirtualBox

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

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

GA/NT/Graphics: warnings
  • 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 63033 2016-08-05 11:19:40Z 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 int rc;
323 DWORD dwrc;
324 ULONG cbReturned;
325 QUERYHGSMIRESULT info;
326 HGSMIQUERYCALLBACKS callbacks;
327 HGSMIQUERYCPORTPROCS portProcs;
328 LOGF_ENTER();
329
330 /* Check if HGSMI is supported and obtain necessary info */
331 rc = VBoxDispMPQueryHGSMIInfo(pDev->hDriver, &info);
332 if (RT_SUCCESS(rc))
333 {
334 rc = VBoxDispMPQueryHGSMICallbacks(pDev->hDriver, &callbacks);
335 if (RT_SUCCESS(rc))
336 {
337 rc = VBoxDispMPHGSMIQueryPortProcs(pDev->hDriver, &portProcs);
338 }
339 }
340 if (RT_SUCCESS(rc))
341 {
342 pDev->hgsmi.bSupported = TRUE;
343
344 pDev->hgsmi.mp = callbacks;
345 pDev->vpAPI = portProcs;
346 }
347
348 if (pDev->hgsmi.bSupported)
349 {
350 HGSMIHANDLERENABLE HandlerReg;
351
352 memset(&HandlerReg, 0, sizeof(HandlerReg));
353 HandlerReg.u8Channel = HGSMI_CH_VBVA;
354 dwrc = EngDeviceIoControl(pDev->hDriver, IOCTL_VIDEO_HGSMI_HANDLER_ENABLE, &HandlerReg, sizeof(HandlerReg),
355 0, NULL, &cbReturned);
356 VBOX_WARN_WINERR(dwrc);
357
358#ifdef VBOX_WITH_VIDEOHWACCEL
359 if (NO_ERROR == dwrc)
360 {
361 VBoxDispVHWAInit(pDev);
362 }
363#endif
364 }
365
366 /* Check if we have enough VRAM and update layout info.
367 * 0=Framebuffer(fixed)->DDrawHeap(all left vram)->VBVABuffer(64k..cbFramebuffer)->DisplayInfo(fixed)->=EndOfVRAM
368 */
369 if (pDev->hgsmi.bSupported)
370 {
371 ULONG cbAvailable;
372 VBOXDISPVRAMLAYOUT *vram = &pDev->layout;
373
374 pDev->iDevice = info.iDevice;
375
376 vram->cbVRAM = pDev->memInfo.VideoRamLength;
377
378 vram->offFramebuffer = 0;
379 vram->cbFramebuffer = RT_ALIGN_32(pDev->memInfo.FrameBufferLength, 0x1000);
380 cbAvailable = vram->cbVRAM - vram->cbFramebuffer;
381
382 if (cbAvailable <= info.u32DisplayInfoSize)
383 {
384 pDev->hgsmi.bSupported = FALSE;
385 }
386 else
387 {
388 vram->offDisplayInfo = vram->cbVRAM - info.u32DisplayInfoSize;
389 vram->cbDisplayInfo = info.u32DisplayInfoSize;
390 cbAvailable -= vram->cbDisplayInfo;
391
392 for (vram->cbVBVABuffer = vram->cbFramebuffer;
393 vram->cbVBVABuffer >= info.u32MinVBVABufferSize;
394 vram->cbVBVABuffer /= 2)
395 {
396 if (vram->cbVBVABuffer < cbAvailable)
397 {
398 break;
399 }
400 }
401
402 if (vram->cbVBVABuffer >= cbAvailable)
403 {
404 pDev->hgsmi.bSupported = FALSE;
405 }
406 else
407 {
408 vram->offDDrawHeap = vram->offFramebuffer + vram->cbFramebuffer;
409
410 cbAvailable -= vram->cbVBVABuffer;
411 vram->cbDDrawHeap = cbAvailable;
412
413 vram->offVBVABuffer = vram->offDDrawHeap + vram->cbDDrawHeap;
414 }
415 }
416 }
417
418 /* Setup HGSMI heap in the display information area.
419 * The area has some space reserved for HGSMI event flags in the beginning.
420 */
421 if (pDev->hgsmi.bSupported)
422 {
423 LOG(("offBase=%#x", info.areaDisplay.offBase));
424
425 rc = HGSMIHeapSetup(&pDev->hgsmi.ctx.heapCtx,
426 (uint8_t *)pDev->memInfo.VideoRamBase+pDev->layout.offDisplayInfo+sizeof(HGSMIHOSTFLAGS),
427 pDev->layout.cbDisplayInfo-sizeof(HGSMIHOSTFLAGS),
428 info.areaDisplay.offBase+pDev->layout.offDisplayInfo+sizeof(HGSMIHOSTFLAGS),
429 &g_hgsmiEnvDisp);
430
431 if (RT_SUCCESS(rc))
432 {
433 pDev->hgsmi.ctx.port = info.IOPortGuestCommand;
434 }
435 else
436 {
437 VBOX_WARNRC(rc);
438 pDev->hgsmi.bSupported = FALSE;
439 }
440 }
441
442 /* If we don't have HGSMI or doesn't have enough VRAM, setup layout without VBVA buffer and display info */
443 if (!pDev->hgsmi.bSupported)
444 {
445 VBOXDISPVRAMLAYOUT *vram = &pDev->layout;
446
447 pDev->iDevice = 0;
448
449 /* Setup a layout without both the VBVA buffer and the display information. */
450 vram->cbVRAM = pDev->memInfo.VideoRamLength;
451
452 vram->offFramebuffer = 0;
453 vram->cbFramebuffer = RT_ALIGN_32(pDev->memInfo.FrameBufferLength, 0x1000);
454
455 vram->offDDrawHeap = vram->offFramebuffer + vram->cbFramebuffer;
456 vram->cbDDrawHeap = vram->cbVRAM - vram->offDDrawHeap;
457
458 vram->offVBVABuffer = vram->offDDrawHeap + vram->cbDDrawHeap;
459 vram->cbVBVABuffer = 0;
460
461 vram->offDisplayInfo = vram->offVBVABuffer + vram->cbVBVABuffer;
462 vram->cbDisplayInfo = 0;
463 }
464
465 /* Update buffer layout in VBVA context info */
466 VBoxVBVASetupBufferContext(&pDev->vbvaCtx, pDev->layout.offVBVABuffer, pDev->layout.cbVBVABuffer);
467
468 LOG(("\n"
469 " cbVRAM=%#X\n"
470 " offFramebuffer=%#X cbFramebuffer=%#X\n"
471 " offDDrawHeap=%#X cbDDrawHeap=%#X\n"
472 " offVBVABuffer=%#X cbVBVABuffer=%#X\n"
473 " offDisplayInfo=%#X cbDisplayInfo=%#X\n",
474 pDev->layout.cbVRAM,
475 pDev->layout.offFramebuffer, pDev->layout.cbFramebuffer,
476 pDev->layout.offDDrawHeap, pDev->layout.cbDDrawHeap,
477 pDev->layout.offVBVABuffer, pDev->layout.cbVBVABuffer,
478 pDev->layout.offDisplayInfo, pDev->layout.cbDisplayInfo
479 ));
480
481 LOGF_LEAVE();
482 return VINF_SUCCESS;
483}
484
485void VBoxDispVBVAHostCommandComplete(PVBOXDISPDEV pDev, VBVAHOSTCMD *pCmd)
486{
487 pDev->hgsmi.mp.pfnCompletionHandler(pDev->hgsmi.mp.hContext, pCmd);
488}
489
490void vbvaReportDirtyRect(PVBOXDISPDEV pDev, RECTL *pRectOrig)
491{
492 if (pDev && pRectOrig)
493 {
494
495 LOG(("dirty rect: left %d, top: %d, width: %d, height: %d",
496 pRectOrig->left, pRectOrig->top,
497 pRectOrig->right - pRectOrig->left, pRectOrig->bottom - pRectOrig->top));
498
499 VBVACMDHDR hdr;
500 RECTL rect;
501
502 /* Ensure correct order. */
503 if (pRectOrig->left <= pRectOrig->right)
504 {
505 rect.left = pRectOrig->left;
506 rect.right = pRectOrig->right;
507 }
508 else
509 {
510 rect.left = pRectOrig->right;
511 rect.right = pRectOrig->left;
512 }
513
514 if (pRectOrig->top <= pRectOrig->bottom)
515 {
516 rect.top = pRectOrig->top;
517 rect.bottom = pRectOrig->bottom;
518 }
519 else
520 {
521 rect.top = pRectOrig->bottom;
522 rect.bottom = pRectOrig->top;
523 }
524
525 /* Clip the rectangle. */
526 rect.left = RT_CLAMP(rect.left, 0, (LONG)pDev->mode.ulWidth);
527 rect.top = RT_CLAMP(rect.top, 0, (LONG)pDev->mode.ulHeight);
528 rect.right = RT_CLAMP(rect.right, 0, (LONG)pDev->mode.ulWidth);
529 rect.bottom = RT_CLAMP(rect.bottom, 0, (LONG)pDev->mode.ulHeight);
530
531 /* If the rectangle is empty, still report it. */
532 if (rect.right < rect.left)
533 {
534 rect.right = rect.left;
535 }
536 if (rect.bottom < rect.top)
537 {
538 rect.bottom = rect.top;
539 }
540
541 hdr.x = (int16_t)(rect.left + pDev->orgDev.x);
542 hdr.y = (int16_t)(rect.top + pDev->orgDev.y);
543 hdr.w = (uint16_t)(rect.right - rect.left);
544 hdr.h = (uint16_t)(rect.bottom - rect.top);
545
546 VBoxVBVAWrite(&pDev->vbvaCtx, &pDev->hgsmi.ctx, &hdr, sizeof(hdr));
547 }
548}
549
550static void vbvaReportDirtyPath(PVBOXDISPDEV pDev, PATHOBJ *ppo)
551{
552 RECTFX rcfxBounds;
553 RECTL rclBounds;
554
555 PATHOBJ_vGetBounds(ppo, &rcfxBounds);
556
557 rclBounds.left = FXTOLFLOOR(rcfxBounds.xLeft);
558 rclBounds.right = FXTOLCEILING(rcfxBounds.xRight);
559 rclBounds.top = FXTOLFLOOR(rcfxBounds.yTop);
560 rclBounds.bottom = FXTOLCEILING(rcfxBounds.yBottom);
561
562 vbvaReportDirtyRect(pDev, &rclBounds);
563}
564
565static void vbvaReportDirtyClip(PVBOXDISPDEV pDev, CLIPOBJ *pco, RECTL *prcl)
566{
567 if (prcl)
568 {
569 vbvaReportDirtyRect(pDev, prcl);
570 }
571 else if (pco)
572 {
573 vbvaReportDirtyRect(pDev, &pco->rclBounds);
574 }
575}
576
577/*
578 * VBVA driver functions.
579 */
580
581void vbvaDrvLineTo(SURFOBJ *pso, CLIPOBJ *pco, BRUSHOBJ *pbo,
582 LONG x1, LONG y1, LONG x2, LONG y2, RECTL *prclBounds, MIX mix)
583{
584 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
585 vbvaReportDirtyClip(pDev, pco, prclBounds);
586}
587
588void vbvaDrvStrokePath(SURFOBJ *pso, PATHOBJ *ppo, CLIPOBJ *pco, XFORMOBJ *pxo,
589 BRUSHOBJ *pbo, POINTL *pptlBrushOrg, LINEATTRS *plineattrs, MIX mix)
590{
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 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
599 vbvaReportDirtyPath(pDev, ppo);
600}
601
602void vbvaDrvPaint(SURFOBJ *pso, CLIPOBJ *pco, BRUSHOBJ *pbo, POINTL *pptlBrushOrg, MIX mix)
603{
604 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
605 vbvaReportDirtyClip(pDev, pco, NULL);
606}
607
608void vbvaDrvTextOut(SURFOBJ *pso, STROBJ *pstro, FONTOBJ *pfo, CLIPOBJ *pco,
609 RECTL *prclExtra, RECTL *prclOpaque, BRUSHOBJ *pboFore,
610 BRUSHOBJ *pboOpaque, POINTL *pptlOrg, MIX mix)
611{
612 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
613 vbvaReportDirtyClip(pDev, pco, prclOpaque? prclOpaque: &pstro->rclBkGround);
614}
615
616void vbvaDrvSaveScreenBits(SURFOBJ *pso, ULONG iMode, ULONG_PTR ident, RECTL *prcl)
617{
618 PVBOXDISPDEV pDev = (PVBOXDISPDEV)pso->dhpdev;
619
620 Assert(iMode == SS_RESTORE || iMode == SS_SAVE);
621 vbvaReportDirtyRect(pDev, prcl);
622}
623
624void vbvaDrvBitBlt(SURFOBJ *psoTrg, SURFOBJ *psoSrc, SURFOBJ *psoMask, CLIPOBJ *pco, XLATEOBJ *pxlo,
625 RECTL *prclTrg, POINTL *pptlSrc, POINTL *pptlMask, BRUSHOBJ *pbo, POINTL *pptlBrush,
626 ROP4 rop4)
627{
628 PVBOXDISPDEV pDev = (PVBOXDISPDEV)psoTrg->dhpdev;
629 vbvaReportDirtyClip(pDev, pco, prclTrg);
630}
631
632void vbvaDrvStretchBlt(SURFOBJ *psoDest, SURFOBJ *psoSrc, SURFOBJ *psoMask, CLIPOBJ *pco, XLATEOBJ *pxlo,
633 COLORADJUSTMENT *pca, POINTL *pptlHTOrg, RECTL *prclDest, RECTL *prclSrc,
634 POINTL *pptlMask, ULONG iMode)
635{
636 PVBOXDISPDEV pDev = (PVBOXDISPDEV)psoDest->dhpdev;
637 vbvaReportDirtyClip(pDev, pco, prclDest);
638}
639
640void vbvaDrvCopyBits(SURFOBJ *psoDest, SURFOBJ *psoSrc, CLIPOBJ *pco, XLATEOBJ *pxlo,
641 RECTL *prclDest, POINTL *pptlSrc)
642{
643 PVBOXDISPDEV pDev = (PVBOXDISPDEV)psoDest->dhpdev;
644 vbvaReportDirtyClip(pDev, pco, prclDest);
645}
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