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