ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/utils/cfhq2xa.C
Revision: 1.5
Committed: Thu Nov 8 19:43:30 2007 UTC (16 years, 7 months ago) by root
Content type: text/plain
Branch: MAIN
CVS Tags: rel-2_80, rel-2_6, rel-2_7, rel-2_4, rel-2_5, rel-2_72, rel-2_73, rel-2_71, rel-2_76, rel-2_77, rel-2_74, rel-2_75, rel-2_54, rel-2_55, rel-2_56, rel-2_79, rel-2_52, rel-2_53, rel-2_32, rel-2_78, rel-2_61, rel-2_43, rel-2_42, rel-2_41
Changes since 1.4: +4 -4 lines
Log Message: 
update copyrights and other minor stuff to deliantra

File Contents

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