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

File Contents

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