ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/utils/cfhq2xa.C
Revision: 1.2
Committed: Mon May 28 21:21:42 2007 UTC (16 years, 11 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.1: +24 -19 lines
Log Message: 
update copyrights in common/*.C and util/*.C

File Contents

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