ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/utils/cfhq2xa.C
Revision: 1.9
Committed: Fri Mar 26 00:59:22 2010 UTC (14 years, 2 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.8: +1 -1 lines
Log Message: 
remove bogus 2007 copyright that was added wrongly by the script, update to affero license

File Contents

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