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

# Content
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