![[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 / vga|
Return to bitblt.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: bitblt.c
3: *
4: * BitBlt
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: \**************************************************************************/
8: #include "driver.h"
9: #include "bitblt.h"
10:
11: BOOL bConvertBrush(BRUSHINST *pbri);
12: VOID vCompiledBlt(PDEVSURF,LONG,LONG,PDEVSURF,LONG,LONG,
13: LONG,LONG,ULONG,BRUSHINST *,ULONG,ULONG,ULONG *,POINTL *);
14:
15: /******************************Public*Data*********************************\
16: * ROP translation table
17: *
18: * Translates the usual ternary rop into A-vector notation. Each bit in
19: * this new notation corresponds to a term in a polynomial translation of
20: * the rop.
21: *
22: * Rop(D,S,P) = a + a D + a S + a P + a DS + a DP + a SP + a DSP
23: * 0 d s p ds dp sp dsp
24: *
25: * History:
26: * 24-Aug-1990 -by- Donald Sidoroff [donalds]
27: * Added it as a global table for the VGA driver.
28: \**************************************************************************/
29:
30: BYTE gajRop[] =
31: {
32: 0x00, 0xff, 0xb2, 0x4d, 0xd4, 0x2b, 0x66, 0x99,
33: 0x90, 0x6f, 0x22, 0xdd, 0x44, 0xbb, 0xf6, 0x09,
34: 0xe8, 0x17, 0x5a, 0xa5, 0x3c, 0xc3, 0x8e, 0x71,
35: 0x78, 0x87, 0xca, 0x35, 0xac, 0x53, 0x1e, 0xe1,
36: 0xa0, 0x5f, 0x12, 0xed, 0x74, 0x8b, 0xc6, 0x39,
37: 0x30, 0xcf, 0x82, 0x7d, 0xe4, 0x1b, 0x56, 0xa9,
38: 0x48, 0xb7, 0xfa, 0x05, 0x9c, 0x63, 0x2e, 0xd1,
39: 0xd8, 0x27, 0x6a, 0x95, 0x0c, 0xf3, 0xbe, 0x41,
40: 0xc0, 0x3f, 0x72, 0x8d, 0x14, 0xeb, 0xa6, 0x59,
41: 0x50, 0xaf, 0xe2, 0x1d, 0x84, 0x7b, 0x36, 0xc9,
42: 0x28, 0xd7, 0x9a, 0x65, 0xfc, 0x03, 0x4e, 0xb1,
43: 0xb8, 0x47, 0x0a, 0xf5, 0x6c, 0x93, 0xde, 0x21,
44: 0x60, 0x9f, 0xd2, 0x2d, 0xb4, 0x4b, 0x06, 0xf9,
45: 0xf0, 0x0f, 0x42, 0xbd, 0x24, 0xdb, 0x96, 0x69,
46: 0x88, 0x77, 0x3a, 0xc5, 0x5c, 0xa3, 0xee, 0x11,
47: 0x18, 0xe7, 0xaa, 0x55, 0xcc, 0x33, 0x7e, 0x81,
48: 0x80, 0x7f, 0x32, 0xcd, 0x54, 0xab, 0xe6, 0x19,
49: 0x10, 0xef, 0xa2, 0x5d, 0xc4, 0x3b, 0x76, 0x89,
50: 0x68, 0x97, 0xda, 0x25, 0xbc, 0x43, 0x0e, 0xf1,
51: 0xf8, 0x07, 0x4a, 0xb5, 0x2c, 0xd3, 0x9e, 0x61,
52: 0x20, 0xdf, 0x92, 0x6d, 0xf4, 0x0b, 0x46, 0xb9,
53: 0xb0, 0x4f, 0x02, 0xfd, 0x64, 0x9b, 0xd6, 0x29,
54: 0xc8, 0x37, 0x7a, 0x85, 0x1c, 0xe3, 0xae, 0x51,
55: 0x58, 0xa7, 0xea, 0x15, 0x8c, 0x73, 0x3e, 0xc1,
56: 0x40, 0xbf, 0xf2, 0x0d, 0x94, 0x6b, 0x26, 0xd9,
57: 0xd0, 0x2f, 0x62, 0x9d, 0x04, 0xfb, 0xb6, 0x49,
58: 0xa8, 0x57, 0x1a, 0xe5, 0x7c, 0x83, 0xce, 0x31,
59: 0x38, 0xc7, 0x8a, 0x75, 0xec, 0x13, 0x5e, 0xa1,
60: 0xe0, 0x1f, 0x52, 0xad, 0x34, 0xcb, 0x86, 0x79,
61: 0x70, 0x8f, 0xc2, 0x3d, 0xa4, 0x5b, 0x16, 0xe9,
62: 0x08, 0xf7, 0xba, 0x45, 0xdc, 0x23, 0x6e, 0x91,
63: 0x98, 0x67, 0x2a, 0xd5, 0x4c, 0xb3, 0xfe, 0x01
64: };
65:
66:
67: /******************************Public*Data*********************************\
68: * ROP to mix translation table
69: *
70: * Table to translate ternary raster ops to mixes (binary raster ops). Ternary
71: * raster ops that can't be translated to mixes are translated to 0 (0 is not
72: * a valid mix).
73: *
74: \**************************************************************************/
75:
76: UCHAR jRop3ToMix[256] = {
77: R2_BLACK, 0, 0, 0, 0, R2_NOTMERGEPEN, 0, 0,
78: 0, 0, R2_MASKNOTPEN, 0, 0, 0, 0, R2_NOTCOPYPEN,
79: 0, 0, 0, 0, 0, 0, 0, 0,
80: 0, 0, 0, 0, 0, 0, 0, 0,
81: 0, 0, 0, 0, 0, 0, 0, 0,
82: 0, 0, 0, 0, 0, 0, 0, 0,
83: 0, 0, 0, 0, 0, 0, 0, 0,
84: 0, 0, 0, 0, 0, 0, 0, 0,
85: 0, 0, 0, 0, 0, 0, 0, 0,
86: 0, 0, 0, 0, 0, 0, 0, 0,
87: R2_MASKPENNOT, 0, 0, 0, 0, R2_NOT, 0, 0,
88: 0, 0, R2_XORPEN, 0, 0, 0, 0, R2_NOTMASKPEN,
89: 0, 0, 0, 0, 0, 0, 0, 0,
90: 0, 0, 0, 0, 0, 0, 0, 0,
91: 0, 0, 0, 0, 0, 0, 0, 0,
92: 0, 0, 0, 0, 0, 0, 0, 0,
93: 0, 0, 0, 0, 0, 0, 0, 0,
94: 0, 0, 0, 0, 0, 0, 0, 0,
95: 0, 0, 0, 0, 0, 0, 0, 0,
96: 0, 0, 0, 0, 0, 0, 0, 0,
97: R2_MASKPEN, 0, 0, 0, 0, R2_NOTXORPEN, 0, 0,
98: 0, 0, R2_NOP, 0, 0, 0, 0, R2_MERGENOTPEN,
99: 0, 0, 0, 0, 0, 0, 0, 0,
100: 0, 0, 0, 0, 0, 0, 0, 0,
101: 0, 0, 0, 0, 0, 0, 0, 0,
102: 0, 0, 0, 0, 0, 0, 0, 0,
103: 0, 0, 0, 0, 0, 0, 0, 0,
104: 0, 0, 0, 0, 0, 0, 0, 0,
105: 0, 0, 0, 0, 0, 0, 0, 0,
106: 0, 0, 0, 0, 0, 0, 0, 0,
107: R2_COPYPEN, 0, 0, 0, 0, R2_MERGEPENNOT, 0, 0,
108: 0, 0, R2_MERGEPEN, 0, 0, 0, 0, R2_WHITE
109: };
110:
111:
112: /******************************Public*Routine******************************\
113: * VOID DrvBitBlt(pso,pso,pso,pco,pxlo,prcl,pptl,pptl,pdbrush,pptl,rop4)
114: *
115: * Bitblt.
116: *
117: \**************************************************************************/
118:
119: BOOL DrvBitBlt
120: (
121: SURFOBJ *psoTrg, // Target surface
122: SURFOBJ *psoSrc, // Source surface
123: SURFOBJ *psoMask, // Mask
124: CLIPOBJ *pco, // Clip through this
125: XLATEOBJ *pxlo, // Color translation
126: RECTL *prclTrg, // Target offset and extent
127: POINTL *pptlSrc, // Source offset
128: POINTL *pptlMask, // Mask offset
129: BRUSHOBJ *pbo, // Pointer to brush object
130: POINTL *pptlBrush, // Brush offset
131: ROP4 rop4 // Raster operation
132: )
133: {
134: BYTE jForeRop; // Foreground rop in A-vector notation
135: BYTE jBackRop; // Background rop in A-vector notation
136: BYTE jORedRops; // jForeRop | jBackRop
137: BRUSHINST bri; // Instance of a brush
138: BRUSHINST *pbri; // Pointer to a brush instance
139:
140: DEVSURF dsurfSrc; // For source if a DIB
141: PDEVSURF pdsurfTrg; // Pointer for target
142: PDEVSURF pdsurfSrc; // Pointer for source if present
143:
144: ULONG iSolidColor; // Solid color for solid brushes
145: BOOL bMore; // Clip continuation flag
146: ULONG ircl; // Clip enumeration rectangle index
147: RECT_ENUM bben; // Clip enumerator
148: ULONG *pulXlate; // Pointer to color xlate vector
149: BYTE jClipping;
150: MIX mix; // Mix, when solid fill performed
151: RECTL rclTemp;
152: ULONG ulBkColor;
153: ULONG ulFgColor;
154: PRECTL prcl;
155: POINTL ptlTemp;
156: UCHAR *pucDIB4ToVGAConvTables;
157: VOID (*pfnPatBlt)(PDEVSURF,ULONG,PRECTL,MIX, BRUSHINST *,PPOINTL);
158:
159:
160: // Let the engine handle the stuff we can't yet do.
161: if (psoSrc != (SURFOBJ *) NULL) {
162: if ((psoSrc->iBitmapFormat != BMF_1BPP) &&
163: (psoSrc->iBitmapFormat != BMF_4BPP) &&
164: (psoSrc->iBitmapFormat != BMF_8BPP)) {
165:
166: return(EngBitBlt(psoTrg,psoSrc,psoMask,
167: pco,pxlo,prclTrg,pptlSrc,pptlMask,
168: pbo,pptlBrush,rop4));
169:
170: } else {
171: // We only handle SRCCOPY screen-to-screen blts right now
172: if ((psoSrc->dhsurf == psoTrg->dhsurf) && (rop4 != 0x0000CCCC)) {
173:
174: return(EngBitBlt(psoTrg,psoSrc,psoMask,
175: pco,pxlo,prclTrg,pptlSrc,pptlMask,
176: pbo,pptlBrush,rop4));
177: }
178: }
179: }
180:
181: if ((rop4 & 0x000000FF) != ((rop4 >> 8) & 0x000000FF)) {
182:
183: return(EngBitBlt(psoTrg,psoSrc,psoMask,
184: pco,pxlo,prclTrg,pptlSrc,pptlMask,
185: pbo,pptlBrush,rop4));
186: }
187:
188: // Get the target surface's pointer. The target must always be a device
189: // surface
190:
191: pdsurfTrg = (PDEVSURF) psoTrg->dhsurf;
192:
193: // Set up the clipping type
194: if (pco == (CLIPOBJ *) NULL) {
195: // No CLIPOBJ provided, so we don't have to worry about clipping
196: jClipping = DC_TRIVIAL;
197: } else {
198: // Use the CLIPOBJ-provided clipping
199: jClipping = pco->iDComplexity;
200: }
201:
202:
203: // Break the rops with the VGA as the destination surface into two classes,
204: // those that can call special case static code (currently: vTrgBlt(solid
205: // fills) and vAlignedSrcCopy (aligned srccopy blts)), and those that must
206: // call the compiled blt code
207:
208: if (pdsurfTrg->iFormat == BMF_PHYSDEVICE) {
209:
210: // Masked cases must be handled differently
211:
212: if ((rop4 & 0xFF) == ((rop4 >> 8) & 0xFF)) {
213:
214: // Special case static code for no-mask cases
215:
216: // Calculate mix from ROP if possible (not possible if it's truly a
217: // ternary rop or a real rop4, but we can treat all pure binary
218: // rops as mixes rather than rop4s)
219: mix = jRop3ToMix[rop4 & 0xFF];
220: pbri = (BRUSHINST *)NULL;
221:
222: switch (mix) {
223: case R2_MASKNOTPEN:
224: case R2_NOTCOPYPEN:
225: case R2_XORPEN:
226: case R2_MASKPEN:
227: case R2_NOTXORPEN:
228: case R2_MERGENOTPEN:
229: case R2_COPYPEN:
230: case R2_MERGEPEN:
231: case R2_NOTMERGEPEN:
232: case R2_MASKPENNOT:
233: case R2_NOTMASKPEN:
234: case R2_MERGEPENNOT:
235: // vTrgBlt can only handle solid color fills
236: if (pbo->iSolidColor != 0xffffffff)
237: {
238: iSolidColor = pbo->iSolidColor;
239: }
240: else
241: {
242: // TrgBlt can only handle solid brushes, but let's
243: // see if we can use our special case pattern code.
244: //
245: pbri = (BRUSHINST *)pbo->pvRbrush;
246: if (pbri == (BRUSHINST *)NULL)
247: {
248: pbri = (BRUSHINST *)BRUSHOBJ_pvGetRbrush(pbo);
249:
250: if (pbri == (BRUSHINST *)NULL)
251: {
252: return(EngBitBlt(psoTrg, psoSrc, psoMask, pco,
253: pxlo, prclTrg, pptlSrc, pptlMask, pbo,
254: pptlBrush, rop4));
255: }
256: }
257:
258: // We currently only do mono patterns.
259:
260: pfnPatBlt = vMonoPatBlt;
261:
262: if (pbri->usStyle != BRI_MONO_PATTERN)
263: pfnPatBlt = vClrPatBlt;
264:
265: // We only support non-8 wide brushes with R2_COPYPEN
266:
267: if ((mix != R2_COPYPEN) && (pbri->RealWidth != 8))
268: break;
269:
270: }
271: // Rops that are implicit solid colors
272:
273: case R2_NOT:
274: case R2_WHITE:
275: case R2_BLACK:
276: // We can do a special-case solid fill
277:
278: switch(jClipping) {
279: case DC_TRIVIAL:
280:
281: // Just fill the rectangle with a solid color
282: if (pbri == (BRUSHINST *)NULL)
283: {
284: vTrgBlt(pdsurfTrg, 1, prclTrg, mix,
285: iSolidColor);
286: }
287: else
288: {
289: (*pfnPatBlt)(pdsurfTrg, 1, prclTrg, mix,
290: pbri, pptlBrush);
291: }
292: break;
293:
294: case DC_RECT:
295:
296: // Clip the solid fill to the clip rectangle
297: if (!DrvIntersectRect(&rclTemp, prclTrg,
298: &pco->rclBounds)) {
299: return(TRUE);
300: }
301:
302: // Fill the clipped rectangle
303: if (pbri == (BRUSHINST *)NULL)
304: {
305: vTrgBlt(pdsurfTrg, 1, &rclTemp, mix,
306: iSolidColor);
307: }
308: else
309: {
310: (*pfnPatBlt)(pdsurfTrg, 1, &rclTemp, mix,
311: pbri, pptlBrush);
312: }
313: break;
314:
315: case DC_COMPLEX:
316:
317: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES,
318: CD_ANY, ENUM_RECT_LIMIT);
319:
320: do {
321: bMore = CLIPOBJ_bEnum(pco,(ULONG) sizeof(bben),
322: (PVOID) &bben);
323:
324: for (ircl = 0; ircl < bben.c; ircl++) {
325: PRECTL prcl = &bben.arcl[ircl];
326:
327: DrvIntersectRect(prcl,prcl,prclTrg);
328:
329: if (pbri == (BRUSHINST *)NULL) {
330:
331: vTrgBlt(pdsurfTrg, 1, prcl, mix,
332: iSolidColor);
333: } else {
334:
335: (*pfnPatBlt)(pdsurfTrg, 1, prcl, mix,
336: pbri, pptlBrush);
337: }
338: }
339: } while(bMore);
340: }
341:
342: case R2_NOP:
343: return TRUE;
344:
345: default:
346: break;
347: }
348:
349: // Not a special-case solid fill; see if it's a screen-to-screen
350: // SRCCOPY blt, another of our special cases
351:
352: if (rop4 == 0x0000CCCC) {
353:
354: // SRCCOPY blt
355:
356: if (psoSrc->dhsurf == psoTrg->dhsurf) {
357:
358: INT iCopyDir;
359: PFN_ScreenToScreenBlt pfn_Blt;
360:
361: // It's a screen-to-screen SRCCOPY; special-case it
362:
363: // Determine the direction in which the copy must proceed
364: // Note that although we could detect cases where the source
365: // and dest don't overlap and handle them top to bottom, all
366: // copy directions are equally fast, so there's no reason to go
367: // top to bottom except possibly that it looks better. But it
368: // also takes time to detect non-overlap, so I'm not doing it
369:
370: if (pptlSrc->y >= prclTrg->top) {
371: if (pptlSrc->x >= prclTrg->left) {
372: iCopyDir = CD_RIGHTDOWN;
373: } else {
374: iCopyDir = CD_LEFTDOWN;
375: }
376: } else {
377: if (pptlSrc->x >= prclTrg->left) {
378: iCopyDir = CD_RIGHTUP;
379: } else {
380: iCopyDir = CD_LEFTUP;
381: }
382: }
383:
384: // These values are expected by vAlignedSrcCopy
385:
386: switch(jClipping) {
387:
388: case DC_TRIVIAL:
389: // Just copy the rectangle
390: if ((((prclTrg->left ^ pptlSrc->x) & 0x07) == 0)) {
391: vAlignedSrcCopy(pdsurfTrg, prclTrg,
392: pptlSrc, iCopyDir);
393: } else {
394: vNonAlignedSrcCopy(pdsurfTrg, prclTrg,
395: pptlSrc, iCopyDir);
396: }
397: break;
398:
399: case DC_RECT:
400: // Clip the solid fill to the clip rectangle
401: if (!DrvIntersectRect(&rclTemp, prclTrg, &pco->rclBounds))
402: {
403: return(TRUE);
404: }
405:
406: // Adjust the source point for clipping too
407: ptlTemp.x = pptlSrc->x + rclTemp.left - prclTrg->left;
408: ptlTemp.y = pptlSrc->y + rclTemp.top - prclTrg->top;
409:
410: // Copy the clipped rectangle
411: if ((((prclTrg->left ^ pptlSrc->x) & 0x07) == 0)) {
412: vAlignedSrcCopy(pdsurfTrg, &rclTemp, &ptlTemp,
413: iCopyDir);
414: } else {
415: vNonAlignedSrcCopy(pdsurfTrg, &rclTemp, &ptlTemp,
416: iCopyDir);
417: }
418: break;
419:
420: case DC_COMPLEX:
421:
422: if ((((prclTrg->left ^ pptlSrc->x) & 0x07) == 0)) {
423: pfn_Blt = vAlignedSrcCopy;
424: } else {
425: pfn_Blt = vNonAlignedSrcCopy;
426: }
427:
428: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES,
429: iCopyDir, ENUM_RECT_LIMIT);
430:
431: do {
432: bMore = CLIPOBJ_bEnum(pco,(ULONG) sizeof(bben),
433: (PVOID) &bben);
434:
435: for (ircl = 0; ircl < bben.c; ircl++) {
436: PRECTL prcl = &bben.arcl[ircl];
437:
438: DrvIntersectRect(prcl,prcl,prclTrg);
439:
440: // Adjust the source point for clipping too
441: ptlTemp.x = pptlSrc->x + prcl->left -
442: prclTrg->left;
443: ptlTemp.y = pptlSrc->y + prcl->top -
444: prclTrg->top;
445: pfn_Blt(pdsurfTrg, prcl,
446: &ptlTemp, iCopyDir);
447: }
448: } while(bMore);
449: break;
450: }
451:
452: return TRUE;
453:
454: } else if ((psoSrc->iType == STYPE_BITMAP) &&
455: (psoSrc->iBitmapFormat == BMF_4BPP) &&
456: ((pxlo == NULL) || (pxlo->flXlate == XO_TRIVIAL))) {
457:
458: // Special case DIB4 to VGA copy if no translation
459:
460: pucDIB4ToVGAConvTables =
461: ((PDEVSURF) psoTrg->dhsurf)->ppdev->
462: pucDIB4ToVGAConvTables;
463:
464: // Make just enough of a fake DEVSURF for the source so
465: // that the DIB to VGA code can work
466:
467: dsurfSrc.lNextScan = psoSrc->lDelta;
468: dsurfSrc.pvBitmapStart = psoSrc->pvScan0;
469:
470: // Clip as needed
471:
472: if ((pco == NULL) || (pco->iDComplexity == DC_TRIVIAL)) {
473:
474: // No clipping, just copy the DIB to the VGA
475:
476: vDIB2VGA((PDEVSURF) psoTrg->dhsurf, &dsurfSrc,
477: prclTrg, pptlSrc, pucDIB4ToVGAConvTables);
478:
479: } else if (pco->iDComplexity == DC_RECT) {
480:
481: // Clip the destination to the clip rectangle; we
482: // should never get a NULL result
483: if (DrvIntersectRect(&rclTemp, prclTrg, &pco->rclBounds)) {
484:
485: // Adjust the source point for clipping too
486: ptlTemp.x = pptlSrc->x + rclTemp.left - prclTrg->left;
487: ptlTemp.y = pptlSrc->y + rclTemp.top - prclTrg->top;
488:
489: // Blt the clipped rectangle
490: vDIB2VGA((PDEVSURF) psoTrg->dhsurf, &dsurfSrc,
491: &rclTemp, &ptlTemp, pucDIB4ToVGAConvTables);
492: }
493: return(TRUE);
494:
495: } else { // DC_COMPLEX:
496:
497: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES,
498: CD_ANY, ENUM_RECT_LIMIT);
499:
500: do {
501: bMore = CLIPOBJ_bEnum(pco,(ULONG) sizeof(bben),
502: (PVOID) &bben);
503: prcl = bben.arcl;
504: for (ircl = 0; ircl < bben.c; ircl++, prcl++) {
505:
506: // Clip the destination to the clip rectangle;
507: // we should never get a NULL result
508:
509: DrvIntersectRect(prcl,prcl,prclTrg);
510:
511: // Adjust the source point for clipping too
512: ptlTemp.x = pptlSrc->x + prcl->left -
513: prclTrg->left;
514: ptlTemp.y = pptlSrc->y + prcl->top -
515: prclTrg->top;
516:
517: // Blt the clipped rectangle
518: vDIB2VGA((PDEVSURF) psoTrg->dhsurf,
519: &dsurfSrc, prcl, &ptlTemp,
520: pucDIB4ToVGAConvTables);
521: }
522: } while(bMore);
523: }
524:
525: return(TRUE);
526:
527: }
528: }
529: }
530: }
531:
532:
533: // Couldn't be special cased. Set up to call the old kludged compiling code.
534:
535:
536: {
537: LONG xSrc;
538: LONG ySrc;
539: RECTL *prcl;
540:
541:
542: // Translate the rop from old notation into two A-vector rops
543:
544: jForeRop = gajRop[rop4 & 0xff];
545: jBackRop = gajRop[(rop4 >> 8) & 0xff];
546: jORedRops = jForeRop | jBackRop;
547:
548:
549: // Get the source surface if a source is needed. The source may be any of
550: // 1) the screen, 2) a device managed bitmap, 3) an engine bitmap
551:
552: if (jORedRops & AVEC_NEED_SOURCE) {
553:
554: if (psoSrc->dhsurf == (DHSURF) 0) {
555: // Source is an engine bitmap
556: #ifdef FIREWALLS
557: dsurfSrc.ident = 0x46525354; // "TSRF"
558: #endif
559: dsurfSrc.flSurf = DS_DIB; // Supporting a DIB
560: dsurfSrc.iFormat = (BYTE)psoSrc->iBitmapFormat;
561: dsurfSrc.sizlSurf = psoSrc->sizlBitmap;
562: dsurfSrc.lNextScan = psoSrc->lDelta;
563: dsurfSrc.pvScan0 = psoSrc->pvScan0;
564: dsurfSrc.pvBitmapStart = psoSrc->pvScan0;
565: dsurfSrc.pvConv = pdsurfTrg->pvConv;
566:
567: pdsurfSrc = &dsurfSrc; // Construct source into here
568:
569: } else {
570: // Source is a device format bitmap or the device itself
571: pdsurfSrc = (PDEVSURF) psoSrc->dhsurf;
572: }
573: } else {
574: pdsurfSrc = (PDEVSURF) NULL; // Assume no source
575: }
576:
577:
578: // If a brush is required, do what is necessary to get it. We might be
579: // able to just use the solid color accelerator, we might have to force it
580: // to be realized (which could fail).
581:
582: if (jORedRops & AVEC_NEED_PATTERN) {
583:
584: // See if there is a solid color accelerator for the brush. If so
585: // we can just pick it up and use it.
586:
587: if (pbo->iSolidColor != 0xffffffff) {
588: bri.usStyle = BRI_SOLID;
589: bri.fjAccel =
590: (BYTE)((pbo->iSolidColor & COLOR_BITS) | SOLID_BRUSH);
591: pbri = &bri;
592: } else {
593: // If there is no realization of the brush, we must force it
594:
595: if (pbo->pvRbrush == (PVOID)NULL)
596: {
597: pbri = (BRUSHINST *)BRUSHOBJ_pvGetRbrush(pbo);
598:
599: if (pbri == (BRUSHINST *)NULL)
600: {
601: return(EngBitBlt(psoTrg, psoSrc, psoMask, pco, pxlo,
602: prclTrg, pptlSrc, pptlMask, pbo, pptlBrush,
603: rop4));
604: }
605: }
606: else
607: {
608: pbri = (BRUSHINST *)pbo->pvRbrush;
609: }
610:
611: if (!bConvertBrush(pbri)) {
612: return(EngBitBlt(psoTrg, psoSrc, psoMask, pco, pxlo,
613: prclTrg, pptlSrc, pptlMask, pbo, pptlBrush, rop4));
614: }
615: }
616: }
617:
618:
619:
620: // Determine if color translation is required. If so, then get the
621: // color translation vector. if no source is involved, then no
622: // xlateobj will have been passed.
623:
624: if ((jORedRops & AVEC_NEED_SOURCE) &&
625: (pxlo != NULL) &&
626: (pxlo->flXlate & XO_TABLE))
627: {
628: pulXlate = pxlo->pulXlate;
629: ulFgColor = pulXlate[0] << 24; // Mono --> color translation
630: ulBkColor = pulXlate[1] << 24;
631: }
632: else
633: {
634: pulXlate = (PULONG) NULL; // No xlate vector
635: }
636:
637:
638: // Note: blts where VGA memory is both the source and the destination
639: // should never make it to this point; it's assumed that the VGA is the
640: // destination and the destination only
641: // BUGBUG this must be changed when we support DFBs, to make VGAs
642: // possibly neither source nor destination, and (maybe?) source but DFB
643: // dest
644:
645: // Perform blt with specified clipping.
646: // BUGBUG only top->bottom blts are currently supported
647:
648: switch(jClipping) {
649:
650: RECTL rclTemp;
651:
652: case DC_RECT:
653: if (!DrvIntersectRect(&rclTemp, prclTrg, &pco->rclBounds)) {
654: break;
655: }
656:
657: // Adjust the source (if any) accordingly
658: if (jORedRops & AVEC_NEED_SOURCE) {
659: pptlSrc->x += rclTemp.left - prclTrg->left;
660: pptlSrc->y += rclTemp.top - prclTrg->top;
661: }
662:
663: *prclTrg = rclTemp;
664:
665: case DC_TRIVIAL:
666:
667: // Cycle through all banks that the blt dest spans
668:
669: // If the proper bank for the top scan line of
670: // the blt dest isn't mapped in, map it in
671: if ((prclTrg->top < pdsurfTrg->rcl1WindowClip.top) ||
672: (prclTrg->top >= pdsurfTrg->rcl1WindowClip.bottom)) {
673:
674: // Map in the bank containing the top line of the blt dest
675: pdsurfTrg->pfnBankControl(pdsurfTrg,
676: prclTrg->top,
677: JustifyTop);
678: }
679:
680: // Now draw the part of the rect that's in each bank
681: for (;;) {
682:
683: // Clip the blt dest to the bank
684: DrvIntersectRect(&rclTemp, prclTrg,
685: &pdsurfTrg->rcl1WindowClip);
686:
687: // Adjust the source (if any) accordingly
688: if (jORedRops & AVEC_NEED_SOURCE) {
689: xSrc = pptlSrc->x + rclTemp.left - prclTrg->left;
690: ySrc = pptlSrc->y + rclTemp.top - prclTrg->top;
691: }
692:
693: vCompiledBlt(pdsurfTrg,
694: rclTemp.left,
695: rclTemp.top,
696: pdsurfSrc,
697: xSrc,
698: ySrc,
699: rclTemp.right - rclTemp.left,
700: rclTemp.bottom - rclTemp.top,
701: rop4,
702: pbri,
703: ulBkColor,
704: ulFgColor,
705: pulXlate,
706: pptlBrush);
707:
708: // Done if this bank contains the last line of the blt
709: if (prclTrg->bottom <=
710: pdsurfTrg->rcl1WindowClip.bottom) {
711: break;
712: }
713:
714: // Map in the next bank
715: pdsurfTrg->pfnBankControl(pdsurfTrg,
716: pdsurfTrg->rcl1WindowClip.bottom,
717: JustifyTop);
718: }
719:
720: break;
721:
722:
723: case DC_COMPLEX:
724:
725: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, ENUM_RECT_LIMIT);
726: bMore = TRUE;
727:
728: do {
729: if (bMore) {
730: // Enumerate more clip rects
731: bMore = CLIPOBJ_bEnum(pco,(ULONG) sizeof(bben),
732: (PVOID) &bben);
733: }
734:
735: // Draw the portion of the blt dest that intersects each
736: // clip rect in turn
737: for (ircl = 0; ircl < bben.c; ircl++) {
738:
739: prcl = &bben.arcl[ircl];
740:
741: // Find the intersection of the target rect and the
742: // current clip rect, then draw all banks of the
743: // clipped target rect, if it's not NULL
744: DrvIntersectRect(prcl, prcl, prclTrg);
745:
746: // Cycle through all banks that the blt dest spans
747:
748: // If the proper bank for the top scan line of
749: // the blt dest isn't mapped in, map it in
750: if ((prcl->top <
751: pdsurfTrg->rcl1WindowClip.top) ||
752: (prcl->top >=
753: pdsurfTrg->rcl1WindowClip.bottom)) {
754:
755: // Map in the bank containing the top line of
756: // the blt dest
757: pdsurfTrg->pfnBankControl(pdsurfTrg,
758: prcl->top,
759: JustifyTop);
760: }
761:
762: // Now draw the part of the clipped rect that's in
763: // each bank
764: for (;;) {
765:
766: RECTL rclTemp;
767:
768: // Clip the blt dest to the bank
769: DrvIntersectRect(&rclTemp, prcl,
770: &pdsurfTrg->rcl1WindowClip);
771:
772: // Adjust the source (if any) accordingly
773: if (jORedRops & AVEC_NEED_SOURCE) {
774: xSrc = pptlSrc->x + rclTemp.left -
775: prclTrg->left;
776: ySrc = pptlSrc->y + rclTemp.top -
777: prclTrg->top;
778: }
779:
780: vCompiledBlt(pdsurfTrg,
781: rclTemp.left,
782: rclTemp.top,
783: pdsurfSrc,
784: xSrc,
785: ySrc,
786: rclTemp.right - rclTemp.left,
787: rclTemp.bottom - rclTemp.top,
788: rop4,
789: pbri,
790: ulBkColor,
791: ulFgColor,
792: pulXlate,
793: pptlBrush);
794:
795: // Done if this bank contains the last line of
796: // the blt
797: if (prcl->bottom <=
798: pdsurfTrg->rcl1WindowClip.bottom) {
799: break;
800: }
801:
802: // Map in the next bank
803: pdsurfTrg->pfnBankControl(pdsurfTrg,
804: pdsurfTrg->rcl1WindowClip.bottom,
805: JustifyTop);
806: }
807: }
808: } while(bMore);
809:
810: break;
811:
812: } // switch(jClipping);
813:
814: }
815:
816: return TRUE;
817: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.