?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
First import
[xorg_rtime.git] / xorg-server-1.4 / mi / mibank.c
blob32e963fabcc4b3adcbc323e6830744c56a3e1d7f
1 /*
2 * Copyright 1997 through 2004 by Marc Aurele La France (TSI @ UQV), tsi@xfree86.org
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that copyright
7 * notice and this permission notice appear in supporting documentation, and
8 * that the name of Marc Aurele La France not be used in advertising or
9 * publicity pertaining to distribution of the software without specific,
10 * written prior permission. Marc Aurele La France makes no representations
11 * about the suitability of this software for any purpose. It is provided
12 * "as-is" without express or implied warranty.
13 *
14 * MARC AURELE LA FRANCE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
16 * EVENT SHALL MARC AURELE LA FRANCE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
20 * PERFORMANCE OF THIS SOFTWARE.
21 */
22
23 /*
24 * Copyright 1990,91,92,93 by Thomas Roell, Germany.
25 * Copyright 1991,92,93 by SGCS (Snitily Graphics Consulting Services), USA.
26 *
27 * Permission to use, copy, modify, distribute, and sell this software
28 * and its documentation for any purpose is hereby granted without fee,
29 * provided that the above copyright notice appear in all copies and
30 * that both that copyright notice and this permission notice appear
31 * in supporting documentation, and that the name of Thomas Roell nor
32 * SGCS be used in advertising or publicity pertaining to distribution
33 * of the software without specific, written prior permission.
34 * Thomas Roell nor SGCS makes no representations about the suitability
35 * of this software for any purpose. It is provided "as is" without
36 * express or implied warranty.
37 *
38 * THOMAS ROELL AND SGCS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
39 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
40 * FITNESS, IN NO EVENT SHALL THOMAS ROELL OR SGCS BE LIABLE FOR ANY
41 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
42 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
43 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
44 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
45 */
46
47
48 /*
49 * This thing originated from an idea of Edwin Goei and his bank switching
50 * code for the DEC TX board.
51 */
52
53 /*
54 * Heavily modified for the XFree86 Project to turn this into an mi wrapper.
55 * --- Marc Aurele La France (tsi@xfree86.org)
56 */
57
58 /*
59 * "Heavily modified", indeed! By the time this is finalized, there probably
60 * won't be much left of Roell's code...
61 *
62 * Miscellaneous notes:
63 * - Pixels with imbedded bank boundaries are required to be off-screen. There
64 * >might< be a way to fool the underlying framebuffer into dealing with
65 * partial pixels.
66 * - Plans to generalise this to do (hardware) colour plane switching have been
67 * dropped due to colour flashing concerns.
68 *
69 * TODO:
70 * - Allow miModifyBanking() to change BankSize and nBankDepth.
71 * - Re-instate shared and double banking for framebuffers whose pixmap formats
72 * don't describe how the server "sees" the screen.
73 * - Remove remaining assumptions that a pixmap's devPrivate field points
74 * directly to its pixel data.
75 */
76
77 /* #define NO_ALLOCA 1 */
78
79 #ifdef HAVE_DIX_CONFIG_H
80 #include <dix-config.h>
81 #endif
82
83 #include "servermd.h"
84 #include "gcstruct.h"
85 #include "pixmapstr.h"
86 #include "scrnintstr.h"
87 #include "windowstr.h"
88 #include "mi.h"
89 #include "mibank.h"
90
91 #define BANK_SINGLE 0
92 #define BANK_SHARED 1
93 #define BANK_DOUBLE 2
94 #define BANK_NOBANK 3
95
96 typedef struct _miBankScreen
97 {
98 miBankInfoRec BankInfo;
99 unsigned int nBankBPP;
100 unsigned int type;
101
102 unsigned long nBitsPerBank;
103 unsigned long nBitsPerScanline;
104 unsigned long nPixelsPerScanlinePadUnit;
105
106 PixmapPtr pScreenPixmap;
107 PixmapPtr pBankPixmap;
108 GCPtr pBankGC;
109
110 int nBanks, maxRects;
111 RegionPtr *pBanks;
112
113 pointer pbits;
114
115 /*
116 * Screen Wrappers
117 */
118 CreateScreenResourcesProcPtr CreateScreenResources;
119 ModifyPixmapHeaderProcPtr ModifyPixmapHeader;
120 CloseScreenProcPtr CloseScreen;
121 GetImageProcPtr GetImage;
122 GetSpansProcPtr GetSpans;
123 CreateGCProcPtr CreateGC;
124 PaintWindowBackgroundProcPtr PaintWindowBackground;
125 PaintWindowBorderProcPtr PaintWindowBorder;
126 CopyWindowProcPtr CopyWindow;
127 BSFuncRec BackingStoreFuncs;
128 } miBankScreenRec, *miBankScreenPtr;
129
130 typedef struct _miBankGC
131 {
132 GCOps *wrappedOps, *unwrappedOps;
133 GCFuncs *wrappedFuncs, *unwrappedFuncs;
134
135 Bool fastCopy, fastPlane;
136
137 RegionPtr pBankedClips[1];
138 } miBankGCRec, *miBankGCPtr;
139
140 typedef struct _miBankQueue
141 {
142 Bool fastBlit;
143 unsigned short srcBankNo;
144 unsigned short dstBankNo;
145 short x;
146 short y;
147 short w;
148 short h;
149 } miBankQueue;
150
151 /*
152 * CAVEAT: This banking scheme requires that the DDX store Pixmap data in the
153 * server's address space.
154 */
155
156 #define ModifyPixmap(_pPix, _width, _devKind, _pbits) \
157 (*pScreen->ModifyPixmapHeader)((_pPix), \
158 (_width), -1, -1, -1, (_devKind), (_pbits))
159
160 #define SET_SINGLE_BANK(_pPix, _width, _devKind, _no) \
161 ModifyPixmap(_pPix, _width, _devKind, \
162 (char *)pScreenPriv->BankInfo.pBankA + \
163 (*pScreenPriv->BankInfo.SetSourceAndDestinationBanks)(pScreen, (_no)) - \
164 (pScreenPriv->BankInfo.BankSize * (_no)))
165
166 #define SET_SOURCE_BANK(_pPix, _width, _devKind, _no) \
167 ModifyPixmap(_pPix, _width, _devKind, \
168 (char *)pScreenPriv->BankInfo.pBankA + \
169 (*pScreenPriv->BankInfo.SetSourceBank)(pScreen, (_no)) - \
170 (pScreenPriv->BankInfo.BankSize * (_no)))
171
172 #define SET_DESTINATION_BANK(_pPix, _width, _devKind, _no) \
173 ModifyPixmap(_pPix, _width, _devKind, \
174 (char *)pScreenPriv->BankInfo.pBankB + \
175 (*pScreenPriv->BankInfo.SetDestinationBank)(pScreen, (_no)) - \
176 (pScreenPriv->BankInfo.BankSize * (_no)))
177
178 #define ALLOCATE_LOCAL_ARRAY(atype, ntype) \
179 (atype *)ALLOCATE_LOCAL((ntype) * sizeof(atype))
180
181 static int miBankScreenIndex;
182 static int miBankGCIndex;
183 static unsigned long miBankGeneration = 0;
184
185 #define BANK_SCRPRIVLVAL pScreen->devPrivates[miBankScreenIndex].ptr
186
187 #define BANK_SCRPRIVATE ((miBankScreenPtr)(BANK_SCRPRIVLVAL))
188
189 #define BANK_GCPRIVLVAL(pGC) (pGC)->devPrivates[miBankGCIndex].ptr
190
191 #define BANK_GCPRIVATE(pGC) ((miBankGCPtr)(BANK_GCPRIVLVAL(pGC)))
192
193 #define PIXMAP_STATUS(_pPix) \
194 pointer pbits = (_pPix)->devPrivate.ptr
195
196 #define PIXMAP_SAVE(_pPix) \
197 PIXMAP_STATUS(_pPix); \
198 if (pbits == (pointer)pScreenPriv) \
199 (_pPix)->devPrivate.ptr = pScreenPriv->pbits
200
201 #define PIXMAP_RESTORE(_pPix) \
202 (_pPix)->devPrivate.ptr = pbits
203
204 #define BANK_SAVE \
205 int width = pScreenPriv->pBankPixmap->drawable.width; \
206 int devKind = pScreenPriv->pBankPixmap->devKind; \
207 PIXMAP_SAVE(pScreenPriv->pBankPixmap)
208
209 #define BANK_RESTORE \
210 pScreenPriv->pBankPixmap->drawable.width = width; \
211 pScreenPriv->pBankPixmap->devKind = devKind; \
212 PIXMAP_RESTORE(pScreenPriv->pBankPixmap)
213
214 #define SCREEN_STATUS \
215 PIXMAP_STATUS(pScreenPriv->pScreenPixmap)
216
217 #define SCREEN_SAVE \
218 PIXMAP_SAVE(pScreenPriv->pScreenPixmap)
219
220 #define SCREEN_RESTORE \
221 PIXMAP_RESTORE(pScreenPriv->pScreenPixmap)
222
223 #define SCREEN_INIT \
224 miBankScreenPtr pScreenPriv = BANK_SCRPRIVATE
225
226 #define SCREEN_UNWRAP(field) \
227 pScreen->field = pScreenPriv->field
228
229 #define SCREEN_WRAP(field, wrapper) \
230 pScreenPriv->field = pScreen->field; \
231 pScreen->field = wrapper
232
233 #define GC_INIT(pGC) \
234 miBankGCPtr pGCPriv = BANK_GCPRIVATE(pGC)
235
236 #define GC_UNWRAP(pGC) \
237 pGCPriv->unwrappedOps = (pGC)->ops; \
238 pGCPriv->unwrappedFuncs = (pGC)->funcs; \
239 (pGC)->ops = pGCPriv->wrappedOps; \
240 (pGC)->funcs = pGCPriv->wrappedFuncs
241
242 #define GC_WRAP(pGC) \
243 pGCPriv->wrappedOps = (pGC)->ops; \
244 pGCPriv->wrappedFuncs = (pGC)->funcs; \
245 (pGC)->ops = pGCPriv->unwrappedOps; \
246 (pGC)->funcs = pGCPriv->unwrappedFuncs
247
248 #define IS_BANKED(pDrawable) \
249 ((pbits == (pointer)pScreenPriv) && \
250 (((DrawablePtr)(pDrawable))->type == DRAWABLE_WINDOW))
251
252 #define CLIP_SAVE \
253 RegionPtr pOrigCompositeClip = pGC->pCompositeClip
254
255 #define CLIP_RESTORE \
256 pGC->pCompositeClip = pOrigCompositeClip
257
258 #define GCOP_INIT \
259 ScreenPtr pScreen = pGC->pScreen; \
260 SCREEN_INIT; \
261 GC_INIT(pGC)
262
263 #define GCOP_UNWRAP \
264 GC_UNWRAP(pGC)
265
266 #define GCOP_WRAP \
267 GC_WRAP(pGC)
268
269 #define GCOP_TOP_PART \
270 for (i = 0; i < pScreenPriv->nBanks; i++) \
271 { \
272 if (!(pGC->pCompositeClip = pGCPriv->pBankedClips[i])) \
273 continue; \
274 GCOP_UNWRAP; \
275 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i)
276
277 #define GCOP_BOTTOM_PART \
278 GCOP_WRAP; \
279 }
280
281 #define GCOP_SIMPLE(statement) \
282 if (nArray > 0) \
283 { \
284 GCOP_INIT; \
285 SCREEN_SAVE; \
286 if (!IS_BANKED(pDrawable)) \
287 { \
288 GCOP_UNWRAP; \
289 statement; \
290 GCOP_WRAP; \
291 } \
292 else \
293 { \
294 int i; \
295 CLIP_SAVE; \
296 GCOP_TOP_PART; \
297 statement; \
298 GCOP_BOTTOM_PART; \
299 CLIP_RESTORE; \
300 } \
301 SCREEN_RESTORE; \
302 }
303
304 #define GCOP_0D_ARGS mode,
305 #define GCOP_1D_ARGS
306 #define GCOP_2D_ARGS shape, mode,
307
308 #define GCOP_COMPLEX(aop, atype) \
309 if (nArray > 0) \
310 { \
311 GCOP_INIT; \
312 SCREEN_SAVE; \
313 if (!IS_BANKED(pDrawable)) \
314 { \
315 GCOP_UNWRAP; \
316 (*pGC->ops->aop)(pDrawable, pGC, GCOP_ARGS nArray, pArray); \
317 GCOP_WRAP; \
318 } \
319 else \
320 { \
321 atype *aarg = pArray, *acopy; \
322 int i; \
323 CLIP_SAVE; \
324 if ((acopy = ALLOCATE_LOCAL_ARRAY(atype, nArray))) \
325 aarg = acopy; \
326 GCOP_TOP_PART; \
327 if (acopy) \
328 memcpy(acopy, pArray, nArray * sizeof(atype)); \
329 (*pGC->ops->aop)(pDrawable, pGC, GCOP_ARGS nArray, aarg); \
330 GCOP_BOTTOM_PART; \
331 DEALLOCATE_LOCAL(acopy); \
332 CLIP_RESTORE; \
333 } \
334 SCREEN_RESTORE; \
335 }
336
337 /*********************
338 * Utility functions *
339 *********************/
340
341 static int
342 miBankOf(
343 miBankScreenPtr pScreenPriv,
344 int x,
345 int y
346 )
347 {
348 int iBank = ((x * (int)pScreenPriv->nBankBPP) +
349 (y * (long)pScreenPriv->nBitsPerScanline)) /
350 (long)pScreenPriv->nBitsPerBank;
351
352 if (iBank < 0)
353 iBank = 0;
354 else if (iBank >= pScreenPriv->nBanks)
355 iBank = pScreenPriv->nBanks - 1;
356
357 return iBank;
358 }
359
360 #define FirstBankOf(_x, _y) miBankOf(pScreenPriv, (_x), (_y))
361 #define LastBankOf(_x, _y) miBankOf(pScreenPriv, (_x) - 1, (_y))
362
363 /* Determine banking type from the BankInfoRec */
364 static unsigned int
365 miBankDeriveType(
366 ScreenPtr pScreen,
367 miBankInfoPtr pBankInfo
368 )
369 {
370 unsigned int type;
371
372 if (pBankInfo->pBankA == pBankInfo->pBankB)
373 {
374 if (pBankInfo->SetSourceBank == pBankInfo->SetDestinationBank)
375 {
376 if (pBankInfo->SetSourceAndDestinationBanks !=
377 pBankInfo->SetSourceBank)
378 return BANK_NOBANK;
379
380 type = BANK_SINGLE;
381 }
382 else
383 {
384 if (pBankInfo->SetSourceAndDestinationBanks ==
385 pBankInfo->SetDestinationBank)
386 return BANK_NOBANK;
387 if (pBankInfo->SetSourceAndDestinationBanks ==
388 pBankInfo->SetSourceBank)
389 return BANK_NOBANK;
390
391 type = BANK_SHARED;
392 }
393 }
394 else
395 {
396 if ((unsigned long)abs((char *)pBankInfo->pBankA -
397 (char *)pBankInfo->pBankB) < pBankInfo->BankSize)
398 return BANK_NOBANK;
399
400 if (pBankInfo->SetSourceBank == pBankInfo->SetDestinationBank)
401 {
402 if (pBankInfo->SetSourceAndDestinationBanks !=
403 pBankInfo->SetSourceBank)
404 return BANK_NOBANK;
405 }
406 else
407 {
408 if (pBankInfo->SetSourceAndDestinationBanks ==
409 pBankInfo->SetDestinationBank)
410 return BANK_NOBANK;
411 }
412
413 type = BANK_DOUBLE;
414 }
415
416 /*
417 * Internal limitation: Currently, only single banking is supported when
418 * the pixmap format and the screen's pixel format are different. The
419 * following test is only partially successful at detecting this condition.
420 */
421 if (pBankInfo->nBankDepth != pScreen->rootDepth)
422 type = BANK_SINGLE;
423
424 return type;
425 }
426
427 /* Least common multiple */
428 static unsigned int
429 miLCM(
430 unsigned int x,
431 unsigned int y
432 )
433 {
434 unsigned int m = x, n = y, o;
435
436 while ((o = m % n))
437 {
438 m = n;
439 n = o;
440 }
441
442 return (x / n) * y;
443 }
444
445 /******************
446 * GCOps wrappers *
447 ******************/
448
449 static void
450 miBankFillSpans(
451 DrawablePtr pDrawable,
452 GCPtr pGC,
453 int nArray,
454 DDXPointPtr pptInit,
455 int *pwidthInit,
456 int fSorted
457 )
458 {
459 GCOP_SIMPLE((*pGC->ops->FillSpans)(pDrawable, pGC,
460 nArray, pptInit, pwidthInit, fSorted));
461 }
462
463 static void
464 miBankSetSpans(
465 DrawablePtr pDrawable,
466 GCPtr pGC,
467 char *psrc,
468 DDXPointPtr ppt,
469 int *pwidth,
470 int nArray,
471 int fSorted
472 )
473 {
474 GCOP_SIMPLE((*pGC->ops->SetSpans)(pDrawable, pGC, psrc,
475 ppt, pwidth, nArray, fSorted));
476 }
477
478 static void
479 miBankPutImage(
480 DrawablePtr pDrawable,
481 GCPtr pGC,
482 int depth,
483 int x,
484 int y,
485 int w,
486 int h,
487 int leftPad,
488 int format,
489 char *pImage
490 )
491 {
492 if ((w > 0) && (h > 0))
493 {
494 GCOP_INIT;
495 SCREEN_SAVE;
496
497 if (!IS_BANKED(pDrawable))
498 {
499 GCOP_UNWRAP;
500
501 (*pGC->ops->PutImage)(pDrawable, pGC, depth, x, y, w, h,
502 leftPad, format, pImage);
503
504 GCOP_WRAP;
505 }
506 else
507 {
508 int i, j;
509
510 CLIP_SAVE;
511
512 i = FirstBankOf(x + pDrawable->x, y + pDrawable->y);
513 j = LastBankOf(x + pDrawable->x + w, y + pDrawable->y + h);
514 for (; i <= j; i++)
515 {
516 if (!(pGC->pCompositeClip = pGCPriv->pBankedClips[i]))
517 continue;
518
519 GCOP_UNWRAP;
520
521 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
522
523 (*pGC->ops->PutImage)(pDrawable, pGC, depth, x, y, w, h,
524 leftPad, format, pImage);
525
526 GCOP_WRAP;
527 }
528
529 CLIP_RESTORE;
530 }
531
532 SCREEN_RESTORE;
533 }
534 }
535
536 /*
537 * Here the CopyArea/CopyPlane wrappers. First off, we have to clip against
538 * the source in order to make the minimal number of copies in case of slow
539 * systems. Also the exposure handling is quite tricky. Special attention
540 * is to be given to the way the copies are sequenced. The list of boxes after
541 * the source clip is used to build a workqueue, that contains the atomic
542 * copies (i.e. only from one bank to one bank). Doing so produces a minimal
543 * list of things to do.
544 */
545 static RegionPtr
546 miBankCopy(
547 DrawablePtr pSrc,
548 DrawablePtr pDst,
549 GCPtr pGC,
550 int srcx,
551 int srcy,
552 int w,
553 int h,
554 int dstx,
555 int dsty,
556 unsigned long plane,
557 Bool SinglePlane
558 )
559 {
560 int cx1, cy1, cx2, cy2;
561 int ns, nd, nse, nde, dx, dy, xorg = 0, yorg = 0;
562 int maxWidth = 0, maxHeight = 0, paddedWidth = 0;
563 int nBox, nBoxClipSrc, nBoxClipDst, nQueue;
564 BoxPtr pBox, pBoxClipSrc, pBoxClipDst;
565 BoxRec fastBox, ccBox;
566 RegionPtr ret = NULL, prgnSrcClip = NULL;
567 RegionRec rgnDst;
568 char *pImage = NULL;
569 miBankQueue *pQueue, *pQueueNew, *Queue;
570 miBankQueue *pQueueTmp, *pQueueNext, *pQueueBase;
571 Bool fastBlit, freeSrcClip, fastClip;
572 Bool fExpose = FALSE, fastExpose = FALSE;
573
574 GCOP_INIT;
575 SCREEN_SAVE;
576
577 if (!IS_BANKED(pSrc) && !IS_BANKED(pDst))
578 {
579 GCOP_UNWRAP;
580
581 if (SinglePlane)
582 ret = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
583 srcx, srcy, w, h, dstx, dsty, plane);
584 else
585 ret = (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
586 srcx, srcy, w, h, dstx, dsty);
587
588 GCOP_WRAP;
589 }
590 else if (!IS_BANKED(pDst))
591 {
592 fExpose = pGC->fExpose;
593 pGC->fExpose = FALSE;
594
595 xorg = pSrc->x;
596 yorg = pSrc->y;
597 dx = dstx - srcx;
598 dy = dsty - srcy;
599 srcx += xorg;
600 srcy += yorg;
601
602 ns = FirstBankOf(srcx, srcy);
603 nse = LastBankOf(srcx + w, srcy + h);
604 for (; ns <= nse; ns++)
605 {
606 if (!pScreenPriv->pBanks[ns])
607 continue;
608
609 nBox = REGION_NUM_RECTS(pScreenPriv->pBanks[ns]);
610 pBox = REGION_RECTS(pScreenPriv->pBanks[ns]);
611
612 for (; nBox--; pBox++)
613 {
614 cx1 = max(pBox->x1, srcx);
615 cy1 = max(pBox->y1, srcy);
616 cx2 = min(pBox->x2, srcx + w);
617 cy2 = min(pBox->y2, srcy + h);
618
619 if ((cx1 >= cx2) || (cy1 >= cy2))
620 continue;
621
622 GCOP_UNWRAP;
623
624 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, ns);
625
626 if (SinglePlane)
627 (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
628 cx1 - xorg, cy1 - yorg,
629 cx2 - cx1, cy2 - cy1,
630 cx1 + dx - xorg, cy1 + dy - yorg, plane);
631 else
632 (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
633 cx1 - xorg, cy1 - yorg,
634 cx2 - cx1, cy2 - cy1,
635 cx1 + dx - xorg, cy1 + dy - yorg);
636
637 GCOP_WRAP;
638 }
639 }
640
641 pGC->fExpose = fExpose;
642 srcx -= xorg;
643 srcy -= yorg;
644 }
645 else if (!IS_BANKED(pSrc))
646 {
647 CLIP_SAVE;
648
649 if (pGC->miTranslate)
650 {
651 xorg = pDst->x;
652 yorg = pDst->y;
653 }
654 dx = srcx - dstx;
655 dy = srcy - dsty;
656 dstx += xorg;
657 dsty += yorg;
658
659 nd = FirstBankOf(dstx, dsty);
660 nde = LastBankOf(dstx + w, dsty + h);
661 for (; nd <= nde; nd++)
662 {
663 if (!(pGC->pCompositeClip = pGCPriv->pBankedClips[nd]))
664 continue;
665
666 /*
667 * It's faster to let the lower-level CopyArea do the clipping
668 * within each bank.
669 */
670 nBox = REGION_NUM_RECTS(pScreenPriv->pBanks[nd]);
671 pBox = REGION_RECTS(pScreenPriv->pBanks[nd]);
672
673 for (; nBox--; pBox++)
674 {
675 cx1 = max(pBox->x1, dstx);
676 cy1 = max(pBox->y1, dsty);
677 cx2 = min(pBox->x2, dstx + w);
678 cy2 = min(pBox->y2, dsty + h);
679
680 if ((cx1 >= cx2) || (cy1 >= cy2))
681 continue;
682
683 GCOP_UNWRAP;
684
685 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, nd);
686
687 if (SinglePlane)
688 (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
689 cx1 + dx - xorg, cy1 + dy - yorg,
690 cx2 - cx1, cy2 - cy1,
691 cx1 - xorg, cy1 - yorg, plane);
692 else
693 (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
694 cx1 + dx - xorg, cy1 + dy - yorg,
695 cx2 - cx1, cy2 - cy1,
696 cx1 - xorg, cy1 - yorg);
697
698 GCOP_WRAP;
699 }
700 }
701
702 CLIP_RESTORE;
703 }
704 else /* IS_BANKED(pSrc) && IS_BANKED(pDst) */
705 {
706 CLIP_SAVE;
707
708 fExpose = pGC->fExpose;
709
710 fastBox.x1 = srcx + pSrc->x;
711 fastBox.y1 = srcy + pSrc->y;
712 fastBox.x2 = fastBox.x1 + w;
713 fastBox.y2 = fastBox.y1 + h;
714
715 dx = dstx - fastBox.x1;
716 dy = dsty - fastBox.y1;
717 if (pGC->miTranslate)
718 {
719 xorg = pDst->x;
720 yorg = pDst->y;
721 }
722
723 /*
724 * Clip against the source. Otherwise we will blit too much for SINGLE
725 * and SHARED banked systems.
726 */
727 freeSrcClip = FALSE;
728 fastClip = FALSE;
729 fastExpose = FALSE;
730
731 if (pGC->subWindowMode != IncludeInferiors)
732 prgnSrcClip = &((WindowPtr)pSrc)->clipList;
733 else if (!((WindowPtr)pSrc)->parent)
734 fastClip = TRUE;
735 else if ((pSrc == pDst) && (pGC->clientClipType == CT_NONE))
736 prgnSrcClip = pGC->pCompositeClip;
737 else
738 {
739 prgnSrcClip = NotClippedByChildren((WindowPtr)pSrc);
740 freeSrcClip = TRUE;
741 }
742
743 if (fastClip)
744 {
745 fastExpose = TRUE;
746
747 /*
748 * Clip the source. If regions extend beyond the source size, make
749 * sure exposure events get sent.
750 */
751 if (fastBox.x1 < pSrc->x)
752 {
753 fastBox.x1 = pSrc->x;
754 fastExpose = FALSE;
755 }
756 if (fastBox.y1 < pSrc->y)
757 {
758 fastBox.y1 = pSrc->y;
759 fastExpose = FALSE;
760 }
761 if (fastBox.x2 > pSrc->x + (int) pSrc->width)
762 {
763 fastBox.x2 = pSrc->x + (int) pSrc->width;
764 fastExpose = FALSE;
765 }
766 if (fastBox.y2 > pSrc->y + (int) pSrc->height)
767 {
768 fastBox.y2 = pSrc->y + (int) pSrc->height;
769 fastExpose = FALSE;
770 }
771
772 nBox = 1;
773 pBox = &fastBox;
774 }
775 else
776 {
777 REGION_INIT(pScreen, &rgnDst, &fastBox, 1);
778 REGION_INTERSECT(pScreen, &rgnDst, &rgnDst, prgnSrcClip);
779 pBox = REGION_RECTS(&rgnDst);
780 nBox = REGION_NUM_RECTS(&rgnDst);
781 }
782
783 /*
784 * fastBlit can only be TRUE if we don't need to worry about attempts
785 * to read partial pixels through the destination bank.
786 */
787 if (SinglePlane)
788 fastBlit = pGCPriv->fastPlane;
789 else
790 fastBlit = pGCPriv->fastCopy;
791
792 nQueue = nBox * pScreenPriv->maxRects * 2;
793 pQueue = Queue = ALLOCATE_LOCAL_ARRAY(miBankQueue, nQueue);
794
795 if (Queue)
796 {
797 for (; nBox--; pBox++)
798 {
799 ns = FirstBankOf(pBox->x1, pBox->y1);
800 nse = LastBankOf(pBox->x2, pBox->y2);
801 for (; ns <= nse; ns++)
802 {
803 if (!pScreenPriv->pBanks[ns])
804 continue;
805
806 nBoxClipSrc = REGION_NUM_RECTS(pScreenPriv->pBanks[ns]);
807 pBoxClipSrc = REGION_RECTS(pScreenPriv->pBanks[ns]);
808
809 for (; nBoxClipSrc--; pBoxClipSrc++)
810 {
811 cx1 = max(pBox->x1, pBoxClipSrc->x1);
812 cy1 = max(pBox->y1, pBoxClipSrc->y1);
813 cx2 = min(pBox->x2, pBoxClipSrc->x2);
814 cy2 = min(pBox->y2, pBoxClipSrc->y2);
815
816 /* Check to see if the region is empty */
817 if ((cx1 >= cx2) || (cy1 >= cy2))
818 continue;
819
820 /* Translate c[xy]* to destination coordinates */
821 cx1 += dx + xorg;
822 cy1 += dy + yorg;
823 cx2 += dx + xorg;
824 cy2 += dy + yorg;
825
826 nd = FirstBankOf(cx1, cy1);
827 nde = LastBankOf(cx2, cy2);
828 for (; nd <= nde; nd++)
829 {
830 if (!pGCPriv->pBankedClips[nd])
831 continue;
832
833 /*
834 * Clients can send quite large clip descriptions,
835 * so use the bank clips here instead.
836 */
837 nBoxClipDst =
838 REGION_NUM_RECTS(pScreenPriv->pBanks[nd]);
839 pBoxClipDst =
840 REGION_RECTS(pScreenPriv->pBanks[nd]);
841
842 for (; nBoxClipDst--; pBoxClipDst++)
843 {
844 ccBox.x1 = max(cx1, pBoxClipDst->x1);
845 ccBox.y1 = max(cy1, pBoxClipDst->y1);
846 ccBox.x2 = min(cx2, pBoxClipDst->x2);
847 ccBox.y2 = min(cy2, pBoxClipDst->y2);
848
849 /* Check to see if the region is empty */
850 if ((ccBox.x1 >= ccBox.x2) ||
851 (ccBox.y1 >= ccBox.y2))
852 continue;
853
854 pQueue->srcBankNo = ns;
855 pQueue->dstBankNo = nd;
856 pQueue->x = ccBox.x1 - xorg;
857 pQueue->y = ccBox.y1 - yorg;
858 pQueue->w = ccBox.x2 - ccBox.x1;
859 pQueue->h = ccBox.y2 - ccBox.y1;
860
861 if (maxWidth < pQueue->w)
862 maxWidth = pQueue->w;
863 if (maxHeight < pQueue->h)
864 maxHeight = pQueue->h;
865
866 /*
867 * When shared banking is used and the source
868 * and destination banks differ, prevent
869 * attempts to fetch partial scanline pad units
870 * through the destination bank.
871 */
872 pQueue->fastBlit = fastBlit;
873 if (fastBlit &&
874 (pScreenPriv->type == BANK_SHARED) &&
875 (ns != nd) &&
876 ((ccBox.x1 %
877 pScreenPriv->nPixelsPerScanlinePadUnit) ||
878 (ccBox.x2 %
879 pScreenPriv->nPixelsPerScanlinePadUnit) ||
880 (RECT_IN_REGION(pScreen,
881 pGCPriv->pBankedClips[nd], &ccBox) !=
882 rgnIN)))
883 pQueue->fastBlit = FALSE;
884 pQueue++;
885 }
886 }
887 }
888 }
889 }
890 }
891
892 if (!fastClip)
893 {
894 REGION_UNINIT(pScreen, &rgnDst);
895 if (freeSrcClip)
896 REGION_DESTROY(pScreen, prgnSrcClip);
897 }
898
899 pQueueNew = pQueue;
900 nQueue = pQueue - Queue;
901
902 if (nQueue > 0)
903 {
904 BANK_SAVE;
905
906 pQueue = Queue;
907
908 if ((nQueue > 1) &&
909 ((pSrc == pDst) || (pGC->subWindowMode == IncludeInferiors)))
910 {
911 if ((srcy + pSrc->y) < (dsty + yorg))
912 {
913 /* Sort from bottom to top */
914 pQueueBase = pQueueNext = pQueue + nQueue - 1;
915
916 while (pQueueBase >= pQueue)
917 {
918 while ((pQueueNext >= pQueue) &&
919 (pQueueBase->y == pQueueNext->y))
920 pQueueNext--;
921
922 pQueueTmp = pQueueNext + 1;
923 while (pQueueTmp <= pQueueBase)
924 *pQueueNew++ = *pQueueTmp++;
925
926 pQueueBase = pQueueNext;
927 }
928
929 pQueueNew -= nQueue;
930 pQueue = pQueueNew;
931 pQueueNew = Queue;
932 }
933
934 if ((srcx + pSrc->x) < (dstx + xorg))
935 {
936 /* Sort from right to left */
937 pQueueBase = pQueueNext = pQueue;
938
939 while (pQueueBase < pQueue + nQueue)
940 {
941 while ((pQueueNext < pQueue + nQueue) &&
942 (pQueueNext->y == pQueueBase->y))
943 pQueueNext++;
944
945 pQueueTmp = pQueueNext;
946 while (pQueueTmp != pQueueBase)
947 *pQueueNew++ = *--pQueueTmp;
948
949 pQueueBase = pQueueNext;
950 }
951
952 pQueueNew -= nQueue;
953 pQueue = pQueueNew;
954 }
955 }
956
957 paddedWidth = PixmapBytePad(maxWidth,
958 pScreenPriv->pScreenPixmap->drawable.depth);
959 pImage = (char *)ALLOCATE_LOCAL(paddedWidth * maxHeight);
960
961 pGC->fExpose = FALSE;
962
963 while (nQueue--)
964 {
965 pGC->pCompositeClip = pGCPriv->pBankedClips[pQueue->dstBankNo];
966
967 GCOP_UNWRAP;
968
969 if (pQueue->srcBankNo == pQueue->dstBankNo)
970 {
971 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap,
972 -1, -1, pQueue->srcBankNo);
973
974 if (SinglePlane)
975 (*pGC->ops->CopyPlane)(pSrc, pDst, pGC,
976 pQueue->x - dx - pSrc->x, pQueue->y - dy - pSrc->y,
977 pQueue->w, pQueue->h, pQueue->x, pQueue->y, plane);
978 else
979 (*pGC->ops->CopyArea)(pSrc, pDst, pGC,
980 pQueue->x - dx - pSrc->x, pQueue->y - dy - pSrc->y,
981 pQueue->w, pQueue->h, pQueue->x, pQueue->y);
982 }
983 else if (pQueue->fastBlit)
984 {
985 SET_SOURCE_BANK (pScreenPriv->pBankPixmap,
986 pScreenPriv->pScreenPixmap->drawable.width,
987 pScreenPriv->pScreenPixmap->devKind,
988 pQueue->srcBankNo);
989 SET_DESTINATION_BANK(pScreenPriv->pScreenPixmap,
990 -1, -1, pQueue->dstBankNo);
991
992 if (SinglePlane)
993 (*pGC->ops->CopyPlane)(
994 (DrawablePtr)pScreenPriv->pBankPixmap, pDst, pGC,
995 pQueue->x - dx, pQueue->y - dy,
996 pQueue->w, pQueue->h, pQueue->x, pQueue->y, plane);
997 else
998 (*pGC->ops->CopyArea)(
999 (DrawablePtr)pScreenPriv->pBankPixmap, pDst, pGC,
1000 pQueue->x - dx, pQueue->y - dy,
1001 pQueue->w, pQueue->h, pQueue->x, pQueue->y);
1002 }
1003 else if (pImage)
1004 {
1005 ModifyPixmap(pScreenPriv->pBankPixmap,
1006 maxWidth, paddedWidth, pImage);
1007
1008 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap,
1009 -1, -1, pQueue->srcBankNo);
1010
1011 (*pScreenPriv->pBankGC->ops->CopyArea)(
1012 pSrc, (DrawablePtr)pScreenPriv->pBankPixmap,
1013 pScreenPriv->pBankGC,
1014 pQueue->x - dx - pSrc->x, pQueue->y - dy - pSrc->y,
1015 pQueue->w, pQueue->h, 0, 0);
1016
1017 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap,
1018 -1, -1, pQueue->dstBankNo);
1019
1020 if (SinglePlane)
1021 (*pGC->ops->CopyPlane)(
1022 (DrawablePtr)pScreenPriv->pBankPixmap,
1023 pDst, pGC, 0, 0, pQueue->w, pQueue->h,
1024 pQueue->x, pQueue->y, plane);
1025 else
1026 (*pGC->ops->CopyArea)(
1027 (DrawablePtr)pScreenPriv->pBankPixmap,
1028 pDst, pGC, 0, 0, pQueue->w, pQueue->h,
1029 pQueue->x, pQueue->y);
1030 }
1031
1032 GCOP_WRAP;
1033
1034 pQueue++;
1035 }
1036
1037 DEALLOCATE_LOCAL(pImage);
1038
1039 BANK_RESTORE;
1040 }
1041
1042 CLIP_RESTORE;
1043
1044 pGC->fExpose = fExpose;
1045
1046 DEALLOCATE_LOCAL(Queue);
1047 }
1048
1049 SCREEN_RESTORE;
1050
1051 if (!fExpose || fastExpose)
1052 return ret;
1053
1054 return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, 0);
1055 }
1056
1057 static RegionPtr
1058 miBankCopyArea(
1059 DrawablePtr pSrc,
1060 DrawablePtr pDst,
1061 GCPtr pGC,
1062 int srcx,
1063 int srcy,
1064 int w,
1065 int h,
1066 int dstx,
1067 int dsty
1068 )
1069 {
1070 return miBankCopy(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, 0, FALSE);
1071 }
1072
1073 static RegionPtr
1074 miBankCopyPlane(
1075 DrawablePtr pSrc,
1076 DrawablePtr pDst,
1077 GCPtr pGC,
1078 int srcx,
1079 int srcy,
1080 int w,
1081 int h,
1082 int dstx,
1083 int dsty,
1084 unsigned long plane
1085 )
1086 {
1087 return
1088 miBankCopy(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, plane, TRUE);
1089 }
1090
1091 static void
1092 miBankPolyPoint(
1093 DrawablePtr pDrawable,
1094 GCPtr pGC,
1095 int mode,
1096 int nArray,
1097 xPoint *pArray
1098 )
1099 {
1100 # define GCOP_ARGS GCOP_0D_ARGS
1101 GCOP_COMPLEX(PolyPoint, xPoint);
1102 # undef GCOP_ARGS
1103 }
1104
1105 static void
1106 miBankPolylines(
1107 DrawablePtr pDrawable,
1108 GCPtr pGC,
1109 int mode,
1110 int nArray,
1111 DDXPointPtr pArray
1112 )
1113 {
1114 # define GCOP_ARGS GCOP_0D_ARGS
1115 GCOP_COMPLEX(Polylines, DDXPointRec);
1116 # undef GCOP_ARGS
1117 }
1118
1119 static void
1120 miBankPolySegment(
1121 DrawablePtr pDrawable,
1122 GCPtr pGC,
1123 int nArray,
1124 xSegment *pArray
1125 )
1126 {
1127 # define GCOP_ARGS GCOP_1D_ARGS
1128 GCOP_COMPLEX(PolySegment, xSegment);
1129 # undef GCOP_ARGS
1130 }
1131
1132 static void
1133 miBankPolyRectangle(
1134 DrawablePtr pDrawable,
1135 GCPtr pGC,
1136 int nArray,
1137 xRectangle *pArray
1138 )
1139 {
1140 # define GCOP_ARGS GCOP_1D_ARGS
1141 GCOP_COMPLEX(PolyRectangle, xRectangle);
1142 # undef GCOP_ARGS
1143 }
1144
1145 static void
1146 miBankPolyArc(
1147 DrawablePtr pDrawable,
1148 GCPtr pGC,
1149 int nArray,
1150 xArc *pArray
1151 )
1152 {
1153 # define GCOP_ARGS GCOP_1D_ARGS
1154 GCOP_COMPLEX(PolyArc, xArc);
1155 # undef GCOP_ARGS
1156 }
1157
1158 static void
1159 miBankFillPolygon(
1160 DrawablePtr pDrawable,
1161 GCPtr pGC,
1162 int shape,
1163 int mode,
1164 int nArray,
1165 DDXPointRec *pArray
1166 )
1167 {
1168 # define GCOP_ARGS GCOP_2D_ARGS
1169 GCOP_COMPLEX(FillPolygon, DDXPointRec);
1170 # undef GCOP_ARGS
1171 }
1172
1173 static void
1174 miBankPolyFillRect(
1175 DrawablePtr pDrawable,
1176 GCPtr pGC,
1177 int nArray,
1178 xRectangle *pArray
1179 )
1180 {
1181 # define GCOP_ARGS GCOP_1D_ARGS
1182 GCOP_COMPLEX(PolyFillRect, xRectangle);
1183 # undef GCOP_ARGS
1184 }
1185
1186 static void
1187 miBankPolyFillArc(
1188 DrawablePtr pDrawable,
1189 GCPtr pGC,
1190 int nArray,
1191 xArc *pArray
1192 )
1193 {
1194 # define GCOP_ARGS GCOP_1D_ARGS
1195 GCOP_COMPLEX(PolyFillArc, xArc);
1196 # undef GCOP_ARGS
1197 }
1198
1199 static int
1200 miBankPolyText8(
1201 DrawablePtr pDrawable,
1202 GCPtr pGC,
1203 int x,
1204 int y,
1205 int nArray,
1206 char *pchar
1207 )
1208 {
1209 int retval = x;
1210
1211 GCOP_SIMPLE(retval =
1212 (*pGC->ops->PolyText8)(pDrawable, pGC, x, y, nArray, pchar));
1213
1214 return retval;
1215 }
1216
1217 static int
1218 miBankPolyText16(
1219 DrawablePtr pDrawable,
1220 GCPtr pGC,
1221 int x,
1222 int y,
1223 int nArray,
1224 unsigned short *pchar
1225 )
1226 {
1227 int retval = x;
1228
1229 GCOP_SIMPLE(retval =
1230 (*pGC->ops->PolyText16)(pDrawable, pGC, x, y, nArray, pchar));
1231
1232 return retval;
1233 }
1234
1235 static void
1236 miBankImageText8(
1237 DrawablePtr pDrawable,
1238 GCPtr pGC,
1239 int x,
1240 int y,
1241 int nArray,
1242 char *pchar
1243 )
1244 {
1245 GCOP_SIMPLE((*pGC->ops->ImageText8)(pDrawable, pGC, x, y, nArray, pchar));
1246 }
1247
1248 static void
1249 miBankImageText16(
1250 DrawablePtr pDrawable,
1251 GCPtr pGC,
1252 int x,
1253 int y,
1254 int nArray,
1255 unsigned short *pchar
1256 )
1257 {
1258 GCOP_SIMPLE((*pGC->ops->ImageText16)(pDrawable, pGC, x, y, nArray, pchar));
1259 }
1260
1261 static void
1262 miBankImageGlyphBlt(
1263 DrawablePtr pDrawable,
1264 GCPtr pGC,
1265 int x,
1266 int y,
1267 unsigned int nArray,
1268 CharInfoPtr *ppci,
1269 pointer pglyphBase
1270 )
1271 {
1272 GCOP_SIMPLE((*pGC->ops->ImageGlyphBlt)(pDrawable, pGC,
1273 x, y, nArray, ppci, pglyphBase));
1274 }
1275
1276 static void
1277 miBankPolyGlyphBlt(
1278 DrawablePtr pDrawable,
1279 GCPtr pGC,
1280 int x,
1281 int y,
1282 unsigned int nArray,
1283 CharInfoPtr *ppci,
1284 pointer pglyphBase
1285 )
1286 {
1287 GCOP_SIMPLE((*pGC->ops->PolyGlyphBlt)(pDrawable, pGC,
1288 x, y, nArray, ppci, pglyphBase));
1289 }
1290
1291 static void
1292 miBankPushPixels(
1293 GCPtr pGC,
1294 PixmapPtr pBitmap,
1295 DrawablePtr pDrawable,
1296 int w,
1297 int h,
1298 int x,
1299 int y
1300 )
1301 {
1302 if ((w > 0) && (h > 0))
1303 {
1304 GCOP_INIT;
1305 SCREEN_SAVE;
1306
1307 if (!IS_BANKED(pDrawable))
1308 {
1309 GCOP_UNWRAP;
1310
1311 (*pGC->ops->PushPixels)(pGC, pBitmap, pDrawable, w, h, x, y);
1312
1313 GCOP_WRAP;
1314 }
1315 else
1316 {
1317 int i, j;
1318
1319 CLIP_SAVE;
1320
1321 i = FirstBankOf(x, y);
1322 j = LastBankOf(x + w, y + h);
1323 for (; i <= j; i++)
1324 {
1325 if (!(pGC->pCompositeClip = pGCPriv->pBankedClips[i]))
1326 continue;
1327
1328 GCOP_UNWRAP;
1329
1330 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
1331
1332 (*pGC->ops->PushPixels)(pGC, pBitmap, pDrawable, w, h, x, y);
1333
1334 GCOP_WRAP;
1335 }
1336
1337 CLIP_RESTORE;
1338 }
1339
1340 SCREEN_RESTORE;
1341 }
1342 }
1343
1344 static GCOps miBankGCOps =
1345 {
1346 miBankFillSpans,
1347 miBankSetSpans,
1348 miBankPutImage,
1349 miBankCopyArea,
1350 miBankCopyPlane,
1351 miBankPolyPoint,
1352 miBankPolylines,
1353 miBankPolySegment,
1354 miBankPolyRectangle,
1355 miBankPolyArc,
1356 miBankFillPolygon,
1357 miBankPolyFillRect,
1358 miBankPolyFillArc,
1359 miBankPolyText8,
1360 miBankPolyText16,
1361 miBankImageText8,
1362 miBankImageText16,
1363 miBankImageGlyphBlt,
1364 miBankPolyGlyphBlt,
1365 miBankPushPixels,
1366 {NULL} /* devPrivate */
1367 };
1368
1369 /********************
1370 * GCFuncs wrappers *
1371 ********************/
1372
1373 static void
1374 miBankValidateGC(
1375 GCPtr pGC,
1376 unsigned long changes,
1377 DrawablePtr pDrawable
1378 )
1379 {
1380 GC_INIT(pGC);
1381 GC_UNWRAP(pGC);
1382
1383 (*pGC->funcs->ValidateGC)(pGC, changes, pDrawable);
1384
1385 if ((changes & (GCClipXOrigin|GCClipYOrigin|GCClipMask|GCSubwindowMode)) ||
1386 (pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS)))
1387 {
1388 ScreenPtr pScreen = pGC->pScreen;
1389 RegionPtr prgnClip;
1390 unsigned long planemask;
1391 int i;
1392
1393 SCREEN_INIT;
1394 SCREEN_SAVE;
1395
1396 if (IS_BANKED(pDrawable))
1397 {
1398 for (i = 0; i < pScreenPriv->nBanks; i++)
1399 {
1400 if (!pScreenPriv->pBanks[i])
1401 continue;
1402
1403 if (!(prgnClip = pGCPriv->pBankedClips[i]))
1404 prgnClip = REGION_CREATE(pScreen, NULL, 1);
1405
1406 REGION_INTERSECT(pScreen, prgnClip,
1407 pScreenPriv->pBanks[i], pGC->pCompositeClip);
1408
1409 if ((REGION_NUM_RECTS(prgnClip) <= 1) &&
1410 ((prgnClip->extents.x1 == prgnClip->extents.x2) ||
1411 (prgnClip->extents.y1 == prgnClip->extents.y2)))
1412 {
1413 REGION_DESTROY(pScreen, prgnClip);
1414 pGCPriv->pBankedClips[i] = NULL;
1415 }
1416 else
1417 pGCPriv->pBankedClips[i] = prgnClip;
1418 }
1419
1420 /*
1421 * fastCopy and fastPlane can only be TRUE if we don't need to
1422 * worry about attempts to read partial pixels through the
1423 * destination bank.
1424 */
1425 switch (pScreenPriv->type)
1426 {
1427 case BANK_SHARED:
1428 pGCPriv->fastCopy = pGCPriv->fastPlane = FALSE;
1429
1430 if ((pGC->alu != GXclear) && (pGC->alu != GXcopy) &&
1431 (pGC->alu != GXcopyInverted) && (pGC->alu != GXset))
1432 break;
1433
1434 if (pScreen->rootDepth == 1)
1435 pGCPriv->fastPlane = TRUE;
1436
1437 /* This is probably paranoia */
1438 if ((pDrawable->depth != pScreen->rootDepth) ||
1439 (pDrawable->depth != pGC->depth))
1440 break;
1441
1442 planemask = (1 << pGC->depth) - 1;
1443 if ((pGC->planemask & planemask) == planemask)
1444 pGCPriv->fastCopy = TRUE;
1445
1446 break;
1447
1448 case BANK_DOUBLE:
1449 pGCPriv->fastCopy = pGCPriv->fastPlane = TRUE;
1450 break;
1451
1452 default:
1453 pGCPriv->fastCopy = pGCPriv->fastPlane = FALSE;
1454 break;
1455 }
1456 }
1457 else
1458 {
1459 /*
1460 * Here we are on a pixmap and don't need all that special clipping
1461 * stuff, hence free it.
1462 */
1463 for (i = 0; i < pScreenPriv->nBanks; i++)
1464 {
1465 if (!pGCPriv->pBankedClips[i])
1466 continue;
1467
1468 REGION_DESTROY(pScreen, pGCPriv->pBankedClips[i]);
1469 pGCPriv->pBankedClips[i] = NULL;
1470 }
1471 }
1472
1473 SCREEN_RESTORE;
1474 }
1475
1476 GC_WRAP(pGC);
1477 }
1478
1479 static void
1480 miBankChangeGC(
1481 GCPtr pGC,
1482 unsigned long mask
1483 )
1484 {
1485 GC_INIT(pGC);
1486 GC_UNWRAP(pGC);
1487
1488 (*pGC->funcs->ChangeGC)(pGC, mask);
1489
1490 GC_WRAP(pGC);
1491 }
1492
1493 static void
1494 miBankCopyGC(
1495 GCPtr pGCSrc,
1496 unsigned long mask,
1497 GCPtr pGCDst
1498 )
1499 {
1500 GC_INIT(pGCDst);
1501 GC_UNWRAP(pGCDst);
1502
1503 (*pGCDst->funcs->CopyGC)(pGCSrc, mask, pGCDst);
1504
1505 GC_WRAP(pGCDst);
1506 }
1507
1508 static void
1509 miBankDestroyGC(
1510 GCPtr pGC
1511 )
1512 {
1513 ScreenPtr pScreen = pGC->pScreen;
1514 int i;
1515
1516 SCREEN_INIT;
1517 GC_INIT(pGC);
1518 GC_UNWRAP(pGC);
1519
1520 (*pGC->funcs->DestroyGC)(pGC);
1521
1522 for (i = 0; i < pScreenPriv->nBanks; i++)
1523 {
1524 if (!pGCPriv->pBankedClips[i])
1525 continue;
1526
1527 REGION_DESTROY(pScreen, pGCPriv->pBankedClips[i]);
1528 pGCPriv->pBankedClips[i] = NULL;
1529 }
1530
1531 GC_WRAP(pGC);
1532 }
1533
1534 static void
1535 miBankChangeClip(
1536 GCPtr pGC,
1537 int type,
1538 pointer pvalue,
1539 int nrects
1540 )
1541 {
1542 GC_INIT(pGC);
1543 GC_UNWRAP(pGC);
1544
1545 (*pGC->funcs->ChangeClip)(pGC, type, pvalue, nrects);
1546
1547 GC_WRAP(pGC);
1548 }
1549
1550 static void
1551 miBankDestroyClip(
1552 GCPtr pGC
1553 )
1554 {
1555 GC_INIT(pGC);
1556 GC_UNWRAP(pGC);
1557
1558 (*pGC->funcs->DestroyClip)(pGC);
1559
1560 GC_WRAP(pGC);
1561 }
1562
1563 static void
1564 miBankCopyClip(
1565 GCPtr pGCDst,
1566 GCPtr pGCSrc
1567 )
1568 {
1569 GC_INIT(pGCDst);
1570 GC_UNWRAP(pGCDst);
1571
1572 (*pGCDst->funcs->CopyClip)(pGCDst, pGCSrc);
1573
1574 GC_WRAP(pGCDst);
1575 }
1576
1577 static GCFuncs miBankGCFuncs =
1578 {
1579 miBankValidateGC,
1580 miBankChangeGC,
1581 miBankCopyGC,
1582 miBankDestroyGC,
1583 miBankChangeClip,
1584 miBankDestroyClip,
1585 miBankCopyClip
1586 };
1587
1588 /*******************
1589 * Screen Wrappers *
1590 *******************/
1591
1592 static Bool
1593 miBankCreateScreenResources(
1594 ScreenPtr pScreen
1595 )
1596 {
1597 Bool retval;
1598
1599 SCREEN_INIT;
1600 SCREEN_UNWRAP(CreateScreenResources);
1601
1602 if ((retval = (*pScreen->CreateScreenResources)(pScreen)))
1603 {
1604 /* Set screen buffer address to something recognizable */
1605 pScreenPriv->pScreenPixmap = (*pScreen->GetScreenPixmap)(pScreen);
1606 pScreenPriv->pbits = pScreenPriv->pScreenPixmap->devPrivate.ptr;
1607 pScreenPriv->pScreenPixmap->devPrivate.ptr = (pointer)pScreenPriv;
1608
1609 /* Get shadow pixmap; width & height of 0 means no pixmap data */
1610 pScreenPriv->pBankPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0,
1611 pScreenPriv->pScreenPixmap->drawable.depth);
1612 if (!pScreenPriv->pBankPixmap)
1613 retval = FALSE;
1614 }
1615
1616 /* Shadow the screen */
1617 if (retval)
1618 retval = (*pScreen->ModifyPixmapHeader)(pScreenPriv->pBankPixmap,
1619 pScreenPriv->pScreenPixmap->drawable.width,
1620 pScreenPriv->pScreenPixmap->drawable.height,
1621 pScreenPriv->pScreenPixmap->drawable.depth,
1622 pScreenPriv->pScreenPixmap->drawable.bitsPerPixel,
1623 pScreenPriv->pScreenPixmap->devKind, NULL);
1624
1625 /* Create shadow GC */
1626 if (retval)
1627 {
1628 pScreenPriv->pBankGC = CreateScratchGC(pScreen,
1629 pScreenPriv->pBankPixmap->drawable.depth);
1630 if (!pScreenPriv->pBankGC)
1631 retval = FALSE;
1632 }
1633
1634 /* Validate shadow GC */
1635 if (retval)
1636 {
1637 pScreenPriv->pBankGC->graphicsExposures = FALSE;
1638 pScreenPriv->pBankGC->subWindowMode = IncludeInferiors;
1639 ValidateGC((DrawablePtr)pScreenPriv->pBankPixmap,
1640 pScreenPriv->pBankGC);
1641 }
1642
1643 SCREEN_WRAP(CreateScreenResources, miBankCreateScreenResources);
1644
1645 return retval;
1646 }
1647
1648 static Bool
1649 miBankModifyPixmapHeader(
1650 PixmapPtr pPixmap,
1651 int width,
1652 int height,
1653 int depth,
1654 int bitsPerPixel,
1655 int devKind,
1656 pointer pPixData
1657 )
1658 {
1659 Bool retval = FALSE;
1660
1661 if (pPixmap)
1662 {
1663 ScreenPtr pScreen = pPixmap->drawable.pScreen;
1664
1665 SCREEN_INIT;
1666 PIXMAP_SAVE(pPixmap);
1667 SCREEN_UNWRAP(ModifyPixmapHeader);
1668
1669 retval = (*pScreen->ModifyPixmapHeader)(pPixmap, width, height,
1670 depth, bitsPerPixel, devKind, pPixData);
1671
1672 SCREEN_WRAP(ModifyPixmapHeader, miBankModifyPixmapHeader);
1673
1674 if (pbits == (pointer)pScreenPriv)
1675 {
1676 pScreenPriv->pbits = pPixmap->devPrivate.ptr;
1677 pPixmap->devPrivate.ptr = pbits;
1678 }
1679 }
1680
1681 return retval;
1682 }
1683
1684 static Bool
1685 miBankCloseScreen(
1686 int nIndex,
1687 ScreenPtr pScreen
1688 )
1689 {
1690 int i;
1691
1692 SCREEN_INIT;
1693
1694 /* Free shadow GC */
1695 FreeScratchGC(pScreenPriv->pBankGC);
1696
1697 /* Free shadow pixmap */
1698 (*pScreen->DestroyPixmap)(pScreenPriv->pBankPixmap);
1699
1700 /* Restore screen pixmap devPrivate pointer */
1701 pScreenPriv->pScreenPixmap->devPrivate.ptr = pScreenPriv->pbits;
1702
1703 /* Delete bank clips */
1704 for (i = 0; i < pScreenPriv->nBanks; i++)
1705 if (pScreenPriv->pBanks[i])
1706 REGION_DESTROY(pScreen, pScreenPriv->pBanks[i]);
1707
1708 Xfree(pScreenPriv->pBanks);
1709
1710 SCREEN_UNWRAP(CreateScreenResources);
1711 SCREEN_UNWRAP(ModifyPixmapHeader);
1712 SCREEN_UNWRAP(CloseScreen);
1713 SCREEN_UNWRAP(GetImage);
1714 SCREEN_UNWRAP(GetSpans);
1715 SCREEN_UNWRAP(CreateGC);
1716 SCREEN_UNWRAP(PaintWindowBackground);
1717 SCREEN_UNWRAP(PaintWindowBorder);
1718 SCREEN_UNWRAP(CopyWindow);
1719 SCREEN_UNWRAP(BackingStoreFuncs);
1720
1721 Xfree(pScreenPriv);
1722 return (*pScreen->CloseScreen)(nIndex, pScreen);
1723 }
1724
1725 static void
1726 miBankGetImage(
1727 DrawablePtr pDrawable,
1728 int sx,
1729 int sy,
1730 int w,
1731 int h,
1732 unsigned int format,
1733 unsigned long planemask,
1734 char *pImage
1735 )
1736 {
1737 if ((w > 0) && (h > 0))
1738 {
1739 ScreenPtr pScreen = pDrawable->pScreen;
1740
1741 SCREEN_INIT;
1742 SCREEN_STATUS;
1743 SCREEN_UNWRAP(GetImage);
1744
1745 if (!IS_BANKED(pDrawable))
1746 {
1747 (*pScreen->GetImage)(pDrawable, sx, sy, w, h,
1748 format, planemask, pImage);
1749 }
1750 else
1751 {
1752 int paddedWidth;
1753 char *pBankImage;
1754
1755 paddedWidth = PixmapBytePad(w,
1756 pScreenPriv->pScreenPixmap->drawable.depth);
1757 pBankImage = (char *)ALLOCATE_LOCAL(paddedWidth * h);
1758
1759 if (pBankImage)
1760 {
1761 BANK_SAVE;
1762
1763 ModifyPixmap(pScreenPriv->pBankPixmap, w, paddedWidth,
1764 pBankImage);
1765
1766 (*pScreenPriv->pBankGC->ops->CopyArea)(
1767 (DrawablePtr)WindowTable[pScreen->myNum],
1768 (DrawablePtr)pScreenPriv->pBankPixmap,
1769 pScreenPriv->pBankGC,
1770 sx + pDrawable->x, sy + pDrawable->y, w, h, 0, 0);
1771
1772 (*pScreen->GetImage)((DrawablePtr)pScreenPriv->pBankPixmap,
1773 0, 0, w, h, format, planemask, pImage);
1774
1775 BANK_RESTORE;
1776
1777 DEALLOCATE_LOCAL(pBankImage);
1778 }
1779 }
1780
1781 SCREEN_WRAP(GetImage, miBankGetImage);
1782 }
1783 }
1784
1785 static void
1786 miBankGetSpans(
1787 DrawablePtr pDrawable,
1788 int wMax,
1789 DDXPointPtr ppt,
1790 int *pwidth,
1791 int nspans,
1792 char *pImage
1793 )
1794 {
1795 if (nspans > 0)
1796 {
1797 ScreenPtr pScreen = pDrawable->pScreen;
1798
1799 SCREEN_INIT;
1800 SCREEN_STATUS;
1801 SCREEN_UNWRAP(GetSpans);
1802
1803 if (!IS_BANKED(pDrawable))
1804 {
1805 (*pScreen->GetSpans)(pDrawable, wMax, ppt, pwidth, nspans, pImage);
1806 }
1807 else
1808 {
1809 char *pBankImage;
1810 int paddedWidth;
1811 DDXPointRec pt;
1812
1813 pt.x = pt.y = 0;
1814
1815 paddedWidth =
1816 PixmapBytePad(pScreenPriv->pScreenPixmap->drawable.width,
1817 pScreenPriv->pScreenPixmap->drawable.depth);
1818 pBankImage = (char *)ALLOCATE_LOCAL(paddedWidth);
1819
1820 if (pBankImage)
1821 {
1822 BANK_SAVE;
1823
1824 ModifyPixmap(pScreenPriv->pBankPixmap,
1825 pScreenPriv->pScreenPixmap->drawable.width,
1826 paddedWidth, pBankImage);
1827
1828 for (; nspans--; ppt++, pwidth++)
1829 {
1830 if (*pwidth <= 0)
1831 continue;
1832
1833 (*pScreenPriv->pBankGC->ops->CopyArea)(
1834 (DrawablePtr)WindowTable[pScreen->myNum],
1835 (DrawablePtr)pScreenPriv->pBankPixmap,
1836 pScreenPriv->pBankGC,
1837 ppt->x, ppt->y, *pwidth, 1, 0, 0);
1838
1839 (*pScreen->GetSpans)((DrawablePtr)pScreenPriv->pBankPixmap,
1840 wMax, &pt, pwidth, 1, pImage);
1841
1842 pImage = pImage + PixmapBytePad(*pwidth, pDrawable->depth);
1843 }
1844
1845 BANK_RESTORE;
1846
1847 DEALLOCATE_LOCAL(pBankImage);
1848 }
1849 }
1850
1851 SCREEN_WRAP(GetSpans, miBankGetSpans);
1852 }
1853 }
1854
1855 static Bool
1856 miBankCreateGC(
1857 GCPtr pGC
1858 )
1859 {
1860 ScreenPtr pScreen = pGC->pScreen;
1861 miBankGCPtr pGCPriv = BANK_GCPRIVATE(pGC);
1862 Bool ret;
1863
1864 SCREEN_INIT;
1865 SCREEN_UNWRAP(CreateGC);
1866
1867 if ((ret = (*pScreen->CreateGC)(pGC)))
1868 {
1869 pGCPriv->unwrappedOps = &miBankGCOps;
1870 pGCPriv->unwrappedFuncs = &miBankGCFuncs;
1871 GC_WRAP(pGC);
1872
1873 memset(&pGCPriv->pBankedClips, 0,
1874 pScreenPriv->nBanks * sizeof(pGCPriv->pBankedClips));
1875 }
1876
1877 SCREEN_WRAP(CreateGC, miBankCreateGC);
1878
1879 return ret;
1880 }
1881
1882 static void
1883 miBankPaintWindow(
1884 WindowPtr pWin,
1885 RegionPtr pRegion,
1886 int what
1887 )
1888 {
1889 ScreenPtr pScreen = pWin->drawable.pScreen;
1890 RegionRec tmpReg;
1891 int i;
1892 PaintWindowProcPtr PaintWindow;
1893
1894 SCREEN_INIT;
1895 SCREEN_SAVE;
1896
1897 if (what == PW_BORDER)
1898 {
1899 SCREEN_UNWRAP(PaintWindowBorder);
1900 PaintWindow = pScreen->PaintWindowBorder;
1901 }
1902 else
1903 {
1904 SCREEN_UNWRAP(PaintWindowBackground);
1905 PaintWindow = pScreen->PaintWindowBackground;
1906 }
1907
1908 if (!IS_BANKED(pWin))
1909 {
1910 (*PaintWindow)(pWin, pRegion, what);
1911 }
1912 else
1913 {
1914 REGION_NULL(pScreen, &tmpReg);
1915
1916 for (i = 0; i < pScreenPriv->nBanks; i++)
1917 {
1918 if (!pScreenPriv->pBanks[i])
1919 continue;
1920
1921 REGION_INTERSECT(pScreen, &tmpReg, pRegion,
1922 pScreenPriv->pBanks[i]);
1923
1924 if (REGION_NIL(&tmpReg))
1925 continue;
1926
1927 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
1928
1929 (*PaintWindow)(pWin, &tmpReg, what);
1930 }
1931
1932 REGION_UNINIT(pScreen, &tmpReg);
1933 }
1934
1935 if (what == PW_BORDER)
1936 {
1937 SCREEN_WRAP(PaintWindowBorder, miBankPaintWindow);
1938 }
1939 else
1940 {
1941 SCREEN_WRAP(PaintWindowBackground, miBankPaintWindow);
1942 }
1943
1944 SCREEN_RESTORE;
1945 }
1946
1947 static void
1948 miBankCopyWindow(
1949 WindowPtr pWindow,
1950 DDXPointRec ptOldOrg,
1951 RegionPtr pRgnSrc
1952 )
1953 {
1954 ScreenPtr pScreen = pWindow->drawable.pScreen;
1955 GCPtr pGC;
1956 int dx, dy, nBox;
1957 DrawablePtr pDrawable = (DrawablePtr)WindowTable[pScreen->myNum];
1958 RegionPtr pRgnDst;
1959 BoxPtr pBox, pBoxTmp, pBoxNext, pBoxBase, pBoxNew1, pBoxNew2;
1960 XID subWindowMode = IncludeInferiors;
1961
1962 pGC = GetScratchGC(pDrawable->depth, pScreen);
1963
1964 ChangeGC(pGC, GCSubwindowMode, &subWindowMode);
1965 ValidateGC(pDrawable, pGC);
1966
1967 pRgnDst = REGION_CREATE(pScreen, NULL, 1);
1968
1969 dx = ptOldOrg.x - pWindow->drawable.x;
1970 dy = ptOldOrg.y - pWindow->drawable.y;
1971 REGION_TRANSLATE(pScreen, pRgnSrc, -dx, -dy);
1972 REGION_INTERSECT(pScreen, pRgnDst, &pWindow->borderClip, pRgnSrc);
1973
1974 pBox = REGION_RECTS(pRgnDst);
1975 nBox = REGION_NUM_RECTS(pRgnDst);
1976
1977 pBoxNew1 = NULL;
1978 pBoxNew2 = NULL;
1979
1980 if (nBox > 1)
1981 {
1982 if (dy < 0)
1983 {
1984 /* Sort boxes from bottom to top */
1985 pBoxNew1 = ALLOCATE_LOCAL_ARRAY(BoxRec, nBox);
1986
1987 if (pBoxNew1)
1988 {
1989 pBoxBase = pBoxNext = pBox + nBox - 1;
1990
1991 while (pBoxBase >= pBox)
1992 {
1993 while ((pBoxNext >= pBox) &&
1994 (pBoxBase->y1 == pBoxNext->y1))
1995 pBoxNext--;
1996
1997 pBoxTmp = pBoxNext + 1;
1998
1999 while (pBoxTmp <= pBoxBase)
2000 *pBoxNew1++ = *pBoxTmp++;
2001
2002 pBoxBase = pBoxNext;
2003 }
2004
2005 pBoxNew1 -= nBox;
2006 pBox = pBoxNew1;
2007 }
2008 }
2009
2010 if (dx < 0)
2011 {
2012 /* Sort boxes from right to left */
2013 pBoxNew2 = ALLOCATE_LOCAL_ARRAY(BoxRec, nBox);
2014
2015 if (pBoxNew2)
2016 {
2017 pBoxBase = pBoxNext = pBox;
2018
2019 while (pBoxBase < pBox + nBox)
2020 {
2021 while ((pBoxNext < pBox + nBox) &&
2022 (pBoxNext->y1 == pBoxBase->y1))
2023 pBoxNext++;
2024
2025 pBoxTmp = pBoxNext;
2026
2027 while (pBoxTmp != pBoxBase)
2028 *pBoxNew2++ = *--pBoxTmp;
2029
2030 pBoxBase = pBoxNext;
2031 }
2032
2033 pBoxNew2 -= nBox;
2034 pBox = pBoxNew2;
2035 }
2036 }
2037 }
2038
2039 while (nBox--)
2040 {
2041 (*pGC->ops->CopyArea)(pDrawable, pDrawable, pGC,
2042 pBox->x1 + dx, pBox->y1 + dy,
2043 pBox->x2 - pBox->x1, pBox->y2 - pBox->y1,
2044 pBox->x1, pBox->y1);
2045
2046 pBox++;
2047 }
2048
2049 FreeScratchGC(pGC);
2050
2051 REGION_DESTROY(pScreen, pRgnDst);
2052
2053 DEALLOCATE_LOCAL(pBoxNew2);
2054 DEALLOCATE_LOCAL(pBoxNew1);
2055 }
2056
2057 /**************************
2058 * Backing store wrappers *
2059 **************************/
2060
2061 static void
2062 miBankSaveAreas(
2063 PixmapPtr pPixmap,
2064 RegionPtr prgnSave,
2065 int xorg,
2066 int yorg,
2067 WindowPtr pWin
2068 )
2069 {
2070 ScreenPtr pScreen = pPixmap->drawable.pScreen;
2071 RegionRec rgnClipped;
2072 int i;
2073
2074 SCREEN_INIT;
2075 SCREEN_SAVE;
2076 SCREEN_UNWRAP(BackingStoreFuncs.SaveAreas);
2077
2078 if (!IS_BANKED(pWin))
2079 {
2080 (*pScreen->BackingStoreFuncs.SaveAreas)(pPixmap, prgnSave, xorg, yorg,
2081 pWin);
2082 }
2083 else
2084 {
2085 REGION_NULL(pScreen, &rgnClipped);
2086 REGION_TRANSLATE(pScreen, prgnSave, xorg, yorg);
2087
2088 for (i = 0; i < pScreenPriv->nBanks; i++)
2089 {
2090 if (!pScreenPriv->pBanks[i])
2091 continue;
2092
2093 REGION_INTERSECT(pScreen, &rgnClipped,
2094 prgnSave, pScreenPriv->pBanks[i]);
2095
2096 if (REGION_NIL(&rgnClipped))
2097 continue;
2098
2099 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
2100
2101 REGION_TRANSLATE(pScreen, &rgnClipped, -xorg, -yorg);
2102
2103 (*pScreen->BackingStoreFuncs.SaveAreas)(pPixmap, &rgnClipped,
2104 xorg, yorg, pWin);
2105 }
2106
2107 REGION_TRANSLATE(pScreen, prgnSave, -xorg, -yorg);
2108 REGION_UNINIT(pScreen, &rgnClipped);
2109 }
2110
2111 SCREEN_WRAP(BackingStoreFuncs.SaveAreas, miBankSaveAreas);
2112 SCREEN_RESTORE;
2113 }
2114
2115 static void
2116 miBankRestoreAreas(
2117 PixmapPtr pPixmap,
2118 RegionPtr prgnRestore,
2119 int xorg,
2120 int yorg,
2121 WindowPtr pWin
2122 )
2123 {
2124 ScreenPtr pScreen = pPixmap->drawable.pScreen;
2125 RegionRec rgnClipped;
2126 int i;
2127
2128 SCREEN_INIT;
2129 SCREEN_SAVE;
2130 SCREEN_UNWRAP(BackingStoreFuncs.RestoreAreas);
2131
2132 if (!IS_BANKED(pWin))
2133 {
2134 (*pScreen->BackingStoreFuncs.RestoreAreas)(pPixmap, prgnRestore,
2135 xorg, yorg, pWin);
2136 }
2137 else
2138 {
2139 REGION_NULL(pScreen, &rgnClipped);
2140
2141 for (i = 0; i < pScreenPriv->nBanks; i++)
2142 {
2143 if (!pScreenPriv->pBanks[i])
2144 continue;
2145
2146 REGION_INTERSECT(pScreen, &rgnClipped,
2147 prgnRestore, pScreenPriv->pBanks[i]);
2148
2149 if (REGION_NIL(&rgnClipped))
2150 continue;
2151
2152 SET_SINGLE_BANK(pScreenPriv->pScreenPixmap, -1, -1, i);
2153
2154 (*pScreen->BackingStoreFuncs.RestoreAreas)(pPixmap, &rgnClipped,
2155 xorg, yorg, pWin);
2156 }
2157
2158 REGION_UNINIT(pScreen, &rgnClipped);
2159 }
2160
2161 SCREEN_WRAP(BackingStoreFuncs.RestoreAreas, miBankRestoreAreas);
2162 SCREEN_RESTORE;
2163 }
2164
2165 _X_EXPORT Bool
2166 miInitializeBanking(
2167 ScreenPtr pScreen,
2168 unsigned int xsize,
2169 unsigned int ysize,
2170 unsigned int width,
2171 miBankInfoPtr pBankInfo
2172 )
2173 {
2174 miBankScreenPtr pScreenPriv;
2175 unsigned long nBitsPerBank, nBitsPerScanline, nPixelsPerScanlinePadUnit;
2176 unsigned long BankBase, ServerPad;
2177 unsigned int type, iBank, nBanks, maxRects, we, nBankBPP;
2178 int i;
2179
2180 if (!pBankInfo || !pBankInfo->BankSize)
2181 return TRUE; /* No banking required */
2182
2183 /* Sanity checks */
2184
2185 if (!pScreen || !xsize || !ysize || (xsize > width) ||
2186 !pBankInfo->SetSourceBank || !pBankInfo->SetDestinationBank ||
2187 !pBankInfo->SetSourceAndDestinationBanks ||
2188 !pBankInfo->pBankA || !pBankInfo->pBankB ||
2189 !pBankInfo->nBankDepth)
2190 return FALSE;
2191
2192 /*
2193 * DDX *must* have registered a pixmap format whose depth is
2194 * pBankInfo->nBankDepth. This is not necessarily the rootDepth
2195 * pixmap format.
2196 */
2197 i = 0;
2198 while (screenInfo.formats[i].depth != pBankInfo->nBankDepth)
2199 if (++i >= screenInfo.numPixmapFormats)
2200 return FALSE;
2201 nBankBPP = screenInfo.formats[i].bitsPerPixel;
2202
2203 i = 0;
2204 while (screenInfo.formats[i].depth != pScreen->rootDepth)
2205 if (++i >= screenInfo.numPixmapFormats)
2206 return FALSE;
2207
2208 if (nBankBPP > screenInfo.formats[i].bitsPerPixel)
2209 return FALSE;
2210
2211 /* Determine banking type */
2212 if ((type = miBankDeriveType(pScreen, pBankInfo)) == BANK_NOBANK)
2213 return FALSE;
2214
2215 /* Internal data */
2216
2217 nBitsPerBank = pBankInfo->BankSize * 8;
2218 ServerPad = PixmapBytePad(1, pBankInfo->nBankDepth) * 8;
2219 if (nBitsPerBank % ServerPad)
2220 return FALSE;
2221 nBitsPerScanline = PixmapBytePad(width, pBankInfo->nBankDepth) * 8;
2222 nBanks = ((nBitsPerScanline * (ysize - 1)) +
2223 (nBankBPP * xsize) + nBitsPerBank - 1) / nBitsPerBank;
2224 nPixelsPerScanlinePadUnit = miLCM(ServerPad, nBankBPP) / nBankBPP;
2225
2226 /* Private areas */
2227
2228 if (miBankGeneration != serverGeneration)
2229 {
2230 if (((miBankScreenIndex = AllocateScreenPrivateIndex()) < 0) ||
2231 ((miBankGCIndex = AllocateGCPrivateIndex()) < 0))
2232 return FALSE;
2233
2234 miBankGeneration = serverGeneration;
2235 }
2236
2237 if (!AllocateGCPrivate(pScreen, miBankGCIndex,
2238 (nBanks * sizeof(RegionPtr)) +
2239 (sizeof(miBankGCRec) - sizeof(RegionPtr))))
2240 return FALSE;
2241
2242 if (!(pScreenPriv = (miBankScreenPtr)Xcalloc(sizeof(miBankScreenRec))))
2243 return FALSE;
2244
2245 if (!(pScreenPriv->pBanks = /* Allocate and clear */
2246 (RegionPtr *)Xcalloc(nBanks * sizeof(RegionPtr))))
2247 {
2248 Xfree(pScreenPriv);
2249 return FALSE;
2250 }
2251
2252 /*
2253 * Translate banks into clipping regions which are themselves clipped
2254 * against the screen. This also ensures that pixels with imbedded bank
2255 * boundaries are off-screen.
2256 */
2257
2258 BankBase = 0;
2259 maxRects = 0;
2260 we = 0;
2261 for (iBank = 0; iBank < nBanks; iBank++)
2262 {
2263 xRectangle pRects[3], *pRect = pRects;
2264 unsigned int xb, yb, xe, ye;
2265
2266 xb = ((BankBase + nBankBPP - 1) % nBitsPerScanline) / nBankBPP;
2267 yb = (BankBase + nBankBPP - 1) / nBitsPerScanline;
2268 if (xb >= xsize)
2269 {
2270 xb = we = 0;
2271 yb++;
2272 }
2273 if (yb >= ysize)
2274 {
2275 we = 0;
2276 break;
2277 }
2278
2279 if (we)
2280 break;
2281
2282 BankBase += nBitsPerBank;
2283
2284 we = (BankBase % nBitsPerScanline) % nBankBPP;
2285 xe = (BankBase % nBitsPerScanline) / nBankBPP;
2286 ye = BankBase / nBitsPerScanline;
2287 if (xe >= xsize)
2288 {
2289 we = xe = 0;
2290 ye++;
2291 }
2292 if (ye >= ysize)
2293 {
2294 we = xe = 0;
2295 ye = ysize;
2296 }
2297
2298 if (yb == ye)
2299 {
2300 if (xb >= xe)
2301 continue;
2302
2303 pRect->x = xb;
2304 pRect->y = yb;
2305 pRect->width = xe - xb;
2306 pRect->height = 1;
2307 maxRects += 2;
2308 pRect++;
2309 }
2310 else
2311 {
2312 if (xb)
2313 {
2314 pRect->x = xb;
2315 pRect->y = yb++;
2316 pRect->width = xsize - xb;
2317 pRect->height = 1;
2318 maxRects += 2;
2319 pRect++;
2320 }
2321
2322 if (yb < ye)
2323 {
2324 pRect->x = 0;
2325 pRect->y = yb;
2326 pRect->width = xsize;
2327 pRect->height = ye - yb;
2328 maxRects += min(pRect->height, 3) + 1;
2329 pRect++;
2330 }
2331
2332 if (xe)
2333 {
2334 pRect->x = 0;
2335 pRect->y = ye;
2336 pRect->width = xe;
2337 pRect->height = 1;
2338 maxRects += 2;
2339 pRect++;
2340 }
2341 }
2342
2343 pScreenPriv->pBanks[iBank] =
2344 RECTS_TO_REGION(pScreen, pRect - pRects, pRects, 0);
2345 if (!pScreenPriv->pBanks[iBank] ||
2346 REGION_NAR(pScreenPriv->pBanks[iBank]))
2347 {
2348 we = 1;
2349 break;
2350 }
2351 }
2352
2353 if (we && (iBank < nBanks))
2354 {
2355 for (i = iBank; i >= 0; i--)
2356 if (pScreenPriv->pBanks[i])
2357 REGION_DESTROY(pScreen, pScreenPriv->pBanks[i]);
2358
2359 Xfree(pScreenPriv->pBanks);
2360 Xfree(pScreenPriv);
2361
2362 return FALSE;
2363 }
2364
2365 /* Open for business */
2366
2367 pScreenPriv->type = type;
2368 pScreenPriv->nBanks = nBanks;
2369 pScreenPriv->maxRects = maxRects;
2370 pScreenPriv->nBankBPP = nBankBPP;
2371 pScreenPriv->BankInfo = *pBankInfo;
2372 pScreenPriv->nBitsPerBank = nBitsPerBank;
2373 pScreenPriv->nBitsPerScanline = nBitsPerScanline;
2374 pScreenPriv->nPixelsPerScanlinePadUnit = nPixelsPerScanlinePadUnit;
2375
2376 SCREEN_WRAP(CreateScreenResources, miBankCreateScreenResources);
2377 SCREEN_WRAP(ModifyPixmapHeader, miBankModifyPixmapHeader);
2378 SCREEN_WRAP(CloseScreen, miBankCloseScreen);
2379 SCREEN_WRAP(GetImage, miBankGetImage);
2380 SCREEN_WRAP(GetSpans, miBankGetSpans);
2381 SCREEN_WRAP(CreateGC, miBankCreateGC);
2382 SCREEN_WRAP(PaintWindowBackground, miBankPaintWindow);
2383 SCREEN_WRAP(PaintWindowBorder, miBankPaintWindow);
2384 SCREEN_WRAP(CopyWindow, miBankCopyWindow);
2385
2386 pScreenPriv->BackingStoreFuncs = pScreen->BackingStoreFuncs;
2387
2388 pScreen->BackingStoreFuncs.SaveAreas = miBankSaveAreas;
2389 pScreen->BackingStoreFuncs.RestoreAreas = miBankRestoreAreas;
2390 /* ??????????????????????????????????????????????????????????????
2391 pScreen->BackingStoreFuncs.SetClipmaskRgn = miBankSetClipmaskRgn;
2392 ?????????????????????????????????????????????????????????????? */
2393
2394 BANK_SCRPRIVLVAL = (pointer)pScreenPriv;
2395
2396 return TRUE;
2397 }
2398
2399 /* This is used to force GC revalidation when the banking type is changed */
2400 /*ARGSUSED*/
2401 static int
2402 miBankNewSerialNumber(
2403 WindowPtr pWin,
2404 pointer unused
2405 )
2406 {
2407 pWin->drawable.serialNumber = NEXT_SERIAL_NUMBER;
2408 return WT_WALKCHILDREN;
2409 }
2410
2411 /* This entry modifies the banking interface */
2412 _X_EXPORT Bool
2413 miModifyBanking(
2414 ScreenPtr pScreen,
2415 miBankInfoPtr pBankInfo
2416 )
2417 {
2418 unsigned int type;
2419
2420 if (!pScreen)
2421 return FALSE;
2422
2423 if (miBankGeneration == serverGeneration)
2424 {
2425 SCREEN_INIT;
2426
2427 if (pScreenPriv)
2428 {
2429 if (!pBankInfo || !pBankInfo->BankSize ||
2430 !pBankInfo->pBankA || !pBankInfo->pBankB ||
2431 !pBankInfo->SetSourceBank || !pBankInfo->SetDestinationBank ||
2432 !pBankInfo->SetSourceAndDestinationBanks)
2433 return FALSE;
2434
2435 /* BankSize and nBankDepth cannot, as yet, be changed */
2436 if ((pScreenPriv->BankInfo.BankSize != pBankInfo->BankSize) ||
2437 (pScreenPriv->BankInfo.nBankDepth != pBankInfo->nBankDepth))
2438 return FALSE;
2439
2440 if ((type = miBankDeriveType(pScreen, pBankInfo)) == BANK_NOBANK)
2441 return FALSE;
2442
2443 /* Reset banking info */
2444 pScreenPriv->BankInfo = *pBankInfo;
2445 if (type != pScreenPriv->type)
2446 {
2447 /*
2448 * Banking type is changing. Revalidate all window GC's.
2449 */
2450 pScreenPriv->type = type;
2451 WalkTree(pScreen, miBankNewSerialNumber, 0);
2452 }
2453
2454 return TRUE;
2455 }
2456 }
2457
2458 if (!pBankInfo || !pBankInfo->BankSize)
2459 return TRUE; /* No change requested */
2460
2461 return FALSE;
2462 }
2463
2464 /*
2465 * Given various screen attributes, determine the minimum scanline width such
2466 * that each scanline is server and DDX padded and any pixels with imbedded
2467 * bank boundaries are off-screen. This function returns -1 if such a width
2468 * cannot exist. This function exists because the DDX needs to be able to
2469 * determine this width before initializing a frame buffer.
2470 */
2471 int
2472 miScanLineWidth(
2473 unsigned int xsize, /* pixels */
2474 unsigned int ysize, /* pixels */
2475 unsigned int width, /* pixels */
2476 unsigned long BankSize, /* char's */
2477 PixmapFormatRec *pBankFormat,
2478 unsigned int nWidthUnit /* bits */
2479 )
2480 {
2481 unsigned long nBitsPerBank, nBitsPerScanline, nBitsPerScanlinePadUnit;
2482 unsigned long minBitsPerScanline, maxBitsPerScanline;
2483
2484 /* Sanity checks */
2485
2486 if (!nWidthUnit || !pBankFormat)
2487 return -1;
2488
2489 nBitsPerBank = BankSize * 8;
2490 if (nBitsPerBank % pBankFormat->scanlinePad)
2491 return -1;
2492
2493 if (xsize > width)
2494 width = xsize;
2495 nBitsPerScanlinePadUnit = miLCM(pBankFormat->scanlinePad, nWidthUnit);
2496 nBitsPerScanline =
2497 (((width * pBankFormat->bitsPerPixel) + nBitsPerScanlinePadUnit - 1) /
2498 nBitsPerScanlinePadUnit) * nBitsPerScanlinePadUnit;
2499 width = nBitsPerScanline / pBankFormat->bitsPerPixel;
2500
2501 if (!xsize || !(nBitsPerBank % pBankFormat->bitsPerPixel))
2502 return (int)width;
2503
2504 /*
2505 * Scanlines will be server-pad aligned at this point. They will also be
2506 * a multiple of nWidthUnit bits long. Ensure that pixels with imbedded
2507 * bank boundaries are off-screen.
2508 *
2509 * It seems reasonable to limit total frame buffer size to 1/16 of the
2510 * theoretical maximum address space size. On a machine with 32-bit
2511 * addresses (to 8-bit quantities) this turns out to be 256MB. Not only
2512 * does this provide a simple limiting condition for the loops below, but
2513 * it also prevents unsigned long wraparounds.
2514 */
2515 if (!ysize)
2516 return -1;
2517
2518 minBitsPerScanline = xsize * pBankFormat->bitsPerPixel;
2519 if (minBitsPerScanline > nBitsPerBank)
2520 return -1;
2521
2522 if (ysize == 1)
2523 return (int)width;
2524
2525 maxBitsPerScanline =
2526 (((unsigned long)(-1) >> 1) - minBitsPerScanline) / (ysize - 1);
2527 while (nBitsPerScanline <= maxBitsPerScanline)
2528 {
2529 unsigned long BankBase, BankUnit;
2530
2531 BankUnit = ((nBitsPerBank + nBitsPerScanline - 1) / nBitsPerBank) *
2532 nBitsPerBank;
2533 if (!(BankUnit % nBitsPerScanline))
2534 return (int)width;
2535
2536 for (BankBase = BankUnit; ; BankBase += nBitsPerBank)
2537 {
2538 unsigned long x, y;
2539
2540 y = BankBase / nBitsPerScanline;
2541 if (y >= ysize)
2542 return (int)width;
2543
2544 x = BankBase % nBitsPerScanline;
2545 if (!(x % pBankFormat->bitsPerPixel))
2546 continue;
2547
2548 if (x < minBitsPerScanline)
2549 {
2550 /*
2551 * Skip ahead certain widths by dividing the excess scanline
2552 * amongst the y's.
2553 */
2554 y *= nBitsPerScanlinePadUnit;
2555 nBitsPerScanline +=
2556 ((x + y - 1) / y) * nBitsPerScanlinePadUnit;
2557 width = nBitsPerScanline / pBankFormat->bitsPerPixel;
2558 break;
2559 }
2560
2561 if (BankBase != BankUnit)
2562 continue;
2563
2564 if (!(nBitsPerScanline % x))
2565 return (int)width;
2566
2567 BankBase = ((nBitsPerScanline - minBitsPerScanline) /
2568 (nBitsPerScanline - x)) * BankUnit;
2569 }
2570 }
2571
2572 return -1;
2573 }
A new scheduler for Xserver