ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/utils/cfhq2xa.C
Revision: 1.1
Committed: Sun Apr 1 00:36:35 2007 UTC (17 years, 1 month ago) by root
Content type: text/plain
Branch: MAIN
CVS Tags: rel-2_1
Log Message: 
- add cfhq2xa to the installed binaries
- cfutil: autogenerate 64x64 versions out of existing 32x32 versions
  if required (--cache is highly recommended).
- rename faces to facedata to avoid clashes with the old file.
- add the 64x64 tiles to faceset 1 in the server (unused)

TODO: protocol to split faces (they are too large)
TODO: devise a faceset protocol incompatible enough with gcfclient so it
      doesn't puke.

File Contents

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