![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to copybits.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 copybits.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: copybits.c
3: *
4: * DrvCopyBits
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: \**************************************************************************/
8: #include "driver.h"
9: #include "bitblt.h"
10:
11: BOOL DrvCopyBits
12: (
13: SURFOBJ *psoTrg,
14: SURFOBJ *psoSrc,
15: CLIPOBJ *pco,
16: XLATEOBJ *pxlo,
17: PRECTL prclTrg,
18: PPOINTL pptlSrc
19: )
20: {
21: PDEVSURF pdsurf; // Pointer to a device surface
22:
23: LONG lDelta; // Delta to next scan of destination
24: PVOID pjDstScan0; // Pointer to scan 0 of destination DIB
25: ULONG *pulXlate; // Pointer to color xlate vector
26:
27: BOOL bMore; // Clip continuation flag
28: ULONG ircl; // Clip enumeration rectangle index
29: RECT_ENUM cben; // Clip enumerator
30: RECTL rclTemp;
31: PRECTL prcl;
32: POINTL ptlTemp;
33: DEVSURF dsurfSrc;
34: PDEVSURF pdsurfTrg; // Pointer for target
35: PDEVSURF pdsurfSrc; // Pointer for source if present
36: INT iCopyDir;
37: PFN_ScreenToScreenBlt pfn_Blt;
38: RECT_ENUM bben; // Clip enumerator
39: BYTE jClipping;
40: UCHAR *pucDIB4ToVGAConvTables;
41:
42:
43: // ASSERT(psoTrg != (SURFOBJ *) NULL, "DrvCopyBits: NULL Pointer for Target\n");
44: // ASSERT(psoSrc != (SURFOBJ *) NULL, "DrvCopyBits: NULL Pointer for Source\n");
45: // ASSERT(prclTrg != (RECTL *) NULL, "DrvCopyBits: NULL Pointer for Rect\n");
46: // ASSERT(pptlSrc != (POINTL *) NULL, "DrvCopyBits: NULL Pointer for Point\n");
47:
48: // ASSERT(((psoTrg->dhsurf != (DHSURF) 0) || (psoSrc->dhsurf != (DHSURF) 0)),
49: // "DrvCopyBits: No device surface involved\n");
50:
51: // Check for device surface to device surface
52:
53: if ((psoTrg->iType == STYPE_DEVICE) && (psoSrc->iType == STYPE_DEVICE))
54: {
55: pdsurfTrg = (PDEVSURF) psoTrg->dhsurf;
56: pdsurfSrc = (PDEVSURF) psoSrc->dhsurf;
57:
58: // It's a screen-to-screen aligned SRCCOPY; special-case it
59:
60: // Determine the direction in which the copy must proceed
61: // Note that although we could detect cases where the source
62: // and dest don't overlap and handle them top to bottom, all
63: // copy directions are equally fast, so there's no reason to go
64: // top to bottom except possibly that it looks better. But it
65: // also takes time to detect non-overlap, so I'm not doing it
66:
67: // Set up the clipping type
68:
69: if (pco == (CLIPOBJ *) NULL)
70: {
71: // No CLIPOBJ provided, so we don't have to worry about clipping
72:
73: jClipping = DC_TRIVIAL;
74: }
75: else
76: {
77: // Use the CLIPOBJ-provided clipping
78:
79: jClipping = pco->iDComplexity;
80: }
81:
82:
83: if (pptlSrc->y >= prclTrg->top) {
84: if (pptlSrc->x >= prclTrg->left) {
85: iCopyDir = CD_RIGHTDOWN;
86: } else {
87: iCopyDir = CD_LEFTDOWN;
88: }
89: } else {
90: if (pptlSrc->x >= prclTrg->left) {
91: iCopyDir = CD_RIGHTUP;
92: } else {
93: iCopyDir = CD_LEFTUP;
94: }
95: }
96:
97: // These values are expected by vAlignedSrcCopy
98: // ASSERT(((CD_RIGHTDOWN == 0) && (CD_LEFTDOWN == 1) &&
99: // (CD_RIGHTUP == 2) && (CD_LEFTUP == 3)),
100: // "DrvBitBlt: Bad clip enumeration direction constants");
101:
102: switch(jClipping) {
103:
104: case DC_TRIVIAL:
105: // Just copy the rectangle
106: if ((((prclTrg->left ^ pptlSrc->x) & 0x07) == 0)) {
107: vAlignedSrcCopy(pdsurfTrg, prclTrg,
108: pptlSrc, iCopyDir);
109: } else {
110: vNonAlignedSrcCopy(pdsurfTrg, prclTrg,
111: pptlSrc, iCopyDir);
112: }
113: break;
114:
115: case DC_RECT:
116: // Clip the solid fill to the clip rectangle
117: if (!DrvIntersectRect(&rclTemp, prclTrg,
118: &pco->rclBounds)) {
119: // Nothing to draw; completely clipped
120: return TRUE;
121: }
122:
123: // Adjust the source point for clipping too
124: ptlTemp.x = pptlSrc->x + rclTemp.left - prclTrg->left;
125: ptlTemp.y = pptlSrc->y + rclTemp.top - prclTrg->top;
126:
127: // Copy the clipped rectangle
128: if ((((prclTrg->left ^ pptlSrc->x) & 0x07) == 0)) {
129: vAlignedSrcCopy(pdsurfTrg, &rclTemp, &ptlTemp,
130: iCopyDir);
131: } else {
132: vNonAlignedSrcCopy(pdsurfTrg, &rclTemp, &ptlTemp,
133: iCopyDir);
134: }
135: break;
136:
137: case DC_COMPLEX:
138:
139: if ((((prclTrg->left ^ pptlSrc->x) & 0x07) == 0)) {
140: pfn_Blt = vAlignedSrcCopy;
141: } else {
142: pfn_Blt = vNonAlignedSrcCopy;
143: }
144:
145: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES,
146: iCopyDir, ENUM_RECT_LIMIT);
147:
148: do {
149: bMore = CLIPOBJ_bEnum(pco,(ULONG) sizeof(bben),
150: (PVOID) &bben);
151:
152: prcl = bben.arcl;
153: for (ircl = 0; ircl < bben.c; ircl++, prcl++) {
154:
155: DrvIntersectRect(prcl,prcl,prclTrg);
156: // Adjust the source point for clipping too
157: ptlTemp.x = pptlSrc->x + prcl->left -
158: prclTrg->left;
159: ptlTemp.y = pptlSrc->y + prcl->top -
160: prclTrg->top;
161: pfn_Blt(pdsurfTrg, prcl,
162: &ptlTemp, iCopyDir);
163:
164: }
165: } while(bMore);
166: break;
167: }
168: return TRUE;
169: }
170:
171: if (psoSrc->iType == STYPE_BITMAP) {
172:
173: // DIB to screen
174:
175: switch(psoSrc->iBitmapFormat)
176: {
177: case BMF_4BPP: // special case compatible DIBs with no translation
178:
179: if ((pxlo == NULL) || (pxlo->flXlate == XO_TRIVIAL)) {
180:
181: pucDIB4ToVGAConvTables =
182: ((PDEVSURF) psoTrg->dhsurf)->ppdev->
183: pucDIB4ToVGAConvTables;
184:
185: // Make just enough of a fake DEVSURF for the source so that
186: // the DIB to VGA code can work
187:
188: dsurfSrc.lNextScan = psoSrc->lDelta;
189: dsurfSrc.pvBitmapStart = psoSrc->pvScan0;
190:
191: // Clip as needed
192:
193: if ((pco == NULL) || (pco->iDComplexity == DC_TRIVIAL)) {
194:
195: // No clipping, just copy the DIB to the VGA
196:
197: vDIB2VGA((PDEVSURF) psoTrg->dhsurf, &dsurfSrc, prclTrg,
198: pptlSrc, pucDIB4ToVGAConvTables);
199:
200: } else if (pco->iDComplexity == DC_RECT) {
201:
202: // Clip the destination to the clip rectangle; we
203: // should never get a NULL result
204: if (DrvIntersectRect(&rclTemp, prclTrg, &pco->rclBounds)) {
205:
206: // Adjust the source point for clipping too
207: ptlTemp.x = pptlSrc->x + rclTemp.left - prclTrg->left;
208: ptlTemp.y = pptlSrc->y + rclTemp.top - prclTrg->top;
209:
210: // Blt the clipped rectangle
211: vDIB2VGA((PDEVSURF) psoTrg->dhsurf, &dsurfSrc,
212: &rclTemp, &ptlTemp, pucDIB4ToVGAConvTables);
213: }
214: return(TRUE);
215:
216: } else { // DC_COMPLEX:
217:
218: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES,
219: CD_ANY, ENUM_RECT_LIMIT);
220:
221: do {
222: bMore = CLIPOBJ_bEnum(pco,(ULONG) sizeof(bben),
223: (PVOID) &bben);
224: prcl = bben.arcl;
225: for (ircl = 0; ircl < bben.c; ircl++, prcl++) {
226:
227: // Clip the destination to the clip rectangle;
228: // we should never get a NULL result
229: DrvIntersectRect(prcl,prcl,prclTrg);
230:
231: // Adjust the source point for clipping too
232: ptlTemp.x = pptlSrc->x + prcl->left -
233: prclTrg->left;
234: ptlTemp.y = pptlSrc->y + prcl->top -
235: prclTrg->top;
236:
237: // Blt the clipped rectangle
238: vDIB2VGA((PDEVSURF) psoTrg->dhsurf,
239: &dsurfSrc, prcl, &ptlTemp,
240: pucDIB4ToVGAConvTables);
241: }
242: } while(bMore);
243:
244: }
245:
246: return(TRUE);
247: }
248:
249: case BMF_1BPP:
250: case BMF_8BPP:
251:
252: return(DrvBitBlt(psoTrg,
253: psoSrc,
254: (SURFOBJ *) NULL,
255: pco,
256: pxlo,
257: prclTrg,
258: pptlSrc,
259: (POINTL *) NULL,
260: (BRUSHOBJ *) NULL,
261: (POINTL *) NULL,
262: 0x0000cccc));
263:
264: case BMF_8RLE:
265: case BMF_4RLE:
266: return(bRleBlt(psoTrg, psoSrc, pco, pxlo, prclTrg, pptlSrc));
267:
268: }
269: }
270: else
271: {
272: // screen to DIB
273:
274: // ASSERT(psoTrg->iType == STYPE_BITMAP, "ERROR CopyBits got 2 DIBs");
275:
276: if (psoTrg->iBitmapFormat == BMF_4BPP)
277: {
278: pdsurf = (PDEVSURF) psoSrc->dhsurf;
279:
280: // Get the data for the destination DIB.
281:
282: lDelta = psoTrg->lDelta;
283: pjDstScan0 = (PBYTE) psoTrg->pvScan0;
284:
285: // Setup for any color translation which may be needed !!! Is any needed at all?
286:
287: if (pxlo == NULL)
288: {
289: pulXlate = NULL;
290: }
291: else
292: {
293: if (pxlo->flXlate & XO_TABLE)
294: pulXlate = pxlo->pulXlate;
295: else
296: {
297: // ASSERT(pxlo->flXlate & XO_TRIVIAL, "DrvCopyBits: Hopelessly complex translation\n");
298: pulXlate = (PULONG) NULL;
299: }
300: }
301:
302: // Set up for clip enumeration.
303:
304: if (pco != (CLIPOBJ *) NULL)
305: {
306: switch(pco->iDComplexity)
307: {
308: case DC_TRIVIAL:
309: bMore = FALSE;
310: cben.c = 1;
311: cben.arcl[0] = *prclTrg; // Use the target for clipping
312: break;
313:
314: case DC_RECT:
315: bMore = FALSE;
316: cben.c = 1;
317: cben.arcl[0] = pco->rclBounds; // Use the bounds for clipping
318: break;
319:
320: case DC_COMPLEX:
321: bMore = TRUE;
322: cben.c = 0;
323: CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_ANY, ENUM_RECT_LIMIT);
324: break;
325: }
326: }
327: else
328: {
329: bMore = FALSE;
330: cben.c = 1;
331: cben.arcl[0] = *prclTrg; // Use the target for clipping
332: }
333:
334: // Call the VGA conversion routine, adjusted for each rectangle
335:
336: do
337: {
338: LONG xSrc;
339: LONG ySrc;
340: RECTL *prcl;
341:
342: if (bMore)
343: bMore = CLIPOBJ_bEnum(pco,(ULONG) sizeof(cben), (PVOID) &cben);
344:
345: for (ircl = 0; ircl < cben.c; ircl++)
346: {
347: prcl = &cben.arcl[ircl];
348:
349: xSrc = pptlSrc->x + prcl->left - prclTrg->left;
350: ySrc = pptlSrc->y + prcl->top - prclTrg->top;
351:
352: vConvertVGA2DIB(pdsurf,
353: xSrc,
354: ySrc,
355: pjDstScan0,
356: prcl->left,
357: prcl->top,
358: prcl->right - prcl->left,
359: prcl->bottom - prcl->top,
360: lDelta,
361: psoTrg->iBitmapFormat,
362: pulXlate);
363: }
364: } while (bMore);
365:
366: return(TRUE);
367: }
368: }
369:
370: // This is how we do any formats that we don't support in our inner loops.
371:
372: return(SimCopyBits(psoTrg, psoSrc, pco, pxlo, prclTrg, pptlSrc));
373: }
374:
375: /******************************Public*Routine******************************\
376: * SimCopyBits
377: *
378: * This function simulates CopyBits for the driver when the driver is asked
379: * to blt to formats it does not support. It converts any blt to be between
380: * the device's preferred format and the screen.
381: *
382: \**************************************************************************/
383:
384: BOOL SimCopyBits
385: (
386: SURFOBJ *psoTrg,
387: SURFOBJ *psoSrc,
388: CLIPOBJ *pco,
389: XLATEOBJ *pxlo,
390: PRECTL prclTrg,
391: PPOINTL pptlSrc
392: )
393: {
394: HBITMAP hbmTmp;
395: SURFOBJ *psoTmp;
396: RECTL rclTmp;
397: SIZEL sizlTmp;
398: BOOL bReturn = FALSE;
399: static POINTL ptl00 = {0,0};
400:
401: rclTmp.top = rclTmp.left = 0;
402: rclTmp.right = sizlTmp.cx = prclTrg->right - prclTrg->left;
403: rclTmp.bottom = sizlTmp.cy = prclTrg->bottom - prclTrg->top;
404:
405: // Create bitmap in our compatible format.
406:
407: hbmTmp = EngCreateBitmap(sizlTmp, sizlTmp.cx / 2, BMF_4BPP, 0, NULL);
408:
409: if (hbmTmp)
410: {
411: if ((psoTmp = EngLockSurface((HSURF)hbmTmp)) != NULL)
412: {
413: if (psoSrc->iType == STYPE_BITMAP)
414: {
415: // blting from DIB to screen
416:
417: if (EngCopyBits(psoTmp, psoSrc, NULL, pxlo, &rclTmp, pptlSrc))
418: {
419: // Let DrvCopyBits do this easy case copy to screen.
420:
421: bReturn = DrvCopyBits(psoTrg, psoTmp, pco, NULL, prclTrg, &ptl00);
422: }
423: }
424: else
425: {
426: // blting from screen to DIB
427:
428: if (DrvCopyBits(psoTmp, psoSrc, NULL, NULL, &rclTmp, pptlSrc))
429: {
430: // Let EngCopyBits copy between DIBS
431:
432: bReturn = EngCopyBits(psoTrg, psoTmp, pco, pxlo, prclTrg, &ptl00);
433: }
434: }
435:
436: EngUnlockSurface(psoTmp);
437: }
438:
439: EngDeleteSurface((HSURF)hbmTmp);
440: }
441:
442: return(bReturn);
443: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.