ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/utils/cfhq2xa.C
Revision: 1.16
Committed: Sat Nov 17 23:40:05 2018 UTC (5 years, 6 months ago) by root
Content type: text/plain
Branch: MAIN
CVS Tags: HEAD
Changes since 1.15: +1 -0 lines
Log Message: 
copyright update 2018

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