ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/utils/cfhq2xa.C
Revision: 1.3
Committed: Sun Jul 1 05:00:21 2007 UTC (16 years, 11 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.2: +11 -12 lines
Log Message: 
- upgrade crossfire trt to the GPL version 3 (hopefully correctly).
- add a single file covered by the GNU Affero General Public License
  (which is not yet released, so I used the current draft, which is
  legally a bit wavy, but its likely better than nothing as it expresses
  direct intent by the authors, and we can upgrade as soon as it has been
  released).
  * this should ensure availability of source code for the server at least
    and hopefully also archetypes and maps even when modified versions
    are not being distributed, in accordance of section 13 of the agplv3.

File Contents

# User Rev Content
1 root 1.2 /*
2 root 1.3 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3 root 1.2 *
4     * Copyright (©) 2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5     * Copyright (©) 2003,2007 MaxSt <maxst@hiend3d.com>
6     *
7 root 1.3 * Crossfire TRT is free software: you can redistribute it and/or modify
8     * it under the terms of the GNU General Public License as published by
9     * the Free Software Foundation, either version 3 of the License, or
10     * (at your option) any later version.
11 root 1.2 *
12 root 1.3 * This program is distributed in the hope that it will be useful,
13     * but WITHOUT ANY WARRANTY; without even the implied warranty of
14     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15     * GNU General Public License for more details.
16 root 1.2 *
17 root 1.3 * You should have received a copy of the GNU General Public License
18     * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 root 1.2 *
20     * The authors can be reached via e-mail to <crossfire@schmorp.de>
21     */
22    
23     // note: the original code was released under the LGPL version 2.1
24 root 1.1
25     #include <cstdio>
26     #include <cstring>
27     #include <stdlib.h>
28     #include <stdint.h>
29     #include <endian.h>
30    
31     using namespace std;
32    
33     #if __BYTE_ORDER == __BIG_ENDIAN
34     # define Rshift 24
35     # define Gshift 16
36     # define Bshift 8
37     # define Ashift 0
38     #else
39     # define Rshift 0
40     # define Gshift 8
41     # define Bshift 16
42     # define Ashift 24
43     #endif
44    
45     #define Cmask 0xffUL
46     #define Amask (Cmask << Ashift)
47    
48     typedef uint32_t pixel;
49    
50     // hq2xa
51    
52     # define trY 0x30
53     # define trU 0x11
54     # define trV 0x10
55     # define trA 0x40
56    
57     static inline pixel lerp (pixel c1, int w1, pixel c2, int w2, pixel c3, int w3, int shift)
58     {
59     #if 0
60     if (!(c1 >> Ashift) & Cmask) w1 = 0;
61     if (!(c2 >> Ashift) & Cmask) w2 = 0;
62     if (!(c3 >> Ashift) & Cmask) w3 = 0;
63     #endif
64    
65     int w = w1 + w2 + w3;
66    
67     return ((((c1 >> shift) & Cmask) * w1 + ((c2 >> shift) & Cmask) * w2 + ((c3 >> shift) & Cmask) * w3 + w / 2) / w) << shift;
68     }
69    
70     inline void lerp (unsigned char *pc, pixel c1, int w1, pixel c2, int w2, pixel c3 = 0, int w3 = 0)
71     {
72     *(pixel *)pc = lerp (c1, w1, c2, w2, c3, w3, Rshift)
73     | lerp (c1, w1, c2, w2, c3, w3, Gshift)
74     | lerp (c1, w1, c2, w2, c3, w3, Bshift)
75     | lerp (c1, w1, c2, w2, c3, w3, Ashift);
76     }
77    
78     inline void Interp1 (unsigned char *pc, pixel c1, pixel c2)
79     {
80     lerp (pc, c1, 3, c2, 1);
81     }
82    
83     inline void Interp2 (unsigned char *pc, pixel c1, pixel c2, pixel c3)
84     {
85     lerp (pc, c1, 2, c2, 1, c3, 1);
86     }
87    
88     inline void Interp5 (unsigned char *pc, pixel c1, pixel c2)
89     {
90     lerp (pc, c1, 1, c2, 1);
91     }
92    
93     inline void Interp6 (unsigned char *pc, pixel c1, pixel c2, pixel c3)
94     {
95     lerp (pc, c1, 5, c2, 2, c3, 1);
96     }
97    
98     inline void Interp7 (unsigned char *pc, pixel c1, pixel c2, pixel c3)
99     {
100     lerp (pc, c1, 6, c2, 1, c3, 1);
101     }
102    
103     inline void Interp9 (unsigned char *pc, pixel c1, pixel c2, pixel c3)
104     {
105     lerp (pc, c1, 2, c2, 3, c2, 3);
106     }
107    
108     inline void Interp10 (unsigned char *pc, pixel c1, pixel c2, pixel c3)
109     {
110     lerp (pc, c1, 14, c2, 1, c3, 1);
111     }
112    
113     #define PIXEL00_0 *((pixel *)(pOut)) = w[5];
114     #define PIXEL00_10 Interp1(pOut, w[5], w[1]);
115     #define PIXEL00_11 Interp1(pOut, w[5], w[4]);
116     #define PIXEL00_12 Interp1(pOut, w[5], w[2]);
117     #define PIXEL00_20 Interp2(pOut, w[5], w[4], w[2]);
118     #define PIXEL00_21 Interp2(pOut, w[5], w[1], w[2]);
119     #define PIXEL00_22 Interp2(pOut, w[5], w[1], w[4]);
120     #define PIXEL00_60 Interp6(pOut, w[5], w[2], w[4]);
121     #define PIXEL00_61 Interp6(pOut, w[5], w[4], w[2]);
122     #define PIXEL00_70 Interp7(pOut, w[5], w[4], w[2]);
123     #define PIXEL00_90 Interp9(pOut, w[5], w[4], w[2]);
124     #define PIXEL00_100 Interp10(pOut, w[5], w[4], w[2]);
125     #define PIXEL01_0 *((pixel *)(pOut + sizeof (pixel))) = w[5];
126     #define PIXEL01_10 Interp1(pOut + sizeof (pixel), w[5], w[3]);
127     #define PIXEL01_11 Interp1(pOut + sizeof (pixel), w[5], w[2]);
128     #define PIXEL01_12 Interp1(pOut + sizeof (pixel), w[5], w[6]);
129     #define PIXEL01_20 Interp2(pOut + sizeof (pixel), w[5], w[2], w[6]);
130     #define PIXEL01_21 Interp2(pOut + sizeof (pixel), w[5], w[3], w[6]);
131     #define PIXEL01_22 Interp2(pOut + sizeof (pixel), w[5], w[3], w[2]);
132     #define PIXEL01_60 Interp6(pOut + sizeof (pixel), w[5], w[6], w[2]);
133     #define PIXEL01_61 Interp6(pOut + sizeof (pixel), w[5], w[2], w[6]);
134     #define PIXEL01_70 Interp7(pOut + sizeof (pixel), w[5], w[2], w[6]);
135     #define PIXEL01_90 Interp9(pOut + sizeof (pixel), w[5], w[2], w[6]);
136     #define PIXEL01_100 Interp10(pOut + sizeof (pixel), w[5], w[2], w[6]);
137     #define PIXEL10_0 *((pixel *)(pOut+BpL)) = w[5];
138     #define PIXEL10_10 Interp1(pOut+BpL, w[5], w[7]);
139     #define PIXEL10_11 Interp1(pOut+BpL, w[5], w[8]);
140     #define PIXEL10_12 Interp1(pOut+BpL, w[5], w[4]);
141     #define PIXEL10_20 Interp2(pOut+BpL, w[5], w[8], w[4]);
142     #define PIXEL10_21 Interp2(pOut+BpL, w[5], w[7], w[4]);
143     #define PIXEL10_22 Interp2(pOut+BpL, w[5], w[7], w[8]);
144     #define PIXEL10_60 Interp6(pOut+BpL, w[5], w[4], w[8]);
145     #define PIXEL10_61 Interp6(pOut+BpL, w[5], w[8], w[4]);
146     #define PIXEL10_70 Interp7(pOut+BpL, w[5], w[8], w[4]);
147     #define PIXEL10_90 Interp9(pOut+BpL, w[5], w[8], w[4]);
148     #define PIXEL10_100 Interp10(pOut+BpL, w[5], w[8], w[4]);
149     #define PIXEL11_0 *((pixel *)(pOut+BpL + sizeof (pixel))) = w[5];
150     #define PIXEL11_10 Interp1(pOut+BpL + sizeof (pixel), w[5], w[9]);
151     #define PIXEL11_11 Interp1(pOut+BpL + sizeof (pixel), w[5], w[6]);
152     #define PIXEL11_12 Interp1(pOut+BpL + sizeof (pixel), w[5], w[8]);
153     #define PIXEL11_20 Interp2(pOut+BpL + sizeof (pixel), w[5], w[6], w[8]);
154     #define PIXEL11_21 Interp2(pOut+BpL + sizeof (pixel), w[5], w[9], w[8]);
155     #define PIXEL11_22 Interp2(pOut+BpL + sizeof (pixel), w[5], w[9], w[6]);
156     #define PIXEL11_60 Interp6(pOut+BpL + sizeof (pixel), w[5], w[8], w[6]);
157     #define PIXEL11_61 Interp6(pOut+BpL + sizeof (pixel), w[5], w[6], w[8]);
158     #define PIXEL11_70 Interp7(pOut+BpL + sizeof (pixel), w[5], w[6], w[8]);
159     #define PIXEL11_90 Interp9(pOut+BpL + sizeof (pixel), w[5], w[6], w[8]);
160     #define PIXEL11_100 Interp10(pOut+BpL + sizeof (pixel), w[5], w[6], w[8]);
161    
162     inline pixel RGBAtoYUVA (pixel w)
163     {
164     int r = (w >> Rshift) & Cmask;
165     int g = (w >> Gshift) & Cmask;
166     int b = (w >> Bshift) & Cmask;
167     int a = (w >> Ashift) & Cmask;
168    
169     int Y = (r + g + b) / 4;
170     int u = 128 + (r - b) / 4;
171     int v = 128 + (2 * g - r - b) / 8;
172    
173     return (Y << Rshift)
174     | (u << Gshift)
175     | (v << Bshift)
176     | (a << Ashift);
177     }
178    
179     inline bool Diff (pixel w1, pixel w2)
180     {
181     pixel YUV1 = RGBAtoYUVA (w1);
182     pixel YUV2 = RGBAtoYUVA (w2);
183    
184     return ((abs (((YUV1 >> Rshift) & Cmask) - ((YUV2 >> Rshift) & Cmask)) > trY) ||
185     (abs (((YUV1 >> Gshift) & Cmask) - ((YUV2 >> Gshift) & Cmask)) > trU) ||
186     (abs (((YUV1 >> Bshift) & Cmask) - ((YUV2 >> Bshift) & Cmask)) > trV) ||
187     (abs (((YUV1 >> Ashift) & Cmask) - ((YUV2 >> Ashift) & Cmask)) > trA) );
188     }
189    
190     void
191     hq2x_32 (unsigned char *pIn, unsigned char *pOut, int Xres, int Yres, int BpL, bool wrap)
192     {
193     int i, j, k;
194     int prevline, nextline;
195     pixel w[10];
196    
197     // +----+----+----+
198     // | | | |
199     // | w1 | w2 | w3 |
200     // +----+----+----+
201     // | | | |
202     // | w4 | w5 | w6 |
203     // +----+----+----+
204     // | | | |
205     // | w7 | w8 | w9 |
206     // +----+----+----+
207    
208     for (j = 0; j < Yres; j++)
209     {
210     if (j > 0)
211     prevline = -Xres * sizeof (pixel);
212     else
213     prevline = wrap ? -(Yres - 1) * Xres * sizeof (pixel) : 0;
214    
215     if (j < Yres - 1)
216     nextline = Xres * sizeof (pixel);
217     else
218     nextline = wrap ? -(Yres - 1) * Xres * sizeof (pixel) : 0;
219    
220     for (i = 0; i < Xres; i++)
221     {
222     w[2] = *((pixel *) (pIn + prevline));
223     w[5] = *((pixel *) pIn);
224     w[8] = *((pixel *) (pIn + nextline));
225    
226     if (i > 0)
227     {
228     w[1] = *((pixel *) (pIn + prevline - sizeof (pixel)));
229     w[4] = *((pixel *) (pIn - sizeof (pixel)));
230     w[7] = *((pixel *) (pIn + nextline - sizeof (pixel)));
231     }
232     else if (wrap)
233     {
234     w[1] = *((pixel *) (pIn + prevline + (Xres - 1) * sizeof (pixel)));
235     w[4] = *((pixel *) (pIn + (Xres - 1) * sizeof (pixel)));
236     w[7] = *((pixel *) (pIn + nextline + (Xres - 1) * sizeof (pixel)));
237     }
238     else
239     {
240     w[1] = w[2];
241     w[4] = w[5];
242     w[7] = w[8];
243     }
244    
245     if (i < Xres - 1)
246     {
247     w[3] = *((pixel *) (pIn + prevline + sizeof (pixel)));
248     w[6] = *((pixel *) (pIn + sizeof (pixel)));
249     w[9] = *((pixel *) (pIn + nextline + sizeof (pixel)));
250     }
251     else
252     {
253     w[3] = w[2];
254     w[6] = w[5];
255     w[9] = w[8];
256     }
257    
258     int pattern = 0;
259     int flag = 1;
260    
261     for (k = 1; k <= 9; k++)
262     {
263     if (k == 5)
264     continue;
265    
266     if (Diff (w[5], w[k]))
267     pattern |= flag;
268    
269     flag <<= 1;
270     }
271    
272     switch (pattern)
273     {
274     case 0:
275     case 1:
276     case 4:
277     case 32:
278     case 128:
279     case 5:
280     case 132:
281     case 160:
282     case 33:
283     case 129:
284     case 36:
285     case 133:
286     case 164:
287     case 161:
288     case 37:
289     case 165:
290     {
291     PIXEL00_20 PIXEL01_20 PIXEL10_20 PIXEL11_20 break;
292     }
293     case 2:
294     case 34:
295     case 130:
296     case 162:
297     {
298     PIXEL00_22 PIXEL01_21 PIXEL10_20 PIXEL11_20 break;
299     }
300     case 16:
301     case 17:
302     case 48:
303     case 49:
304     {
305     PIXEL00_20 PIXEL01_22 PIXEL10_20 PIXEL11_21 break;
306     }
307     case 64:
308     case 65:
309     case 68:
310     case 69:
311     {
312     PIXEL00_20 PIXEL01_20 PIXEL10_21 PIXEL11_22 break;
313     }
314     case 8:
315     case 12:
316     case 136:
317     case 140:
318     {
319     PIXEL00_21 PIXEL01_20 PIXEL10_22 PIXEL11_20 break;
320     }
321     case 3:
322     case 35:
323     case 131:
324     case 163:
325     {
326     PIXEL00_11 PIXEL01_21 PIXEL10_20 PIXEL11_20 break;
327     }
328     case 6:
329     case 38:
330     case 134:
331     case 166:
332     {
333     PIXEL00_22 PIXEL01_12 PIXEL10_20 PIXEL11_20 break;
334     }
335     case 20:
336     case 21:
337     case 52:
338     case 53:
339     {
340     PIXEL00_20 PIXEL01_11 PIXEL10_20 PIXEL11_21 break;
341     }
342     case 144:
343     case 145:
344     case 176:
345     case 177:
346     {
347     PIXEL00_20 PIXEL01_22 PIXEL10_20 PIXEL11_12 break;
348     }
349     case 192:
350     case 193:
351     case 196:
352     case 197:
353     {
354     PIXEL00_20 PIXEL01_20 PIXEL10_21 PIXEL11_11 break;
355     }
356     case 96:
357     case 97:
358     case 100:
359     case 101:
360     {
361     PIXEL00_20 PIXEL01_20 PIXEL10_12 PIXEL11_22 break;
362     }
363     case 40:
364     case 44:
365     case 168:
366     case 172:
367     {
368     PIXEL00_21 PIXEL01_20 PIXEL10_11 PIXEL11_20 break;
369     }
370     case 9:
371     case 13:
372     case 137:
373     case 141:
374     {
375     PIXEL00_12 PIXEL01_20 PIXEL10_22 PIXEL11_20 break;
376     }
377     case 18:
378     case 50:
379     {
380     PIXEL00_22 if (Diff (w[2], w[6]))
381     {
382     PIXEL01_10}
383     else
384     {
385     PIXEL01_20}
386     PIXEL10_20 PIXEL11_21 break;
387     }
388     case 80:
389     case 81:
390     {
391     PIXEL00_20 PIXEL01_22 PIXEL10_21 if (Diff (w[6], w[8]))
392     {
393     PIXEL11_10}
394     else
395     {
396     PIXEL11_20}
397     break;
398     }
399     case 72:
400     case 76:
401     {
402     PIXEL00_21 PIXEL01_20 if (Diff (w[8], w[4]))
403     {
404     PIXEL10_10}
405     else
406     {
407     PIXEL10_20}
408     PIXEL11_22 break;
409     }
410     case 10:
411     case 138:
412     {
413     if (Diff (w[4], w[2]))
414     {
415     PIXEL00_10}
416     else
417     {
418     PIXEL00_20}
419     PIXEL01_21 PIXEL10_22 PIXEL11_20 break;
420     }
421     case 66:
422     {
423     PIXEL00_22 PIXEL01_21 PIXEL10_21 PIXEL11_22 break;
424     }
425     case 24:
426     {
427     PIXEL00_21 PIXEL01_22 PIXEL10_22 PIXEL11_21 break;
428     }
429     case 7:
430     case 39:
431     case 135:
432     {
433     PIXEL00_11 PIXEL01_12 PIXEL10_20 PIXEL11_20 break;
434     }
435     case 148:
436     case 149:
437     case 180:
438     {
439     PIXEL00_20 PIXEL01_11 PIXEL10_20 PIXEL11_12 break;
440     }
441     case 224:
442     case 228:
443     case 225:
444     {
445     PIXEL00_20 PIXEL01_20 PIXEL10_12 PIXEL11_11 break;
446     }
447     case 41:
448     case 169:
449     case 45:
450     {
451     PIXEL00_12 PIXEL01_20 PIXEL10_11 PIXEL11_20 break;
452     }
453     case 22:
454     case 54:
455     {
456     PIXEL00_22 if (Diff (w[2], w[6]))
457     {
458     PIXEL01_0}
459     else
460     {
461     PIXEL01_20}
462     PIXEL10_20 PIXEL11_21 break;
463     }
464     case 208:
465     case 209:
466     {
467     PIXEL00_20 PIXEL01_22 PIXEL10_21 if (Diff (w[6], w[8]))
468     {
469     PIXEL11_0}
470     else
471     {
472     PIXEL11_20}
473     break;
474     }
475     case 104:
476     case 108:
477     {
478     PIXEL00_21 PIXEL01_20 if (Diff (w[8], w[4]))
479     {
480     PIXEL10_0}
481     else
482     {
483     PIXEL10_20}
484     PIXEL11_22 break;
485     }
486     case 11:
487     case 139:
488     {
489     if (Diff (w[4], w[2]))
490     {
491     PIXEL00_0}
492     else
493     {
494     PIXEL00_20}
495     PIXEL01_21 PIXEL10_22 PIXEL11_20 break;
496     }
497     case 19:
498     case 51:
499     {
500     if (Diff (w[2], w[6]))
501     {
502     PIXEL00_11 PIXEL01_10}
503     else
504     {
505     PIXEL00_60 PIXEL01_90}
506     PIXEL10_20 PIXEL11_21 break;
507     }
508     case 146:
509     case 178:
510     {
511     PIXEL00_22 if (Diff (w[2], w[6]))
512     {
513     PIXEL01_10 PIXEL11_12}
514     else
515     {
516     PIXEL01_90 PIXEL11_61}
517     PIXEL10_20 break;
518     }
519     case 84:
520     case 85:
521     {
522     PIXEL00_20 if (Diff (w[6], w[8]))
523     {
524     PIXEL01_11 PIXEL11_10}
525     else
526     {
527     PIXEL01_60 PIXEL11_90}
528     PIXEL10_21 break;
529     }
530     case 112:
531     case 113:
532     {
533     PIXEL00_20 PIXEL01_22 if (Diff (w[6], w[8]))
534     {
535     PIXEL10_12 PIXEL11_10}
536     else
537     {
538     PIXEL10_61 PIXEL11_90}
539     break;
540     }
541     case 200:
542     case 204:
543     {
544     PIXEL00_21 PIXEL01_20 if (Diff (w[8], w[4]))
545     {
546     PIXEL10_10 PIXEL11_11}
547     else
548     {
549     PIXEL10_90 PIXEL11_60}
550     break;
551     }
552     case 73:
553     case 77:
554     {
555     if (Diff (w[8], w[4]))
556     {
557     PIXEL00_12 PIXEL10_10}
558     else
559     {
560     PIXEL00_61 PIXEL10_90}
561     PIXEL01_20 PIXEL11_22 break;
562     }
563     case 42:
564     case 170:
565     {
566     if (Diff (w[4], w[2]))
567     {
568     PIXEL00_10 PIXEL10_11}
569     else
570     {
571     PIXEL00_90 PIXEL10_60}
572     PIXEL01_21 PIXEL11_20 break;
573     }
574     case 14:
575     case 142:
576     {
577     if (Diff (w[4], w[2]))
578     {
579     PIXEL00_10 PIXEL01_12}
580     else
581     {
582     PIXEL00_90 PIXEL01_61}
583     PIXEL10_22 PIXEL11_20 break;
584     }
585     case 67:
586     {
587     PIXEL00_11 PIXEL01_21 PIXEL10_21 PIXEL11_22 break;
588     }
589     case 70:
590     {
591     PIXEL00_22 PIXEL01_12 PIXEL10_21 PIXEL11_22 break;
592     }
593     case 28:
594     {
595     PIXEL00_21 PIXEL01_11 PIXEL10_22 PIXEL11_21 break;
596     }
597     case 152:
598     {
599     PIXEL00_21 PIXEL01_22 PIXEL10_22 PIXEL11_12 break;
600     }
601     case 194:
602     {
603     PIXEL00_22 PIXEL01_21 PIXEL10_21 PIXEL11_11 break;
604     }
605     case 98:
606     {
607     PIXEL00_22 PIXEL01_21 PIXEL10_12 PIXEL11_22 break;
608     }
609     case 56:
610     {
611     PIXEL00_21 PIXEL01_22 PIXEL10_11 PIXEL11_21 break;
612     }
613     case 25:
614     {
615     PIXEL00_12 PIXEL01_22 PIXEL10_22 PIXEL11_21 break;
616     }
617     case 26:
618     case 31:
619     {
620     if (Diff (w[4], w[2]))
621     {
622     PIXEL00_0}
623     else
624     {
625     PIXEL00_20}
626     if (Diff (w[2], w[6]))
627     {
628     PIXEL01_0}
629     else
630     {
631     PIXEL01_20}
632     PIXEL10_22 PIXEL11_21 break;
633     }
634     case 82:
635     case 214:
636     {
637     PIXEL00_22 if (Diff (w[2], w[6]))
638     {
639     PIXEL01_0}
640     else
641     {
642     PIXEL01_20}
643     PIXEL10_21 if (Diff (w[6], w[8]))
644     {
645     PIXEL11_0}
646     else
647     {
648     PIXEL11_20}
649     break;
650     }
651     case 88:
652     case 248:
653     {
654     PIXEL00_21 PIXEL01_22 if (Diff (w[8], w[4]))
655     {
656     PIXEL10_0}
657     else
658     {
659     PIXEL10_20}
660     if (Diff (w[6], w[8]))
661     {
662     PIXEL11_0}
663     else
664     {
665     PIXEL11_20}
666     break;
667     }
668     case 74:
669     case 107:
670     {
671     if (Diff (w[4], w[2]))
672     {
673     PIXEL00_0}
674     else
675     {
676     PIXEL00_20}
677     PIXEL01_21 if (Diff (w[8], w[4]))
678     {
679     PIXEL10_0}
680     else
681     {
682     PIXEL10_20}
683     PIXEL11_22 break;
684     }
685     case 27:
686     {
687     if (Diff (w[4], w[2]))
688     {
689     PIXEL00_0}
690     else
691     {
692     PIXEL00_20}
693     PIXEL01_10 PIXEL10_22 PIXEL11_21 break;
694     }
695     case 86:
696     {
697     PIXEL00_22 if (Diff (w[2], w[6]))
698     {
699     PIXEL01_0}
700     else
701     {
702     PIXEL01_20}
703     PIXEL10_21 PIXEL11_10 break;
704     }
705     case 216:
706     {
707     PIXEL00_21 PIXEL01_22 PIXEL10_10 if (Diff (w[6], w[8]))
708     {
709     PIXEL11_0}
710     else
711     {
712     PIXEL11_20}
713     break;
714     }
715     case 106:
716     {
717     PIXEL00_10 PIXEL01_21 if (Diff (w[8], w[4]))
718     {
719     PIXEL10_0}
720     else
721     {
722     PIXEL10_20}
723     PIXEL11_22 break;
724     }
725     case 30:
726     {
727     PIXEL00_10 if (Diff (w[2], w[6]))
728     {
729     PIXEL01_0}
730     else
731     {
732     PIXEL01_20}
733     PIXEL10_22 PIXEL11_21 break;
734     }
735     case 210:
736     {
737     PIXEL00_22 PIXEL01_10 PIXEL10_21 if (Diff (w[6], w[8]))
738     {
739     PIXEL11_0}
740     else
741     {
742     PIXEL11_20}
743     break;
744     }
745     case 120:
746     {
747     PIXEL00_21 PIXEL01_22 if (Diff (w[8], w[4]))
748     {
749     PIXEL10_0}
750     else
751     {
752     PIXEL10_20}
753     PIXEL11_10 break;
754     }
755     case 75:
756     {
757     if (Diff (w[4], w[2]))
758     {
759     PIXEL00_0}
760     else
761     {
762     PIXEL00_20}
763     PIXEL01_21 PIXEL10_10 PIXEL11_22 break;
764     }
765     case 29:
766     {
767     PIXEL00_12 PIXEL01_11 PIXEL10_22 PIXEL11_21 break;
768     }
769     case 198:
770     {
771     PIXEL00_22 PIXEL01_12 PIXEL10_21 PIXEL11_11 break;
772     }
773     case 184:
774     {
775     PIXEL00_21 PIXEL01_22 PIXEL10_11 PIXEL11_12 break;
776     }
777     case 99:
778     {
779     PIXEL00_11 PIXEL01_21 PIXEL10_12 PIXEL11_22 break;
780     }
781     case 57:
782     {
783     PIXEL00_12 PIXEL01_22 PIXEL10_11 PIXEL11_21 break;
784     }
785     case 71:
786     {
787     PIXEL00_11 PIXEL01_12 PIXEL10_21 PIXEL11_22 break;
788     }
789     case 156:
790     {
791     PIXEL00_21 PIXEL01_11 PIXEL10_22 PIXEL11_12 break;
792     }
793     case 226:
794     {
795     PIXEL00_22 PIXEL01_21 PIXEL10_12 PIXEL11_11 break;
796     }
797     case 60:
798     {
799     PIXEL00_21 PIXEL01_11 PIXEL10_11 PIXEL11_21 break;
800     }
801     case 195:
802     {
803     PIXEL00_11 PIXEL01_21 PIXEL10_21 PIXEL11_11 break;
804     }
805     case 102:
806     {
807     PIXEL00_22 PIXEL01_12 PIXEL10_12 PIXEL11_22 break;
808     }
809     case 153:
810     {
811     PIXEL00_12 PIXEL01_22 PIXEL10_22 PIXEL11_12 break;
812     }
813     case 58:
814     {
815     if (Diff (w[4], w[2]))
816     {
817     PIXEL00_10}
818     else
819     {
820     PIXEL00_70}
821     if (Diff (w[2], w[6]))
822     {
823     PIXEL01_10}
824     else
825     {
826     PIXEL01_70}
827     PIXEL10_11 PIXEL11_21 break;
828     }
829     case 83:
830     {
831     PIXEL00_11 if (Diff (w[2], w[6]))
832     {
833     PIXEL01_10}
834     else
835     {
836     PIXEL01_70}
837     PIXEL10_21 if (Diff (w[6], w[8]))
838     {
839     PIXEL11_10}
840     else
841     {
842     PIXEL11_70}
843     break;
844     }
845     case 92:
846     {
847     PIXEL00_21 PIXEL01_11 if (Diff (w[8], w[4]))
848     {
849     PIXEL10_10}
850     else
851     {
852     PIXEL10_70}
853     if (Diff (w[6], w[8]))
854     {
855     PIXEL11_10}
856     else
857     {
858     PIXEL11_70}
859     break;
860     }
861     case 202:
862     {
863     if (Diff (w[4], w[2]))
864     {
865     PIXEL00_10}
866     else
867     {
868     PIXEL00_70}
869     PIXEL01_21 if (Diff (w[8], w[4]))
870     {
871     PIXEL10_10}
872     else
873     {
874     PIXEL10_70}
875     PIXEL11_11 break;
876     }
877     case 78:
878     {
879     if (Diff (w[4], w[2]))
880     {
881     PIXEL00_10}
882     else
883     {
884     PIXEL00_70}
885     PIXEL01_12 if (Diff (w[8], w[4]))
886     {
887     PIXEL10_10}
888     else
889     {
890     PIXEL10_70}
891     PIXEL11_22 break;
892     }
893     case 154:
894     {
895     if (Diff (w[4], w[2]))
896     {
897     PIXEL00_10}
898     else
899     {
900     PIXEL00_70}
901     if (Diff (w[2], w[6]))
902     {
903     PIXEL01_10}
904     else
905     {
906     PIXEL01_70}
907     PIXEL10_22 PIXEL11_12 break;
908     }
909     case 114:
910     {
911     PIXEL00_22 if (Diff (w[2], w[6]))
912     {
913     PIXEL01_10}
914     else
915     {
916     PIXEL01_70}
917     PIXEL10_12 if (Diff (w[6], w[8]))
918     {
919     PIXEL11_10}
920     else
921     {
922     PIXEL11_70}
923     break;
924     }
925     case 89:
926     {
927     PIXEL00_12 PIXEL01_22 if (Diff (w[8], w[4]))
928     {
929     PIXEL10_10}
930     else
931     {
932     PIXEL10_70}
933     if (Diff (w[6], w[8]))
934     {
935     PIXEL11_10}
936     else
937     {
938     PIXEL11_70}
939     break;
940     }
941     case 90:
942     {
943     if (Diff (w[4], w[2]))
944     {
945     PIXEL00_10}
946     else
947     {
948     PIXEL00_70}
949     if (Diff (w[2], w[6]))
950     {
951     PIXEL01_10}
952     else
953     {
954     PIXEL01_70}
955     if (Diff (w[8], w[4]))
956     {
957     PIXEL10_10}
958     else
959     {
960     PIXEL10_70}
961     if (Diff (w[6], w[8]))
962     {
963     PIXEL11_10}
964     else
965     {
966     PIXEL11_70}
967     break;
968     }
969     case 55:
970     case 23:
971     {
972     if (Diff (w[2], w[6]))
973     {
974     PIXEL00_11 PIXEL01_0}
975     else
976     {
977     PIXEL00_60 PIXEL01_90}
978     PIXEL10_20 PIXEL11_21 break;
979     }
980     case 182:
981     case 150:
982     {
983     PIXEL00_22 if (Diff (w[2], w[6]))
984     {
985     PIXEL01_0 PIXEL11_12}
986     else
987     {
988     PIXEL01_90 PIXEL11_61}
989     PIXEL10_20 break;
990     }
991     case 213:
992     case 212:
993     {
994     PIXEL00_20 if (Diff (w[6], w[8]))
995     {
996     PIXEL01_11 PIXEL11_0}
997     else
998     {
999     PIXEL01_60 PIXEL11_90}
1000     PIXEL10_21 break;
1001     }
1002     case 241:
1003     case 240:
1004     {
1005     PIXEL00_20 PIXEL01_22 if (Diff (w[6], w[8]))
1006     {
1007     PIXEL10_12 PIXEL11_0}
1008     else
1009     {
1010     PIXEL10_61 PIXEL11_90}
1011     break;
1012     }
1013     case 236:
1014     case 232:
1015     {
1016     PIXEL00_21 PIXEL01_20 if (Diff (w[8], w[4]))
1017     {
1018     PIXEL10_0 PIXEL11_11}
1019     else
1020     {
1021     PIXEL10_90 PIXEL11_60}
1022     break;
1023     }
1024     case 109:
1025     case 105:
1026     {
1027     if (Diff (w[8], w[4]))
1028     {
1029     PIXEL00_12 PIXEL10_0}
1030     else
1031     {
1032     PIXEL00_61 PIXEL10_90}
1033     PIXEL01_20 PIXEL11_22 break;
1034     }
1035     case 171:
1036     case 43:
1037     {
1038     if (Diff (w[4], w[2]))
1039     {
1040     PIXEL00_0 PIXEL10_11}
1041     else
1042     {
1043     PIXEL00_90 PIXEL10_60}
1044     PIXEL01_21 PIXEL11_20 break;
1045     }
1046     case 143:
1047     case 15:
1048     {
1049     if (Diff (w[4], w[2]))
1050     {
1051     PIXEL00_0 PIXEL01_12}
1052     else
1053     {
1054     PIXEL00_90 PIXEL01_61}
1055     PIXEL10_22 PIXEL11_20 break;
1056     }
1057     case 124:
1058     {
1059     PIXEL00_21 PIXEL01_11 if (Diff (w[8], w[4]))
1060     {
1061     PIXEL10_0}
1062     else
1063     {
1064     PIXEL10_20}
1065     PIXEL11_10 break;
1066     }
1067     case 203:
1068     {
1069     if (Diff (w[4], w[2]))
1070     {
1071     PIXEL00_0}
1072     else
1073     {
1074     PIXEL00_20}
1075     PIXEL01_21 PIXEL10_10 PIXEL11_11 break;
1076     }
1077     case 62:
1078     {
1079     PIXEL00_10 if (Diff (w[2], w[6]))
1080     {
1081     PIXEL01_0}
1082     else
1083     {
1084     PIXEL01_20}
1085     PIXEL10_11 PIXEL11_21 break;
1086     }
1087     case 211:
1088     {
1089     PIXEL00_11 PIXEL01_10 PIXEL10_21 if (Diff (w[6], w[8]))
1090     {
1091     PIXEL11_0}
1092     else
1093     {
1094     PIXEL11_20}
1095     break;
1096     }
1097     case 118:
1098     {
1099     PIXEL00_22 if (Diff (w[2], w[6]))
1100     {
1101     PIXEL01_0}
1102     else
1103     {
1104     PIXEL01_20}
1105     PIXEL10_12 PIXEL11_10 break;
1106     }
1107     case 217:
1108     {
1109     PIXEL00_12 PIXEL01_22 PIXEL10_10 if (Diff (w[6], w[8]))
1110     {
1111     PIXEL11_0}
1112     else
1113     {
1114     PIXEL11_20}
1115     break;
1116     }
1117     case 110:
1118     {
1119     PIXEL00_10 PIXEL01_12 if (Diff (w[8], w[4]))
1120     {
1121     PIXEL10_0}
1122     else
1123     {
1124     PIXEL10_20}
1125     PIXEL11_22 break;
1126     }
1127     case 155:
1128     {
1129     if (Diff (w[4], w[2]))
1130     {
1131     PIXEL00_0}
1132     else
1133     {
1134     PIXEL00_20}
1135     PIXEL01_10 PIXEL10_22 PIXEL11_12 break;
1136     }
1137     case 188:
1138     {
1139     PIXEL00_21 PIXEL01_11 PIXEL10_11 PIXEL11_12 break;
1140     }
1141     case 185:
1142     {
1143     PIXEL00_12 PIXEL01_22 PIXEL10_11 PIXEL11_12 break;
1144     }
1145     case 61:
1146     {
1147     PIXEL00_12 PIXEL01_11 PIXEL10_11 PIXEL11_21 break;
1148     }
1149     case 157:
1150     {
1151     PIXEL00_12 PIXEL01_11 PIXEL10_22 PIXEL11_12 break;
1152     }
1153     case 103:
1154     {
1155     PIXEL00_11 PIXEL01_12 PIXEL10_12 PIXEL11_22 break;
1156     }
1157     case 227:
1158     {
1159     PIXEL00_11 PIXEL01_21 PIXEL10_12 PIXEL11_11 break;
1160     }
1161     case 230:
1162     {
1163     PIXEL00_22 PIXEL01_12 PIXEL10_12 PIXEL11_11 break;
1164     }
1165     case 199:
1166     {
1167     PIXEL00_11 PIXEL01_12 PIXEL10_21 PIXEL11_11 break;
1168     }
1169     case 220:
1170     {
1171     PIXEL00_21 PIXEL01_11 if (Diff (w[8], w[4]))
1172     {
1173     PIXEL10_10}
1174     else
1175     {
1176     PIXEL10_70}
1177     if (Diff (w[6], w[8]))
1178     {
1179     PIXEL11_0}
1180     else
1181     {
1182     PIXEL11_20}
1183     break;
1184     }
1185     case 158:
1186     {
1187     if (Diff (w[4], w[2]))
1188     {
1189     PIXEL00_10}
1190     else
1191     {
1192     PIXEL00_70}
1193     if (Diff (w[2], w[6]))
1194     {
1195     PIXEL01_0}
1196     else
1197     {
1198     PIXEL01_20}
1199     PIXEL10_22 PIXEL11_12 break;
1200     }
1201     case 234:
1202     {
1203     if (Diff (w[4], w[2]))
1204     {
1205     PIXEL00_10}
1206     else
1207     {
1208     PIXEL00_70}
1209     PIXEL01_21 if (Diff (w[8], w[4]))
1210     {
1211     PIXEL10_0}
1212     else
1213     {
1214     PIXEL10_20}
1215     PIXEL11_11 break;
1216     }
1217     case 242:
1218     {
1219     PIXEL00_22 if (Diff (w[2], w[6]))
1220     {
1221     PIXEL01_10}
1222     else
1223     {
1224     PIXEL01_70}
1225     PIXEL10_12 if (Diff (w[6], w[8]))
1226     {
1227     PIXEL11_0}
1228     else
1229     {
1230     PIXEL11_20}
1231     break;
1232     }
1233     case 59:
1234     {
1235     if (Diff (w[4], w[2]))
1236     {
1237     PIXEL00_0}
1238     else
1239     {
1240     PIXEL00_20}
1241     if (Diff (w[2], w[6]))
1242     {
1243     PIXEL01_10}
1244     else
1245     {
1246     PIXEL01_70}
1247     PIXEL10_11 PIXEL11_21 break;
1248     }
1249     case 121:
1250     {
1251     PIXEL00_12 PIXEL01_22 if (Diff (w[8], w[4]))
1252     {
1253     PIXEL10_0}
1254     else
1255     {
1256     PIXEL10_20}
1257     if (Diff (w[6], w[8]))
1258     {
1259     PIXEL11_10}
1260     else
1261     {
1262     PIXEL11_70}
1263     break;
1264     }
1265     case 87:
1266     {
1267     PIXEL00_11 if (Diff (w[2], w[6]))
1268     {
1269     PIXEL01_0}
1270     else
1271     {
1272     PIXEL01_20}
1273     PIXEL10_21 if (Diff (w[6], w[8]))
1274     {
1275     PIXEL11_10}
1276     else
1277     {
1278     PIXEL11_70}
1279     break;
1280     }
1281     case 79:
1282     {
1283     if (Diff (w[4], w[2]))
1284     {
1285     PIXEL00_0}
1286     else
1287     {
1288     PIXEL00_20}
1289     PIXEL01_12 if (Diff (w[8], w[4]))
1290     {
1291     PIXEL10_10}
1292     else
1293     {
1294     PIXEL10_70}
1295     PIXEL11_22 break;
1296     }
1297     case 122:
1298     {
1299     if (Diff (w[4], w[2]))
1300     {
1301     PIXEL00_10}
1302     else
1303     {
1304     PIXEL00_70}
1305     if (Diff (w[2], w[6]))
1306     {
1307     PIXEL01_10}
1308     else
1309     {
1310     PIXEL01_70}
1311     if (Diff (w[8], w[4]))
1312     {
1313     PIXEL10_0}
1314     else
1315     {
1316     PIXEL10_20}
1317     if (Diff (w[6], w[8]))
1318     {
1319     PIXEL11_10}
1320     else
1321     {
1322     PIXEL11_70}
1323     break;
1324     }
1325     case 94:
1326     {
1327     if (Diff (w[4], w[2]))
1328     {
1329     PIXEL00_10}
1330     else
1331     {
1332     PIXEL00_70}
1333     if (Diff (w[2], w[6]))
1334     {
1335     PIXEL01_0}
1336     else
1337     {
1338     PIXEL01_20}
1339     if (Diff (w[8], w[4]))
1340     {
1341     PIXEL10_10}
1342     else
1343     {
1344     PIXEL10_70}
1345     if (Diff (w[6], w[8]))
1346     {
1347     PIXEL11_10}
1348     else
1349     {
1350     PIXEL11_70}
1351     break;
1352     }
1353     case 218:
1354     {
1355     if (Diff (w[4], w[2]))
1356     {
1357     PIXEL00_10}
1358     else
1359     {
1360     PIXEL00_70}
1361     if (Diff (w[2], w[6]))
1362     {
1363     PIXEL01_10}
1364     else
1365     {
1366     PIXEL01_70}
1367     if (Diff (w[8], w[4]))
1368     {
1369     PIXEL10_10}
1370     else
1371     {
1372     PIXEL10_70}
1373     if (Diff (w[6], w[8]))
1374     {
1375     PIXEL11_0}
1376     else
1377     {
1378     PIXEL11_20}
1379     break;
1380     }
1381     case 91:
1382     {
1383     if (Diff (w[4], w[2]))
1384     {
1385     PIXEL00_0}
1386     else
1387     {
1388     PIXEL00_20}
1389     if (Diff (w[2], w[6]))
1390     {
1391     PIXEL01_10}
1392     else
1393     {
1394     PIXEL01_70}
1395     if (Diff (w[8], w[4]))
1396     {
1397     PIXEL10_10}
1398     else
1399     {
1400     PIXEL10_70}
1401     if (Diff (w[6], w[8]))
1402     {
1403     PIXEL11_10}
1404     else
1405     {
1406     PIXEL11_70}
1407     break;
1408     }
1409     case 229:
1410     {
1411     PIXEL00_20 PIXEL01_20 PIXEL10_12 PIXEL11_11 break;
1412     }
1413     case 167:
1414     {
1415     PIXEL00_11 PIXEL01_12 PIXEL10_20 PIXEL11_20 break;
1416     }
1417     case 173:
1418     {
1419     PIXEL00_12 PIXEL01_20 PIXEL10_11 PIXEL11_20 break;
1420     }
1421     case 181:
1422     {
1423     PIXEL00_20 PIXEL01_11 PIXEL10_20 PIXEL11_12 break;
1424     }
1425     case 186:
1426     {
1427     if (Diff (w[4], w[2]))
1428     {
1429     PIXEL00_10}
1430     else
1431     {
1432     PIXEL00_70}
1433     if (Diff (w[2], w[6]))
1434     {
1435     PIXEL01_10}
1436     else
1437     {
1438     PIXEL01_70}
1439     PIXEL10_11 PIXEL11_12 break;
1440     }
1441     case 115:
1442     {
1443     PIXEL00_11 if (Diff (w[2], w[6]))
1444     {
1445     PIXEL01_10}
1446     else
1447     {
1448     PIXEL01_70}
1449     PIXEL10_12 if (Diff (w[6], w[8]))
1450     {
1451     PIXEL11_10}
1452     else
1453     {
1454     PIXEL11_70}
1455     break;
1456     }
1457     case 93:
1458     {
1459     PIXEL00_12 PIXEL01_11 if (Diff (w[8], w[4]))
1460     {
1461     PIXEL10_10}
1462     else
1463     {
1464     PIXEL10_70}
1465     if (Diff (w[6], w[8]))
1466     {
1467     PIXEL11_10}
1468     else
1469     {
1470     PIXEL11_70}
1471     break;
1472     }
1473     case 206:
1474     {
1475     if (Diff (w[4], w[2]))
1476     {
1477     PIXEL00_10}
1478     else
1479     {
1480     PIXEL00_70}
1481     PIXEL01_12 if (Diff (w[8], w[4]))
1482     {
1483     PIXEL10_10}
1484     else
1485     {
1486     PIXEL10_70}
1487     PIXEL11_11 break;
1488     }
1489     case 205:
1490     case 201:
1491     {
1492     PIXEL00_12 PIXEL01_20 if (Diff (w[8], w[4]))
1493     {
1494     PIXEL10_10}
1495     else
1496     {
1497     PIXEL10_70}
1498     PIXEL11_11 break;
1499     }
1500     case 174:
1501     case 46:
1502     {
1503     if (Diff (w[4], w[2]))
1504     {
1505     PIXEL00_10}
1506     else
1507     {
1508     PIXEL00_70}
1509     PIXEL01_12 PIXEL10_11 PIXEL11_20 break;
1510     }
1511     case 179:
1512     case 147:
1513     {
1514     PIXEL00_11 if (Diff (w[2], w[6]))
1515     {
1516     PIXEL01_10}
1517     else
1518     {
1519     PIXEL01_70}
1520     PIXEL10_20 PIXEL11_12 break;
1521     }
1522     case 117:
1523     case 116:
1524     {
1525     PIXEL00_20 PIXEL01_11 PIXEL10_12 if (Diff (w[6], w[8]))
1526     {
1527     PIXEL11_10}
1528     else
1529     {
1530     PIXEL11_70}
1531     break;
1532     }
1533     case 189:
1534     {
1535     PIXEL00_12 PIXEL01_11 PIXEL10_11 PIXEL11_12 break;
1536     }
1537     case 231:
1538     {
1539     PIXEL00_11 PIXEL01_12 PIXEL10_12 PIXEL11_11 break;
1540     }
1541     case 126:
1542     {
1543     PIXEL00_10 if (Diff (w[2], w[6]))
1544     {
1545     PIXEL01_0}
1546     else
1547     {
1548     PIXEL01_20}
1549     if (Diff (w[8], w[4]))
1550     {
1551     PIXEL10_0}
1552     else
1553     {
1554     PIXEL10_20}
1555     PIXEL11_10 break;
1556     }
1557     case 219:
1558     {
1559     if (Diff (w[4], w[2]))
1560     {
1561     PIXEL00_0}
1562     else
1563     {
1564     PIXEL00_20}
1565     PIXEL01_10 PIXEL10_10 if (Diff (w[6], w[8]))
1566     {
1567     PIXEL11_0}
1568     else
1569     {
1570     PIXEL11_20}
1571     break;
1572     }
1573     case 125:
1574     {
1575     if (Diff (w[8], w[4]))
1576     {
1577     PIXEL00_12 PIXEL10_0}
1578     else
1579     {
1580     PIXEL00_61 PIXEL10_90}
1581     PIXEL01_11 PIXEL11_10 break;
1582     }
1583     case 221:
1584     {
1585     PIXEL00_12 if (Diff (w[6], w[8]))
1586     {
1587     PIXEL01_11 PIXEL11_0}
1588     else
1589     {
1590     PIXEL01_60 PIXEL11_90}
1591     PIXEL10_10 break;
1592     }
1593     case 207:
1594     {
1595     if (Diff (w[4], w[2]))
1596     {
1597     PIXEL00_0 PIXEL01_12}
1598     else
1599     {
1600     PIXEL00_90 PIXEL01_61}
1601     PIXEL10_10 PIXEL11_11 break;
1602     }
1603     case 238:
1604     {
1605     PIXEL00_10 PIXEL01_12 if (Diff (w[8], w[4]))
1606     {
1607     PIXEL10_0 PIXEL11_11}
1608     else
1609     {
1610     PIXEL10_90 PIXEL11_60}
1611     break;
1612     }
1613     case 190:
1614     {
1615     PIXEL00_10 if (Diff (w[2], w[6]))
1616     {
1617     PIXEL01_0 PIXEL11_12}
1618     else
1619     {
1620     PIXEL01_90 PIXEL11_61}
1621     PIXEL10_11 break;
1622     }
1623     case 187:
1624     {
1625     if (Diff (w[4], w[2]))
1626     {
1627     PIXEL00_0 PIXEL10_11}
1628     else
1629     {
1630     PIXEL00_90 PIXEL10_60}
1631     PIXEL01_10 PIXEL11_12 break;
1632     }
1633     case 243:
1634     {
1635     PIXEL00_11 PIXEL01_10 if (Diff (w[6], w[8]))
1636     {
1637     PIXEL10_12 PIXEL11_0}
1638     else
1639     {
1640     PIXEL10_61 PIXEL11_90}
1641     break;
1642     }
1643     case 119:
1644     {
1645     if (Diff (w[2], w[6]))
1646     {
1647     PIXEL00_11 PIXEL01_0}
1648     else
1649     {
1650     PIXEL00_60 PIXEL01_90}
1651     PIXEL10_12 PIXEL11_10 break;
1652     }
1653     case 237:
1654     case 233:
1655     {
1656     PIXEL00_12 PIXEL01_20 if (Diff (w[8], w[4]))
1657     {
1658     PIXEL10_0}
1659     else
1660     {
1661     PIXEL10_100}
1662     PIXEL11_11 break;
1663     }
1664     case 175:
1665     case 47:
1666     {
1667     if (Diff (w[4], w[2]))
1668     {
1669     PIXEL00_0}
1670     else
1671     {
1672     PIXEL00_100}
1673     PIXEL01_12 PIXEL10_11 PIXEL11_20 break;
1674     }
1675     case 183:
1676     case 151:
1677     {
1678     PIXEL00_11 if (Diff (w[2], w[6]))
1679     {
1680     PIXEL01_0}
1681     else
1682     {
1683     PIXEL01_100}
1684     PIXEL10_20 PIXEL11_12 break;
1685     }
1686     case 245:
1687     case 244:
1688     {
1689     PIXEL00_20 PIXEL01_11 PIXEL10_12 if (Diff (w[6], w[8]))
1690     {
1691     PIXEL11_0}
1692     else
1693     {
1694     PIXEL11_100}
1695     break;
1696     }
1697     case 250:
1698     {
1699     PIXEL00_10 PIXEL01_10 if (Diff (w[8], w[4]))
1700     {
1701     PIXEL10_0}
1702     else
1703     {
1704     PIXEL10_20}
1705     if (Diff (w[6], w[8]))
1706     {
1707     PIXEL11_0}
1708     else
1709     {
1710     PIXEL11_20}
1711     break;
1712     }
1713     case 123:
1714     {
1715     if (Diff (w[4], w[2]))
1716     {
1717     PIXEL00_0}
1718     else
1719     {
1720     PIXEL00_20}
1721     PIXEL01_10 if (Diff (w[8], w[4]))
1722     {
1723     PIXEL10_0}
1724     else
1725     {
1726     PIXEL10_20}
1727     PIXEL11_10 break;
1728     }
1729     case 95:
1730     {
1731     if (Diff (w[4], w[2]))
1732     {
1733     PIXEL00_0}
1734     else
1735     {
1736     PIXEL00_20}
1737     if (Diff (w[2], w[6]))
1738     {
1739     PIXEL01_0}
1740     else
1741     {
1742     PIXEL01_20}
1743     PIXEL10_10 PIXEL11_10 break;
1744     }
1745     case 222:
1746     {
1747     PIXEL00_10 if (Diff (w[2], w[6]))
1748     {
1749     PIXEL01_0}
1750     else
1751     {
1752     PIXEL01_20}
1753     PIXEL10_10 if (Diff (w[6], w[8]))
1754     {
1755     PIXEL11_0}
1756     else
1757     {
1758     PIXEL11_20}
1759     break;
1760     }
1761     case 252:
1762     {
1763     PIXEL00_21 PIXEL01_11 if (Diff (w[8], w[4]))
1764     {
1765     PIXEL10_0}
1766     else
1767     {
1768     PIXEL10_20}
1769     if (Diff (w[6], w[8]))
1770     {
1771     PIXEL11_0}
1772     else
1773     {
1774     PIXEL11_100}
1775     break;
1776     }
1777     case 249:
1778     {
1779     PIXEL00_12 PIXEL01_22 if (Diff (w[8], w[4]))
1780     {
1781     PIXEL10_0}
1782     else
1783     {
1784     PIXEL10_100}
1785     if (Diff (w[6], w[8]))
1786     {
1787     PIXEL11_0}
1788     else
1789     {
1790     PIXEL11_20}
1791     break;
1792     }
1793     case 235:
1794     {
1795     if (Diff (w[4], w[2]))
1796     {
1797     PIXEL00_0}
1798     else
1799     {
1800     PIXEL00_20}
1801     PIXEL01_21 if (Diff (w[8], w[4]))
1802     {
1803     PIXEL10_0}
1804     else
1805     {
1806     PIXEL10_100}
1807     PIXEL11_11 break;
1808     }
1809     case 111:
1810     {
1811     if (Diff (w[4], w[2]))
1812     {
1813     PIXEL00_0}
1814     else
1815     {
1816     PIXEL00_100}
1817     PIXEL01_12 if (Diff (w[8], w[4]))
1818     {
1819     PIXEL10_0}
1820     else
1821     {
1822     PIXEL10_20}
1823     PIXEL11_22 break;
1824     }
1825     case 63:
1826     {
1827     if (Diff (w[4], w[2]))
1828     {
1829     PIXEL00_0}
1830     else
1831     {
1832     PIXEL00_100}
1833     if (Diff (w[2], w[6]))
1834     {
1835     PIXEL01_0}
1836     else
1837     {
1838     PIXEL01_20}
1839     PIXEL10_11 PIXEL11_21 break;
1840     }
1841     case 159:
1842     {
1843     if (Diff (w[4], w[2]))
1844     {
1845     PIXEL00_0}
1846     else
1847     {
1848     PIXEL00_20}
1849     if (Diff (w[2], w[6]))
1850     {
1851     PIXEL01_0}
1852     else
1853     {
1854     PIXEL01_100}
1855     PIXEL10_22 PIXEL11_12 break;
1856     }
1857     case 215:
1858     {
1859     PIXEL00_11 if (Diff (w[2], w[6]))
1860     {
1861     PIXEL01_0}
1862     else
1863     {
1864     PIXEL01_100}
1865     PIXEL10_21 if (Diff (w[6], w[8]))
1866     {
1867     PIXEL11_0}
1868     else
1869     {
1870     PIXEL11_20}
1871     break;
1872     }
1873     case 246:
1874     {
1875     PIXEL00_22 if (Diff (w[2], w[6]))
1876     {
1877     PIXEL01_0}
1878     else
1879     {
1880     PIXEL01_20}
1881     PIXEL10_12 if (Diff (w[6], w[8]))
1882     {
1883     PIXEL11_0}
1884     else
1885     {
1886     PIXEL11_100}
1887     break;
1888     }
1889     case 254:
1890     {
1891     PIXEL00_10 if (Diff (w[2], w[6]))
1892     {
1893     PIXEL01_0}
1894     else
1895     {
1896     PIXEL01_20}
1897     if (Diff (w[8], w[4]))
1898     {
1899     PIXEL10_0}
1900     else
1901     {
1902     PIXEL10_20}
1903     if (Diff (w[6], w[8]))
1904     {
1905     PIXEL11_0}
1906     else
1907     {
1908     PIXEL11_100}
1909     break;
1910     }
1911     case 253:
1912     {
1913     PIXEL00_12 PIXEL01_11 if (Diff (w[8], w[4]))
1914     {
1915     PIXEL10_0}
1916     else
1917     {
1918     PIXEL10_100}
1919     if (Diff (w[6], w[8]))
1920     {
1921     PIXEL11_0}
1922     else
1923     {
1924     PIXEL11_100}
1925     break;
1926     }
1927     case 251:
1928     {
1929     if (Diff (w[4], w[2]))
1930     {
1931     PIXEL00_0}
1932     else
1933     {
1934     PIXEL00_20}
1935     PIXEL01_10 if (Diff (w[8], w[4]))
1936     {
1937     PIXEL10_0}
1938     else
1939     {
1940     PIXEL10_100}
1941     if (Diff (w[6], w[8]))
1942     {
1943     PIXEL11_0}
1944     else
1945     {
1946     PIXEL11_20}
1947     break;
1948     }
1949     case 239:
1950     {
1951     if (Diff (w[4], w[2]))
1952     {
1953     PIXEL00_0}
1954     else
1955     {
1956     PIXEL00_100}
1957     PIXEL01_12 if (Diff (w[8], w[4]))
1958     {
1959     PIXEL10_0}
1960     else
1961     {
1962     PIXEL10_100}
1963     PIXEL11_11 break;
1964     }
1965     case 127:
1966     {
1967     if (Diff (w[4], w[2]))
1968     {
1969     PIXEL00_0}
1970     else
1971     {
1972     PIXEL00_100}
1973     if (Diff (w[2], w[6]))
1974     {
1975     PIXEL01_0}
1976     else
1977     {
1978     PIXEL01_20}
1979     if (Diff (w[8], w[4]))
1980     {
1981     PIXEL10_0}
1982     else
1983     {
1984     PIXEL10_20}
1985     PIXEL11_10 break;
1986     }
1987     case 191:
1988     {
1989     if (Diff (w[4], w[2]))
1990     {
1991     PIXEL00_0}
1992     else
1993     {
1994     PIXEL00_100}
1995     if (Diff (w[2], w[6]))
1996     {
1997     PIXEL01_0}
1998     else
1999     {
2000     PIXEL01_100}
2001     PIXEL10_11 PIXEL11_12 break;
2002     }
2003     case 223:
2004     {
2005     if (Diff (w[4], w[2]))
2006     {
2007     PIXEL00_0}
2008     else
2009     {
2010     PIXEL00_20}
2011     if (Diff (w[2], w[6]))
2012     {
2013     PIXEL01_0}
2014     else
2015     {
2016     PIXEL01_100}
2017     PIXEL10_10 if (Diff (w[6], w[8]))
2018     {
2019     PIXEL11_0}
2020     else
2021     {
2022     PIXEL11_20}
2023     break;
2024     }
2025     case 247:
2026     {
2027     PIXEL00_11 if (Diff (w[2], w[6]))
2028     {
2029     PIXEL01_0}
2030     else
2031     {
2032     PIXEL01_100}
2033     PIXEL10_12 if (Diff (w[6], w[8]))
2034     {
2035     PIXEL11_0}
2036     else
2037     {
2038     PIXEL11_100}
2039     break;
2040     }
2041     case 255:
2042     {
2043     if (Diff (w[4], w[2]))
2044     {
2045     PIXEL00_0}
2046     else
2047     {
2048     PIXEL00_100}
2049     if (Diff (w[2], w[6]))
2050     {
2051     PIXEL01_0}
2052     else
2053     {
2054     PIXEL01_100}
2055     if (Diff (w[8], w[4]))
2056     {
2057     PIXEL10_0}
2058     else
2059     {
2060     PIXEL10_100}
2061     if (Diff (w[6], w[8]))
2062     {
2063     PIXEL11_0}
2064     else
2065     {
2066     PIXEL11_100}
2067     break;
2068     }
2069     }
2070     pIn += sizeof (pixel);
2071     pOut += sizeof (pixel) * 2;
2072     }
2073    
2074     pOut += BpL;
2075     }
2076     }
2077    
2078     // filla
2079    
2080     static inline void gather (pixel *img, char *flag, int x, int y, int w, int h, int &c, int &r, int &g, int &b)
2081     {
2082     if (x < 0 || x >= w)
2083     return;
2084    
2085     if (y < 0 || y >= h)
2086     return;
2087    
2088     int p = img [y * w + x];
2089    
2090     int weight = (p >> Ashift) & Cmask;
2091     if (!weight)
2092     weight = !!flag [y * w + x];
2093    
2094     if (!weight)
2095     return;
2096    
2097     c += weight;
2098    
2099     r += ((p >> Rshift) & Cmask) * weight;
2100     g += ((p >> Gshift) & Cmask) * weight;
2101     b += ((p >> Bshift) & Cmask) * weight;
2102     }
2103    
2104     static void filla (pixel *img, int w, int h)
2105     {
2106     char *flag = (char *)calloc (w * h, 1);
2107     char *flag2 = (char *)calloc (w * h, 1);
2108     pixel *dst = new pixel [w * h];
2109    
2110     for (int iter = 3; --iter; )
2111     {
2112     for (int x = 0; x < w; x++)
2113     for (int y = 0; y < h; y++)
2114     {
2115     int o = y * w + x;
2116    
2117     if ((img [o] & Amask) || flag [o])
2118     dst [o] = img [o];
2119     else
2120     {
2121     int weight = 0, r = 0, g = 0, b = 0;
2122    
2123     gather (img, flag, x - 1, y - 1, w, h, weight, r, g, b);
2124     gather (img, flag, x , y - 1, w, h, weight, r, g, b);
2125     gather (img, flag, x + 1, y - 1, w, h, weight, r, g, b);
2126     gather (img, flag, x - 1, y , w, h, weight, r, g, b);
2127     gather (img, flag, x + 1, y , w, h, weight, r, g, b);
2128     gather (img, flag, x - 1, y + 1, w, h, weight, r, g, b);
2129     gather (img, flag, x , y + 1, w, h, weight, r, g, b);
2130     gather (img, flag, x + 1, y + 1, w, h, weight, r, g, b);
2131    
2132     if (weight)
2133     {
2134     flag2 [o] = 1;
2135     dst [o] = ((r + weight / 2) / weight) << Rshift
2136     | ((g + weight / 2) / weight) << Gshift
2137     | ((b + weight / 2) / weight) << Bshift;
2138     }
2139     else
2140     dst [o] = img [o]; // not yet here
2141     }
2142     }
2143    
2144     memcpy (img, dst, w * h * sizeof (pixel));
2145     memcpy (flag, flag2, w * h);
2146     }
2147    
2148     for (int o = w * h; o--; )
2149     if (!(img [o] & Amask || flag [o]))
2150     img [o] = 0;
2151    
2152     delete [] dst;
2153     free (flag);
2154     free (flag2);
2155     }
2156    
2157     static void cleara (pixel *img, int w, int h)
2158     {
2159     for (int o = 0; o < w * h; o++)
2160     {
2161     pixel pix = img [o];
2162     if (!((pix >> Ashift) & Cmask))
2163     img [o] = 0;
2164     }
2165     }
2166    
2167     int main (int argc, char* argv[])
2168     {
2169     if (argc <= 3)
2170     {
2171     printf("\nUsage: hq2xa w h wrap <input.rgba >output.rgba\n");
2172     printf("input file must be 32 bit rgba w*h.\n");
2173     return 1;
2174     }
2175    
2176     int w = atoi (argv [1]);
2177     int h = atoi (argv [2]);
2178     bool wrap = !!atoi (argv [3]);
2179    
2180     int size = w * h * sizeof (pixel);
2181    
2182     unsigned char *in = new unsigned char [size];
2183     unsigned char *out = new unsigned char [size * 4];
2184    
2185     if (fread (in, size, 1, stdin) != 1)
2186     {
2187     perror ("unable to read input file\n");
2188     exit (1);
2189     }
2190    
2191     filla ((pixel *)in, w, h);
2192     hq2x_32 (in, out, w, h, w * sizeof (pixel) * 2, wrap);
2193     cleara ((pixel *)out, w * 2, h * 2);
2194    
2195     if (fwrite (out, size * 4, 1, stdout) != 1)
2196     {
2197     perror ("unable to read output file\n");
2198     exit (1);
2199     }
2200    
2201     return 0;
2202     }
2203