ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/utils/cfhq2xa.C
Revision: 1.15
Committed: Fri Nov 18 05:53:42 2016 UTC (7 years, 6 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.14: +11 -4 lines
Log Message: 
*** empty log message ***

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