ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/utils/cfhq2xa.C
Revision: 1.3
Committed: Sun Jul 1 05:00:21 2007 UTC (16 years, 10 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.2: +11 -12 lines
Log Message: 
- upgrade crossfire trt to the GPL version 3 (hopefully correctly).
- add a single file covered by the GNU Affero General Public License
  (which is not yet released, so I used the current draft, which is
  legally a bit wavy, but its likely better than nothing as it expresses
  direct intent by the authors, and we can upgrade as soon as it has been
  released).
  * this should ensure availability of source code for the server at least
    and hopefully also archetypes and maps even when modified versions
    are not being distributed, in accordance of section 13 of the agplv3.

File Contents

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