← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/vnc4/gutsy

« back to all changes in this revision

Viewing changes to unix/xc/programs/Xserver/hw/xfree86/drivers/vmware/bits2pixels.c

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2006-05-15 20:35:17 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060515203517-l4lre1ku942mn26k
Tags: 4.1.1+X4.3.0-10
* Correction of critical security issue. Thanks to Martin Kogler
  <e9925248@student.tuwien.ac.at> that informed me about the issue,
  and provided the patch.
  This flaw was originally found by Steve Wiseman of intelliadmin.com.
* Applied patch from Javier Kohen <jkohen@users.sourceforge.net> that
  inform the user that only 8 first characters of the password will
  actually be used when typing more than 8 characters, closes:
  #355619.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unix/xc/programs/Xserver/hw/xfree86/drivers/vmware/bits2pixels.c
 
1
/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/vmware/bits2pixels.c,v 1.2 2002/12/11 17:07:58 dawes Exp $ */
 
2
/* **********************************************************
 
3
 * Copyright (C) 1999-2001 VMware, Inc.
 
4
 * All Rights Reserved
 
5
 * **********************************************************/
 
6
#ifdef VMX86_DEVEL
 
7
char rcsId_bits2pixels[] = "Id: bits2pixels.c,v 1.6 2001/01/26 23:32:15 yoel Exp $";
 
8
#else
 
9
#define FILECODE "F(814)"
 
10
#endif
 
11
 
 
12
/*
 
13
 * bits2pixels.c --
 
14
 *
 
15
 *      Emulation routines to convert bitmaps to pixmaps
 
16
 */
 
17
 
 
18
#include "vm_basic_types.h"
 
19
#include "bits2pixels.h"
 
20
 
 
21
 
 
22
/*
 
23
 *  Local functions
 
24
 */
 
25
 
 
26
static void RasterBitsToPixels8(uint8 *bits, uint32 bits_increment,
 
27
                         uint8 *pix, uint32 pix_increment,
 
28
                         uint32 width, uint32 height, uint32 fg, uint32 bg);
 
29
 
 
30
static void RasterBitsToPixels16(uint8 *bits, uint32 bits_increment,
 
31
                          uint8 *pix, uint32 pix_increment,
 
32
                          uint32 width, uint32 height, uint32 fg, uint32 bg);
 
33
 
 
34
static void RasterBitsToPixels24(uint8 *bits, uint32 bits_increment,
 
35
                          uint8 *pix, uint32 pix_increment,
 
36
                          uint32 width, uint32 height, uint32 fg, uint32 bg);
 
37
 
 
38
static void RasterBitsToPixels32(uint8 *bits, uint32 bits_increment,
 
39
                          uint8 *pix, uint32 pix_increment,
 
40
                          uint32 width, uint32 height, uint32 fg, uint32 bg);
 
41
 
 
42
 
 
43
/*
 
44
 *----------------------------------------------------------------------
 
45
 *
 
46
 * vmwareRaster_BitsToPixels --
 
47
 *
 
48
 *      Convert a bitmap to a pixmap, converting 1 bits to the foreground
 
49
 *      color (fg) and 0 bits to the background color (bg).
 
50
 *
 
51
 * Results:
 
52
 *      Pixmap filled with pixels
 
53
 *
 
54
 * Side effects:
 
55
 *      None
 
56
 *
 
57
 *----------------------------------------------------------------------
 
58
 */
 
59
 
 
60
void
 
61
vmwareRaster_BitsToPixels(uint8 *bits, uint32 bits_increment,
 
62
                    uint8 *pix, uint32 pix_increment, int bytes_per_pixel,
 
63
                    uint32 width, uint32 height, uint32 fg, uint32 bg)
 
64
{
 
65
   switch (bytes_per_pixel) {
 
66
      case 1:
 
67
         RasterBitsToPixels8(bits, bits_increment, pix, pix_increment,
 
68
                             width, height, fg, bg);
 
69
         break;
 
70
 
 
71
      case 2:
 
72
         RasterBitsToPixels16(bits, bits_increment, pix, pix_increment,
 
73
                              width, height, fg, bg);
 
74
         break;
 
75
 
 
76
      case 3:
 
77
         RasterBitsToPixels24(bits, bits_increment, pix, pix_increment,
 
78
                              width, height, fg, bg);
 
79
         break;
 
80
 
 
81
      case 4:
 
82
         RasterBitsToPixels32(bits, bits_increment, pix, pix_increment,
 
83
                              width, height, fg, bg);
 
84
         break;
 
85
   }
 
86
}
 
87
 
 
88
 
 
89
/*
 
90
 *----------------------------------------------------------------------
 
91
 *
 
92
 * RasterBitsToPixels8 --
 
93
 *
 
94
 *      Convert a bitmap to a pixmap, converting 1 bits to the foreground
 
95
 *      color (fg) and 0 bits to the background color (bg), for an 8-bit
 
96
 *      pixmap
 
97
 *
 
98
 * Results:
 
99
 *      Pixmap filled with pixels
 
100
 *
 
101
 * Side effects:
 
102
 *      None
 
103
 *
 
104
 *----------------------------------------------------------------------
 
105
 */
 
106
 
 
107
void
 
108
RasterBitsToPixels8(uint8 *bits, uint32 bits_increment,
 
109
                    uint8 *pix, uint32 pix_increment,
 
110
                    uint32 width, uint32 height, uint32 fg, uint32 bg)
 
111
{
 
112
   uint8 *lpix, *lbits;
 
113
   int i, j;
 
114
   uint32 expbits = 0;           /* Bits to be expanded */
 
115
 
 
116
   for (i=0; i<height; i++) {
 
117
      lpix = pix;
 
118
      lbits = bits;
 
119
      for (j = width ; j > 0; j -= 4) {
 
120
         expbits = (*lbits >> 4) & 0x0f;
 
121
         
 
122
         if (j < 4)
 
123
            break;
 
124
         
 
125
         switch (expbits) {
 
126
         case 0:
 
127
            *lpix++ = bg;
 
128
            *lpix++ = bg;
 
129
            *lpix++ = bg;
 
130
            *lpix++ = bg;
 
131
            break;
 
132
         case 1:
 
133
            *lpix++ = bg;
 
134
            *lpix++ = bg;
 
135
            *lpix++ = bg;
 
136
            *lpix++ = fg;
 
137
            break;
 
138
         case 2:
 
139
            *lpix++ = bg;
 
140
            *lpix++ = bg;
 
141
            *lpix++ = fg;
 
142
            *lpix++ = bg;
 
143
            break;
 
144
         case 3:
 
145
            *lpix++ = bg;
 
146
            *lpix++ = bg;
 
147
            *lpix++ = fg;
 
148
            *lpix++ = fg;
 
149
            break;
 
150
         case 4:
 
151
            *lpix++ = bg;
 
152
            *lpix++ = fg;
 
153
            *lpix++ = bg;
 
154
            *lpix++ = bg;
 
155
            break;
 
156
         case 5:
 
157
            *lpix++ = bg;
 
158
            *lpix++ = fg;
 
159
            *lpix++ = bg;
 
160
            *lpix++ = fg;
 
161
            break;
 
162
         case 6:
 
163
            *lpix++ = bg;
 
164
            *lpix++ = fg;
 
165
            *lpix++ = fg;
 
166
            *lpix++ = bg;
 
167
            break;
 
168
         case 7:
 
169
            *lpix++ = bg;
 
170
            *lpix++ = fg;
 
171
            *lpix++ = fg;
 
172
            *lpix++ = fg;
 
173
            break;
 
174
         case 8:
 
175
            *lpix++ = fg;
 
176
            *lpix++ = bg;
 
177
            *lpix++ = bg;
 
178
            *lpix++ = bg;
 
179
            break;
 
180
         case 9:
 
181
            *lpix++ = fg;
 
182
            *lpix++ = bg;
 
183
            *lpix++ = bg;
 
184
            *lpix++ = fg;
 
185
            break;
 
186
         case 10:
 
187
            *lpix++ = fg;
 
188
            *lpix++ = bg;
 
189
            *lpix++ = fg;
 
190
            *lpix++ = bg;
 
191
            break;
 
192
         case 11:
 
193
            *lpix++ = fg;
 
194
            *lpix++ = bg;
 
195
            *lpix++ = fg;
 
196
            *lpix++ = fg;
 
197
            break;
 
198
         case 12:
 
199
            *lpix++ = fg;
 
200
            *lpix++ = fg;
 
201
            *lpix++ = bg;
 
202
            *lpix++ = bg;
 
203
            break;
 
204
         case 13:
 
205
            *lpix++ = fg;
 
206
            *lpix++ = fg;
 
207
            *lpix++ = bg;
 
208
            *lpix++ = fg;
 
209
            break;
 
210
         case 14:
 
211
            *lpix++ = fg;
 
212
            *lpix++ = fg;
 
213
            *lpix++ = fg;
 
214
            *lpix++ = bg;
 
215
            break;
 
216
         case 15:
 
217
            *lpix++ = fg;
 
218
            *lpix++ = fg;
 
219
            *lpix++ = fg;
 
220
            *lpix++ = fg;
 
221
            break;
 
222
         }
 
223
 
 
224
         expbits = *lbits & 0x0f;
 
225
 
 
226
         j -= 4;
 
227
         if (j < 4) {
 
228
            break;
 
229
         }
 
230
 
 
231
         switch (expbits) {
 
232
         case 0:
 
233
            *lpix++ = bg;
 
234
            *lpix++ = bg;
 
235
            *lpix++ = bg;
 
236
            *lpix++ = bg;
 
237
            break;
 
238
         case 1:
 
239
            *lpix++ = bg;
 
240
            *lpix++ = bg;
 
241
            *lpix++ = bg;
 
242
            *lpix++ = fg;
 
243
            break;
 
244
         case 2:
 
245
            *lpix++ = bg;
 
246
            *lpix++ = bg;
 
247
            *lpix++ = fg;
 
248
            *lpix++ = bg;
 
249
            break;
 
250
         case 3:
 
251
            *lpix++ = bg;
 
252
            *lpix++ = bg;
 
253
            *lpix++ = fg;
 
254
            *lpix++ = fg;
 
255
            break;
 
256
         case 4:
 
257
            *lpix++ = bg;
 
258
            *lpix++ = fg;
 
259
            *lpix++ = bg;
 
260
            *lpix++ = bg;
 
261
            break;
 
262
         case 5:
 
263
            *lpix++ = bg;
 
264
            *lpix++ = fg;
 
265
            *lpix++ = bg;
 
266
            *lpix++ = fg;
 
267
            break;
 
268
         case 6:
 
269
            *lpix++ = bg;
 
270
            *lpix++ = fg;
 
271
            *lpix++ = fg;
 
272
            *lpix++ = bg;
 
273
            break;
 
274
         case 7:
 
275
            *lpix++ = bg;
 
276
            *lpix++ = fg;
 
277
            *lpix++ = fg;
 
278
            *lpix++ = fg;
 
279
            break;
 
280
         case 8:
 
281
            *lpix++ = fg;
 
282
            *lpix++ = bg;
 
283
            *lpix++ = bg;
 
284
            *lpix++ = bg;
 
285
            break;
 
286
         case 9:
 
287
            *lpix++ = fg;
 
288
            *lpix++ = bg;
 
289
            *lpix++ = bg;
 
290
            *lpix++ = fg;
 
291
            break;
 
292
         case 10:
 
293
            *lpix++ = fg;
 
294
            *lpix++ = bg;
 
295
            *lpix++ = fg;
 
296
            *lpix++ = bg;
 
297
            break;
 
298
         case 11:
 
299
            *lpix++ = fg;
 
300
            *lpix++ = bg;
 
301
            *lpix++ = fg;
 
302
            *lpix++ = fg;
 
303
            break;
 
304
         case 12:
 
305
            *lpix++ = fg;
 
306
            *lpix++ = fg;
 
307
            *lpix++ = bg;
 
308
            *lpix++ = bg;
 
309
            break;
 
310
         case 13:
 
311
            *lpix++ = fg;
 
312
            *lpix++ = fg;
 
313
            *lpix++ = bg;
 
314
            *lpix++ = fg;
 
315
            break;
 
316
         case 14:
 
317
            *lpix++ = fg;
 
318
            *lpix++ = fg;
 
319
            *lpix++ = fg;
 
320
            *lpix++ = bg;
 
321
            break;
 
322
         case 15:
 
323
            *lpix++ = fg;
 
324
            *lpix++ = fg;
 
325
            *lpix++ = fg;
 
326
            *lpix++ = fg;
 
327
            break;
 
328
         }
 
329
         lbits++;
 
330
      }
 
331
 
 
332
      if (j > 0) {
 
333
         *lpix++ = (expbits & 0x08) ? fg : bg;
 
334
         j--;
 
335
         if (j > 0) {
 
336
            *lpix++ = (expbits & 0x04) ? fg : bg;
 
337
            j--;
 
338
            if (j > 0) {
 
339
               *lpix++ = (expbits & 0x02) ? fg : bg;
 
340
               j--;
 
341
            }
 
342
         }
 
343
      }
 
344
 
 
345
      pix += pix_increment;
 
346
      bits += bits_increment;
 
347
   }
 
348
   return;
 
349
}
 
350
 
 
351
 
 
352
/*
 
353
 *----------------------------------------------------------------------
 
354
 *
 
355
 * RasterBitsToPixels16 --
 
356
 *
 
357
 *      Convert a bitmap to a pixmap, converting 1 bits to the foreground
 
358
 *      color (fg) and 0 bits to the background color (bg), for a 16-bit
 
359
 *      pixmap
 
360
 *
 
361
 * Results:
 
362
 *      Pixmap filled with pixels
 
363
 *
 
364
 * Side effects:
 
365
 *      None
 
366
 *
 
367
 *----------------------------------------------------------------------
 
368
 */
 
369
 
 
370
void
 
371
RasterBitsToPixels16(uint8 *bits, uint32 bits_increment,
 
372
                     uint8 *pix, uint32 pix_increment,
 
373
                     uint32 width, uint32 height, uint32 fg, uint32 bg)
 
374
{
 
375
   uint16 *lpix;
 
376
   uint8 *lbits;
 
377
   int i, j;
 
378
   uint32 expbits = 0;           /* Bits to be expanded */
 
379
 
 
380
   for (i=0; i<height; i++) {
 
381
      lpix = (uint16 *)pix;
 
382
      lbits = bits;
 
383
      for (j = width; j > 0; j -= 4) {
 
384
         expbits = (*lbits >> 4) & 0x0f;
 
385
 
 
386
         if (j < 4)
 
387
            break;
 
388
 
 
389
         switch (expbits) {
 
390
         case 0:
 
391
            *lpix++ = bg;
 
392
            *lpix++ = bg;
 
393
            *lpix++ = bg;
 
394
            *lpix++ = bg;
 
395
            break;
 
396
         case 1:
 
397
            *lpix++ = bg;
 
398
            *lpix++ = bg;
 
399
            *lpix++ = bg;
 
400
            *lpix++ = fg;
 
401
            break;
 
402
         case 2:
 
403
            *lpix++ = bg;
 
404
            *lpix++ = bg;
 
405
            *lpix++ = fg;
 
406
            *lpix++ = bg;
 
407
            break;
 
408
         case 3:
 
409
            *lpix++ = bg;
 
410
            *lpix++ = bg;
 
411
            *lpix++ = fg;
 
412
            *lpix++ = fg;
 
413
            break;
 
414
         case 4:
 
415
            *lpix++ = bg;
 
416
            *lpix++ = fg;
 
417
            *lpix++ = bg;
 
418
            *lpix++ = bg;
 
419
            break;
 
420
         case 5:
 
421
            *lpix++ = bg;
 
422
            *lpix++ = fg;
 
423
            *lpix++ = bg;
 
424
            *lpix++ = fg;
 
425
            break;
 
426
         case 6:
 
427
            *lpix++ = bg;
 
428
            *lpix++ = fg;
 
429
            *lpix++ = fg;
 
430
            *lpix++ = bg;
 
431
            break;
 
432
         case 7:
 
433
            *lpix++ = bg;
 
434
            *lpix++ = fg;
 
435
            *lpix++ = fg;
 
436
            *lpix++ = fg;
 
437
            break;
 
438
         case 8:
 
439
            *lpix++ = fg;
 
440
            *lpix++ = bg;
 
441
            *lpix++ = bg;
 
442
            *lpix++ = bg;
 
443
            break;
 
444
         case 9:
 
445
            *lpix++ = fg;
 
446
            *lpix++ = bg;
 
447
            *lpix++ = bg;
 
448
            *lpix++ = fg;
 
449
            break;
 
450
         case 10:
 
451
            *lpix++ = fg;
 
452
            *lpix++ = bg;
 
453
            *lpix++ = fg;
 
454
            *lpix++ = bg;
 
455
            break;
 
456
         case 11:
 
457
            *lpix++ = fg;
 
458
            *lpix++ = bg;
 
459
            *lpix++ = fg;
 
460
            *lpix++ = fg;
 
461
            break;
 
462
         case 12:
 
463
            *lpix++ = fg;
 
464
            *lpix++ = fg;
 
465
            *lpix++ = bg;
 
466
            *lpix++ = bg;
 
467
            break;
 
468
         case 13:
 
469
            *lpix++ = fg;
 
470
            *lpix++ = fg;
 
471
            *lpix++ = bg;
 
472
            *lpix++ = fg;
 
473
            break;
 
474
         case 14:
 
475
            *lpix++ = fg;
 
476
            *lpix++ = fg;
 
477
            *lpix++ = fg;
 
478
            *lpix++ = bg;
 
479
            break;
 
480
         case 15:
 
481
            *lpix++ = fg;
 
482
            *lpix++ = fg;
 
483
            *lpix++ = fg;
 
484
            *lpix++ = fg;
 
485
            break;
 
486
         }
 
487
 
 
488
         expbits = *lbits & 0x0f;
 
489
 
 
490
         j -= 4;
 
491
         if (j < 4) {
 
492
            break;
 
493
         }
 
494
 
 
495
         switch (expbits) {
 
496
         case 0:
 
497
            *lpix++ = bg;
 
498
            *lpix++ = bg;
 
499
            *lpix++ = bg;
 
500
            *lpix++ = bg;
 
501
            break;
 
502
         case 1:
 
503
            *lpix++ = bg;
 
504
            *lpix++ = bg;
 
505
            *lpix++ = bg;
 
506
            *lpix++ = fg;
 
507
            break;
 
508
         case 2:
 
509
            *lpix++ = bg;
 
510
            *lpix++ = bg;
 
511
            *lpix++ = fg;
 
512
            *lpix++ = bg;
 
513
            break;
 
514
         case 3:
 
515
            *lpix++ = bg;
 
516
            *lpix++ = bg;
 
517
            *lpix++ = fg;
 
518
            *lpix++ = fg;
 
519
            break;
 
520
         case 4:
 
521
            *lpix++ = bg;
 
522
            *lpix++ = fg;
 
523
            *lpix++ = bg;
 
524
            *lpix++ = bg;
 
525
            break;
 
526
         case 5:
 
527
            *lpix++ = bg;
 
528
            *lpix++ = fg;
 
529
            *lpix++ = bg;
 
530
            *lpix++ = fg;
 
531
            break;
 
532
         case 6:
 
533
            *lpix++ = bg;
 
534
            *lpix++ = fg;
 
535
            *lpix++ = fg;
 
536
            *lpix++ = bg;
 
537
            break;
 
538
         case 7:
 
539
            *lpix++ = bg;
 
540
            *lpix++ = fg;
 
541
            *lpix++ = fg;
 
542
            *lpix++ = fg;
 
543
            break;
 
544
         case 8:
 
545
            *lpix++ = fg;
 
546
            *lpix++ = bg;
 
547
            *lpix++ = bg;
 
548
            *lpix++ = bg;
 
549
            break;
 
550
         case 9:
 
551
            *lpix++ = fg;
 
552
            *lpix++ = bg;
 
553
            *lpix++ = bg;
 
554
            *lpix++ = fg;
 
555
            break;
 
556
         case 10:
 
557
            *lpix++ = fg;
 
558
            *lpix++ = bg;
 
559
            *lpix++ = fg;
 
560
            *lpix++ = bg;
 
561
            break;
 
562
         case 11:
 
563
            *lpix++ = fg;
 
564
            *lpix++ = bg;
 
565
            *lpix++ = fg;
 
566
            *lpix++ = fg;
 
567
            break;
 
568
         case 12:
 
569
            *lpix++ = fg;
 
570
            *lpix++ = fg;
 
571
            *lpix++ = bg;
 
572
            *lpix++ = bg;
 
573
            break;
 
574
         case 13:
 
575
            *lpix++ = fg;
 
576
            *lpix++ = fg;
 
577
            *lpix++ = bg;
 
578
            *lpix++ = fg;
 
579
            break;
 
580
         case 14:
 
581
            *lpix++ = fg;
 
582
            *lpix++ = fg;
 
583
            *lpix++ = fg;
 
584
            *lpix++ = bg;
 
585
            break;
 
586
         case 15:
 
587
            *lpix++ = fg;
 
588
            *lpix++ = fg;
 
589
            *lpix++ = fg;
 
590
            *lpix++ = fg;
 
591
            break;
 
592
         }
 
593
         lbits++;
 
594
      }
 
595
 
 
596
      if (j > 0) {
 
597
         *lpix++ = (expbits & 0x08) ? fg : bg;
 
598
         j--;
 
599
         if (j > 0) {
 
600
            *lpix++ = (expbits & 0x04) ? fg : bg;
 
601
            j--;
 
602
            if (j > 0) {
 
603
               *lpix++ = (expbits & 0x02) ? fg : bg;
 
604
               j--;
 
605
            }
 
606
         }
 
607
      }
 
608
 
 
609
      pix += pix_increment;
 
610
      bits += bits_increment;
 
611
   }
 
612
   return;
 
613
}
 
614
 
 
615
 
 
616
 
 
617
/*
 
618
 *----------------------------------------------------------------------
 
619
 *
 
620
 * RasterBitsToPixels24 --
 
621
 *
 
622
 *      Convert a bitmap to a pixmap, converting 1 bits to the foreground
 
623
 *      color (fg) and 0 bits to the background color (bg), for a 24-bit
 
624
 *      pixmap
 
625
 *
 
626
 * Results:
 
627
 *      Pixmap filled with pixels
 
628
 *
 
629
 * Side effects:
 
630
 *      None
 
631
 *
 
632
 *----------------------------------------------------------------------
 
633
 */
 
634
 
 
635
void
 
636
RasterBitsToPixels24(uint8 *bits, uint32 bits_increment,
 
637
                     uint8 *pix, uint32 pix_increment,
 
638
                     uint32 width, uint32 height, uint32 fg, uint32 bg)
 
639
{
 
640
   uint8 *lpix, *lbits;
 
641
   uint32 fgColor1, fgColor2, fgColor3;
 
642
   uint32 bgColor1, bgColor2, bgColor3;
 
643
 
 
644
   int i, j;
 
645
   uint32 expbits = 0;           /* Bits to be expanded */
 
646
 
 
647
   fgColor1 = fg & 0x000000ff;
 
648
   fgColor2 = (fg >> 8) & 0x000000ff;
 
649
   fgColor3 = (fg >> 16) & 0x000000ff;
 
650
 
 
651
   bgColor1 = bg & 0x000000ff;
 
652
   bgColor2 = (bg >> 8) & 0x000000ff;
 
653
   bgColor3 = (bg >> 16) & 0x000000ff;
 
654
 
 
655
   for (i=0; i<height; i++) {
 
656
      lpix = pix;
 
657
      lbits = bits;
 
658
      for (j = width; j > 0; j -= 4) {
 
659
         expbits = (*lbits >> 4) & 0x0f;
 
660
 
 
661
         if (j < 4)
 
662
            break;
 
663
 
 
664
         switch (expbits) {
 
665
         case 0:
 
666
            *lpix++ = bgColor1;
 
667
            *lpix++ = bgColor2;
 
668
            *lpix++ = bgColor3;
 
669
            *lpix++ = bgColor1;
 
670
            *lpix++ = bgColor2;
 
671
            *lpix++ = bgColor3;
 
672
            *lpix++ = bgColor1;
 
673
            *lpix++ = bgColor2;
 
674
            *lpix++ = bgColor3;
 
675
            *lpix++ = bgColor1;
 
676
            *lpix++ = bgColor2;
 
677
            *lpix++ = bgColor3;
 
678
            break;
 
679
         case 1:
 
680
            *lpix++ = bgColor1;
 
681
            *lpix++ = bgColor2;
 
682
            *lpix++ = bgColor3;
 
683
            *lpix++ = bgColor1;
 
684
            *lpix++ = bgColor2;
 
685
            *lpix++ = bgColor3;
 
686
            *lpix++ = bgColor1;
 
687
            *lpix++ = bgColor2;
 
688
            *lpix++ = bgColor3;
 
689
            *lpix++ = fgColor1;
 
690
            *lpix++ = fgColor2;
 
691
            *lpix++ = fgColor3;
 
692
            break;
 
693
         case 2:
 
694
            *lpix++ = bgColor1;
 
695
            *lpix++ = bgColor2;
 
696
            *lpix++ = bgColor3;
 
697
            *lpix++ = bgColor1;
 
698
            *lpix++ = bgColor2;
 
699
            *lpix++ = bgColor3;
 
700
            *lpix++ = fgColor1;
 
701
            *lpix++ = fgColor2;
 
702
            *lpix++ = fgColor3;
 
703
            *lpix++ = bgColor1;
 
704
            *lpix++ = bgColor2;
 
705
            *lpix++ = bgColor3;
 
706
            break;
 
707
         case 3:
 
708
            *lpix++ = bgColor1;
 
709
            *lpix++ = bgColor2;
 
710
            *lpix++ = bgColor3;
 
711
            *lpix++ = bgColor1;
 
712
            *lpix++ = bgColor2;
 
713
            *lpix++ = bgColor3;
 
714
            *lpix++ = fgColor1;
 
715
            *lpix++ = fgColor2;
 
716
            *lpix++ = fgColor3;
 
717
            *lpix++ = fgColor1;
 
718
            *lpix++ = fgColor2;
 
719
            *lpix++ = fgColor3;
 
720
            break;
 
721
         case 4:
 
722
            *lpix++ = bgColor1;
 
723
            *lpix++ = bgColor2;
 
724
            *lpix++ = bgColor3;
 
725
            *lpix++ = fgColor1;
 
726
            *lpix++ = fgColor2;
 
727
            *lpix++ = fgColor3;
 
728
            *lpix++ = bgColor1;
 
729
            *lpix++ = bgColor2;
 
730
            *lpix++ = bgColor3;
 
731
            *lpix++ = bgColor1;
 
732
            *lpix++ = bgColor2;
 
733
            *lpix++ = bgColor3;
 
734
            break;
 
735
         case 5:
 
736
            *lpix++ = bgColor1;
 
737
            *lpix++ = bgColor2;
 
738
            *lpix++ = bgColor3;
 
739
            *lpix++ = fgColor1;
 
740
            *lpix++ = fgColor2;
 
741
            *lpix++ = fgColor3;
 
742
            *lpix++ = bgColor1;
 
743
            *lpix++ = bgColor2;
 
744
            *lpix++ = bgColor3;
 
745
            *lpix++ = fgColor1;
 
746
            *lpix++ = fgColor2;
 
747
            *lpix++ = fgColor3;
 
748
            break;
 
749
         case 6:
 
750
            *lpix++ = bgColor1;
 
751
            *lpix++ = bgColor2;
 
752
            *lpix++ = bgColor3;
 
753
            *lpix++ = fgColor1;
 
754
            *lpix++ = fgColor2;
 
755
            *lpix++ = fgColor3;
 
756
            *lpix++ = fgColor1;
 
757
            *lpix++ = fgColor2;
 
758
            *lpix++ = fgColor3;
 
759
            *lpix++ = bgColor1;
 
760
            *lpix++ = bgColor2;
 
761
            *lpix++ = bgColor3;
 
762
            break;
 
763
         case 7:
 
764
            *lpix++ = bgColor1;
 
765
            *lpix++ = bgColor2;
 
766
            *lpix++ = bgColor3;
 
767
            *lpix++ = fgColor1;
 
768
            *lpix++ = fgColor2;
 
769
            *lpix++ = fgColor3;
 
770
            *lpix++ = fgColor1;
 
771
            *lpix++ = fgColor2;
 
772
            *lpix++ = fgColor3;
 
773
            *lpix++ = fgColor1;
 
774
            *lpix++ = fgColor2;
 
775
            *lpix++ = fgColor3;
 
776
            break;
 
777
         case 8:
 
778
            *lpix++ = fgColor1;
 
779
            *lpix++ = fgColor2;
 
780
            *lpix++ = fgColor3;
 
781
            *lpix++ = bgColor1;
 
782
            *lpix++ = bgColor2;
 
783
            *lpix++ = bgColor3;
 
784
            *lpix++ = bgColor1;
 
785
            *lpix++ = bgColor2;
 
786
            *lpix++ = bgColor3;
 
787
            *lpix++ = bgColor1;
 
788
            *lpix++ = bgColor2;
 
789
            *lpix++ = bgColor3;
 
790
            break;
 
791
         case 9:
 
792
            *lpix++ = fgColor1;
 
793
            *lpix++ = fgColor2;
 
794
            *lpix++ = fgColor3;
 
795
            *lpix++ = bgColor1;
 
796
            *lpix++ = bgColor2;
 
797
            *lpix++ = bgColor3;
 
798
            *lpix++ = bgColor1;
 
799
            *lpix++ = bgColor2;
 
800
            *lpix++ = bgColor3;
 
801
            *lpix++ = fgColor1;
 
802
            *lpix++ = fgColor2;
 
803
            *lpix++ = fgColor3;
 
804
            break;
 
805
         case 10:
 
806
            *lpix++ = fgColor1;
 
807
            *lpix++ = fgColor2;
 
808
            *lpix++ = fgColor3;
 
809
            *lpix++ = bgColor1;
 
810
            *lpix++ = bgColor2;
 
811
            *lpix++ = bgColor3;
 
812
            *lpix++ = fgColor1;
 
813
            *lpix++ = fgColor2;
 
814
            *lpix++ = fgColor3;
 
815
            *lpix++ = bgColor1;
 
816
            *lpix++ = bgColor2;
 
817
            *lpix++ = bgColor3;
 
818
            break;
 
819
         case 11:
 
820
            *lpix++ = fgColor1;
 
821
            *lpix++ = fgColor2;
 
822
            *lpix++ = fgColor3;
 
823
            *lpix++ = bgColor1;
 
824
            *lpix++ = bgColor2;
 
825
            *lpix++ = bgColor3;
 
826
            *lpix++ = fgColor1;
 
827
            *lpix++ = fgColor2;
 
828
            *lpix++ = fgColor3;
 
829
            *lpix++ = fgColor1;
 
830
            *lpix++ = fgColor2;
 
831
            *lpix++ = fgColor3;
 
832
            break;
 
833
         case 12:
 
834
            *lpix++ = fgColor1;
 
835
            *lpix++ = fgColor2;
 
836
            *lpix++ = fgColor3;
 
837
            *lpix++ = fgColor1;
 
838
            *lpix++ = fgColor2;
 
839
            *lpix++ = fgColor3;
 
840
            *lpix++ = bgColor1;
 
841
            *lpix++ = bgColor2;
 
842
            *lpix++ = bgColor3;
 
843
            *lpix++ = bgColor1;
 
844
            *lpix++ = bgColor2;
 
845
            *lpix++ = bgColor3;
 
846
            break;
 
847
         case 13:
 
848
            *lpix++ = fgColor1;
 
849
            *lpix++ = fgColor2;
 
850
            *lpix++ = fgColor3;
 
851
            *lpix++ = fgColor1;
 
852
            *lpix++ = fgColor2;
 
853
            *lpix++ = fgColor3;
 
854
            *lpix++ = bgColor1;
 
855
            *lpix++ = bgColor2;
 
856
            *lpix++ = bgColor3;
 
857
            *lpix++ = fgColor1;
 
858
            *lpix++ = fgColor2;
 
859
            *lpix++ = fgColor3;
 
860
            break;
 
861
         case 14:
 
862
            *lpix++ = fgColor1;
 
863
            *lpix++ = fgColor2;
 
864
            *lpix++ = fgColor3;
 
865
            *lpix++ = fgColor1;
 
866
            *lpix++ = fgColor2;
 
867
            *lpix++ = fgColor3;
 
868
            *lpix++ = fgColor1;
 
869
            *lpix++ = fgColor2;
 
870
            *lpix++ = fgColor3;
 
871
            *lpix++ = bgColor1;
 
872
            *lpix++ = bgColor2;
 
873
            *lpix++ = bgColor3;
 
874
            break;
 
875
         case 15:
 
876
            *lpix++ = fgColor1;
 
877
            *lpix++ = fgColor2;
 
878
            *lpix++ = fgColor3;
 
879
            *lpix++ = fgColor1;
 
880
            *lpix++ = fgColor2;
 
881
            *lpix++ = fgColor3;
 
882
            *lpix++ = fgColor1;
 
883
            *lpix++ = fgColor2;
 
884
            *lpix++ = fgColor3;
 
885
            *lpix++ = fgColor1;
 
886
            *lpix++ = fgColor2;
 
887
            *lpix++ = fgColor3;
 
888
            break;
 
889
         }
 
890
 
 
891
         expbits = *lbits & 0x0f;
 
892
 
 
893
         j -= 4;
 
894
         if (j < 4) {
 
895
            break;
 
896
         }
 
897
 
 
898
         switch (expbits) {
 
899
         case 0:
 
900
            *lpix++ = bgColor1;
 
901
            *lpix++ = bgColor2;
 
902
            *lpix++ = bgColor3;
 
903
            *lpix++ = bgColor1;
 
904
            *lpix++ = bgColor2;
 
905
            *lpix++ = bgColor3;
 
906
            *lpix++ = bgColor1;
 
907
            *lpix++ = bgColor2;
 
908
            *lpix++ = bgColor3;
 
909
            *lpix++ = bgColor1;
 
910
            *lpix++ = bgColor2;
 
911
            *lpix++ = bgColor3;
 
912
            break;
 
913
         case 1:
 
914
            *lpix++ = bgColor1;
 
915
            *lpix++ = bgColor2;
 
916
            *lpix++ = bgColor3;
 
917
            *lpix++ = bgColor1;
 
918
            *lpix++ = bgColor2;
 
919
            *lpix++ = bgColor3;
 
920
            *lpix++ = bgColor1;
 
921
            *lpix++ = bgColor2;
 
922
            *lpix++ = bgColor3;
 
923
            *lpix++ = fgColor1;
 
924
            *lpix++ = fgColor2;
 
925
            *lpix++ = fgColor3;
 
926
            break;
 
927
         case 2:
 
928
            *lpix++ = bgColor1;
 
929
            *lpix++ = bgColor2;
 
930
            *lpix++ = bgColor3;
 
931
            *lpix++ = bgColor1;
 
932
            *lpix++ = bgColor2;
 
933
            *lpix++ = bgColor3;
 
934
            *lpix++ = fgColor1;
 
935
            *lpix++ = fgColor2;
 
936
            *lpix++ = fgColor3;
 
937
            *lpix++ = bgColor1;
 
938
            *lpix++ = bgColor2;
 
939
            *lpix++ = bgColor3;
 
940
            break;
 
941
         case 3:
 
942
            *lpix++ = bgColor1;
 
943
            *lpix++ = bgColor2;
 
944
            *lpix++ = bgColor3;
 
945
            *lpix++ = bgColor1;
 
946
            *lpix++ = bgColor2;
 
947
            *lpix++ = bgColor3;
 
948
            *lpix++ = fgColor1;
 
949
            *lpix++ = fgColor2;
 
950
            *lpix++ = fgColor3;
 
951
            *lpix++ = fgColor1;
 
952
            *lpix++ = fgColor2;
 
953
            *lpix++ = fgColor3;
 
954
            break;
 
955
         case 4:
 
956
            *lpix++ = bgColor1;
 
957
            *lpix++ = bgColor2;
 
958
            *lpix++ = bgColor3;
 
959
            *lpix++ = fgColor1;
 
960
            *lpix++ = fgColor2;
 
961
            *lpix++ = fgColor3;
 
962
            *lpix++ = bgColor1;
 
963
            *lpix++ = bgColor2;
 
964
            *lpix++ = bgColor3;
 
965
            *lpix++ = bgColor1;
 
966
            *lpix++ = bgColor2;
 
967
            *lpix++ = bgColor3;
 
968
            break;
 
969
         case 5:
 
970
            *lpix++ = bgColor1;
 
971
            *lpix++ = bgColor2;
 
972
            *lpix++ = bgColor3;
 
973
            *lpix++ = fgColor1;
 
974
            *lpix++ = fgColor2;
 
975
            *lpix++ = fgColor3;
 
976
            *lpix++ = bgColor1;
 
977
            *lpix++ = bgColor2;
 
978
            *lpix++ = bgColor3;
 
979
            *lpix++ = fgColor1;
 
980
            *lpix++ = fgColor2;
 
981
            *lpix++ = fgColor3;
 
982
            break;
 
983
         case 6:
 
984
            *lpix++ = bgColor1;
 
985
            *lpix++ = bgColor2;
 
986
            *lpix++ = bgColor3;
 
987
            *lpix++ = fgColor1;
 
988
            *lpix++ = fgColor2;
 
989
            *lpix++ = fgColor3;
 
990
            *lpix++ = fgColor1;
 
991
            *lpix++ = fgColor2;
 
992
            *lpix++ = fgColor3;
 
993
            *lpix++ = bgColor1;
 
994
            *lpix++ = bgColor2;
 
995
            *lpix++ = bgColor3;
 
996
            break;
 
997
         case 7:
 
998
            *lpix++ = bgColor1;
 
999
            *lpix++ = bgColor2;
 
1000
            *lpix++ = bgColor3;
 
1001
            *lpix++ = fgColor1;
 
1002
            *lpix++ = fgColor2;
 
1003
            *lpix++ = fgColor3;
 
1004
            *lpix++ = fgColor1;
 
1005
            *lpix++ = fgColor2;
 
1006
            *lpix++ = fgColor3;
 
1007
            *lpix++ = fgColor1;
 
1008
            *lpix++ = fgColor2;
 
1009
            *lpix++ = fgColor3;
 
1010
            break;
 
1011
         case 8:
 
1012
            *lpix++ = fgColor1;
 
1013
            *lpix++ = fgColor2;
 
1014
            *lpix++ = fgColor3;
 
1015
            *lpix++ = bgColor1;
 
1016
            *lpix++ = bgColor2;
 
1017
            *lpix++ = bgColor3;
 
1018
            *lpix++ = bgColor1;
 
1019
            *lpix++ = bgColor2;
 
1020
            *lpix++ = bgColor3;
 
1021
            *lpix++ = bgColor1;
 
1022
            *lpix++ = bgColor2;
 
1023
            *lpix++ = bgColor3;
 
1024
            break;
 
1025
         case 9:
 
1026
            *lpix++ = fgColor1;
 
1027
            *lpix++ = fgColor2;
 
1028
            *lpix++ = fgColor3;
 
1029
            *lpix++ = bgColor1;
 
1030
            *lpix++ = bgColor2;
 
1031
            *lpix++ = bgColor3;
 
1032
            *lpix++ = bgColor1;
 
1033
            *lpix++ = bgColor2;
 
1034
            *lpix++ = bgColor3;
 
1035
            *lpix++ = fgColor1;
 
1036
            *lpix++ = fgColor2;
 
1037
            *lpix++ = fgColor3;
 
1038
            break;
 
1039
         case 10:
 
1040
            *lpix++ = fgColor1;
 
1041
            *lpix++ = fgColor2;
 
1042
            *lpix++ = fgColor3;
 
1043
            *lpix++ = bgColor1;
 
1044
            *lpix++ = bgColor2;
 
1045
            *lpix++ = bgColor3;
 
1046
            *lpix++ = fgColor1;
 
1047
            *lpix++ = fgColor2;
 
1048
            *lpix++ = fgColor3;
 
1049
            *lpix++ = bgColor1;
 
1050
            *lpix++ = bgColor2;
 
1051
            *lpix++ = bgColor3;
 
1052
            break;
 
1053
         case 11:
 
1054
            *lpix++ = fgColor1;
 
1055
            *lpix++ = fgColor2;
 
1056
            *lpix++ = fgColor3;
 
1057
            *lpix++ = bgColor1;
 
1058
            *lpix++ = bgColor2;
 
1059
            *lpix++ = bgColor3;
 
1060
            *lpix++ = fgColor1;
 
1061
            *lpix++ = fgColor2;
 
1062
            *lpix++ = fgColor3;
 
1063
            *lpix++ = fgColor1;
 
1064
            *lpix++ = fgColor2;
 
1065
            *lpix++ = fgColor3;
 
1066
            break;
 
1067
         case 12:
 
1068
            *lpix++ = fgColor1;
 
1069
            *lpix++ = fgColor2;
 
1070
            *lpix++ = fgColor3;
 
1071
            *lpix++ = fgColor1;
 
1072
            *lpix++ = fgColor2;
 
1073
            *lpix++ = fgColor3;
 
1074
            *lpix++ = bgColor1;
 
1075
            *lpix++ = bgColor2;
 
1076
            *lpix++ = bgColor3;
 
1077
            *lpix++ = bgColor1;
 
1078
            *lpix++ = bgColor2;
 
1079
            *lpix++ = bgColor3;
 
1080
            break;
 
1081
         case 13:
 
1082
            *lpix++ = fgColor1;
 
1083
            *lpix++ = fgColor2;
 
1084
            *lpix++ = fgColor3;
 
1085
            *lpix++ = fgColor1;
 
1086
            *lpix++ = fgColor2;
 
1087
            *lpix++ = fgColor3;
 
1088
            *lpix++ = bgColor1;
 
1089
            *lpix++ = bgColor2;
 
1090
            *lpix++ = bgColor3;
 
1091
            *lpix++ = fgColor1;
 
1092
            *lpix++ = fgColor2;
 
1093
            *lpix++ = fgColor3;
 
1094
            break;
 
1095
         case 14:
 
1096
            *lpix++ = fgColor1;
 
1097
            *lpix++ = fgColor2;
 
1098
            *lpix++ = fgColor3;
 
1099
            *lpix++ = fgColor1;
 
1100
            *lpix++ = fgColor2;
 
1101
            *lpix++ = fgColor3;
 
1102
            *lpix++ = fgColor1;
 
1103
            *lpix++ = fgColor2;
 
1104
            *lpix++ = fgColor3;
 
1105
            *lpix++ = bgColor1;
 
1106
            *lpix++ = bgColor2;
 
1107
            *lpix++ = bgColor3;
 
1108
            break;
 
1109
         case 15:
 
1110
            *lpix++ = fgColor1;
 
1111
            *lpix++ = fgColor2;
 
1112
            *lpix++ = fgColor3;
 
1113
            *lpix++ = fgColor1;
 
1114
            *lpix++ = fgColor2;
 
1115
            *lpix++ = fgColor3;
 
1116
            *lpix++ = fgColor1;
 
1117
            *lpix++ = fgColor2;
 
1118
            *lpix++ = fgColor3;
 
1119
            *lpix++ = fgColor1;
 
1120
            *lpix++ = fgColor2;
 
1121
            *lpix++ = fgColor3;
 
1122
            break;
 
1123
         }
 
1124
         lbits++;
 
1125
      }
 
1126
 
 
1127
      if (j > 0) {
 
1128
         *lpix++ = (expbits & 0x08) ? fgColor1 : bgColor1;
 
1129
         *lpix++ = (expbits & 0x08) ? fgColor2 : bgColor2;
 
1130
         *lpix++ = (expbits & 0x08) ? fgColor3 : bgColor3;
 
1131
         j--;
 
1132
         if (j > 0) {
 
1133
            *lpix++ = (expbits & 0x04) ? fgColor1 : bgColor1;
 
1134
            *lpix++ = (expbits & 0x04) ? fgColor2 : bgColor2;
 
1135
            *lpix++ = (expbits & 0x04) ? fgColor3 : bgColor3;
 
1136
            j--;
 
1137
            if (j > 0) {
 
1138
               *lpix++ = (expbits & 0x02) ? fgColor1 : bgColor1;
 
1139
               *lpix++ = (expbits & 0x02) ? fgColor2 : bgColor2;
 
1140
               *lpix++ = (expbits & 0x02) ? fgColor3 : bgColor3;
 
1141
               j--;
 
1142
            }
 
1143
         }
 
1144
      }
 
1145
 
 
1146
      pix += pix_increment;
 
1147
      bits += bits_increment;
 
1148
   }
 
1149
   return;
 
1150
}
 
1151
 
 
1152
 
 
1153
 
 
1154
/*
 
1155
 *----------------------------------------------------------------------
 
1156
 *
 
1157
 * RasterBitsToPixels32 --
 
1158
 *
 
1159
 *      Convert a bitmap to a pixmap, converting 1 bits to the foreground
 
1160
 *      color (fg) and 0 bits to the background color (bg), for a 32-bit
 
1161
 *      pixmap
 
1162
 *
 
1163
 * Results:
 
1164
 *      Pixmap filled with pixels
 
1165
 *
 
1166
 * Side effects:
 
1167
 *      None
 
1168
 *
 
1169
 *----------------------------------------------------------------------
 
1170
 */
 
1171
 
 
1172
void
 
1173
RasterBitsToPixels32(uint8 *bits, uint32 bits_increment,
 
1174
                     uint8 *pix, uint32 pix_increment,
 
1175
                     uint32 width, uint32 height, uint32 fg, uint32 bg)
 
1176
{
 
1177
   uint32 *lpix;
 
1178
   uint8 *lbits;
 
1179
   int i, j;
 
1180
   uint32 expbits = 0;           /* Bits to be expanded */
 
1181
 
 
1182
   for (i=0; i<height; i++) {
 
1183
      lpix = (uint32 *)pix;
 
1184
      lbits = bits;
 
1185
      for (j = width; j > 0; j -= 4) {
 
1186
         expbits = (*lbits >> 4) & 0x0f;
 
1187
         
 
1188
         if (j < 4)
 
1189
            break;
 
1190
 
 
1191
         switch (expbits) {
 
1192
         case 0:
 
1193
            *lpix++ = bg;
 
1194
            *lpix++ = bg;
 
1195
            *lpix++ = bg;
 
1196
            *lpix++ = bg;
 
1197
            break;
 
1198
         case 1:
 
1199
            *lpix++ = bg;
 
1200
            *lpix++ = bg;
 
1201
            *lpix++ = bg;
 
1202
            *lpix++ = fg;
 
1203
            break;
 
1204
         case 2:
 
1205
            *lpix++ = bg;
 
1206
            *lpix++ = bg;
 
1207
            *lpix++ = fg;
 
1208
            *lpix++ = bg;
 
1209
            break;
 
1210
         case 3:
 
1211
            *lpix++ = bg;
 
1212
            *lpix++ = bg;
 
1213
            *lpix++ = fg;
 
1214
            *lpix++ = fg;
 
1215
            break;
 
1216
         case 4:
 
1217
            *lpix++ = bg;
 
1218
            *lpix++ = fg;
 
1219
            *lpix++ = bg;
 
1220
            *lpix++ = bg;
 
1221
            break;
 
1222
         case 5:
 
1223
            *lpix++ = bg;
 
1224
            *lpix++ = fg;
 
1225
            *lpix++ = bg;
 
1226
            *lpix++ = fg;
 
1227
            break;
 
1228
         case 6:
 
1229
            *lpix++ = bg;
 
1230
            *lpix++ = fg;
 
1231
            *lpix++ = fg;
 
1232
            *lpix++ = bg;
 
1233
            break;
 
1234
         case 7:
 
1235
            *lpix++ = bg;
 
1236
            *lpix++ = fg;
 
1237
            *lpix++ = fg;
 
1238
            *lpix++ = fg;
 
1239
            break;
 
1240
         case 8:
 
1241
            *lpix++ = fg;
 
1242
            *lpix++ = bg;
 
1243
            *lpix++ = bg;
 
1244
            *lpix++ = bg;
 
1245
            break;
 
1246
         case 9:
 
1247
            *lpix++ = fg;
 
1248
            *lpix++ = bg;
 
1249
            *lpix++ = bg;
 
1250
            *lpix++ = fg;
 
1251
            break;
 
1252
         case 10:
 
1253
            *lpix++ = fg;
 
1254
            *lpix++ = bg;
 
1255
            *lpix++ = fg;
 
1256
            *lpix++ = bg;
 
1257
            break;
 
1258
         case 11:
 
1259
            *lpix++ = fg;
 
1260
            *lpix++ = bg;
 
1261
            *lpix++ = fg;
 
1262
            *lpix++ = fg;
 
1263
            break;
 
1264
         case 12:
 
1265
            *lpix++ = fg;
 
1266
            *lpix++ = fg;
 
1267
            *lpix++ = bg;
 
1268
            *lpix++ = bg;
 
1269
            break;
 
1270
         case 13:
 
1271
            *lpix++ = fg;
 
1272
            *lpix++ = fg;
 
1273
            *lpix++ = bg;
 
1274
            *lpix++ = fg;
 
1275
            break;
 
1276
         case 14:
 
1277
            *lpix++ = fg;
 
1278
            *lpix++ = fg;
 
1279
            *lpix++ = fg;
 
1280
            *lpix++ = bg;
 
1281
            break;
 
1282
         case 15:
 
1283
            *lpix++ = fg;
 
1284
            *lpix++ = fg;
 
1285
            *lpix++ = fg;
 
1286
            *lpix++ = fg;
 
1287
            break;
 
1288
         }
 
1289
 
 
1290
         expbits = *lbits & 0x0f;
 
1291
 
 
1292
         j -= 4;
 
1293
         if (j < 4) {
 
1294
            break;
 
1295
         }
 
1296
 
 
1297
         switch (expbits) {
 
1298
         case 0:
 
1299
            *lpix++ = bg;
 
1300
            *lpix++ = bg;
 
1301
            *lpix++ = bg;
 
1302
            *lpix++ = bg;
 
1303
            break;
 
1304
         case 1:
 
1305
            *lpix++ = bg;
 
1306
            *lpix++ = bg;
 
1307
            *lpix++ = bg;
 
1308
            *lpix++ = fg;
 
1309
            break;
 
1310
         case 2:
 
1311
            *lpix++ = bg;
 
1312
            *lpix++ = bg;
 
1313
            *lpix++ = fg;
 
1314
            *lpix++ = bg;
 
1315
            break;
 
1316
         case 3:
 
1317
            *lpix++ = bg;
 
1318
            *lpix++ = bg;
 
1319
            *lpix++ = fg;
 
1320
            *lpix++ = fg;
 
1321
            break;
 
1322
         case 4:
 
1323
            *lpix++ = bg;
 
1324
            *lpix++ = fg;
 
1325
            *lpix++ = bg;
 
1326
            *lpix++ = bg;
 
1327
            break;
 
1328
         case 5:
 
1329
            *lpix++ = bg;
 
1330
            *lpix++ = fg;
 
1331
            *lpix++ = bg;
 
1332
            *lpix++ = fg;
 
1333
            break;
 
1334
         case 6:
 
1335
            *lpix++ = bg;
 
1336
            *lpix++ = fg;
 
1337
            *lpix++ = fg;
 
1338
            *lpix++ = bg;
 
1339
            break;
 
1340
         case 7:
 
1341
            *lpix++ = bg;
 
1342
            *lpix++ = fg;
 
1343
            *lpix++ = fg;
 
1344
            *lpix++ = fg;
 
1345
            break;
 
1346
         case 8:
 
1347
            *lpix++ = fg;
 
1348
            *lpix++ = bg;
 
1349
            *lpix++ = bg;
 
1350
            *lpix++ = bg;
 
1351
            break;
 
1352
         case 9:
 
1353
            *lpix++ = fg;
 
1354
            *lpix++ = bg;
 
1355
            *lpix++ = bg;
 
1356
            *lpix++ = fg;
 
1357
            break;
 
1358
         case 10:
 
1359
            *lpix++ = fg;
 
1360
            *lpix++ = bg;
 
1361
            *lpix++ = fg;
 
1362
            *lpix++ = bg;
 
1363
            break;
 
1364
         case 11:
 
1365
            *lpix++ = fg;
 
1366
            *lpix++ = bg;
 
1367
            *lpix++ = fg;
 
1368
            *lpix++ = fg;
 
1369
            break;
 
1370
         case 12:
 
1371
            *lpix++ = fg;
 
1372
            *lpix++ = fg;
 
1373
            *lpix++ = bg;
 
1374
            *lpix++ = bg;
 
1375
            break;
 
1376
         case 13:
 
1377
            *lpix++ = fg;
 
1378
            *lpix++ = fg;
 
1379
            *lpix++ = bg;
 
1380
            *lpix++ = fg;
 
1381
            break;
 
1382
         case 14:
 
1383
            *lpix++ = fg;
 
1384
            *lpix++ = fg;
 
1385
            *lpix++ = fg;
 
1386
            *lpix++ = bg;
 
1387
            break;
 
1388
         case 15:
 
1389
            *lpix++ = fg;
 
1390
            *lpix++ = fg;
 
1391
            *lpix++ = fg;
 
1392
            *lpix++ = fg;
 
1393
            break;
 
1394
         }
 
1395
         lbits++;
 
1396
      }
 
1397
 
 
1398
      if (j > 0) {
 
1399
         *lpix++ = (expbits & 0x08) ? fg : bg;
 
1400
         j--;
 
1401
         if (j > 0) {
 
1402
            *lpix++ = (expbits & 0x04) ? fg : bg;
 
1403
            j--;
 
1404
            if (j > 0) {
 
1405
               *lpix++ = (expbits & 0x02) ? fg : bg;
 
1406
               j--;
 
1407
            }
 
1408
         }
 
1409
      }
 
1410
 
 
1411
      pix += pix_increment;
 
1412
      bits += bits_increment;
 
1413
   }
 
1414
   return;
 
1415
}