← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/xserver-xgl/intrepid

« back to all changes in this revision

Viewing changes to cfb/cfbsolid.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthew Garrett
  • Date: 2006-02-13 14:21:43 UTC
  • Revision ID: james.westby@ubuntu.com-20060213142143-mad6z9xzem7hzxz9
Tags: upstream-7.0.0
Import upstream version 7.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
cfb/cfbsolid.c
 
1
/*
 
2
 * $Xorg: cfbsolid.c,v 1.4 2001/02/09 02:04:38 xorgcvs Exp $
 
3
 *
 
4
Copyright 1990, 1998  The Open Group
 
5
 
 
6
Permission to use, copy, modify, distribute, and sell this software and its
 
7
documentation for any purpose is hereby granted without fee, provided that
 
8
the above copyright notice appear in all copies and that both that
 
9
copyright notice and this permission notice appear in supporting
 
10
documentation.
 
11
 
 
12
The above copyright notice and this permission notice shall be included in
 
13
all copies or substantial portions of the Software.
 
14
 
 
15
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
16
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
17
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 
18
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 
19
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 
20
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
21
 
 
22
Except as contained in this notice, the name of The Open Group shall not be
 
23
used in advertising or otherwise to promote the sale, use or other dealings
 
24
in this Software without prior written authorization from The Open Group.
 
25
 *
 
26
 * Author:  Keith Packard, MIT X Consortium
 
27
 */
 
28
/* $XFree86: xc/programs/Xserver/cfb/cfbsolid.c,v 3.8tsi Exp $ */
 
29
 
 
30
 
 
31
#ifdef HAVE_DIX_CONFIG_H
 
32
#include <dix-config.h>
 
33
#endif
 
34
 
 
35
#include <X11/X.h>
 
36
#include <X11/Xmd.h>
 
37
#include "servermd.h"
 
38
#include "gcstruct.h"
 
39
#include "window.h"
 
40
#include "pixmapstr.h"
 
41
#include "scrnintstr.h"
 
42
#include "windowstr.h"
 
43
 
 
44
#include "cfb.h"
 
45
#include "cfbmskbits.h"
 
46
#include "cfbrrop.h"
 
47
 
 
48
#include "mi.h"
 
49
#include "mispans.h"
 
50
 
 
51
#if defined(FAST_CONSTANT_OFFSET_MODE) && (RROP != GXcopy)
 
52
# define Expand(left,right,leftAdjust) {\
 
53
    int part = nmiddle & 3; \
 
54
    int widthStep; \
 
55
    widthStep = widthDst - nmiddle - leftAdjust; \
 
56
    nmiddle >>= 2; \
 
57
    pdst = pdstRect; \
 
58
    while (h--) { \
 
59
        left \
 
60
        pdst += part; \
 
61
        switch (part) { \
 
62
            RROP_UNROLL_CASE3(pdst) \
 
63
        } \
 
64
        m = nmiddle; \
 
65
        while (m) { \
 
66
            pdst += 4; \
 
67
            RROP_UNROLL_LOOP4(pdst,-4) \
 
68
            m--; \
 
69
        } \
 
70
        right \
 
71
        pdst += widthStep; \
 
72
    } \
 
73
}
 
74
#else
 
75
# ifdef RROP_UNROLL
 
76
#  define Expand(left,right,leftAdjust) {\
 
77
    int part = nmiddle & RROP_UNROLL_MASK; \
 
78
    int widthStep; \
 
79
    widthStep = widthDst - nmiddle - leftAdjust; \
 
80
    nmiddle >>= RROP_UNROLL_SHIFT; \
 
81
    pdst = pdstRect; \
 
82
    while (h--) { \
 
83
        left \
 
84
        pdst += part; \
 
85
        switch (part) { \
 
86
            RROP_UNROLL_CASE(pdst) \
 
87
        } \
 
88
        m = nmiddle; \
 
89
        while (m) { \
 
90
            pdst += RROP_UNROLL; \
 
91
            RROP_UNROLL_LOOP(pdst) \
 
92
            m--; \
 
93
        } \
 
94
        right \
 
95
        pdst += widthStep; \
 
96
    } \
 
97
}
 
98
 
 
99
# else
 
100
#  define Expand(left, right, leftAdjust) { \
 
101
    while (h--) { \
 
102
        pdst = pdstRect; \
 
103
        left \
 
104
        m = nmiddle; \
 
105
        while (m--) {\
 
106
            RROP_SOLID(pdst); \
 
107
            pdst++; \
 
108
        } \
 
109
        right \
 
110
        pdstRect += widthDst; \
 
111
    } \
 
112
}
 
113
# endif
 
114
#endif
 
115
        
 
116
 
 
117
void
 
118
RROP_NAME(cfbFillRectSolid) (pDrawable, pGC, nBox, pBox)
 
119
    DrawablePtr     pDrawable;
 
120
    GCPtr           pGC;
 
121
    int             nBox;
 
122
    BoxPtr          pBox;
 
123
{
 
124
    register int    m;
 
125
    register CfbBits   *pdst;
 
126
    RROP_DECLARE
 
127
    CfbBits   *pdstBase, *pdstRect;
 
128
    int             nmiddle;
 
129
    int             h;
 
130
    int             w;
 
131
    int             widthDst;
 
132
#if PSZ == 24
 
133
    int             leftIndex, rightIndex;
 
134
#else
 
135
    register CfbBits   leftMask, rightMask;
 
136
#endif
 
137
 
 
138
    cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
 
139
 
 
140
    RROP_FETCH_GC(pGC)
 
141
    
 
142
    for (; nBox; nBox--, pBox++)
 
143
    {
 
144
        pdstRect = pdstBase + pBox->y1 * widthDst;
 
145
        h = pBox->y2 - pBox->y1;
 
146
        w = pBox->x2 - pBox->x1;
 
147
#if PSZ == 8
 
148
        if (w == 1)
 
149
        {
 
150
            register char    *pdstb = ((char *) pdstRect) + pBox->x1;
 
151
            int     incr = widthDst * PGSZB;
 
152
 
 
153
            while (h--)
 
154
            {
 
155
                RROP_SOLID (pdstb);
 
156
                pdstb += incr;
 
157
            }
 
158
        }
 
159
        else
 
160
        {
 
161
#endif
 
162
#if PSZ == 24
 
163
        leftIndex = pBox->x1 &3;
 
164
/*      rightIndex = ((leftIndex+w)<5)?0:pBox->x2 &3;*/
 
165
        rightIndex = pBox->x2 &3;
 
166
 
 
167
        nmiddle = w - rightIndex;
 
168
        if(leftIndex){
 
169
          nmiddle -= (4 - leftIndex);
 
170
        }
 
171
        nmiddle >>= 2;
 
172
        if(nmiddle < 0)
 
173
          nmiddle = 0;
 
174
 
 
175
        pdstRect += (pBox->x1 * 3) >> 2;
 
176
        pdst = pdstRect;        
 
177
        switch(leftIndex+w){
 
178
        case 4:
 
179
            switch(leftIndex){
 
180
            case 0:
 
181
                while(h--){
 
182
#if RROP == GXcopy
 
183
                    *pdst++ = piQxelXor[0];
 
184
                    *pdst++ = piQxelXor[1];
 
185
                    *pdst-- = piQxelXor[2];
 
186
#endif
 
187
#if RROP == GXxor
 
188
                    *pdst++ ^= piQxelXor[0];
 
189
                    *pdst++ ^= piQxelXor[1];
 
190
                    *pdst-- ^= piQxelXor[2];
 
191
#endif
 
192
#if RROP == GXand
 
193
                    *pdst++ &= piQxelAnd[0];
 
194
                    *pdst++ &= piQxelAnd[1];
 
195
                    *pdst-- &= piQxelAnd[2];
 
196
#endif
 
197
#if RROP == GXor
 
198
                    *pdst++ |= piQxelOr[0];
 
199
                    *pdst++ |= piQxelOr[1];
 
200
                    *pdst-- |= piQxelOr[2];
 
201
#endif
 
202
#if RROP == GXset
 
203
                    *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
204
                    pdst++;
 
205
                    *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
206
                    pdst++;
 
207
                    *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
208
                    pdst--;
 
209
#endif
 
210
                    pdst--;
 
211
                    pdst += widthDst;
 
212
                }
 
213
                break;
 
214
            case 1:
 
215
                while(h--){
 
216
#if RROP == GXcopy
 
217
                    *pdst = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 
218
                    pdst++;
 
219
                    *pdst++ = piQxelXor[1];
 
220
                    *pdst-- = piQxelXor[2];
 
221
#endif
 
222
#if RROP == GXxor
 
223
                    *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 
224
                    *pdst++ ^= piQxelXor[1];
 
225
                    *pdst-- ^= piQxelXor[2];
 
226
#endif
 
227
#if RROP == GXand
 
228
                    *pdst++ &= (piQxelAnd[0] | 0x00FFFFFF);
 
229
                    *pdst++ &= piQxelAnd[1];
 
230
                    *pdst-- &= piQxelAnd[2];
 
231
#endif
 
232
#if RROP == GXor
 
233
                    *pdst++ |= (piQxelOr[0] & 0xFF000000);
 
234
                    *pdst++ |= piQxelOr[1];
 
235
                    *pdst-- |= piQxelOr[2];
 
236
#endif
 
237
#if RROP == GXset
 
238
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 
239
                    pdst++;
 
240
                    *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
241
                    pdst++;
 
242
                    *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
243
                    pdst--;
 
244
#endif
 
245
                    pdst--;
 
246
                    pdst += widthDst;
 
247
                }
 
248
                break;
 
249
            case 2:
 
250
                while(h--){
 
251
#if RROP == GXcopy
 
252
                    *pdst = ((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
 
253
                    pdst++;
 
254
                    *pdst-- = piQxelXor[2];
 
255
#endif
 
256
#if RROP == GXxor
 
257
                    *pdst++ ^= (piQxelXor[1] & 0xFFFF0000);
 
258
                    *pdst-- ^= piQxelXor[2];
 
259
#endif
 
260
#if RROP == GXand
 
261
                    *pdst++ &= (piQxelAnd[1] | 0xFFFF);
 
262
                    *pdst-- &= piQxelAnd[2];
 
263
#endif
 
264
#if RROP == GXor
 
265
                    *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 
266
                    *pdst-- |= piQxelOr[2];
 
267
#endif
 
268
#if RROP == GXset
 
269
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 
270
                    pdst++;
 
271
                    *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
272
                    pdst--;
 
273
#endif
 
274
                    pdst += widthDst;
 
275
                }
 
276
                break;
 
277
            case 3:
 
278
                while(h--){
 
279
#if RROP == GXcopy
 
280
                    *pdst = ((*pdst) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
 
281
#endif
 
282
#if RROP == GXxor
 
283
                    *pdst ^= (piQxelXor[2] & 0xFFFFFF00);
 
284
#endif
 
285
#if RROP == GXand
 
286
                    *pdst &= (piQxelAnd[2] | 0xFF);
 
287
#endif
 
288
#if RROP == GXor
 
289
                    *pdst |= (piQxelOr[2] & 0xFFFFFF00);
 
290
#endif
 
291
#if RROP == GXset
 
292
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 
293
#endif
 
294
                    pdst += widthDst;
 
295
                }
 
296
                break;
 
297
            }
 
298
            break;
 
299
        case 3:
 
300
            switch(leftIndex){
 
301
            case 0:
 
302
                while(h--){
 
303
#if RROP == GXcopy
 
304
                    *pdst++ = piQxelXor[0];
 
305
                    *pdst++ = piQxelXor[1];
 
306
                    *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 
307
                    pdst--;
 
308
#endif
 
309
#if RROP == GXxor
 
310
                    *pdst++ ^= piQxelXor[0];
 
311
                    *pdst++ ^= piQxelXor[1];
 
312
                    *pdst-- ^= (piQxelXor[2] & 0xFF);
 
313
#endif
 
314
#if RROP == GXand
 
315
                    *pdst++ &= piQxelAnd[0];
 
316
                    *pdst++ &= piQxelAnd[1];
 
317
                    *pdst-- &= (piQxeAnd[2] | 0xFFFFFF00);
 
318
#endif
 
319
#if RROP == GXor
 
320
                    *pdst++ |= piQxelOr[0];
 
321
                    *pdst++ |= piQxelOr[1];
 
322
                    *pdst-- |= (piQxelOr[2] & 0xFF);
 
323
#endif
 
324
#if RROP == GXset
 
325
                    *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
326
                    pdst++;
 
327
                    *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
328
                    pdst++;
 
329
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 
330
                    pdst--;
 
331
#endif
 
332
                    pdst--;
 
333
                    pdst += widthDst;
 
334
                }
 
335
                break;
 
336
            case 1:
 
337
                while(h--){
 
338
#if RROP == GXcopy
 
339
                    *pdst = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 
340
                    pdst++;
 
341
                    *pdst++ = piQxelXor[1];
 
342
                    *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 
343
                    pdst--;
 
344
#endif
 
345
#if RROP == GXxor
 
346
                    *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 
347
                    *pdst++ ^= piQxelXor[1];
 
348
                    *pdst-- ^= (piQxelXor[2] & 0xFF);
 
349
#endif
 
350
#if RROP == GXand
 
351
                    *pdst++ &= (piQxelAnd[0] | 0x00FFFFFF);
 
352
                    *pdst++ &= piQxelAnd[1];
 
353
                    *pdst-- &= (piQxelAnd[2] | 0xFFFFFF00);
 
354
#endif
 
355
#if RROP == GXor
 
356
                    *pdst++ |= (piQxelOr[0] & 0xFF000000);
 
357
                    *pdst++ |= piQxelOr[1];
 
358
                    *pdst-- |= (piQxelOr[2] & 0xFF);
 
359
#endif
 
360
#if RROP == GXset
 
361
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 
362
                    pdst++;
 
363
                    *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
364
                    pdst++;
 
365
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 
366
                    pdst--;
 
367
#endif
 
368
                    pdst--;
 
369
                    pdst += widthDst;
 
370
                }
 
371
                break;
 
372
            case 2:
 
373
                while(h--){
 
374
#if RROP == GXcopy
 
375
                    *pdst = ((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
 
376
                    pdst++;
 
377
                    *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 
378
                    pdst--;
 
379
#endif
 
380
#if RROP == GXxor
 
381
                    *pdst++ ^= (piQxelXor[1] & 0xFFFF0000);
 
382
                    *pdst-- ^= (piQxelXor[2] & 0xFF);
 
383
#endif
 
384
#if RROP == GXand
 
385
                    *pdst++ &= (piQxelAnd[1] | 0xFFFF);
 
386
                    *pdst-- &= (piQxelAnd[2] | 0xFFFFFF00);
 
387
#endif
 
388
#if RROP == GXor
 
389
                    *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 
390
                    *pdst-- |= (piQxelOr[2] & 0xFF);
 
391
#endif
 
392
#if RROP == GXset
 
393
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 
394
                    pdst++;
 
395
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 
396
                    pdst--;
 
397
#endif
 
398
                    pdst += widthDst;
 
399
                }
 
400
                break;
 
401
            case 3:
 
402
                while(h--){
 
403
#if RROP == GXcopy
 
404
                    *pdst = ((*pdst) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
 
405
#endif
 
406
#if RROP == GXxor
 
407
                    *pdst ^= (piQxelXor[2] & 0xFFFFFF00);
 
408
#endif
 
409
#if RROP == GXand
 
410
                    *pdst &= (piQxelAnd[2] | 0xFF);
 
411
#endif
 
412
#if RROP == GXor
 
413
                    *pdst |= (piQxelOr[2] & 0xFFFFFF00);
 
414
#endif
 
415
#if RROP == GXset
 
416
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 
417
#endif
 
418
                    pdst += widthDst;
 
419
                }
 
420
                break;
 
421
            }
 
422
            break;
 
423
        case 2: /* leftIndex + w = 2*/
 
424
            switch(leftIndex){
 
425
            case 2:
 
426
                while(h--){
 
427
#if RROP == GXcopy
 
428
                    *pdst = ((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
 
429
                    pdst++;
 
430
                    *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 
431
                    pdst--;
 
432
#endif
 
433
#if RROP == GXxor
 
434
                    *pdst++ ^= (piQxelXor[1] & 0xFFFF0000);
 
435
                    *pdst-- ^= (piQxelXor[2] & 0xFF);
 
436
#endif
 
437
#if RROP == GXand
 
438
                    *pdst++ &= (piQxelAnd[1] | 0xFFFF0000);
 
439
                    *pdst-- &= (piQxelAnd[2] | 0xFF);
 
440
#endif
 
441
#if RROP == GXor
 
442
                    *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 
443
                    *pdst-- |= (piQxelOr[2] & 0xFF);
 
444
#endif
 
445
#if RROP == GXset
 
446
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 
447
                    pdst++;
 
448
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 
449
                    pdst--;
 
450
#endif
 
451
                    pdst += widthDst;
 
452
                  }
 
453
                break;
 
454
            case 1:
 
455
                while(h--){
 
456
#if RROP == GXcopy
 
457
                    *pdst = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 
458
                    pdst++;
 
459
                    *pdst = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
 
460
                    pdst--;
 
461
#endif
 
462
#if RROP == GXxor
 
463
                    *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 
464
                    *pdst-- ^= (piQxelXor[1] & 0xFFFF);
 
465
#endif
 
466
#if RROP == GXand
 
467
                    *pdst++ &= (piQxelAnd[0] | 0xFFFFFF);
 
468
                    *pdst-- &= (piQxelAnd[1] | 0xFFFF0000);
 
469
#endif
 
470
#if RROP == GXor
 
471
                    *pdst++ |= (piQxelOr[0] & 0xFF000000);
 
472
                    *pdst-- |= (piQxelOr[1] & 0xFFFF);
 
473
#endif
 
474
#if RROP == GXset
 
475
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 
476
                    pdst++;
 
477
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
 
478
                    pdst--;
 
479
#endif
 
480
                    pdst += widthDst;
 
481
                  }
 
482
                break;
 
483
            case 0: /*case 2 leftIndex == 0 */
 
484
                while(h--){
 
485
#if RROP == GXcopy
 
486
                    *pdst++ = piQxelXor[0];
 
487
                    *pdst = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
 
488
                    pdst--;
 
489
#endif
 
490
#if RROP == GXxor
 
491
                    *pdst++ ^= piQxelXor[0];
 
492
                    *pdst-- ^= (piQxelXor[1] & 0xFFFF);
 
493
#endif
 
494
#if RROP == GXand
 
495
                    *pdst++ &= piQxelAnd[0];
 
496
                    *pdst-- &= (piQxelAnd[1] | 0xFFFF0000);
 
497
#endif
 
498
#if RROP == GXor
 
499
                    *pdst++ |= piQxelOr[0];
 
500
                    *pdst-- |= (piQxelOr[1] & 0xFFFF);
 
501
#endif
 
502
#if RROP == GXset
 
503
                    *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
504
                    pdst++;
 
505
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
 
506
                    pdst--;
 
507
#endif
 
508
                    pdst += widthDst;
 
509
                }
 
510
                break;
 
511
            }
 
512
            break;
 
513
        case 1: /*only if leftIndex = 0 and w = 1*/
 
514
            while(h--){
 
515
#if RROP == GXcopy
 
516
                *pdst = ((*pdst) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
 
517
#endif
 
518
#if RROP == GXxor
 
519
                *pdst ^= (piQxelXor[0] & 0xFFFFFF);
 
520
#endif
 
521
#if RROP == GXand
 
522
                *pdst &= (piQxelAnd[0] | 0xFF000000);
 
523
#endif
 
524
#if RROP == GXor
 
525
                *pdst |= (piQxelOr[0] & 0xFFFFFF);
 
526
#endif
 
527
#if RROP == GXset
 
528
                *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
 
529
#endif
 
530
                pdst += widthDst;
 
531
            }
 
532
            break;
 
533
        case 0: /*never*/
 
534
            break;
 
535
        default:
 
536
            {
 
537
                while(h--){
 
538
                    pdst = pdstRect;
 
539
                    switch(leftIndex){
 
540
                    case 0:
 
541
                        break;
 
542
                    case 1:
 
543
#if RROP == GXcopy
 
544
                        *pdst = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 
545
                        pdst++;
 
546
                        *pdst++ = piQxelXor[1];
 
547
                        *pdst++ = piQxelXor[2];
 
548
#endif
 
549
#if RROP == GXxor
 
550
                        *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 
551
                        *pdst++ ^= piQxelXor[1];
 
552
                        *pdst++ ^= piQxelXor[2];
 
553
#endif
 
554
#if RROP == GXand
 
555
                        *pdst++ &= (piQxelAnd[0] | 0xFFFFFF);
 
556
                        *pdst++ &= piQxelAnd[1];
 
557
                        *pdst++ &= piQxelAnd[2];
 
558
#endif
 
559
#if RROP == GXor
 
560
                        *pdst++ |= (piQxelOr[0] & 0xFF000000);
 
561
                        *pdst++ |= piQxelOr[1];
 
562
                        *pdst++ |= piQxelOr[2];
 
563
#endif
 
564
#if RROP == GXset
 
565
                        *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 
566
                        pdst++;
 
567
                        *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
568
                        pdst++;
 
569
                        *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
570
                        pdst++;
 
571
#endif
 
572
                    break;
 
573
                    case 2:
 
574
#if RROP == GXcopy
 
575
                        *pdst = (((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000));
 
576
                        pdst++;
 
577
                        *pdst++ = piQxelXor[2];
 
578
#endif
 
579
#if RROP == GXxor
 
580
                        *pdst++ ^=(piQxelXor[1] & 0xFFFF0000);
 
581
                        *pdst++ ^= piQxelXor[2];
 
582
#endif
 
583
#if RROP == GXand
 
584
                        *pdst++ &= (piQxelAnd[1] | 0xFFFF);
 
585
                        *pdst++ &= piQxelAnd[2];
 
586
#endif
 
587
#if RROP == GXor
 
588
                        *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 
589
                        *pdst++ |= piQxelOr[2];
 
590
#endif
 
591
#if RROP == GXset
 
592
                        *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 
593
                        pdst++;
 
594
                        *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
595
                        pdst++;
 
596
#endif
 
597
                        break;
 
598
                    case 3:
 
599
#if RROP == GXcopy
 
600
                        *pdst = ((*pdst) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
 
601
                        pdst++;
 
602
#endif
 
603
#if RROP == GXxor
 
604
                        *pdst++ ^= (piQxelXor[2] & 0xFFFFFF00);
 
605
#endif
 
606
#if RROP == GXand
 
607
                        *pdst++ &= (piQxelAnd[2] | 0xFF);
 
608
#endif
 
609
#if RROP == GXor
 
610
                        *pdst++ |= (piQxelOr[2] & 0xFFFFFF00);
 
611
#endif
 
612
#if RROP == GXset
 
613
                        *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 
614
                        pdst++;
 
615
#endif
 
616
                        break;
 
617
                      }
 
618
                    m = nmiddle;
 
619
                    while(m--){
 
620
#if RROP == GXcopy
 
621
                        *pdst++ = piQxelXor[0];
 
622
                        *pdst++ = piQxelXor[1];
 
623
                        *pdst++ = piQxelXor[2];
 
624
#endif
 
625
#if RROP == GXxor
 
626
                        *pdst++ ^= piQxelXor[0];
 
627
                        *pdst++ ^= piQxelXor[1];
 
628
                        *pdst++ ^= piQxelXor[2];
 
629
#endif
 
630
#if RROP == GXand
 
631
                        *pdst++ &= piQxelAnd[0];
 
632
                        *pdst++ &= piQxelAnd[1];
 
633
                        *pdst++ &= piQxelAnd[2];
 
634
#endif
 
635
#if RROP == GXor
 
636
                        *pdst++ |= piQxelOr[0];
 
637
                        *pdst++ |= piQxelOr[1];
 
638
                        *pdst++ |= piQxelOr[2];
 
639
#endif
 
640
#if RROP == GXset
 
641
                        *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
642
                        pdst++;
 
643
                        *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
644
                        pdst++;
 
645
                        *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
646
                        pdst++;
 
647
#endif
 
648
                }
 
649
                switch(rightIndex){
 
650
                case 0:
 
651
                  break;
 
652
                case 1:
 
653
#if RROP == GXcopy
 
654
                  *pdst = ((*pdst) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
 
655
                  pdst++;
 
656
#endif
 
657
#if RROP == GXxor
 
658
                  *pdst++ ^= (piQxelXor[0] & 0xFFFFFF);
 
659
#endif
 
660
#if RROP == GXand
 
661
                  *pdst++ &= (piQxelAnd[0] | 0xFF);
 
662
#endif
 
663
#if RROP == GXor
 
664
                  *pdst++ |= (piQxelOr[0] & 0xFFFFFF);
 
665
#endif
 
666
#if RROP == GXset
 
667
                  *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
 
668
                  pdst++;
 
669
#endif
 
670
                  break;
 
671
                case 2:
 
672
#if RROP == GXcopy
 
673
                  *pdst++ = piQxelXor[0];
 
674
                  *pdst = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
 
675
                  pdst++;
 
676
#endif
 
677
#if RROP == GXxor
 
678
                  *pdst++ ^= piQxelXor[0];
 
679
                  *pdst++ ^= (piQxelXor[1] & 0xFFFF);
 
680
#endif
 
681
#if RROP == GXand
 
682
                  *pdst++ &= piQxelAnd[0];
 
683
                  *pdst++ &= (piQxelAnd[1] | 0xFFFF0000);
 
684
#endif
 
685
#if RROP == GXor
 
686
                  *pdst++ |= piQxelOr[0];
 
687
                  *pdst++ |= (piQxelOr[1] & 0xFFFF);
 
688
#endif
 
689
#if RROP == GXset
 
690
                  *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
691
                  pdst++;
 
692
                  *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
 
693
                  pdst++;
 
694
#endif
 
695
                  break;
 
696
                case 3:
 
697
#if RROP == GXcopy
 
698
                  *pdst++ = piQxelXor[0];
 
699
                  *pdst++ = piQxelXor[1];
 
700
                  *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 
701
                  pdst++;
 
702
#endif
 
703
#if RROP == GXxor
 
704
                  *pdst++ ^= piQxelXor[0];
 
705
                  *pdst++ ^= piQxelXor[1];
 
706
                  *pdst++ ^= (piQxelXor[2] & 0xFF);
 
707
#endif
 
708
#if RROP == GXand
 
709
                  *pdst++ &= piQxelAnd[0];
 
710
                  *pdst++ &= piQxelAnd[1];
 
711
                  *pdst++ &= (piQxelAnd[2] | 0xFFFFFF00);
 
712
#endif
 
713
#if RROP == GXor
 
714
                  *pdst++ |= piQxelOr[0];
 
715
                  *pdst++ |= piQxelOr[1];
 
716
                  *pdst++ |= (piQxelOr[2] & 0xFF);
 
717
#endif
 
718
#if RROP == GXset
 
719
                  *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
720
                  pdst++;
 
721
                  *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
722
                  pdst++;
 
723
                  *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 
724
                  pdst++;
 
725
#endif
 
726
                  break;
 
727
                }
 
728
                pdstRect += widthDst;
 
729
            }
 
730
        }
 
731
        }
 
732
#else /* PSZ != 24 */
 
733
        pdstRect += (pBox->x1 >> PWSH);
 
734
        if ((pBox->x1 & PIM) + w <= PPW)
 
735
        {
 
736
            maskpartialbits(pBox->x1, w, leftMask);
 
737
            pdst = pdstRect;
 
738
            while (h--) {
 
739
                RROP_SOLID_MASK (pdst, leftMask);
 
740
                pdst += widthDst;
 
741
            }
 
742
        }
 
743
        else
 
744
        {
 
745
            maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);
 
746
            if (leftMask)
 
747
            {
 
748
                if (rightMask)  /* left mask and right mask */
 
749
                {
 
750
                    Expand(RROP_SOLID_MASK (pdst, leftMask); pdst++;,
 
751
                           RROP_SOLID_MASK (pdst, rightMask);, 1)
 
752
                }
 
753
                else    /* left mask and no right mask */
 
754
                {
 
755
                    Expand(RROP_SOLID_MASK (pdst, leftMask); pdst++;,
 
756
                           ;, 1)
 
757
                }
 
758
            }
 
759
            else
 
760
            {
 
761
                if (rightMask)  /* no left mask and right mask */
 
762
                {
 
763
                    Expand(;,
 
764
                           RROP_SOLID_MASK (pdst, rightMask);, 0)
 
765
                }
 
766
                else    /* no left mask and no right mask */
 
767
                {
 
768
                    Expand(;,
 
769
                            ;, 0)
 
770
                }
 
771
            }
 
772
        }
 
773
#endif
 
774
#if PSZ == 8
 
775
        }
 
776
#endif
 
777
    }
 
778
    RROP_UNDECLARE
 
779
}
 
780
 
 
781
void
 
782
RROP_NAME(cfbSolidSpans) (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 
783
    DrawablePtr pDrawable;
 
784
    GCPtr       pGC;
 
785
    int         nInit;                  /* number of spans to fill */
 
786
    DDXPointPtr pptInit;                /* pointer to list of start points */
 
787
    int         *pwidthInit;            /* pointer to list of n widths */
 
788
    int         fSorted;
 
789
{
 
790
    CfbBits   *pdstBase;
 
791
    int             widthDst;
 
792
 
 
793
    RROP_DECLARE
 
794
    
 
795
    register CfbBits  *pdst;
 
796
    register int            nlmiddle;
 
797
    register int            w;
 
798
    int                     x;
 
799
    
 
800
                                /* next three parameters are post-clip */
 
801
    int             n;          /* number of spans to fill */
 
802
    DDXPointPtr     ppt;        /* pointer to list of start points */
 
803
    int             *pwidthFree;/* copies of the pointers to free */
 
804
    DDXPointPtr     pptFree;
 
805
    int             *pwidth;
 
806
    cfbPrivGCPtr    devPriv;
 
807
#if PSZ == 24
 
808
    int             leftIndex, rightIndex;
 
809
#else
 
810
    register CfbBits  startmask, endmask;
 
811
#endif
 
812
 
 
813
    devPriv = cfbGetGCPrivate(pGC);
 
814
    RROP_FETCH_GCPRIV(devPriv)
 
815
    n = nInit * miFindMaxBand(pGC->pCompositeClip);
 
816
    pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
 
817
    pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
 
818
    if(!pptFree || !pwidthFree)
 
819
    {
 
820
        if (pptFree) DEALLOCATE_LOCAL(pptFree);
 
821
        if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
 
822
        return;
 
823
    }
 
824
    pwidth = pwidthFree;
 
825
    ppt = pptFree;
 
826
    n = miClipSpans(pGC->pCompositeClip, pptInit, pwidthInit, nInit,
 
827
                     ppt, pwidth, fSorted);
 
828
 
 
829
    cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
 
830
 
 
831
    while (n--)
 
832
    {
 
833
        x = ppt->x;
 
834
        pdst = pdstBase + (ppt->y * widthDst);
 
835
        ++ppt;
 
836
        w = *pwidth++;
 
837
        if (!w)
 
838
            continue;
 
839
#if PSZ == 24
 
840
        leftIndex = x &3;
 
841
/*      rightIndex = ((leftIndex+w)<5)?0:(x+w)&3;*/
 
842
        rightIndex = (x+w)&3;
 
843
 
 
844
        nlmiddle = w - rightIndex;
 
845
        if(leftIndex){
 
846
          nlmiddle -= (4 - leftIndex);
 
847
        }
 
848
/*      nlmiddle += 3;*/
 
849
        nlmiddle >>= 2;
 
850
        if(nlmiddle < 0)
 
851
          nlmiddle = 0;
 
852
 
 
853
        pdst += (x >> 2)*3;
 
854
        pdst += leftIndex? (leftIndex -1):0;
 
855
        switch(leftIndex+w){
 
856
        case 4:
 
857
            switch(leftIndex){
 
858
            case 0:
 
859
#if RROP == GXcopy
 
860
                    *pdst++ = piQxelXor[0];
 
861
                    *pdst++ = piQxelXor[1];
 
862
                    *pdst-- = piQxelXor[2];
 
863
#endif
 
864
#if RROP == GXxor
 
865
                    *pdst++ ^= piQxelXor[0];
 
866
                    *pdst++ ^= piQxelXor[1];
 
867
                    *pdst-- ^= piQxelXor[2];
 
868
#endif
 
869
#if RROP == GXand
 
870
                    *pdst++ &= piQxelAnd[0];
 
871
                    *pdst++ &= piQxelAnd[1];
 
872
                    *pdst-- &= piQxelAnd[2];
 
873
#endif
 
874
#if RROP == GXor
 
875
                    *pdst++ |= piQxelOr[0];
 
876
                    *pdst++ |= piQxelOr[1];
 
877
                    *pdst-- |= piQxelOr[2];
 
878
#endif
 
879
#if RROP == GXset
 
880
                    *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
881
                    pdst++;
 
882
                    *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
883
                    pdst++;
 
884
                    *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
885
                    pdst--;
 
886
#endif
 
887
                    pdst--;
 
888
                break;
 
889
            case 1:
 
890
#if RROP == GXcopy
 
891
                    *pdst = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 
892
                    pdst++;
 
893
                    *pdst++ = piQxelXor[1];
 
894
                    *pdst-- = piQxelXor[2];
 
895
#endif
 
896
#if RROP == GXxor
 
897
                    *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 
898
                    *pdst++ ^= piQxelXor[1];
 
899
                    *pdst-- ^= piQxelXor[2];
 
900
#endif
 
901
#if RROP == GXand
 
902
                    *pdst++ &= (piQxelAnd[0] | 0x00FFFFFF);
 
903
                    *pdst++ &= piQxelAnd[1];
 
904
                    *pdst-- &= piQxelAnd[2];
 
905
#endif
 
906
#if RROP == GXor
 
907
                    *pdst++ |= (piQxelOr[0] & 0xFF000000);
 
908
                    *pdst++ |= piQxelOr[1];
 
909
                    *pdst-- |= piQxelOr[2];
 
910
#endif
 
911
#if RROP == GXset
 
912
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 
913
                    pdst++;
 
914
                    *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
915
                    pdst++;
 
916
                    *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
917
                    pdst--;
 
918
#endif
 
919
                    pdst--;
 
920
                break;
 
921
            case 2:
 
922
#if RROP == GXcopy
 
923
                    *pdst = ((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
 
924
                    pdst++;
 
925
                    *pdst-- = piQxelXor[2];
 
926
#endif
 
927
#if RROP == GXxor
 
928
                    *pdst++ ^= (piQxelXor[1] & 0xFFFF0000);
 
929
                    *pdst-- ^= piQxelXor[2];
 
930
#endif
 
931
#if RROP == GXand
 
932
                    *pdst++ &= (piQxelAnd[1] | 0xFFFF);
 
933
                    *pdst-- &= piQxelAnd[2];
 
934
#endif
 
935
#if RROP == GXor
 
936
                    *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 
937
                    *pdst-- |= piQxelOr[2];
 
938
#endif
 
939
#if RROP == GXset
 
940
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 
941
                    pdst++;
 
942
                    *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
943
                    pdst--;
 
944
#endif
 
945
                break;
 
946
            case 3:
 
947
#if RROP == GXcopy
 
948
                    *pdst = ((*pdst) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
 
949
#endif
 
950
#if RROP == GXxor
 
951
                    *pdst ^= (piQxelXor[2] & 0xFFFFFF00);
 
952
#endif
 
953
#if RROP == GXand
 
954
                    *pdst &= (piQxelAnd[2] | 0xFF);
 
955
#endif
 
956
#if RROP == GXor
 
957
                    *pdst |= (piQxelOr[2] & 0xFFFFFF00);
 
958
#endif
 
959
#if RROP == GXset
 
960
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 
961
#endif
 
962
                break;
 
963
            }
 
964
            break;
 
965
        case 3:
 
966
            switch(leftIndex){
 
967
            case 0:
 
968
#if RROP == GXcopy
 
969
                    *pdst++ = piQxelXor[0];
 
970
                    *pdst++ = piQxelXor[1];
 
971
                    *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 
972
                    pdst--;
 
973
#endif
 
974
#if RROP == GXxor
 
975
                    *pdst++ ^= piQxelXor[0];
 
976
                    *pdst++ ^= piQxelXor[1];
 
977
                    *pdst-- ^= (piQxelXor[2] & 0xFF);
 
978
#endif
 
979
#if RROP == GXand
 
980
                    *pdst++ &= piQxelAnd[0];
 
981
                    *pdst++ &= piQxelAnd[1];
 
982
                    *pdst-- &= (piQxelAnd[2] | 0xFFFFFF00);
 
983
#endif
 
984
#if RROP == GXor
 
985
                    *pdst++ |= piQxelOr[0];
 
986
                    *pdst++ |= piQxelOr[1];
 
987
 
 
988
                    *pdst-- |= (piQxelOr[2] & 0xFF);
 
989
#endif
 
990
#if RROP == GXset
 
991
                    *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
992
                    pdst++;
 
993
                    *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
994
                    pdst++;
 
995
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 
996
                    pdst--;
 
997
#endif
 
998
                    pdst--;
 
999
                break;
 
1000
            case 1:
 
1001
#if RROP == GXcopy
 
1002
                    *pdst = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 
1003
                    pdst++;
 
1004
                    *pdst++ = piQxelXor[1];
 
1005
                    *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 
1006
                    pdst--;
 
1007
#endif
 
1008
#if RROP == GXxor
 
1009
                    *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 
1010
                    *pdst++ ^= piQxelXor[1];
 
1011
                    *pdst-- ^= (piQxelXor[2] & 0xFF);
 
1012
#endif
 
1013
#if RROP == GXand
 
1014
                    *pdst++ &= (piQxelAnd[0] | 0x00FFFFFF);
 
1015
                    *pdst++ &= piQxelAnd[1];
 
1016
                    *pdst-- &= (piQxelAnd[2] | 0xFFFFFF00);
 
1017
#endif
 
1018
#if RROP == GXor
 
1019
                    *pdst++ |= (piQxelOr[0] & 0xFF000000);
 
1020
                    *pdst++ |= piQxelOr[1];
 
1021
                    *pdst-- |= (piQxelOr[2] & 0xFF);
 
1022
#endif
 
1023
#if RROP == GXset
 
1024
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 
1025
                    pdst++;
 
1026
                    *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
1027
                    pdst++;
 
1028
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 
1029
                    pdst--;
 
1030
#endif
 
1031
                    pdst--;
 
1032
                break;
 
1033
            case 2:
 
1034
/*              pdst++;*/
 
1035
#if RROP == GXcopy
 
1036
                    *pdst = ((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
 
1037
                    pdst++;
 
1038
                    *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 
1039
                    pdst--;
 
1040
#endif
 
1041
#if RROP == GXxor
 
1042
                    *pdst++ ^= (piQxelXor[1] & 0xFFFF0000);
 
1043
                    *pdst-- ^= (piQxelXor[2] & 0xFF);
 
1044
#endif
 
1045
#if RROP == GXand
 
1046
                    *pdst++ &= (piQxelAnd[1] | 0xFFFF);
 
1047
                    *pdst-- &= (piQxelAnd[2] | 0xFFFFFF00);
 
1048
#endif
 
1049
#if RROP == GXor
 
1050
                    *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 
1051
                    *pdst-- |= (piQxelOr[2] & 0xFF);
 
1052
#endif
 
1053
#if RROP == GXset
 
1054
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 
1055
                    pdst++;
 
1056
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 
1057
                    pdst--;
 
1058
#endif
 
1059
                break;
 
1060
            }
 
1061
            break;
 
1062
        case 2: /* leftIndex + w = 2*/
 
1063
            if(leftIndex){
 
1064
#if RROP == GXcopy
 
1065
                    *pdst = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 
1066
                    pdst++;
 
1067
                    *pdst = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
 
1068
                    pdst--;
 
1069
#endif
 
1070
#if RROP == GXxor
 
1071
                    *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 
1072
                    *pdst-- ^= (piQxelXor[1] & 0xFFFF);
 
1073
#endif
 
1074
#if RROP == GXand
 
1075
                    *pdst++ &= (piQxelAnd[0] | 0xFFFFFF);
 
1076
                    *pdst-- &= (piQxelAnd[1] | 0xFFFF0000);
 
1077
#endif
 
1078
#if RROP == GXor
 
1079
                    *pdst++ |= (piQxelOr[0] & 0xFF000000);
 
1080
                    *pdst-- |= (piQxelOr[1] & 0xFFFF);
 
1081
#endif
 
1082
#if RROP == GXset
 
1083
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 
1084
                    pdst++;
 
1085
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
 
1086
                    pdst--;
 
1087
#endif
 
1088
            }
 
1089
            else{ /*case 2 leftIndex === 0 */
 
1090
#if RROP == GXcopy
 
1091
                    *pdst++ = piQxelXor[0];
 
1092
                    *pdst = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
 
1093
                    pdst--;
 
1094
#endif
 
1095
#if RROP == GXxor
 
1096
                    *pdst++ ^= piQxelXor[0];
 
1097
                    *pdst-- ^= (piQxelXor[1] & 0xFFFF);
 
1098
#endif
 
1099
#if RROP == GXand
 
1100
                    *pdst++ &= piQxelAnd[0];
 
1101
                    *pdst-- &= (piQxelAnd[1] | 0xFFFF0000);
 
1102
#endif
 
1103
#if RROP == GXor
 
1104
                    *pdst++ |= piQxelOr[0];
 
1105
                    *pdst-- |= (piQxelOr[1] & 0xFFFF);
 
1106
#endif
 
1107
#if RROP == GXset
 
1108
                    *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
1109
                    pdst++;
 
1110
                    *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
 
1111
                    pdst--;
 
1112
#endif
 
1113
            }
 
1114
            break;
 
1115
        case 1: /*only if leftIndex = 0 and w = 1*/
 
1116
#if RROP == GXcopy
 
1117
                *pdst = ((*pdst) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
 
1118
#endif
 
1119
#if RROP == GXxor
 
1120
                *pdst ^= (piQxelXor[0] & 0xFFFFFF);
 
1121
#endif
 
1122
#if RROP == GXand
 
1123
                *pdst &= (piQxelAnd[0] | 0xFF000000);
 
1124
#endif
 
1125
#if RROP == GXor
 
1126
                *pdst |= (piQxelOr[0] & 0xFFFFFF);
 
1127
#endif
 
1128
#if RROP == GXset
 
1129
                *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
 
1130
#endif
 
1131
            break;
 
1132
        case 0: /*never*/
 
1133
            break;
 
1134
        default:
 
1135
        {
 
1136
            switch(leftIndex){
 
1137
                    case 0:
 
1138
                        break;
 
1139
                    case 1:
 
1140
#if RROP == GXcopy
 
1141
                        *pdst = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 
1142
                        pdst++;
 
1143
                        *pdst++ = piQxelXor[1];
 
1144
                        *pdst++ = piQxelXor[2];
 
1145
#endif
 
1146
#if RROP == GXxor
 
1147
                        *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 
1148
                        *pdst++ ^= piQxelXor[1];
 
1149
                        *pdst++ ^= piQxelXor[2];
 
1150
#endif
 
1151
#if RROP == GXand
 
1152
                        *pdst++ &= (piQxelAnd[0] | 0xFFFFFF);
 
1153
                        *pdst++ &= piQxelAnd[1];
 
1154
                        *pdst++ &= piQxelAnd[2];
 
1155
#endif
 
1156
#if RROP == GXor
 
1157
                        *pdst++ |= (piQxelOr[0] & 0xFF000000);
 
1158
                        *pdst++ |= piQxelOr[1];
 
1159
                        *pdst++ |= piQxelOr[2];
 
1160
#endif
 
1161
#if RROP == GXset
 
1162
                        *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 
1163
                        pdst++;
 
1164
                        *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
1165
                        pdst++;
 
1166
                        *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
1167
                        pdst++;
 
1168
#endif
 
1169
                    break;
 
1170
                    case 2:
 
1171
#if RROP == GXcopy
 
1172
                        *pdst = (((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000));
 
1173
                        pdst++;
 
1174
                        *pdst++ = piQxelXor[2];
 
1175
#endif
 
1176
#if RROP == GXxor
 
1177
                        *pdst++ ^=(piQxelXor[1] & 0xFFFF0000);
 
1178
                        *pdst++ ^= piQxelXor[2];
 
1179
#endif
 
1180
#if RROP == GXand
 
1181
                        *pdst++ &= (piQxelAnd[1] | 0xFFFF);
 
1182
                        *pdst++ &= piQxelAnd[2];
 
1183
#endif
 
1184
#if RROP == GXor
 
1185
                        *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 
1186
                        *pdst++ |= piQxelOr[2];
 
1187
#endif
 
1188
#if RROP == GXset
 
1189
                        *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 
1190
                        pdst++;
 
1191
                        *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
1192
                        pdst++;
 
1193
#endif
 
1194
                        break;
 
1195
                    case 3:
 
1196
#if RROP == GXcopy
 
1197
                        *pdst = ((*pdst) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
 
1198
                        pdst++;
 
1199
#endif
 
1200
#if RROP == GXxor
 
1201
                        *pdst++ ^= (piQxelXor[2] & 0xFFFFFF00);
 
1202
#endif
 
1203
#if RROP == GXand
 
1204
                        *pdst++ &= (piQxelAnd[2] | 0xFF);
 
1205
#endif
 
1206
#if RROP == GXor
 
1207
                        *pdst++ |= (piQxelOr[2] & 0xFFFFFF00);
 
1208
#endif
 
1209
#if RROP == GXset
 
1210
                        *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 
1211
                        pdst++;
 
1212
#endif
 
1213
                        break;
 
1214
                    }
 
1215
                    while(nlmiddle--){
 
1216
#if RROP == GXcopy
 
1217
                        *pdst++ = piQxelXor[0];
 
1218
                        *pdst++ = piQxelXor[1];
 
1219
                        *pdst++ = piQxelXor[2];
 
1220
#endif
 
1221
#if RROP == GXxor
 
1222
                        *pdst++ ^= piQxelXor[0];
 
1223
                        *pdst++ ^= piQxelXor[1];
 
1224
                        *pdst++ ^= piQxelXor[2];
 
1225
#endif
 
1226
#if RROP == GXand
 
1227
                        *pdst++ &= piQxelAnd[0];
 
1228
                        *pdst++ &= piQxelAnd[1];
 
1229
                        *pdst++ &= piQxelAnd[2];
 
1230
#endif
 
1231
#if RROP == GXor
 
1232
                        *pdst++ |= piQxelOr[0];
 
1233
                        *pdst++ |= piQxelOr[1];
 
1234
                        *pdst++ |= piQxelOr[2];
 
1235
#endif
 
1236
#if RROP == GXset
 
1237
                        *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
1238
                        pdst++;
 
1239
                        *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
1240
                        pdst++;
 
1241
                        *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 
1242
                        pdst++;
 
1243
#endif
 
1244
                }
 
1245
                switch(rightIndex){
 
1246
                case 0:
 
1247
                  break;
 
1248
                case 1:
 
1249
#if RROP == GXcopy
 
1250
                  *pdst = ((*pdst) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
 
1251
                  pdst++;
 
1252
#endif
 
1253
#if RROP == GXxor
 
1254
                  *pdst++ ^= (piQxelXor[0] & 0xFFFFFF);
 
1255
#endif
 
1256
#if RROP == GXand
 
1257
                  *pdst++ &= (piQxelAnd[0] | 0xFF);
 
1258
#endif
 
1259
#if RROP == GXor
 
1260
                  *pdst++ |= (piQxelOr[0] & 0xFFFFFF);
 
1261
#endif
 
1262
#if RROP == GXset
 
1263
                  *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
 
1264
#endif
 
1265
                  break;
 
1266
                case 2:
 
1267
#if RROP == GXcopy
 
1268
                  *pdst++ = piQxelXor[0];
 
1269
                  *pdst = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
 
1270
                  pdst++;
 
1271
#endif
 
1272
#if RROP == GXxor
 
1273
                  *pdst++ ^= piQxelXor[0];
 
1274
                  *pdst++ ^= (piQxelXor[1] & 0xFFFF);
 
1275
#endif
 
1276
#if RROP == GXand
 
1277
                  *pdst++ &= piQxelAnd[0];
 
1278
                  *pdst++ &= (piQxelAnd[1] | 0xFFFF0000);
 
1279
#endif
 
1280
#if RROP == GXor
 
1281
                  *pdst++ |= piQxelOr[0];
 
1282
                  *pdst++ |= (piQxelOr[1] & 0xFFFF);
 
1283
#endif
 
1284
#if RROP == GXset
 
1285
                  *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
1286
                  pdst++;
 
1287
                  *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
 
1288
                  pdst++;
 
1289
#endif
 
1290
                  break;
 
1291
                case 3:
 
1292
#if RROP == GXcopy
 
1293
                  *pdst++ = piQxelXor[0];
 
1294
                  *pdst++ = piQxelXor[1];
 
1295
                  *pdst = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 
1296
                  pdst++;
 
1297
#endif
 
1298
#if RROP == GXxor
 
1299
                  *pdst++ ^= piQxelXor[0];
 
1300
                  *pdst++ ^= piQxelXor[1];
 
1301
                  *pdst++ ^= (piQxelXor[2] & 0xFF);
 
1302
#endif
 
1303
#if RROP == GXand
 
1304
                  *pdst++ &= piQxelAnd[0];
 
1305
                  *pdst++ &= piQxelAnd[1];
 
1306
                  *pdst++ &= (piQxelAnd[2] | 0xFFFFFF00);
 
1307
#endif
 
1308
#if RROP == GXor
 
1309
                  *pdst++ |= piQxelOr[0];
 
1310
                  *pdst++ |= piQxelOr[1];
 
1311
                  *pdst++ |= (piQxelOr[2] & 0xFF);
 
1312
#endif
 
1313
#if RROP == GXset
 
1314
                  *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 
1315
                  pdst++;
 
1316
                  *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 
1317
                  pdst++;
 
1318
                  *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 
1319
                  pdst++;
 
1320
#endif
 
1321
                  break;
 
1322
                }
 
1323
        }
 
1324
}
 
1325
#else
 
1326
#if PSZ == 8
 
1327
        if (w <= PGSZB)
 
1328
        {
 
1329
            register char   *addrb;
 
1330
 
 
1331
            addrb = ((char *) pdst) + x;
 
1332
            while (w--)
 
1333
            {
 
1334
                RROP_SOLID (addrb);
 
1335
                addrb++;
 
1336
            }
 
1337
        }
 
1338
#else
 
1339
        if ((x & PIM) + w <= PPW)
 
1340
        {
 
1341
            pdst += x >> PWSH;
 
1342
            maskpartialbits (x, w, startmask);
 
1343
            RROP_SOLID_MASK (pdst, startmask);
 
1344
        }
 
1345
#endif
 
1346
        else
 
1347
        {
 
1348
            pdst += x >> PWSH;
 
1349
            maskbits (x, w, startmask, endmask, nlmiddle);
 
1350
            if (startmask)
 
1351
            {
 
1352
                RROP_SOLID_MASK (pdst, startmask);
 
1353
                ++pdst;
 
1354
            }
 
1355
            
 
1356
            RROP_SPAN(pdst,nlmiddle)
 
1357
            if (endmask)
 
1358
            {
 
1359
                RROP_SOLID_MASK (pdst, endmask);
 
1360
            }
 
1361
        }
 
1362
#endif
 
1363
    }
 
1364
    DEALLOCATE_LOCAL(pptFree);
 
1365
    DEALLOCATE_LOCAL(pwidthFree);
 
1366
    RROP_UNDECLARE
 
1367
}