![[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 / xga|
Return to bitblt.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / xga |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: bitblt.c
3: *
4: * XGA bitblit accelerations
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: *
8: \**************************************************************************/
9:
10: #include "driver.h"
11:
12:
13: BOOL bSpecialBlits(
14: SURFOBJ *psoTrg,
15: SURFOBJ *psoSrc,
16: SURFOBJ *psoMask,
17: CLIPOBJ *pco,
18: XLATEOBJ *pxlo,
19: RECTL *prclTrg,
20: POINTL *pptlSrc,
21: POINTL *pptlMask,
22: BRUSHOBJ *pbo,
23: POINTL *pptlBrush,
24: ROP4 rop4
25: );
26:
27: BOOL bScrnToScrnCpy(
28: SURFOBJ *psoTrg,
29: SURFOBJ *psoSrc,
30: SURFOBJ *psoMask,
31: CLIPOBJ *pco,
32: XLATEOBJ *pxlo,
33: RECTL *prclTrg,
34: POINTL *pptlSrc,
35: POINTL *pptlMask,
36: BRUSHOBJ *pbo,
37: POINTL *pptlBrush,
38: ROP4 rop4
39: );
40:
41:
42: BOOL bSolidPattern(
43: SURFOBJ *psoTrg,
44: SURFOBJ *psoSrc,
45: SURFOBJ *psoMask,
46: CLIPOBJ *pco,
47: XLATEOBJ *pxlo,
48: RECTL *prclTrg,
49: POINTL *pptlSrc,
50: POINTL *pptlMask,
51: BRUSHOBJ *pbo,
52: POINTL *pptlBrush,
53: ROP4 rop4
54: );
55:
56:
57:
58: /******************************Public*Data*********************************\
59: * ROP translation table
60: *
61: * Translates the usual ternary rop into A-vector notation. Each bit in
62: * this new notation corresponds to a term in a polynomial translation of
63: * the rop.
64: *
65: * Rop(D,S,P) = a + a D + a S + a P + a DS + a DP + a SP + a DSP
66: * 0 d s p ds dp sp dsp
67: *
68: \**************************************************************************/
69:
70: BYTE gajRop[] =
71: {
72: 0x00, 0xff, 0xb2, 0x4d, 0xd4, 0x2b, 0x66, 0x99,
73: 0x90, 0x6f, 0x22, 0xdd, 0x44, 0xbb, 0xf6, 0x09,
74: 0xe8, 0x17, 0x5a, 0xa5, 0x3c, 0xc3, 0x8e, 0x71,
75: 0x78, 0x87, 0xca, 0x35, 0xac, 0x53, 0x1e, 0xe1,
76: 0xa0, 0x5f, 0x12, 0xed, 0x74, 0x8b, 0xc6, 0x39,
77: 0x30, 0xcf, 0x82, 0x7d, 0xe4, 0x1b, 0x56, 0xa9,
78: 0x48, 0xb7, 0xfa, 0x05, 0x9c, 0x63, 0x2e, 0xd1,
79: 0xd8, 0x27, 0x6a, 0x95, 0x0c, 0xf3, 0xbe, 0x41,
80: 0xc0, 0x3f, 0x72, 0x8d, 0x14, 0xeb, 0xa6, 0x59,
81: 0x50, 0xaf, 0xe2, 0x1d, 0x84, 0x7b, 0x36, 0xc9,
82: 0x28, 0xd7, 0x9a, 0x65, 0xfc, 0x03, 0x4e, 0xb1,
83: 0xb8, 0x47, 0x0a, 0xf5, 0x6c, 0x93, 0xde, 0x21,
84: 0x60, 0x9f, 0xd2, 0x2d, 0xb4, 0x4b, 0x06, 0xf9,
85: 0xf0, 0x0f, 0x42, 0xbd, 0x24, 0xdb, 0x96, 0x69,
86: 0x88, 0x77, 0x3a, 0xc5, 0x5c, 0xa3, 0xee, 0x11,
87: 0x18, 0xe7, 0xaa, 0x55, 0xcc, 0x33, 0x7e, 0x81,
88: 0x80, 0x7f, 0x32, 0xcd, 0x54, 0xab, 0xe6, 0x19,
89: 0x10, 0xef, 0xa2, 0x5d, 0xc4, 0x3b, 0x76, 0x89,
90: 0x68, 0x97, 0xda, 0x25, 0xbc, 0x43, 0x0e, 0xf1,
91: 0xf8, 0x07, 0x4a, 0xb5, 0x2c, 0xd3, 0x9e, 0x61,
92: 0x20, 0xdf, 0x92, 0x6d, 0xf4, 0x0b, 0x46, 0xb9,
93: 0xb0, 0x4f, 0x02, 0xfd, 0x64, 0x9b, 0xd6, 0x29,
94: 0xc8, 0x37, 0x7a, 0x85, 0x1c, 0xe3, 0xae, 0x51,
95: 0x58, 0xa7, 0xea, 0x15, 0x8c, 0x73, 0x3e, 0xc1,
96: 0x40, 0xbf, 0xf2, 0x0d, 0x94, 0x6b, 0x26, 0xd9,
97: 0xd0, 0x2f, 0x62, 0x9d, 0x04, 0xfb, 0xb6, 0x49,
98: 0xa8, 0x57, 0x1a, 0xe5, 0x7c, 0x83, 0xce, 0x31,
99: 0x38, 0xc7, 0x8a, 0x75, 0xec, 0x13, 0x5e, 0xa1,
100: 0xe0, 0x1f, 0x52, 0xad, 0x34, 0xcb, 0x86, 0x79,
101: 0x70, 0x8f, 0xc2, 0x3d, 0xa4, 0x5b, 0x16, 0xe9,
102: 0x08, 0xf7, 0xba, 0x45, 0xdc, 0x23, 0x6e, 0x91,
103: 0x98, 0x67, 0x2a, 0xd5, 0x4c, 0xb3, 0xfe, 0x01
104: };
105:
106:
107: /*****************************************************************************
108: * XGA DrvBitBlt
109: ****************************************************************************/
110: BOOL DrvBitBlt(
111: SURFOBJ *psoTrg,
112: SURFOBJ *psoSrc,
113: SURFOBJ *psoMask,
114: CLIPOBJ *pco,
115: XLATEOBJ *pxlo,
116: RECTL *prclTrg,
117: POINTL *pptlSrc,
118: POINTL *pptlMask,
119: BRUSHOBJ *pbo,
120: POINTL *pptlBrush,
121: ROP4 rop4)
122:
123: {
124: BOOL b;
125:
126:
127: b = bSpecialBlits(psoTrg, psoSrc, psoMask,
128: pco, pxlo,
129: prclTrg, pptlSrc, pptlMask,
130: pbo, pptlBrush,
131: rop4);
132: if (b == TRUE)
133: {
134: return (TRUE);
135: }
136:
137: if ((psoTrg) && (psoTrg->iType == STYPE_DEVICE))
138: psoTrg = ((PPDEV)(psoTrg->dhpdev))->pSurfObj;
139:
140: if ((psoSrc) && (psoSrc->iType == STYPE_DEVICE))
141: psoSrc = ((PPDEV)(psoSrc->dhpdev))->pSurfObj;
142:
143: EngBitBlt(psoTrg,
144: psoSrc,
145: psoMask,
146: pco,
147: pxlo,
148: prclTrg,
149: pptlSrc,
150: pptlMask,
151: pbo,
152: pptlBrush,
153: rop4);
154:
155:
156: }
157:
158:
159: /*****************************************************************************
160: * XGA Special case Blit handler
161: *
162: * Returns TRUE if the blit was handled.
163: ****************************************************************************/
164: BOOL bSpecialBlits(
165: SURFOBJ *psoTrg,
166: SURFOBJ *psoSrc,
167: SURFOBJ *psoMask,
168: CLIPOBJ *pco,
169: XLATEOBJ *pxlo,
170: RECTL *prclTrg,
171: POINTL *pptlSrc,
172: POINTL *pptlMask,
173: BRUSHOBJ *pbo,
174: POINTL *pptlBrush,
175: ROP4 rop4)
176: {
177: BOOL b;
178: HSURF hsurfSrc, hsurfTrg;
179:
180: b = FALSE;
181:
182: DISPDBG((3, "XGA.DLL!bSpecialBlits - rop4: %8.8X\n", rop4));
183: DISPDBG((3, "XGA.DLL!bSpecialBlits - pbo : %8.8X\n", pbo));
184:
185: // Wait for the coprocessor.
186:
187: vWaitForCoProcessor((PPDEV)psoTrg->dhpdev, 100);
188:
189: // NOTE: If the ForeRop and BackRop are the same implicitly
190: // there is no mask.
191:
192: // First test for a screen to screen copy.
193:
194: if (rop4 == 0x0000CCCC)
195: {
196:
197: if (psoTrg != NULL)
198: hsurfTrg = psoTrg->hsurf;
199:
200: if (psoSrc != NULL)
201: hsurfSrc = psoSrc->hsurf;
202:
203: if (hsurfTrg == hsurfSrc)
204: {
205:
206: if (((PPDEV)psoTrg->dhpdev)->ulfBlitAccelerations_debug & SCRN_TO_SCRN_CPY)
207: {
208: b = bScrnToScrnCpy(psoTrg, psoSrc, psoMask,
209: pco, pxlo,
210: prclTrg, pptlSrc, pptlMask,
211: pbo, pptlBrush,
212: rop4);
213: }
214: else
215: {
216: b = FALSE;
217: }
218:
219: }
220:
221: }
222:
223: // Check for a Solid Brush.
224:
225: if (rop4 == 0x0000F0F0)
226: {
227: if (pbo->iSolidColor != -1)
228: {
229: if (((PPDEV)psoTrg->dhpdev)->ulfBlitAccelerations_debug & SOLID_PATTERN)
230: {
231: b = bSolidPattern(psoTrg, psoSrc, psoMask,
232: pco, pxlo,
233: prclTrg, pptlSrc, pptlMask,
234: pbo, pptlBrush,
235: rop4);
236: }
237: else
238: {
239: b = FALSE;
240: }
241:
242: }
243:
244: }
245:
246: return (b);
247:
248: }
249:
250:
251: /*****************************************************************************
252: * XGA Screen to Screen Copy
253: *
254: * Returns TRUE if the blit was handled.
255: ****************************************************************************/
256: BOOL bScrnToScrnCpy(
257: SURFOBJ *psoTrg,
258: SURFOBJ *psoSrc,
259: SURFOBJ *psoMask,
260: CLIPOBJ *pco,
261: XLATEOBJ *pxlo,
262: RECTL *prclTrg,
263: POINTL *pptlSrc,
264: POINTL *pptlMask,
265: BRUSHOBJ *pbo,
266: POINTL *pptlBrush,
267: ROP4 rop4)
268: {
269: BOOL b;
270: INT width,
271: height,
272: xTrg,
273: yTrg,
274: xSrc,
275: ySrc;
276:
277: ULONG ulDirCode,
278: XGAPixelOp,
279: ulXgaMask;
280:
281: PXGACPREGS pXgaCpRegs = ((PPDEV)psoTrg->dhpdev)->pXgaCpRegs;
282:
283:
284: // Important Note: When we get time we should test the Coprocessor
285: // for being busy. If its not then we should execute the code here.
286: // If it is busy we should queue the request. This implies an
287: // interrupt driven XGA.
288:
289: b = bSetXgaClipping((PPDEV)psoTrg->dhpdev, pco, &ulXgaMask);
290: if (b == FALSE)
291: return (b);
292:
293: // Setup the BitBlt parameters.
294:
295: width = (prclTrg->right - prclTrg->left) - 1;
296: height = (prclTrg->bottom - prclTrg->top) - 1;
297:
298: // We need to determine the direction of the blit.
299:
300: ulDirCode = 0;
301: xTrg = prclTrg->left;
302: yTrg = prclTrg->top;
303: xSrc = pptlSrc->x;
304: ySrc = pptlSrc->y;
305:
306: // The horizontal copy direction.
307:
308: if (prclTrg->left > pptlSrc->x)
309: {
310: // R to L
311:
312: xTrg = prclTrg->right - 1;
313: xSrc = pptlSrc->x + width;
314: ulDirCode |= OCT_DX;
315: }
316:
317: // The vertical copy direction.
318:
319: if (prclTrg->top > pptlSrc->y)
320: {
321: // B to T
322:
323: yTrg = prclTrg->bottom - 1;
324: ySrc = pptlSrc->y + height;
325: ulDirCode |= OCT_DY;
326: }
327:
328: pXgaCpRegs->XGAOpDim1 = width;
329: pXgaCpRegs->XGAOpDim2 = height;
330:
331: pXgaCpRegs->XGASourceMapX = xSrc;
332: pXgaCpRegs->XGASourceMapY = ySrc;
333:
334: pXgaCpRegs->XGADestMapX = xTrg;
335: pXgaCpRegs->XGADestMapY = yTrg;
336:
337: pXgaCpRegs->XGAForeGrMix = XGA_S;
338: pXgaCpRegs->XGABackGrMix = XGA_S;
339:
340:
341: // Now build the Pel Operation Register Op Code;
342:
343: XGAPixelOp = BS_SRC_PEL_MAP | FS_SRC_PEL_MAP |
344: STEP_PX_BLT |
345: SRC_PEL_MAP_A | DST_PEL_MAP_A |
346: PATT_FOREGROUND;
347:
348: XGAPixelOp |= ulDirCode;
349: XGAPixelOp |= ulXgaMask;
350:
351: pXgaCpRegs->XGAPixelOp = XGAPixelOp;
352:
353:
354: return (TRUE);
355:
356:
357: }
358:
359: /*****************************************************************************
360: * XGA Solid Pattern
361: *
362: * Returns TRUE if the blit was handled.
363: ****************************************************************************/
364: BOOL bSolidPattern(
365: SURFOBJ *psoTrg,
366: SURFOBJ *psoSrc,
367: SURFOBJ *psoMask,
368: CLIPOBJ *pco,
369: XLATEOBJ *pxlo,
370: RECTL *prclTrg,
371: POINTL *pptlSrc,
372: POINTL *pptlMask,
373: BRUSHOBJ *pbo,
374: POINTL *pptlBrush,
375: ROP4 rop4)
376: {
377: BOOL b;
378: INT width,
379: height;
380:
381: ULONG XGAPixelOp,
382: ulXgaMask;
383:
384: PXGACPREGS pXgaCpRegs = ((PPDEV)psoTrg->dhpdev)->pXgaCpRegs;
385:
386:
387: DISPDBG((2, "XGA.DLL!bSolidPattern - Entry\n"));
388:
389: b = bSetXgaClipping((PPDEV)psoTrg->dhpdev,pco, &ulXgaMask);
390: if (b == FALSE)
391: return (b);
392:
393: // Setup the BitBlt parameters.
394:
395: width = (prclTrg->right - prclTrg->left) - 1;
396: height = (prclTrg->bottom - prclTrg->top) - 1;
397:
398: pXgaCpRegs->XGAOpDim1 = width;
399: pXgaCpRegs->XGAOpDim2 = height;
400:
401: pXgaCpRegs->XGADestMapX = (USHORT) prclTrg->left;
402: pXgaCpRegs->XGADestMapY = (USHORT) prclTrg->top;
403:
404: pXgaCpRegs->XGAForeGrMix = XGA_S;
405: pXgaCpRegs->XGABackGrMix = XGA_S;
406:
407: pXgaCpRegs->XGAForeGrColorReg = pbo->iSolidColor;
408: pXgaCpRegs->XGABackGrColorReg = pbo->iSolidColor;
409:
410: // Now build the Pel Operation Register Op Code;
411:
412: XGAPixelOp = BS_BACK_COLOR | FS_FORE_COLOR |
413: STEP_PX_BLT |
414: SRC_PEL_MAP_A | DST_PEL_MAP_A |
415: PATT_FOREGROUND;
416:
417: XGAPixelOp |= ulXgaMask;
418:
419: pXgaCpRegs->XGAPixelOp = XGAPixelOp;
420:
421: return (TRUE);
422:
423: }
424:
425: /*****************************************************************************
426: * XGA DrvCopyBits
427: ****************************************************************************/
428: BOOL DrvCopyBits(
429: SURFOBJ *psoDest,
430: SURFOBJ *psoSrc,
431: CLIPOBJ *pco,
432: XLATEOBJ *pxlo,
433: RECTL *prclDest,
434: POINTL *pptlSrc)
435: {
436: BOOL b;
437:
438: CLIPOBJ coLocal;
439: SURFOBJ *pso;
440:
441: DISPDBG((2, "XGA.DLL: DrvCopyBits - Entry\n"));
442:
443: // Need to determine which surface is the display.
444: // So we can pickup the address of the XGA coprocessor regs.
445:
446: if ((psoDest) && (psoDest->iType == STYPE_DEVICE))
447: pso = psoDest;
448:
449: else if ((psoSrc) && (psoSrc->iType == STYPE_DEVICE))
450: pso = psoSrc;
451:
452: else
453: {
454: RIP ("XGA.DLL!DrvCopyBits - neither surface is a device surface\n");
455: return (TRUE);
456: }
457:
458: // Wait for the coprocessor.
459:
460: vWaitForCoProcessor((PPDEV)pso->dhpdev, 100);
461:
462: // Protect this routine from a potentially NULL clip object
463:
464: if (pco == NULL)
465: {
466: coLocal.iDComplexity = DC_RECT;
467:
468: coLocal.rclBounds.left = 0;
469: coLocal.rclBounds.top = 0;
470: coLocal.rclBounds.right = ((PPDEV)pso->dhpdev)->cxScreen;
471: coLocal.rclBounds.bottom = ((PPDEV)pso->dhpdev)->cyScreen;
472:
473: pco = &coLocal;
474:
475: }
476:
477: // Check for a Screen to Screen or a Host to Screen blit.
478:
479: b = FALSE;
480:
481: if ((psoDest->iType == STYPE_DEVICE) &&
482: (psoSrc->iType == STYPE_DEVICE) &&
483: (((PPDEV)psoDest->dhpdev)->ulfBlitAccelerations_debug & SCRN_TO_SCRN_CPY))
484: {
485: b = bScrnToScrnCpy(psoDest,
486: psoSrc,
487: NULL,
488: pco,
489: pxlo,
490: prclDest,
491: pptlSrc,
492: NULL,
493: NULL,
494: NULL,
495: 0xcccc);
496: }
497:
498: if (b == FALSE)
499: {
500: if ((psoDest) && (psoDest->iType == STYPE_DEVICE))
501: psoDest = ((PPDEV)(psoDest->dhpdev))->pSurfObj;
502:
503: if ((psoSrc) && (psoSrc->iType == STYPE_DEVICE))
504: psoSrc = ((PPDEV)(psoSrc->dhpdev))->pSurfObj;
505:
506: EngCopyBits(psoDest,
507: psoSrc,
508: pco,
509: pxlo,
510: prclDest,
511: pptlSrc);
512:
513: }
514:
515: return (TRUE);
516:
517: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.