![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitblt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256|
Return to bitblt.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga256 |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: bitblt.c
3: *
4: * Banked Frame Buffer bitblit
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: *
8: \**************************************************************************/
9:
10: #include "driver.h"
11:
12: /************************************************************************\
13: * bIntersectRect
14: *
15: * Calculates the intersection between *prcSrc1 and *prcSrc2,
16: * returning the resulting rect in *prcDst. Returns TRUE if
17: * *prcSrc1 intersects *prcSrc2, FALSE otherwise. If there is no
18: * intersection, an empty rect is returned in *prcDst.
19: \************************************************************************/
20:
21: static const RECTL rclEmpty = { 0, 0, 0, 0 };
22:
23: BOOL bIntersectRect(
24: PRECTL prcDst,
25: PRECTL prcSrc1,
26: PRECTL prcSrc2)
27:
28: {
29: prcDst->left = max(prcSrc1->left, prcSrc2->left);
30: prcDst->right = min(prcSrc1->right, prcSrc2->right);
31:
32: // check for empty rect
33:
34: if (prcDst->left < prcDst->right)
35: {
36: prcDst->top = max(prcSrc1->top, prcSrc2->top);
37: prcDst->bottom = min(prcSrc1->bottom, prcSrc2->bottom);
38:
39: // check for empty rect
40:
41: if (prcDst->top < prcDst->bottom)
42: return(TRUE); // not empty
43: }
44:
45: // empty rect
46:
47: *prcDst = rclEmpty;
48:
49: return(FALSE);
50: }
51:
52: /******************************Public*Routine******************************\
53: * BOOL bPuntScreenToScreenCopyBits(ppdev, pco, pxlo, prclDest, pptlSrc)
54: *
55: * Performs a screen-to-screen CopyBits entirely using an intermediate
56: * temporary buffer and GDI.
57: *
58: * We found that on most machines it was faster to have the engine copy
59: * the source to a buffer, then blit the buffer to the destination, than
60: * to have optimized ASM code that copies a word at a time. The reason?
61: * The engine does d-word moves, which are faster than word moves even
62: * going over the bus to a 16 bit display device.
63: *
64: * We could also write optimized ASM code that does d-word moves, but the
65: * win will be marginal, we're time constrained, we also need a routine
66: * like this to handle complex clip objects and palette translates, and
67: * most of the other times we can use planar copies for important things
68: * like scrolls, anyways.
69: *
70: \**************************************************************************/
71:
72: BOOL bPuntScreenToScreenCopyBits(
73: PPDEV ppdev,
74: CLIPOBJ* pco,
75: XLATEOBJ* pxlo,
76: RECTL* prclDest,
77: POINTL* pptlSrc)
78: {
79: RECTL rclDest;
80: POINTL ptlSrc;
81: BOOL b = TRUE;
82:
83: SURFOBJ* pso = ppdev->pSurfObj;
84: SURFOBJ* psoTmp = ppdev->psoTmp;
85:
86: if (prclDest->top < pptlSrc->y)
87: {
88: ////////////////////////////////////////////////////////////////
89: // Do a top-to-bottom copy:
90: ////////////////////////////////////////////////////////////////
91:
92: LONG ySrcBottom;
93: LONG yDestBottom;
94:
95: LONG yDestTop = prclDest->top;
96: LONG ySrcTop = pptlSrc->y;
97: LONG ySrcLast = ySrcTop + (prclDest->bottom - prclDest->top);
98:
99: if (ySrcTop < ppdev->rcl1WindowClip.top ||
100: ySrcTop >= ppdev->rcl1WindowClip.bottom)
101: {
102: ppdev->pfnBankControl(ppdev, ySrcTop, JustifyTop);
103: }
104:
105: pso->pvScan0 = ppdev->pvBitmapStart;
106:
107: while (TRUE)
108: {
109: // Copy an entire source bank into the temporary buffer:
110:
111: ySrcBottom = min(ySrcLast, ppdev->rcl1WindowClip.bottom);
112:
113: ptlSrc.x = pptlSrc->x;
114: ptlSrc.y = ySrcTop;
115:
116: rclDest.left = prclDest->left;
117: rclDest.top = 0;
118: rclDest.right = prclDest->right;
119: rclDest.bottom = ySrcBottom - ySrcTop;
120:
121: b &= EngCopyBits(psoTmp, pso, NULL, NULL, &rclDest, &ptlSrc);
122:
123: yDestBottom = yDestTop + rclDest.bottom;
124:
125: if (ppdev->rcl1WindowClip.top >= yDestBottom)
126: {
127: ppdev->pfnBankControl(ppdev, yDestBottom - 1, JustifyBottom);
128: pso->pvScan0 = ppdev->pvBitmapStart;
129: }
130:
131: while (TRUE)
132: {
133: // Copy the temporary buffer into one or more destination
134: // banks:
135:
136: LONG yThisTop;
137: LONG yThisBottom;
138: LONG yOffset;
139:
140: yThisBottom = min(yDestBottom, ppdev->rcl1WindowClip.bottom);
141: yThisTop = max(yDestTop, ppdev->rcl1WindowClip.top);
142: yOffset = yThisTop - yDestTop;
143:
144: ptlSrc.x = prclDest->left;
145: ptlSrc.y = yOffset;
146:
147: rclDest.left = prclDest->left;
148: rclDest.top = yThisTop;
149: rclDest.right = prclDest->right;
150: rclDest.bottom = yThisBottom;
151:
152: b &= EngCopyBits(pso, psoTmp, pco, pxlo, &rclDest, &ptlSrc);
153:
154: if (yOffset == 0)
155: break;
156:
157: ppdev->pfnBankControl(ppdev, yThisTop - 1, JustifyBottom);
158: pso->pvScan0 = ppdev->pvBitmapStart;
159: }
160:
161: if (ySrcBottom >= ySrcLast)
162: break;
163:
164: yDestTop = yDestBottom;
165: ySrcTop = ySrcBottom;
166:
167: ppdev->pfnBankControl(ppdev, ySrcTop, JustifyTop);
168: pso->pvScan0 = ppdev->pvBitmapStart;
169: }
170: }
171: else
172: {
173: ////////////////////////////////////////////////////////////////
174: // Do a bottom-to-top copy:
175: ////////////////////////////////////////////////////////////////
176:
177: LONG ySrcTop;
178: LONG yDestTop;
179:
180: LONG yDestBottom = prclDest->bottom;
181: LONG ySrcFirst = pptlSrc->y;
182: LONG ySrcBottom = ySrcFirst + (prclDest->bottom - prclDest->top);
183:
184: if (ySrcBottom <= ppdev->rcl1WindowClip.top ||
185: ySrcBottom > ppdev->rcl1WindowClip.bottom)
186: {
187: ppdev->pfnBankControl(ppdev, ySrcBottom - 1, JustifyBottom);
188: }
189:
190: pso->pvScan0 = ppdev->pvBitmapStart;
191:
192: while (TRUE)
193: {
194: // Copy an entire source bank into the temporary buffer:
195:
196: ySrcTop = max(ySrcFirst, ppdev->rcl1WindowClip.top);
197:
198: ptlSrc.x = pptlSrc->x;
199: ptlSrc.y = ySrcTop;
200:
201: rclDest.left = prclDest->left;
202: rclDest.top = 0;
203: rclDest.right = prclDest->right;
204: rclDest.bottom = ySrcBottom - ySrcTop;
205:
206: b &= EngCopyBits(psoTmp, pso, NULL, NULL, &rclDest, &ptlSrc);
207:
208: yDestTop = yDestBottom - rclDest.bottom;
209:
210: if (ppdev->rcl1WindowClip.bottom <= yDestTop)
211: {
212: ppdev->pfnBankControl(ppdev, yDestTop, JustifyTop);
213: pso->pvScan0 = ppdev->pvBitmapStart;
214: }
215:
216: while (TRUE)
217: {
218: // Copy the temporary buffer into one or more destination
219: // banks:
220:
221: LONG yThisTop;
222: LONG yThisBottom;
223: LONG yOffset;
224:
225: yThisTop = max(yDestTop, ppdev->rcl1WindowClip.top);
226: yThisBottom = min(yDestBottom, ppdev->rcl1WindowClip.bottom);
227: yOffset = yThisTop - yDestTop;
228:
229: ptlSrc.x = prclDest->left;
230: ptlSrc.y = yOffset;
231:
232: rclDest.left = prclDest->left;
233: rclDest.top = yThisTop;
234: rclDest.right = prclDest->right;
235: rclDest.bottom = yThisBottom;
236:
237: b &= EngCopyBits(pso, psoTmp, pco, pxlo, &rclDest, &ptlSrc);
238:
239: if (yThisBottom == yDestBottom)
240: break;
241:
242: ppdev->pfnBankControl(ppdev, yThisBottom, JustifyTop);
243: pso->pvScan0 = ppdev->pvBitmapStart;
244: }
245:
246: if (ySrcTop <= ySrcFirst)
247: break;
248:
249: yDestBottom = yDestTop;
250: ySrcBottom = ySrcTop;
251:
252: ppdev->pfnBankControl(ppdev, ySrcBottom - 1, JustifyBottom);
253: pso->pvScan0 = ppdev->pvBitmapStart;
254: }
255: }
256:
257: return(b);
258: }
259:
260: /******************************Public*Routine******************************\
261: * BOOL bPuntScreenToScreenBitBlt(...)
262: *
263: * Performs a screen-to-screen BitBlt entirely using an intermediate temporary
264: * buffer and GDI.
265: *
266: * This function is basically a clone of bPuntScreenToScreenCopyBits,
267: * except that it can handle funky ROPs and stuff.
268: \**************************************************************************/
269:
270: BOOL bPuntScreenToScreenBitBlt(
271: PPDEV ppdev,
272: SURFOBJ* psoMask,
273: CLIPOBJ* pco,
274: XLATEOBJ* pxlo,
275: RECTL* prclDest,
276: POINTL* pptlSrc,
277: POINTL* pptlMask,
278: BRUSHOBJ* pbo,
279: POINTL* pptlBrush,
280: ROP4 rop4)
281: {
282: RECTL rclDest; // Temporary destination rectangle
283: POINTL ptlSrc; // Temporary source point
284: POINTL ptlMask; // Temporary mask offset
285: POINTL ptlMaskAdjust; // Adjustment for mask offset
286: BOOL b = TRUE;
287:
288: SURFOBJ* pso = ppdev->pSurfObj;
289: SURFOBJ* psoTmp = ppdev->psoTmp;
290:
291: if (psoMask != NULL)
292: {
293: ptlMaskAdjust.x = prclDest->left - pptlMask->x;
294: ptlMaskAdjust.y = prclDest->top - pptlMask->y;
295: }
296:
297: if (prclDest->top < pptlSrc->y)
298: {
299: ////////////////////////////////////////////////////////////////
300: // Do a top-to-bottom copy:
301: ////////////////////////////////////////////////////////////////
302:
303: LONG ySrcBottom;
304: LONG yDestBottom;
305:
306: LONG yDestTop = prclDest->top;
307: LONG ySrcTop = pptlSrc->y;
308: LONG ySrcLast = ySrcTop + (prclDest->bottom - prclDest->top);
309:
310: if (ySrcTop < ppdev->rcl1WindowClip.top ||
311: ySrcTop >= ppdev->rcl1WindowClip.bottom)
312: {
313: ppdev->pfnBankControl(ppdev, ySrcTop, JustifyTop);
314: }
315:
316: pso->pvScan0 = ppdev->pvBitmapStart;
317:
318: while (TRUE)
319: {
320: // Copy an entire source bank into the temporary buffer:
321:
322: ySrcBottom = min(ySrcLast, ppdev->rcl1WindowClip.bottom);
323:
324: ptlSrc.x = pptlSrc->x;
325: ptlSrc.y = ySrcTop;
326:
327: rclDest.left = prclDest->left;
328: rclDest.top = 0;
329: rclDest.right = prclDest->right;
330: rclDest.bottom = ySrcBottom - ySrcTop;
331:
332: b &= EngCopyBits(psoTmp, pso, NULL, NULL, &rclDest, &ptlSrc);
333:
334: yDestBottom = yDestTop + rclDest.bottom;
335:
336: if (ppdev->rcl1WindowClip.top >= yDestBottom)
337: {
338: ppdev->pfnBankControl(ppdev, yDestBottom - 1, JustifyBottom);
339: pso->pvScan0 = ppdev->pvBitmapStart;
340: }
341:
342: while (TRUE)
343: {
344: // Copy the temporary buffer into one or more destination
345: // banks:
346:
347: LONG yThisTop;
348: LONG yThisBottom;
349: LONG yOffset;
350:
351: yThisBottom = min(yDestBottom, ppdev->rcl1WindowClip.bottom);
352: yThisTop = max(yDestTop, ppdev->rcl1WindowClip.top);
353: yOffset = yThisTop - yDestTop;
354:
355: ptlSrc.x = prclDest->left;
356: ptlSrc.y = yOffset;
357:
358: rclDest.left = prclDest->left;
359: rclDest.top = yThisTop;
360: rclDest.right = prclDest->right;
361: rclDest.bottom = yThisBottom;
362:
363: ptlMask.x = rclDest.left - ptlMaskAdjust.x;
364: ptlMask.y = rclDest.top - ptlMaskAdjust.y;
365:
366: b &= EngBitBlt(pso, psoTmp, psoMask, pco, pxlo, &rclDest,
367: &ptlSrc, &ptlMask, pbo, pptlBrush, rop4);
368:
369: if (yOffset == 0)
370: break;
371:
372: ppdev->pfnBankControl(ppdev, yThisTop - 1, JustifyBottom);
373: pso->pvScan0 = ppdev->pvBitmapStart;
374: }
375:
376: if (ySrcBottom >= ySrcLast)
377: break;
378:
379: yDestTop = yDestBottom;
380: ySrcTop = ySrcBottom;
381:
382: ppdev->pfnBankControl(ppdev, ySrcTop, JustifyTop);
383: pso->pvScan0 = ppdev->pvBitmapStart;
384: }
385: }
386: else
387: {
388: ////////////////////////////////////////////////////////////////
389: // Do a bottom-to-top copy:
390: ////////////////////////////////////////////////////////////////
391:
392: LONG ySrcTop;
393: LONG yDestTop;
394:
395: LONG yDestBottom = prclDest->bottom;
396: LONG ySrcFirst = pptlSrc->y;
397: LONG ySrcBottom = ySrcFirst + (prclDest->bottom - prclDest->top);
398:
399: if (ySrcBottom <= ppdev->rcl1WindowClip.top ||
400: ySrcBottom > ppdev->rcl1WindowClip.bottom)
401: {
402: ppdev->pfnBankControl(ppdev, ySrcBottom - 1, JustifyBottom);
403: }
404:
405: pso->pvScan0 = ppdev->pvBitmapStart;
406:
407: while (TRUE)
408: {
409: // Copy an entire source bank into the temporary buffer:
410:
411: ySrcTop = max(ySrcFirst, ppdev->rcl1WindowClip.top);
412:
413: ptlSrc.x = pptlSrc->x;
414: ptlSrc.y = ySrcTop;
415:
416: rclDest.left = prclDest->left;
417: rclDest.top = 0;
418: rclDest.right = prclDest->right;
419: rclDest.bottom = ySrcBottom - ySrcTop;
420:
421: b &= EngCopyBits(psoTmp, pso, NULL, NULL, &rclDest, &ptlSrc);
422:
423: yDestTop = yDestBottom - rclDest.bottom;
424:
425: if (ppdev->rcl1WindowClip.bottom <= yDestTop)
426: {
427: ppdev->pfnBankControl(ppdev, yDestTop, JustifyTop);
428: pso->pvScan0 = ppdev->pvBitmapStart;
429: }
430:
431: while (TRUE)
432: {
433: // Copy the temporary buffer into one or more destination
434: // banks:
435:
436: LONG yThisTop;
437: LONG yThisBottom;
438: LONG yOffset;
439:
440: yThisTop = max(yDestTop, ppdev->rcl1WindowClip.top);
441: yThisBottom = min(yDestBottom, ppdev->rcl1WindowClip.bottom);
442: yOffset = yThisTop - yDestTop;
443:
444: ptlSrc.x = prclDest->left;
445: ptlSrc.y = yOffset;
446:
447: rclDest.left = prclDest->left;
448: rclDest.top = yThisTop;
449: rclDest.right = prclDest->right;
450: rclDest.bottom = yThisBottom;
451:
452: ptlMask.x = rclDest.left - ptlMaskAdjust.x;
453: ptlMask.y = rclDest.top - ptlMaskAdjust.y;
454:
455: b &= EngBitBlt(pso, psoTmp, psoMask, pco, pxlo, &rclDest,
456: &ptlSrc, &ptlMask, pbo, pptlBrush, rop4);
457:
458: if (yThisBottom == yDestBottom)
459: break;
460:
461: ppdev->pfnBankControl(ppdev, yThisBottom, JustifyTop);
462: pso->pvScan0 = ppdev->pvBitmapStart;
463: }
464:
465: if (ySrcTop <= ySrcFirst)
466: break;
467:
468: yDestBottom = yDestTop;
469: ySrcBottom = ySrcTop;
470:
471: ppdev->pfnBankControl(ppdev, ySrcBottom - 1, JustifyBottom);
472: pso->pvScan0 = ppdev->pvBitmapStart;
473: }
474: }
475:
476: return(b);
477: }
478:
479: /******************************Public*Data*********************************\
480: * ROP to mix translation table
481: *
482: * Table to translate ternary raster ops to mixes (binary raster ops). Ternary
483: * raster ops that can't be translated to mixes are translated to 0 (0 is not
484: * a valid mix).
485: *
486: \**************************************************************************/
487:
488: UCHAR jRop3ToMix[256] = {
489: R2_BLACK, 0, 0, 0, 0, R2_NOTMERGEPEN, 0, 0,
490: 0, 0, R2_MASKNOTPEN, 0, 0, 0, 0, R2_NOTCOPYPEN,
491: 0, 0, 0, 0, 0, 0, 0, 0,
492: 0, 0, 0, 0, 0, 0, 0, 0,
493: 0, 0, 0, 0, 0, 0, 0, 0,
494: 0, 0, 0, 0, 0, 0, 0, 0,
495: 0, 0, 0, 0, 0, 0, 0, 0,
496: 0, 0, 0, 0, 0, 0, 0, 0,
497: 0, 0, 0, 0, 0, 0, 0, 0,
498: 0, 0, 0, 0, 0, 0, 0, 0,
499: R2_MASKPENNOT, 0, 0, 0, 0, R2_NOT, 0, 0,
500: 0, 0, R2_XORPEN, 0, 0, 0, 0, R2_NOTMASKPEN,
501: 0, 0, 0, 0, 0, 0, 0, 0,
502: 0, 0, 0, 0, 0, 0, 0, 0,
503: 0, 0, 0, 0, 0, 0, 0, 0,
504: 0, 0, 0, 0, 0, 0, 0, 0,
505: 0, 0, 0, 0, 0, 0, 0, 0,
506: 0, 0, 0, 0, 0, 0, 0, 0,
507: 0, 0, 0, 0, 0, 0, 0, 0,
508: 0, 0, 0, 0, 0, 0, 0, 0,
509: R2_MASKPEN, 0, 0, 0, 0, R2_NOTXORPEN, 0, 0,
510: 0, 0, R2_NOP, 0, 0, 0, 0, R2_MERGENOTPEN,
511: 0, 0, 0, 0, 0, 0, 0, 0,
512: 0, 0, 0, 0, 0, 0, 0, 0,
513: 0, 0, 0, 0, 0, 0, 0, 0,
514: 0, 0, 0, 0, 0, 0, 0, 0,
515: 0, 0, 0, 0, 0, 0, 0, 0,
516: 0, 0, 0, 0, 0, 0, 0, 0,
517: 0, 0, 0, 0, 0, 0, 0, 0,
518: 0, 0, 0, 0, 0, 0, 0, 0,
519: R2_COPYPEN, 0, 0, 0, 0, R2_MERGEPENNOT, 0, 0,
520: 0, 0, R2_MERGEPEN, 0, 0, 0, 0, R2_WHITE
521: };
522:
523: /******************************Public*Routine******************************\
524: * BOOL DrvBitBlt(psoDest, psoSrc, psoMask, pco, pxlo, prclDest, pptlSrc,
525: * pptlMask, pbo, pptlBrush, rop4)
526: *
527: * This routine will handle any blit. Perhaps glacially, but it will be
528: * handled.
529: \**************************************************************************/
530:
531: BOOL DrvBitBlt(
532: SURFOBJ* psoDest,
533: SURFOBJ* psoSrc,
534: SURFOBJ* psoMask,
535: CLIPOBJ* pco,
536: XLATEOBJ* pxlo,
537: RECTL* prclDest,
538: POINTL* pptlSrc,
539: POINTL* pptlMask,
540: BRUSHOBJ* pbo,
541: POINTL* pptlBrush,
542: ROP4 rop4)
543: {
544: BOOL b;
545: POINTL ptlSrc;
546: RECTL rclDest;
547: PPDEV ppdev;
548: SURFOBJ* pso;
549: MIX mix; // Mix, when solid fill performed
550: BYTE jClipping;
551: RECTL rclTmp;
552: POINTL ptlTmp;
553: BBENUM bben; // Clip enumerator
554: BOOL bMore; // Clip continuation flag
555: POINTL ptlMask; // Temporary mask for engine call-backs
556: POINTL ptlMaskAdjust; // Adjustment for mask
557: INT iCopyDir;
558:
559: RBRUSH_COLOR rbc; // Pointer to RBRUSH or iSolidColor value
560: PFNFILL pfnFill = vTrgBlt; // Pointer to appropriate fill routine
561: // (solid color by default)
562:
563: // Set up the clipping type
564: if (pco == (CLIPOBJ *) NULL) {
565: // No CLIPOBJ provided, so we don't have to worry about clipping
566: jClipping = DC_TRIVIAL;
567: } else {
568: // Use the CLIPOBJ-provided clipping
569: jClipping = pco->iDComplexity;
570: }
571:
572: // Handle solid fills to the VGA surface with special-case code if planar
573: // mode is supported.
574: // LATER handle non-planar also
575:
576: if (psoDest->iType == STYPE_DEVICE) {
577:
578: // Destination is the VGA surface
579:
580: // Masked cases must be handled differently
581:
582: if ((((PPDEV) psoDest->dhsurf)->fl & DRIVER_PLANAR_CAPABLE) &&
583: ((rop4 & 0xFF) == ((rop4 >> 8) & 0xFF))) {
584:
585: // Special-case static code for no-mask cases
586:
587: // Calculate mix from ROP if possible (not possible if it's truly a
588: // ternary rop or a real rop4, but we can treat all pure binary
589: // rops as mixes rather than rop4s)
590: mix = jRop3ToMix[rop4 & 0xFF];
591:
592: switch (mix) {
593: case R2_MASKNOTPEN:
594: case R2_NOTCOPYPEN:
595: case R2_XORPEN:
596: case R2_MASKPEN:
597: case R2_NOTXORPEN:
598: case R2_MERGENOTPEN:
599: case R2_COPYPEN:
600: case R2_MERGEPEN:
601: case R2_NOTMERGEPEN:
602: case R2_MASKPENNOT:
603: case R2_NOTMASKPEN:
604: case R2_MERGEPENNOT:
605:
606: // vTrgBlt can only handle solid color fills
607:
608: if (pbo->iSolidColor != 0xffffffff)
609: {
610: rbc.iSolidColor = pbo->iSolidColor;
611: }
612: else
613: {
614: rbc.prb = (RBRUSH*) pbo->pvRbrush;
615: if (rbc.prb == NULL)
616: {
617: rbc.prb = (RBRUSH*) BRUSHOBJ_pvGetRbrush(pbo);
618: if (rbc.prb == NULL)
619: {
620: // If we haven't realized the brush, punt the call
621: // to the engine:
622:
623: break;
624: }
625: }
626: if (!(rbc.prb->fl & RBRUSH_BLACKWHITE) &&
627: (mix != R2_COPYPEN))
628: {
629: // Only black/white brushes can handle ROPs other
630: // than COPYPEN:
631:
632: break;
633: }
634:
635: if (rbc.prb->fl & RBRUSH_NCOLOR)
636: pfnFill = vColorPat;
637: else
638: pfnFill = vMonoPat;
639: }
640:
641: // Rops that are implicit solid colors
642:
643: case R2_NOT:
644: case R2_WHITE:
645: case R2_BLACK:
646: // We can do a special-case solid fill
647:
648: switch(jClipping) {
649: case DC_TRIVIAL:
650:
651: // Just fill the rectangle:
652:
653: (*pfnFill)((PPDEV) psoDest->dhsurf, 1,
654: prclDest, mix, rbc, pptlBrush);
655:
656: break;
657:
658: case DC_RECT:
659:
660: // Clip the solid fill to the clip rectangle
661: if (!bIntersectRect(&rclTmp, prclDest,
662: &pco->rclBounds))
663: return(TRUE);
664:
665: // Fill the clipped rectangle
666:
667: (*pfnFill)((PPDEV) psoDest->dhsurf, 1,
668: &rclTmp, mix, rbc, pptlBrush);
669:
670: break;
671:
672: case DC_COMPLEX:
673:
674: ppdev = (PPDEV) psoDest->dhsurf;
675:
676: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES,
677: CD_ANY, BB_RECT_LIMIT);
678:
679: do {
680: bMore = CLIPOBJ_bEnum(pco,(ULONG) sizeof(bben),
681: (PVOID) &bben);
682:
683: if (bben.c > 0)
684: {
685: RECTL* prclEnd = &bben.arcl[bben.c];
686: RECTL* prcl = &bben.arcl[0];
687:
688: do {
689: bIntersectRect(prcl, prcl, prclDest);
690: prcl++;
691:
692: } while (prcl < prclEnd);
693:
694: (*pfnFill)(ppdev, bben.c, bben.arcl,
695: mix, rbc, pptlBrush);
696: }
697:
698: } while(bMore);
699: }
700:
701: case R2_NOP:
702: return(TRUE);
703:
704: default:
705: break;
706: }
707: }
708: }
709:
710: // Get the correct surface object for the target and the source
711:
712: if (psoDest->iType == STYPE_DEVICE) {
713:
714: if ((psoSrc != NULL) && (psoSrc->iType == STYPE_DEVICE)) {
715:
716: ////////////////////////////////////////////////////////////////
717: // BitBlt screen-to-screen:
718: ////////////////////////////////////////////////////////////////
719:
720: ppdev = (PPDEV) psoDest->dhsurf;
721:
722: // See if we can do a simple CopyBits:
723:
724: if (rop4 == 0x0000CCCC)
725: {
726: ppdev = (PPDEV) psoDest->dhsurf;
727:
728: // We can handle quadpixel-aligned screen-to-screen blts with
729: // no translation:
730:
731: if ((((pptlSrc->x ^ prclDest->left) & 3) == 0) &&
732: (ppdev->fl & DRIVER_PLANAR_CAPABLE) &&
733: ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)))
734: {
735: switch(jClipping)
736: {
737: case DC_TRIVIAL:
738: vPlanarCopyBits(ppdev, prclDest, pptlSrc);
739: return(TRUE);
740:
741: case DC_RECT:
742:
743: // Clip the target rectangle to the clip rectangle:
744:
745: if (!bIntersectRect(&rclTmp, prclDest, &pco->rclBounds))
746: {
747: DISPDBG((0, "DrvBitBlt: Nothing to draw."));
748: return(TRUE);
749: }
750:
751: ptlTmp.x = pptlSrc->x + rclTmp.left - prclDest->left;
752: ptlTmp.y = pptlSrc->y + rclTmp.top - prclDest->top;
753:
754: vPlanarCopyBits(ppdev, &rclTmp, &ptlTmp);
755: return(TRUE);
756:
757: case DC_COMPLEX:
758: if (pptlSrc->y >= prclDest->top)
759: {
760: if (pptlSrc->x >= prclDest->left)
761: iCopyDir = CD_RIGHTDOWN;
762: else
763: iCopyDir = CD_LEFTDOWN;
764: }
765: else
766: {
767: if (pptlSrc->x >= prclDest->left)
768: iCopyDir = CD_RIGHTUP;
769: else
770: iCopyDir = CD_LEFTUP;
771: }
772:
773: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, iCopyDir, 0);
774:
775: do {
776: RECTL* prcl;
777: RECTL* prclEnd;
778:
779: bMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(bben),
780: (PVOID) &bben);
781:
782: prclEnd = &bben.arcl[bben.c];
783: for (prcl = bben.arcl; prcl < prclEnd; prcl++)
784: {
785: if (bIntersectRect(prcl, prclDest, prcl))
786: {
787: ptlTmp.x = pptlSrc->x + prcl->left - prclDest->left;
788: ptlTmp.y = pptlSrc->y + prcl->top - prclDest->top;
789:
790: vPlanarCopyBits(ppdev, prcl, &ptlTmp);
791: }
792: }
793: } while (bMore);
794:
795: return(TRUE);
796: }
797: }
798:
799: // Can't handle in hardware, so punt:
800:
801: return(bPuntScreenToScreenCopyBits(ppdev,
802: pco,
803: pxlo,
804: prclDest,
805: pptlSrc));
806: }
807:
808: // It's more complicated than a CopyBits, so punt it:
809:
810: return(bPuntScreenToScreenBitBlt(ppdev,
811: psoMask,
812: pco,
813: pxlo,
814: prclDest,
815: pptlSrc,
816: pptlMask,
817: pbo,
818: pptlBrush,
819: rop4));
820: }
821:
822: ////////////////////////////////////////////////////////////////
823: // BitBlt to screen:
824: ////////////////////////////////////////////////////////////////
825:
826: ppdev = (PPDEV) psoDest->dhsurf;
827:
828: if ((rop4 == 0x0000CCCC) &&
829: (psoSrc->iBitmapFormat == BMF_8BPP) &&
830: ((pxlo == NULL) || (pxlo->flXlate == XO_TRIVIAL)))
831: {
832: // We have special code for the common 8bpp from memory to screen
833: // with no ROPs:
834:
835: switch(jClipping)
836: {
837: case DC_TRIVIAL:
838: vSrcCopy8bpp(ppdev, prclDest, pptlSrc,
839: psoSrc->lDelta, psoSrc->pvScan0);
840: return(TRUE);
841:
842: case DC_RECT:
843:
844: // Clip the blt to the clip rectangle
845:
846: bIntersectRect(&rclTmp, prclDest, &pco->rclBounds);
847:
848: ptlTmp.x = pptlSrc->x + rclTmp.left - prclDest->left;
849: ptlTmp.y = pptlSrc->y + rclTmp.top - prclDest->top;
850:
851: vSrcCopy8bpp(ppdev, &rclTmp, &ptlTmp,
852: psoSrc->lDelta, psoSrc->pvScan0);
853:
854: return(TRUE);
855:
856: case DC_COMPLEX:
857:
858: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES,
859: CD_ANY, BB_RECT_LIMIT);
860:
861: do {
862: bMore = CLIPOBJ_bEnum(pco,(ULONG) sizeof(bben),
863: (PVOID) &bben);
864:
865: if (bben.c > 0)
866: {
867: RECTL* prclEnd = &bben.arcl[bben.c];
868: RECTL* prcl = &bben.arcl[0];
869:
870: do {
871: bIntersectRect(prcl, prcl, prclDest);
872:
873: ptlTmp.x = pptlSrc->x + prcl->left
874: - prclDest->left;
875: ptlTmp.y = pptlSrc->y + prcl->top
876: - prclDest->top;
877:
878: vSrcCopy8bpp(ppdev, prcl, &ptlTmp,
879: psoSrc->lDelta, psoSrc->pvScan0);
880:
881: prcl++;
882:
883: } while (prcl < prclEnd);
884: }
885:
886: } while(bMore);
887:
888: return(TRUE);
889: }
890: }
891:
892: // Punt the memory-to-screen call back to the engine:
893:
894: if (psoMask != NULL)
895: {
896: ptlMaskAdjust.x = prclDest->left - pptlMask->x;
897: ptlMaskAdjust.y = prclDest->top - pptlMask->y;
898: }
899:
900: pso = ppdev->pSurfObj;
901:
902: vBankStartBltDest(ppdev, pso, pptlSrc, prclDest, &ptlSrc, &rclDest);
903:
904: do {
905: ptlMask.x = rclDest.left - ptlMaskAdjust.x;
906: ptlMask.y = rclDest.top - ptlMaskAdjust.y;
907:
908: b = EngBitBlt(pso,
909: psoSrc,
910: psoMask,
911: pco,
912: pxlo,
913: &rclDest,
914: &ptlSrc,
915: &ptlMask,
916: pbo,
917: pptlBrush,
918: rop4);
919:
920: } while (b && bBankEnumBltDest(ppdev, pso, pptlSrc, prclDest,
921: &ptlSrc, &rclDest));
922:
923: return(b);
924: }
925: else if ((psoSrc != NULL) && (psoSrc->iType == STYPE_DEVICE))
926: {
927: ////////////////////////////////////////////////////////////////
928: // BitBlt from screen:
929: ////////////////////////////////////////////////////////////////
930:
931: if (psoMask != NULL)
932: {
933: ptlMaskAdjust.x = prclDest->left - pptlMask->x;
934: ptlMaskAdjust.y = prclDest->top - pptlMask->y;
935: }
936:
937: ppdev = (PPDEV) psoSrc->dhsurf;
938: pso = ppdev->pSurfObj;
939:
940: vBankStartBltSrc(ppdev, pso, pptlSrc, prclDest, &ptlSrc, &rclDest);
941:
942: do {
943: ptlMask.x = rclDest.left - ptlMaskAdjust.x;
944: ptlMask.y = rclDest.top - ptlMaskAdjust.y;
945:
946: b = EngBitBlt(psoDest,
947: pso,
948: psoMask,
949: pco,
950: pxlo,
951: &rclDest,
952: &ptlSrc,
953: &ptlMask,
954: pbo,
955: pptlBrush,
956: rop4);
957:
958: } while (b && bBankEnumBltSrc(ppdev, pso, pptlSrc, prclDest,
959: &ptlSrc, &rclDest));
960:
961: return(b);
962: }
963:
964: RIP("Got a funky format?");
965: return(FALSE);
966: }
967:
968: /***************************************************************************\
969: * DrvCopyBits
970: \***************************************************************************/
971:
972: BOOL DrvCopyBits(
973: SURFOBJ* psoDest,
974: SURFOBJ* psoSrc,
975: CLIPOBJ* pco,
976: XLATEOBJ* pxlo,
977: RECTL* prclDest,
978: POINTL* pptlSrc)
979: {
980: BOOL b;
981: POINTL ptlSrc;
982: RECTL rclDest;
983: PPDEV ppdev;
984: SURFOBJ* pso;
985: BBENUM bben;
986: BOOL bMore;
987: BYTE jClipping;
988: POINTL ptlTmp;
989: RECTL rclTmp;
990: INT iCopyDir;
991:
992: // Get the correct surface object for the target and the source
993:
994: if (psoDest->iType == STYPE_DEVICE)
995: {
996: // We have to special case screen-to-screen operations:
997:
998: if ((psoSrc != NULL) && (psoSrc->iType == STYPE_DEVICE))
999: {
1000:
1001: ////////////////////////////////////////////////////////////////
1002: // CopyBits screen-to-screen:
1003: ////////////////////////////////////////////////////////////////
1004:
1005: ppdev = (PPDEV) psoDest->dhsurf;
1006:
1007: // We check to see if we can do a planar copy, because usually
1008: // it will be faster. But the hardware has to be capable of
1009: // doing it, and the source and destination must be 4-pel
1010: // aligned.
1011:
1012: if ((((pptlSrc->x ^ prclDest->left) & 3) == 0) &&
1013: (ppdev->fl & DRIVER_PLANAR_CAPABLE) &&
1014: ((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL)))
1015: {
1016: jClipping = (pco != NULL) ? pco->iDComplexity : DC_TRIVIAL;
1017:
1018: switch(jClipping)
1019: {
1020: case DC_TRIVIAL:
1021: vPlanarCopyBits(ppdev, prclDest, pptlSrc);
1022: return(TRUE);
1023:
1024: case DC_RECT:
1025: // Clip the target rectangle to the clip rectangle:
1026:
1027: if (!bIntersectRect(&rclTmp, prclDest, &pco->rclBounds))
1028: {
1029: DISPDBG((0, "DrvCopyBits: Nothing to draw."));
1030: return(TRUE);
1031: }
1032:
1033: ptlTmp.x = pptlSrc->x + rclTmp.left - prclDest->left;
1034: ptlTmp.y = pptlSrc->y + rclTmp.top - prclDest->top;
1035:
1036: vPlanarCopyBits(ppdev, &rclTmp, &ptlTmp);
1037: return(TRUE);
1038:
1039: case DC_COMPLEX:
1040: if (pptlSrc->y >= prclDest->top)
1041: {
1042: if (pptlSrc->x >= prclDest->left)
1043: iCopyDir = CD_RIGHTDOWN;
1044: else
1045: iCopyDir = CD_LEFTDOWN;
1046: }
1047: else
1048: {
1049: if (pptlSrc->x >= prclDest->left)
1050: iCopyDir = CD_RIGHTUP;
1051: else
1052: iCopyDir = CD_LEFTUP;
1053: }
1054:
1055: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, iCopyDir, 0);
1056:
1057: do {
1058: RECTL* prcl;
1059: RECTL* prclEnd;
1060:
1061: bMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(bben),
1062: (PVOID) &bben);
1063:
1064: prclEnd = &bben.arcl[bben.c];
1065: for (prcl = bben.arcl; prcl < prclEnd; prcl++)
1066: {
1067: if (bIntersectRect(prcl, prclDest, prcl))
1068: {
1069: ptlTmp.x = pptlSrc->x + prcl->left - prclDest->left;
1070: ptlTmp.y = pptlSrc->y + prcl->top - prclDest->top;
1071:
1072: vPlanarCopyBits(ppdev, prcl, &ptlTmp);
1073: }
1074: }
1075: } while (bMore);
1076:
1077: return(TRUE);
1078: }
1079: }
1080:
1081: return(bPuntScreenToScreenCopyBits(ppdev,
1082: pco,
1083: pxlo,
1084: prclDest,
1085: pptlSrc));
1086: }
1087:
1088: ////////////////////////////////////////////////////////////////
1089: // CopyBits to screen:
1090: ////////////////////////////////////////////////////////////////
1091:
1092: ppdev = (PPDEV) psoDest->dhsurf;
1093:
1094: if ((psoSrc->iBitmapFormat == BMF_8BPP) &&
1095: ((pxlo == NULL) || (pxlo->flXlate == XO_TRIVIAL)))
1096: {
1097: // We have special code for the common 8bpp from memory to screen
1098: // with no ROPs:
1099:
1100: jClipping = (pco != NULL) ? pco->iDComplexity : DC_TRIVIAL;
1101:
1102: switch(jClipping)
1103: {
1104: case DC_TRIVIAL:
1105: vSrcCopy8bpp(ppdev, prclDest, pptlSrc,
1106: psoSrc->lDelta, psoSrc->pvScan0);
1107: return(TRUE);
1108:
1109: case DC_RECT:
1110:
1111: // Clip the blt to the clip rectangle
1112:
1113: bIntersectRect(&rclTmp, prclDest, &pco->rclBounds);
1114:
1115: ptlTmp.x = pptlSrc->x + rclTmp.left - prclDest->left;
1116: ptlTmp.y = pptlSrc->y + rclTmp.top - prclDest->top;
1117:
1118: vSrcCopy8bpp(ppdev, &rclTmp, &ptlTmp,
1119: psoSrc->lDelta, psoSrc->pvScan0);
1120:
1121: return(TRUE);
1122:
1123: case DC_COMPLEX:
1124:
1125: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES,
1126: CD_ANY, BB_RECT_LIMIT);
1127:
1128: do {
1129: bMore = CLIPOBJ_bEnum(pco,(ULONG) sizeof(bben),
1130: (PVOID) &bben);
1131:
1132: if (bben.c > 0)
1133: {
1134: RECTL* prclEnd = &bben.arcl[bben.c];
1135: RECTL* prcl = &bben.arcl[0];
1136:
1137: do {
1138: bIntersectRect(prcl, prcl, prclDest);
1139:
1140: ptlTmp.x = pptlSrc->x + prcl->left
1141: - prclDest->left;
1142: ptlTmp.y = pptlSrc->y + prcl->top
1143: - prclDest->top;
1144:
1145: vSrcCopy8bpp(ppdev, prcl, &ptlTmp,
1146: psoSrc->lDelta, psoSrc->pvScan0);
1147:
1148: prcl++;
1149:
1150: } while (prcl < prclEnd);
1151: }
1152:
1153: } while(bMore);
1154:
1155: return(TRUE);
1156: }
1157: }
1158:
1159: // Fall back to the engine:
1160:
1161: pso = ppdev->pSurfObj;
1162: vBankStartBltDest(ppdev, pso, pptlSrc, prclDest, &ptlSrc, &rclDest);
1163:
1164: do {
1165: b = EngCopyBits(pso,
1166: psoSrc,
1167: pco,
1168: pxlo,
1169: &rclDest,
1170: &ptlSrc);
1171:
1172: } while (b && bBankEnumBltDest(ppdev, pso, pptlSrc, prclDest,
1173: &ptlSrc, &rclDest));
1174:
1175: return(b);
1176: }
1177: else if ((psoSrc != NULL) && (psoSrc->iType == STYPE_DEVICE))
1178: {
1179: ////////////////////////////////////////////////////////////////
1180: // CopyBits from screen:
1181: ////////////////////////////////////////////////////////////////
1182:
1183: ppdev = (PPDEV) psoSrc->dhsurf;
1184: pso = ppdev->pSurfObj;
1185:
1186: vBankStartBltSrc(ppdev, pso, pptlSrc, prclDest, &ptlSrc, &rclDest);
1187:
1188: do {
1189: b = EngCopyBits(psoDest,
1190: pso,
1191: pco,
1192: pxlo,
1193: &rclDest,
1194: &ptlSrc);
1195:
1196: } while (b && bBankEnumBltSrc(ppdev, pso, pptlSrc, prclDest,
1197: &ptlSrc, &rclDest));
1198:
1199: return(b);
1200: }
1201: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.