hq2xScaler.cpp

Go to the documentation of this file.
00001 //hq2x filter demo program
00002 //----------------------------------------------------------
00003 //Copyright (C) 2003 MaxSt ( maxst@hiend3d.com )
00004 //
00005 //This program is free software; you can redistribute it and/or
00006 //modify it under the terms of the GNU General Public License
00007 //as published by the Free Software Foundation; either
00008 //version 2 of the License, or (at your option) any later
00009 //version.
00010 //
00011 //This program is distributed in the hope that it will be useful,
00012 //but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 //GNU General Public License for more details.
00015 //
00016 //You should have received a copy of the GNU General Public License
00017 //along with this program; if not, write to the Free Software
00018 //Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00019 
00020 #include "pent_include.h"
00021 
00022 #ifdef USE_HQ2X_SCALER
00023 
00024 #include "hq2xScaler.h"
00025 #include "Manips.h"
00026 #include "Texture.h"
00027 
00028 namespace Pentagram {
00029 
00030 static bool InitedLUT = false;
00031 static uint32 RGBtoYUV[65536];
00032 static uint32 YUV1;
00033 static uint32 YUV2;
00034 static const uint32 Ymask = 0x00FF0000;
00035 static const uint32 Umask = 0x0000FF00;
00036 static const uint32 Vmask = 0x000000FF;
00037 static const uint32 trY   = 0x00300000;
00038 static const uint32 trU   = 0x00000700;
00039 static const uint32 trV   = 0x00000006;
00040 static const uint32 tableMaskR = 0;
00041 static const uint32 tableMaskG = 0;
00042 static const uint32 tableMaskB = 0;
00043 
00044 template<class uintX, class Manip, class uintS=uintX> class hq2xScalerInternal {
00045 
00046         static inline void Interp1(uint8 * pc, uintS c1, uintS c2)
00047         {
00048                 //      *((int*)pc) = (c1*3+c2) >> 2;
00049                 uint8 rgba1[4];
00050                 uint8 rgba2[4];
00051                 uint8 res[4];
00052 
00053                 Manip::split(c1,rgba1[0], rgba1[1], rgba1[2], rgba1[3]);
00054                 Manip::split(c2,rgba2[0], rgba2[1], rgba2[2], rgba2[3]);
00055 
00056                 for (int i=0; i<4; i++) res[i]=(rgba1[i]*3+rgba2[i])>>2;
00057 
00058                 *reinterpret_cast<uintX*>(pc) = Manip::merge(res[0],res[1],res[2],res[3]);
00059         }
00060 
00061         static inline void Interp2(uint8 * pc, uintS c1, uintS c2, uintS c3)
00062         {
00063                 //  *((int*)pc) = (c1*2+c2+c3) >> 2;
00064                 uint8 rgba1[4];
00065                 uint8 rgba2[4];
00066                 uint8 rgba3[4];
00067                 uint8 res[4];
00068 
00069                 Manip::split(c1,rgba1[0], rgba1[1], rgba1[2], rgba1[3]);
00070                 Manip::split(c2,rgba2[0], rgba2[1], rgba2[2], rgba2[3]);
00071                 Manip::split(c3,rgba3[0], rgba3[1], rgba3[2], rgba3[3]);
00072 
00073                 for (int i=0; i<4; i++) res[i]=(rgba1[i]*2+rgba2[i]+rgba3[i])>>2;
00074 
00075                 *reinterpret_cast<uintX*>(pc) = Manip::merge(res[0],res[1],res[2],res[3]);
00076 
00077         }
00078 
00079         static inline void Interp5(uint8 * pc, uintS c1, uintS c2)
00080         {
00081                 //  *((int*)pc) = (c1+c2) >> 1;
00082                 uint8 rgba1[4];
00083                 uint8 rgba2[4];
00084                 uint8 res[4];
00085 
00086                 Manip::split(c1,rgba1[0], rgba1[1], rgba1[2], rgba1[3]);
00087                 Manip::split(c2,rgba2[0], rgba2[1], rgba2[2], rgba2[3]);
00088 
00089                 for (int i=0; i<4; i++) res[i]=(rgba1[i]+rgba2[i])>>1;
00090 
00091                 *reinterpret_cast<uintX*>(pc) = Manip::merge(res[0],res[1],res[2],res[3]);
00092 
00093         }
00094 
00095         static inline void Interp6(uint8 * pc, uintS c1, uintS c2, uintS c3)
00096         {
00097                 //*((int*)pc) = (c1*5+c2*2+c3)/8;
00098 
00099                 //*((int*)pc) = ((((c1 & 0x00FF00)*5 + (c2 & 0x00FF00)*2 + (c3 & 0x00FF00) ) & 0x0007F800) +
00100                 //               (((c1 & 0xFF00FF)*5 + (c2 & 0xFF00FF)*2 + (c3 & 0xFF00FF) ) & 0x07F807F8)) >> 3;
00101                 uint8 rgba1[4];
00102                 uint8 rgba2[4];
00103                 uint8 rgba3[4];
00104                 uint8 res[4];
00105 
00106                 Manip::split(c1,rgba1[0], rgba1[1], rgba1[2], rgba1[3]);
00107                 Manip::split(c2,rgba2[0], rgba2[1], rgba2[2], rgba2[3]);
00108                 Manip::split(c3,rgba3[0], rgba3[1], rgba3[2], rgba3[3]);
00109 
00110                 for (int i=0; i<4; i++) res[i]=(rgba1[i]*5+rgba2[i]*2+rgba3[i])>>3;
00111 
00112                 *reinterpret_cast<uintX*>(pc) = Manip::merge(res[0],res[1],res[2],res[3]);
00113         }
00114 
00115         static inline void Interp7(uint8 * pc, uintS c1, uintS c2, uintS c3)
00116         {
00117                 //*((int*)pc) = (c1*6+c2+c3)/8;
00118 
00119                 //*((int*)pc) = ((((c1 & 0x00FF00)*6 + (c2 & 0x00FF00) + (c3 & 0x00FF00) ) & 0x0007F800) +
00120                 //               (((c1 & 0xFF00FF)*6 + (c2 & 0xFF00FF) + (c3 & 0xFF00FF) ) & 0x07F807F8)) >> 3;
00121                 uint8 rgba1[4];
00122                 uint8 rgba2[4];
00123                 uint8 rgba3[4];
00124                 uint8 res[4];
00125 
00126                 Manip::split(c1,rgba1[0], rgba1[1], rgba1[2], rgba1[3]);
00127                 Manip::split(c2,rgba2[0], rgba2[1], rgba2[2], rgba2[3]);
00128                 Manip::split(c3,rgba3[0], rgba3[1], rgba3[2], rgba3[3]);
00129 
00130                 for (int i=0; i<4; i++) res[i]=(rgba1[i]*6+rgba2[i]+rgba3[i])>>3;
00131 
00132                 *reinterpret_cast<uintX*>(pc) = Manip::merge(res[0],res[1],res[2],res[3]);
00133 
00134         }
00135 
00136         static inline void Interp9(uint8 * pc, uintS c1, uintS c2, uintS c3)
00137         {
00138                 //*((int*)pc) = (c1*2+(c2+c3)*3)/8;
00139 
00140                 //*((int*)pc) = ((((c1 & 0x00FF00)*2 + ((c2 & 0x00FF00) + (c3 & 0x00FF00))*3 ) & 0x0007F800) +
00141                 //               (((c1 & 0xFF00FF)*2 + ((c2 & 0xFF00FF) + (c3 & 0xFF00FF))*3 ) & 0x07F807F8)) >> 3;
00142                 uint8 rgba1[4];
00143                 uint8 rgba2[4];
00144                 uint8 rgba3[4];
00145                 uint8 res[4];
00146 
00147                 Manip::split(c1,rgba1[0], rgba1[1], rgba1[2], rgba1[3]);
00148                 Manip::split(c2,rgba2[0], rgba2[1], rgba2[2], rgba2[3]);
00149                 Manip::split(c3,rgba3[0], rgba3[1], rgba3[2], rgba3[3]);
00150 
00151                 for (int i=0; i<4; i++) res[i]=(rgba1[i]*2+(rgba2[i]+rgba3[i])*3)>>3;
00152 
00153                 *reinterpret_cast<uintX*>(pc) = Manip::merge(res[0],res[1],res[2],res[3]);
00154         }
00155 
00156         static inline void Interp10(uint8 * pc, uintS c1, uintS c2, uintS c3)
00157         {
00158                 //*((int*)pc) = (c1*14+c2+c3)/16;
00159 
00160                 //*((int*)pc) = ((((c1 & 0x00FF00)*14 + (c2 & 0x00FF00) + (c3 & 0x00FF00) ) & 0x000FF000) +
00161                 //               (((c1 & 0xFF00FF)*14 + (c2 & 0xFF00FF) + (c3 & 0xFF00FF) ) & 0x0FF00FF0)) >> 4;
00162                 uint8 rgba1[4];
00163                 uint8 rgba2[4];
00164                 uint8 rgba3[4];
00165                 uint32 res[4];
00166 
00167                 Manip::split(c1,rgba1[0], rgba1[1], rgba1[2], rgba1[3]);
00168                 Manip::split(c2,rgba2[0], rgba2[1], rgba2[2], rgba2[3]);
00169                 Manip::split(c3,rgba3[0], rgba3[1], rgba3[2], rgba3[3]);
00170 
00171                 for (int i=0; i<4; i++) res[i]=(rgba1[i]*14+rgba2[i]+rgba3[i])>>4;
00172 
00173                 *reinterpret_cast<uintX*>(pc) = Manip::merge(res[0],res[1],res[2],res[3]);
00174         }
00175 
00176 
00177 #define PIXEL00_0     *(reinterpret_cast<uintX*>(pOut)) = Manip::copy(c32[5]);
00178 #define PIXEL00_10    Interp1(pOut, c32[5], c32[1]);
00179 #define PIXEL00_11    Interp1(pOut, c32[5], c32[4]);
00180 #define PIXEL00_12    Interp1(pOut, c32[5], c32[2]);
00181 #define PIXEL00_20    Interp2(pOut, c32[5], c32[4], c32[2]);
00182 #define PIXEL00_21    Interp2(pOut, c32[5], c32[1], c32[2]);
00183 #define PIXEL00_22    Interp2(pOut, c32[5], c32[1], c32[4]);
00184 #define PIXEL00_60    Interp6(pOut, c32[5], c32[2], c32[4]);
00185 #define PIXEL00_61    Interp6(pOut, c32[5], c32[4], c32[2]);
00186 #define PIXEL00_70    Interp7(pOut, c32[5], c32[4], c32[2]);
00187 #define PIXEL00_90    Interp9(pOut, c32[5], c32[4], c32[2]);
00188 #define PIXEL00_100   Interp10(pOut, c32[5], c32[4], c32[2]);
00189 #define PIXEL01_0     *(reinterpret_cast<uintX*>(pOut+sizeof(uintX))) = Manip::copy(c32[5]);
00190 #define PIXEL01_10    Interp1(pOut+sizeof(uintX), c32[5], c32[3]);
00191 #define PIXEL01_11    Interp1(pOut+sizeof(uintX), c32[5], c32[2]);
00192 #define PIXEL01_12    Interp1(pOut+sizeof(uintX), c32[5], c32[6]);
00193 #define PIXEL01_20    Interp2(pOut+sizeof(uintX), c32[5], c32[2], c32[6]);
00194 #define PIXEL01_21    Interp2(pOut+sizeof(uintX), c32[5], c32[3], c32[6]);
00195 #define PIXEL01_22    Interp2(pOut+sizeof(uintX), c32[5], c32[3], c32[2]);
00196 #define PIXEL01_60    Interp6(pOut+sizeof(uintX), c32[5], c32[6], c32[2]);
00197 #define PIXEL01_61    Interp6(pOut+sizeof(uintX), c32[5], c32[2], c32[6]);
00198 #define PIXEL01_70    Interp7(pOut+sizeof(uintX), c32[5], c32[2], c32[6]);
00199 #define PIXEL01_90    Interp9(pOut+sizeof(uintX), c32[5], c32[2], c32[6]);
00200 #define PIXEL01_100   Interp10(pOut+sizeof(uintX), c32[5], c32[2], c32[6]);
00201 #define PIXEL10_0     *(reinterpret_cast<uintX*>(pOut+BpL)) = Manip::copy(c32[5]);
00202 #define PIXEL10_10    Interp1(pOut+BpL, c32[5], c32[7]);
00203 #define PIXEL10_11    Interp1(pOut+BpL, c32[5], c32[8]);
00204 #define PIXEL10_12    Interp1(pOut+BpL, c32[5], c32[4]);
00205 #define PIXEL10_20    Interp2(pOut+BpL, c32[5], c32[8], c32[4]);
00206 #define PIXEL10_21    Interp2(pOut+BpL, c32[5], c32[7], c32[4]);
00207 #define PIXEL10_22    Interp2(pOut+BpL, c32[5], c32[7], c32[8]);
00208 #define PIXEL10_60    Interp6(pOut+BpL, c32[5], c32[4], c32[8]);
00209 #define PIXEL10_61    Interp6(pOut+BpL, c32[5], c32[8], c32[4]);
00210 #define PIXEL10_70    Interp7(pOut+BpL, c32[5], c32[8], c32[4]);
00211 #define PIXEL10_90    Interp9(pOut+BpL, c32[5], c32[8], c32[4]);
00212 #define PIXEL10_100   Interp10(pOut+BpL, c32[5], c32[8], c32[4]);
00213 #define PIXEL11_0     *(reinterpret_cast<uintX*>(pOut+BpL+sizeof(uintX))) = Manip::copy(c32[5]);
00214 #define PIXEL11_10    Interp1(pOut+BpL+sizeof(uintX), c32[5], c32[9]);
00215 #define PIXEL11_11    Interp1(pOut+BpL+sizeof(uintX), c32[5], c32[6]);
00216 #define PIXEL11_12    Interp1(pOut+BpL+sizeof(uintX), c32[5], c32[8]);
00217 #define PIXEL11_20    Interp2(pOut+BpL+sizeof(uintX), c32[5], c32[6], c32[8]);
00218 #define PIXEL11_21    Interp2(pOut+BpL+sizeof(uintX), c32[5], c32[9], c32[8]);
00219 #define PIXEL11_22    Interp2(pOut+BpL+sizeof(uintX), c32[5], c32[9], c32[6]);
00220 #define PIXEL11_60    Interp6(pOut+BpL+sizeof(uintX), c32[5], c32[8], c32[6]);
00221 #define PIXEL11_61    Interp6(pOut+BpL+sizeof(uintX), c32[5], c32[6], c32[8]);
00222 #define PIXEL11_70    Interp7(pOut+BpL+sizeof(uintX), c32[5], c32[6], c32[8]);
00223 #define PIXEL11_90    Interp9(pOut+BpL+sizeof(uintX), c32[5], c32[6], c32[8]);
00224 #define PIXEL11_100   Interp10(pOut+BpL+sizeof(uintX), c32[5], c32[6], c32[8]);
00225 
00226         static inline bool Diff(unsigned int w1, unsigned int w2)
00227         {
00228                 YUV1 = RGBtoYUV[w1];
00229                 YUV2 = RGBtoYUV[w2];
00230                 return ( ( abs((YUV1 & Ymask) - (YUV2 & Ymask)) > trY ) ||
00231                         ( abs((YUV1 & Umask) - (YUV2 & Umask)) > trU ) ||
00232                         ( abs((YUV1 & Vmask) - (YUV2 & Vmask)) > trV ) );
00233         }
00234 
00235 public:
00236 
00237         static void InitLUTs(void)
00238         {
00239                 if (InitedLUT) return;
00240                 InitedLUT = true;
00241 
00242                 int i, j, k, r, g, b, Y, u, v;
00243 
00244                 for (i=0; i<32; i++)
00245                         for (j=0; j<64; j++)
00246                                 for (k=0; k<32; k++)
00247                                 {
00248                                         r = i << 3;
00249                                         g = j << 2;
00250                                         b = k << 3;
00251                                         Y = (r + g + b) >> 2;
00252                                         u = 128 + ((r - b) >> 2);
00253                                         v = 128 + ((-r + 2*g -b)>>3);
00254                                         RGBtoYUV[ (i << 11) + (j << 5) + k ] = (Y<<16) + (u<<8) + v;
00255                                 }
00256         }
00257 
00258         static bool hq2x_32(Texture *tex, sint32 sx, sint32 sy, sint32 Xres, sint32 Yres, 
00259                 uint8* pOut, sint32 dw, sint32 dh, sint32 BpL, bool clamp_src)
00260         {
00261                 if (Xres*2!=dw || Yres*2!=dh) return false;
00262 
00263                 InitLUTs();
00264 
00265                 int             i, j, k;
00266                 int             prevline, nextline;
00267                 uint32  w16[10];
00268                 uintS   c32[10];
00269 
00270                 // Source buffer pointers
00271                 int tpitch = tex->width*sizeof(uintS);
00272                 uint8 *pIn = reinterpret_cast<uint8*>(tex->buffer) + sy*tpitch + sx*sizeof(uintS);
00273                 int tex_diff = tpitch - Xres*sizeof(uintX);
00274 
00275                 int pix_diff = BpL*2-Xres*2*sizeof(uintX);
00276 
00277                 bool clipX = true;
00278                 bool clipY_Begin = true;
00279                 bool clipY_End = true;
00280 
00281                 if (!clamp_src && sy!=0) clipY_Begin = false;
00282                 if (!clamp_src && (Yres+sy)<tex->height) clipY_End = false;
00283 
00284                 //   +----+----+----+
00285                 //   |    |    |    |
00286                 //   | w1 | w2 | w3 |
00287                 //   +----+----+----+
00288                 //   |    |    |    |
00289                 //   | w4 | w5 | w6 |
00290                 //   +----+----+----+
00291                 //   |    |    |    |
00292                 //   | w7 | w8 | w9 |
00293                 //   +----+----+----+
00294 
00295                 for (j=0; j<Yres; j++)
00296                 {
00297                         if (j==0 || !clipY_Begin)   prevline = -tpitch; else prevline = 0;
00298                         if (j<Yres-1 || !clipY_End)     nextline =  tpitch; else nextline = 0;
00299 
00300                         // Read first 2 columns of pixels 
00301                         c32[2] = c32[3] = *reinterpret_cast<uintS*>(pIn + prevline);
00302                         c32[5] = c32[6] = *reinterpret_cast<uintS*>(pIn);
00303                         c32[8] = c32[9] = *reinterpret_cast<uintS*>(pIn + nextline);
00304 
00305                         w16[2] = w16[3] = Manip::to16bit(c32[2]);
00306                         w16[5] = w16[6] = Manip::to16bit(c32[5]);
00307                         w16[8] = w16[9] = Manip::to16bit(c32[6]);
00308 
00309                         for (i=0; i<Xres; i++)
00310                         {
00311                                 // First col = Prev Second column
00312                                 c32[1] = c32[2];
00313                                 c32[4] = c32[5];
00314                                 c32[7] = c32[8];
00315                                 w16[1] = w16[2];
00316                                 w16[4] = w16[5];
00317                                 w16[7] = w16[8];
00318 
00319                                 // Second col = Prev Third column
00320                                 c32[2] = c32[3];
00321                                 c32[5] = c32[6];
00322                                 c32[8] = c32[9];
00323                                 w16[2] = w16[3];
00324                                 w16[5] = w16[6];
00325                                 w16[8] = w16[9];
00326 
00327                                 // Read Next Pixel
00328                                 if (i<Xres-1 || !clipX)
00329                                 {
00330                                         c32[3] = *reinterpret_cast<uintS*>(pIn + sizeof(uintS) + prevline);
00331                                         c32[6] = *reinterpret_cast<uintS*>(pIn + sizeof(uintS));
00332                                         c32[9] = *reinterpret_cast<uintS*>(pIn + sizeof(uintS) + nextline);
00333                                         w16[3] = Manip::to16bit(c32[3]);
00334                                         w16[6] = Manip::to16bit(c32[6]);
00335                                         w16[9] = Manip::to16bit(c32[9]);
00336                                 }
00337 
00338                                 int pattern = 0;
00339                                 int flag = 1;
00340 
00341                                 YUV1 = RGBtoYUV[w16[5]];
00342 
00343                                 for (k=1; k<=9; k++)
00344                                 {
00345                                         if (k==5) continue;
00346 
00347                                         if ( w16[k] != w16[5] )
00348                                         {
00349                                                 YUV2 = RGBtoYUV[w16[k]];
00350                                                 if ( ( abs((YUV1 & Ymask) - (YUV2 & Ymask)) > trY ) ||
00351                                                         ( abs((YUV1 & Umask) - (YUV2 & Umask)) > trU ) ||
00352                                                         ( abs((YUV1 & Vmask) - (YUV2 & Vmask)) > trV ) )
00353                                                         pattern |= flag;
00354                                         }
00355                                         flag <<= 1;
00356                                 }
00357 
00358                                 switch (pattern)
00359                                 {
00360                                 case 0:
00361                                 case 1:
00362                                 case 4:
00363                                 case 32:
00364                                 case 128:
00365                                 case 5:
00366                                 case 132:
00367                                 case 160:
00368                                 case 33:
00369                                 case 129:
00370                                 case 36:
00371                                 case 133:
00372                                 case 164:
00373                                 case 161:
00374                                 case 37:
00375                                 case 165:
00376                                         {
00377                                                 PIXEL00_20
00378                                                         PIXEL01_20
00379                                                         PIXEL10_20
00380                                                         PIXEL11_20
00381                                                         break;
00382                                         }
00383                                 case 2:
00384                                 case 34:
00385                                 case 130:
00386                                 case 162:
00387                                         {
00388                                                 PIXEL00_22
00389                                                         PIXEL01_21
00390                                                         PIXEL10_20
00391                                                         PIXEL11_20
00392                                                         break;
00393                                         }
00394                                 case 16:
00395                                 case 17:
00396                                 case 48:
00397                                 case 49:
00398                                         {
00399                                                 PIXEL00_20
00400                                                         PIXEL01_22
00401                                                         PIXEL10_20
00402                                                         PIXEL11_21
00403                                                         break;
00404                                         }
00405                                 case 64:
00406                                 case 65:
00407                                 case 68:
00408                                 case 69:
00409                                         {
00410                                                 PIXEL00_20
00411                                                         PIXEL01_20
00412                                                         PIXEL10_21
00413                                                         PIXEL11_22
00414                                                         break;
00415                                         }
00416                                 case 8:
00417                                 case 12:
00418                                 case 136:
00419                                 case 140:
00420                                         {
00421                                                 PIXEL00_21
00422                                                         PIXEL01_20
00423                                                         PIXEL10_22
00424                                                         PIXEL11_20
00425                                                         break;
00426                                         }
00427                                 case 3:
00428                                 case 35:
00429                                 case 131:
00430                                 case 163:
00431                                         {
00432                                                 PIXEL00_11
00433                                                         PIXEL01_21
00434                                                         PIXEL10_20
00435                                                         PIXEL11_20
00436                                                         break;
00437                                         }
00438                                 case 6:
00439                                 case 38:
00440                                 case 134:
00441                                 case 166:
00442                                         {
00443                                                 PIXEL00_22
00444                                                         PIXEL01_12
00445                                                         PIXEL10_20
00446                                                         PIXEL11_20
00447                                                         break;
00448                                         }
00449                                 case 20:
00450                                 case 21:
00451                                 case 52:
00452                                 case 53:
00453                                         {
00454                                                 PIXEL00_20
00455                                                         PIXEL01_11
00456                                                         PIXEL10_20
00457                                                         PIXEL11_21
00458                                                         break;
00459                                         }
00460                                 case 144:
00461                                 case 145:
00462                                 case 176:
00463                                 case 177:
00464                                         {
00465                                                 PIXEL00_20
00466                                                         PIXEL01_22
00467                                                         PIXEL10_20
00468                                                         PIXEL11_12
00469                                                         break;
00470                                         }
00471                                 case 192:
00472                                 case 193:
00473                                 case 196:
00474                                 case 197:
00475                                         {
00476                                                 PIXEL00_20
00477                                                         PIXEL01_20
00478                                                         PIXEL10_21
00479                                                         PIXEL11_11
00480                                                         break;
00481                                         }
00482                                 case 96:
00483                                 case 97:
00484                                 case 100:
00485                                 case 101:
00486                                         {
00487                                                 PIXEL00_20
00488                                                         PIXEL01_20
00489                                                         PIXEL10_12
00490                                                         PIXEL11_22
00491                                                         break;
00492                                         }
00493                                 case 40:
00494                                 case 44:
00495                                 case 168:
00496                                 case 172:
00497                                         {
00498                                                 PIXEL00_21
00499                                                         PIXEL01_20
00500                                                         PIXEL10_11
00501                                                         PIXEL11_20
00502                                                         break;
00503                                         }
00504                                 case 9:
00505                                 case 13:
00506                                 case 137:
00507                                 case 141:
00508                                         {
00509                                                 PIXEL00_12
00510                                                         PIXEL01_20
00511                                                         PIXEL10_22
00512                                                         PIXEL11_20
00513                                                         break;
00514                                         }
00515                                 case 18:
00516                                 case 50:
00517                                         {
00518                                                 PIXEL00_22
00519                                                         if (Diff(w16[2], w16[6]))
00520                                                         {
00521                                                                 PIXEL01_10
00522                                                         }
00523                                                         else
00524                                                         {
00525                                                                 PIXEL01_20
00526                                                         }
00527                                                         PIXEL10_20
00528                                                                 PIXEL11_21
00529                                                                 break;
00530                                         }
00531                                 case 80:
00532                                 case 81:
00533                                         {
00534                                                 PIXEL00_20
00535                                                         PIXEL01_22
00536                                                         PIXEL10_21
00537                                                         if (Diff(w16[6], w16[8]))
00538                                                         {
00539                                                                 PIXEL11_10
00540                                                         }
00541                                                         else
00542                                                         {
00543                                                                 PIXEL11_20
00544                                                         }
00545                                                         break;
00546                                         }
00547                                 case 72:
00548                                 case 76:
00549                                         {
00550                                                 PIXEL00_21
00551                                                         PIXEL01_20
00552                                                         if (Diff(w16[8], w16[4]))
00553                                                         {
00554                                                                 PIXEL10_10
00555                                                         }
00556                                                         else
00557                                                         {
00558                                                                 PIXEL10_20
00559                                                         }
00560                                                         PIXEL11_22
00561                                                                 break;
00562                                         }
00563                                 case 10:
00564                                 case 138:
00565                                         {
00566                                                 if (Diff(w16[4], w16[2]))
00567                                                 {
00568                                                         PIXEL00_10
00569                                                 }
00570                                                 else
00571                                                 {
00572                                                         PIXEL00_20
00573                                                 }
00574                                                 PIXEL01_21
00575                                                         PIXEL10_22
00576                                                         PIXEL11_20
00577                                                         break;
00578                                         }
00579                                 case 66:
00580                                         {
00581                                                 PIXEL00_22
00582                                                         PIXEL01_21
00583                                                         PIXEL10_21
00584                                                         PIXEL11_22
00585                                                         break;
00586                                         }
00587                                 case 24:
00588                                         {
00589                                                 PIXEL00_21
00590                                                         PIXEL01_22
00591                                                         PIXEL10_22
00592                                                         PIXEL11_21
00593                                                         break;
00594                                         }
00595                                 case 7:
00596                                 case 39:
00597                                 case 135:
00598                                         {
00599                                                 PIXEL00_11
00600                                                         PIXEL01_12
00601                                                         PIXEL10_20
00602                                                         PIXEL11_20
00603                                                         break;
00604                                         }
00605                                 case 148:
00606                                 case 149:
00607                                 case 180:
00608                                         {
00609                                                 PIXEL00_20
00610                                                         PIXEL01_11
00611                                                         PIXEL10_20
00612                                                         PIXEL11_12
00613                                                         break;
00614                                         }
00615                                 case 224:
00616                                 case 228:
00617                                 case 225:
00618                                         {
00619                                                 PIXEL00_20
00620                                                         PIXEL01_20
00621                                                         PIXEL10_12
00622                                                         PIXEL11_11
00623                                                         break;
00624                                         }
00625                                 case 41:
00626                                 case 169:
00627                                 case 45:
00628                                         {
00629                                                 PIXEL00_12
00630                                                         PIXEL01_20
00631                                                         PIXEL10_11
00632                                                         PIXEL11_20
00633                                                         break;
00634                                         }
00635                                 case 22:
00636                                 case 54:
00637                                         {
00638                                                 PIXEL00_22
00639                                                         if (Diff(w16[2], w16[6]))
00640                                                         {
00641                                                                 PIXEL01_0
00642                                                         }
00643                                                         else
00644                                                         {
00645                                                                 PIXEL01_20
00646                                                         }
00647                                                         PIXEL10_20
00648                                                                 PIXEL11_21
00649                                                                 break;
00650                                         }
00651                                 case 208:
00652                                 case 209:
00653                                         {
00654                                                 PIXEL00_20
00655                                                         PIXEL01_22
00656                                                         PIXEL10_21
00657                                                         if (Diff(w16[6], w16[8]))
00658                                                         {
00659                                                                 PIXEL11_0
00660                                                         }
00661                                                         else
00662                                                         {
00663                                                                 PIXEL11_20
00664                                                         }
00665                                                         break;
00666                                         }
00667                                 case 104:
00668                                 case 108:
00669                                         {
00670                                                 PIXEL00_21
00671                                                         PIXEL01_20
00672                                                         if (Diff(w16[8], w16[4]))
00673                                                         {
00674                                                                 PIXEL10_0
00675                                                         }
00676                                                         else
00677                                                         {
00678                                                                 PIXEL10_20
00679                                                         }
00680                                                         PIXEL11_22
00681                                                                 break;
00682                                         }
00683                                 case 11:
00684                                 case 139:
00685                                         {
00686                                                 if (Diff(w16[4], w16[2]))
00687                                                 {
00688                                                         PIXEL00_0
00689                                                 }
00690                                                 else
00691                                                 {
00692                                                         PIXEL00_20
00693                                                 }
00694                                                 PIXEL01_21
00695                                                         PIXEL10_22
00696                                                         PIXEL11_20
00697                                                         break;
00698                                         }
00699                                 case 19:
00700                                 case 51:
00701                                         {
00702                                                 if (Diff(w16[2], w16[6]))
00703                                                 {
00704                                                         PIXEL00_11
00705                                                                 PIXEL01_10
00706                                                 }
00707                                                 else
00708                                                 {
00709                                                         PIXEL00_60
00710                                                                 PIXEL01_90
00711                                                 }
00712                                                 PIXEL10_20
00713                                                         PIXEL11_21
00714                                                         break;
00715                                         }
00716                                 case 146:
00717                                 case 178:
00718                                         {
00719                                                 PIXEL00_22
00720                                                         if (Diff(w16[2], w16[6]))
00721                                                         {
00722                                                                 PIXEL01_10
00723                                                                         PIXEL11_12
00724                                                         }
00725                                                         else
00726                                                         {
00727                                                                 PIXEL01_90
00728                                                                         PIXEL11_61
00729                                                         }
00730                                                         PIXEL10_20
00731                                                                 break;
00732                                         }
00733                                 case 84:
00734                                 case 85:
00735                                         {
00736                                                 PIXEL00_20
00737                                                         if (Diff(w16[6], w16[8]))
00738                                                         {
00739                                                                 PIXEL01_11
00740                                                                         PIXEL11_10
00741                                                         }
00742                                                         else
00743                                                         {
00744                                                                 PIXEL01_60
00745                                                                         PIXEL11_90
00746                                                         }
00747                                                         PIXEL10_21
00748                                                                 break;
00749                                         }
00750                                 case 112:
00751                                 case 113:
00752                                         {
00753                                                 PIXEL00_20
00754                                                         PIXEL01_22
00755                                                         if (Diff(w16[6], w16[8]))
00756                                                         {
00757                                                                 PIXEL10_12
00758                                                                         PIXEL11_10
00759                                                         }
00760                                                         else
00761                                                         {
00762                                                                 PIXEL10_61
00763                                                                         PIXEL11_90
00764                                                         }
00765                                                         break;
00766                                         }
00767                                 case 200:
00768                                 case 204:
00769                                         {
00770                                                 PIXEL00_21
00771                                                         PIXEL01_20
00772                                                         if (Diff(w16[8], w16[4]))
00773                                                         {
00774                                                                 PIXEL10_10
00775                                                                         PIXEL11_11
00776                                                         }
00777                                                         else
00778                                                         {
00779                                                                 PIXEL10_90
00780                                                                         PIXEL11_60
00781                                                         }
00782                                                         break;
00783                                         }
00784                                 case 73:
00785                                 case 77:
00786                                         {
00787                                                 if (Diff(w16[8], w16[4]))
00788                                                 {
00789                                                         PIXEL00_12
00790                                                                 PIXEL10_10
00791                                                 }
00792                                                 else
00793                                                 {
00794                                                         PIXEL00_61
00795                                                                 PIXEL10_90
00796                                                 }
00797                                                 PIXEL01_20
00798                                                         PIXEL11_22
00799                                                         break;
00800                                         }
00801                                 case 42:
00802                                 case 170:
00803                                         {
00804                                                 if (Diff(w16[4], w16[2]))
00805                                                 {
00806                                                         PIXEL00_10
00807                                                                 PIXEL10_11
00808                                                 }
00809                                                 else
00810                                                 {
00811                                                         PIXEL00_90
00812                                                                 PIXEL10_60
00813                                                 }
00814                                                 PIXEL01_21
00815                                                         PIXEL11_20
00816                                                         break;
00817                                         }
00818                                 case 14:
00819                                 case 142:
00820                                         {
00821                                                 if (Diff(w16[4], w16[2]))
00822                                                 {
00823                                                         PIXEL00_10
00824                                                                 PIXEL01_12
00825                                                 }
00826                                                 else
00827                                                 {
00828                                                         PIXEL00_90
00829                                                                 PIXEL01_61
00830                                                 }
00831                                                 PIXEL10_22
00832                                                         PIXEL11_20
00833                                                         break;
00834                                         }
00835                                 case 67:
00836                                         {
00837                                                 PIXEL00_11
00838                                                         PIXEL01_21
00839                                                         PIXEL10_21
00840                                                         PIXEL11_22
00841                                                         break;
00842                                         }
00843                                 case 70:
00844                                         {
00845                                                 PIXEL00_22
00846                                                         PIXEL01_12
00847                                                         PIXEL10_21
00848                                                         PIXEL11_22
00849                                                         break;
00850                                         }
00851                                 case 28:
00852                                         {
00853                                                 PIXEL00_21
00854                                                         PIXEL01_11
00855                                                         PIXEL10_22
00856                                                         PIXEL11_21
00857                                                         break;
00858                                         }
00859                                 case 152:
00860                                         {
00861                                                 PIXEL00_21
00862                                                         PIXEL01_22
00863                                                         PIXEL10_22
00864                                                         PIXEL11_12
00865                                                         break;
00866                                         }
00867                                 case 194:
00868                                         {
00869                                                 PIXEL00_22
00870                                                         PIXEL01_21
00871                                                         PIXEL10_21
00872                                                         PIXEL11_11
00873                                                         break;
00874                                         }
00875                                 case 98:
00876                                         {
00877                                                 PIXEL00_22
00878                                                         PIXEL01_21
00879                                                         PIXEL10_12
00880                                                         PIXEL11_22
00881                                                         break;
00882                                         }
00883                                 case 56:
00884                                         {
00885                                                 PIXEL00_21
00886                                                         PIXEL01_22
00887                                                         PIXEL10_11
00888                                                         PIXEL11_21
00889                                                         break;
00890                                         }
00891                                 case 25:
00892                                         {
00893                                                 PIXEL00_12
00894                                                         PIXEL01_22
00895                                                         PIXEL10_22
00896                                                         PIXEL11_21
00897                                                         break;
00898                                         }
00899                                 case 26:
00900                                 case 31:
00901                                         {
00902                                                 if (Diff(w16[4], w16[2]))
00903                                                 {
00904                                                         PIXEL00_0
00905                                                 }
00906                                                 else
00907                                                 {
00908                                                         PIXEL00_20
00909                                                 }
00910                                                 if (Diff(w16[2], w16[6]))
00911                                                 {
00912                                                         PIXEL01_0
00913                                                 }
00914                                                 else
00915                                                 {
00916                                                         PIXEL01_20
00917                                                 }
00918                                                 PIXEL10_22
00919                                                         PIXEL11_21
00920                                                         break;
00921                                         }
00922                                 case 82:
00923                                 case 214:
00924                                         {
00925                                                 PIXEL00_22
00926                                                         if (Diff(w16[2], w16[6]))
00927                                                         {
00928                                                                 PIXEL01_0
00929                                                         }
00930                                                         else
00931                                                         {
00932                                                                 PIXEL01_20
00933                                                         }
00934                                                         PIXEL10_21
00935                                                                 if (Diff(w16[6], w16[8]))
00936                                                                 {
00937                                                                         PIXEL11_0
00938                                                                 }
00939                                                                 else
00940                                                                 {
00941                                                                         PIXEL11_20
00942                                                                 }
00943                                                                 break;
00944                                         }
00945                                 case 88:
00946                                 case 248:
00947                                         {
00948                                                 PIXEL00_21
00949                                                         PIXEL01_22
00950                                                         if (Diff(w16[8], w16[4]))
00951                                                         {
00952                                                                 PIXEL10_0
00953                                                         }
00954                                                         else
00955                                                         {
00956                                                                 PIXEL10_20
00957                                                         }
00958                                                         if (Diff(w16[6], w16[8]))
00959                                                         {
00960                                                                 PIXEL11_0
00961                                                         }
00962                                                         else
00963                                                         {
00964                                                                 PIXEL11_20
00965                                                         }
00966                                                         break;
00967                                         }
00968                                 case 74:
00969                                 case 107:
00970                                         {
00971                                                 if (Diff(w16[4], w16[2]))
00972                                                 {
00973                                                         PIXEL00_0
00974                                                 }
00975                                                 else
00976                                                 {
00977                                                         PIXEL00_20
00978                                                 }
00979                                                 PIXEL01_21
00980                                                         if (Diff(w16[8], w16[4]))
00981                                                         {
00982                                                                 PIXEL10_0
00983                                                         }
00984                                                         else
00985                                                         {
00986                                                                 PIXEL10_20
00987                                                         }
00988                                                         PIXEL11_22
00989                                                                 break;
00990                                         }
00991                                 case 27:
00992                                         {
00993                                                 if (Diff(w16[4], w16[2]))
00994                                                 {
00995                                                         PIXEL00_0
00996                                                 }
00997                                                 else
00998                                                 {
00999                                                         PIXEL00_20
01000                                                 }
01001                                                 PIXEL01_10
01002                                                         PIXEL10_22
01003                                                         PIXEL11_21
01004                                                         break;
01005                                         }
01006                                 case 86:
01007                                         {
01008                                                 PIXEL00_22
01009                                                         if (Diff(w16[2], w16[6]))
01010                                                         {
01011                                                                 PIXEL01_0
01012                                                         }
01013                                                         else
01014                                                         {
01015                                                                 PIXEL01_20
01016                                                         }
01017                                                         PIXEL10_21
01018                                                                 PIXEL11_10
01019                                                                 break;
01020                                         }
01021                                 case 216:
01022                                         {
01023                                                 PIXEL00_21
01024                                                         PIXEL01_22
01025                                                         PIXEL10_10
01026                                                         if (Diff(w16[6], w16[8]))
01027                                                         {
01028                                                                 PIXEL11_0
01029                                                         }
01030                                                         else
01031                                                         {
01032                                                                 PIXEL11_20
01033                                                         }
01034                                                         break;
01035                                         }
01036                                 case 106:
01037                                         {
01038                                                 PIXEL00_10
01039                                                         PIXEL01_21
01040                                                         if (Diff(w16[8], w16[4]))
01041                                                         {
01042                                                                 PIXEL10_0
01043                                                         }
01044                                                         else
01045                                                         {
01046                                                                 PIXEL10_20
01047                                                         }
01048                                                         PIXEL11_22
01049                                                                 break;
01050                                         }
01051                                 case 30:
01052                                         {
01053                                                 PIXEL00_10
01054                                                         if (Diff(w16[2], w16[6]))
01055                                                         {
01056                                                                 PIXEL01_0
01057                                                         }
01058                                                         else
01059                                                         {
01060                                                                 PIXEL01_20
01061                                                         }
01062                                                         PIXEL10_22
01063                                                                 PIXEL11_21
01064                                                                 break;
01065                                         }
01066                                 case 210:
01067                                         {
01068                                                 PIXEL00_22
01069                                                         PIXEL01_10
01070                                                         PIXEL10_21
01071                                                         if (Diff(w16[6], w16[8]))
01072                                                         {
01073                                                                 PIXEL11_0
01074                                                         }
01075                                                         else
01076                                                         {
01077                                                                 PIXEL11_20
01078                                                         }
01079                                                         break;
01080                                         }
01081                                 case 120:
01082                                         {
01083                                                 PIXEL00_21
01084                                                         PIXEL01_22
01085                                                         if (Diff(w16[8], w16[4]))
01086                                                         {
01087                                                                 PIXEL10_0
01088                                                         }
01089                                                         else
01090                                                         {
01091                                                                 PIXEL10_20
01092                                                         }
01093                                                         PIXEL11_10
01094                                                                 break;
01095                                         }
01096                                 case 75:
01097                                         {
01098                                                 if (Diff(w16[4], w16[2]))
01099                                                 {
01100                                                         PIXEL00_0
01101                                                 }
01102                                                 else
01103                                                 {
01104                                                         PIXEL00_20
01105                                                 }
01106                                                 PIXEL01_21
01107                                                         PIXEL10_10
01108                                                         PIXEL11_22
01109                                                         break;
01110                                         }
01111                                 case 29:
01112                                         {
01113                                                 PIXEL00_12
01114                                                         PIXEL01_11
01115                                                         PIXEL10_22
01116                                                         PIXEL11_21
01117                                                         break;
01118                                         }
01119                                 case 198:
01120                                         {
01121                                                 PIXEL00_22
01122                                                         PIXEL01_12
01123                                                         PIXEL10_21
01124                                                         PIXEL11_11
01125                                                         break;
01126                                         }
01127                                 case 184:
01128                                         {
01129                                                 PIXEL00_21
01130                                                         PIXEL01_22
01131                                                         PIXEL10_11
01132                                                         PIXEL11_12
01133                                                         break;
01134                                         }
01135                                 case 99:
01136                                         {
01137                                                 PIXEL00_11
01138                                                         PIXEL01_21
01139                                                         PIXEL10_12
01140                                                         PIXEL11_22
01141                                                         break;
01142                                         }
01143                                 case 57:
01144                                         {
01145                                                 PIXEL00_12
01146                                                         PIXEL01_22
01147                                                         PIXEL10_11
01148                                                         PIXEL11_21
01149                                                         break;
01150                                         }
01151                                 case 71:
01152                                         {
01153                                                 PIXEL00_11
01154                                                         PIXEL01_12
01155                                                         PIXEL10_21
01156                                                         PIXEL11_22
01157                                                         break;
01158                                         }
01159                                 case 156:
01160                                         {
01161                                                 PIXEL00_21
01162                                                         PIXEL01_11
01163                                                         PIXEL10_22
01164                                                         PIXEL11_12
01165                                                         break;
01166                                         }
01167                                 case 226:
01168                                         {
01169                                                 PIXEL00_22
01170                                                         PIXEL01_21
01171                                                         PIXEL10_12
01172                                                         PIXEL11_11
01173                                                         break;
01174                                         }
01175                                 case 60:
01176                                         {
01177                                                 PIXEL00_21
01178                                                         PIXEL01_11
01179                                                         PIXEL10_11
01180                                                         PIXEL11_21
01181                                                         break;
01182                                         }
01183                                 case 195:
01184                                         {
01185                                                 PIXEL00_11
01186                                                         PIXEL01_21
01187                                                         PIXEL10_21
01188                                                         PIXEL11_11
01189                                                         break;
01190                                         }
01191                                 case 102:
01192                                         {
01193                                                 PIXEL00_22
01194                                                         PIXEL01_12
01195                                                         PIXEL10_12
01196                                                         PIXEL11_22
01197                                                         break;
01198                                         }
01199                                 case 153:
01200                                         {
01201                                                 PIXEL00_12
01202                                                         PIXEL01_22
01203                                                         PIXEL10_22
01204                                                         PIXEL11_12
01205                                                         break;
01206                                         }
01207                                 case 58:
01208                                         {
01209                                                 if (Diff(w16[4], w16[2]))
01210                                                 {
01211                                                         PIXEL00_10
01212                                                 }
01213                                                 else
01214                                                 {
01215                                                         PIXEL00_70
01216                                                 }
01217                                                 if (Diff(w16[2], w16[6]))
01218                                                 {
01219                                                         PIXEL01_10
01220                                                 }
01221                                                 else
01222                                                 {
01223                                                         PIXEL01_70
01224                                                 }
01225                                                 PIXEL10_11
01226                                                         PIXEL11_21
01227                                                         break;
01228                                         }
01229                                 case 83:
01230                                         {
01231                                                 PIXEL00_11
01232                                                         if (Diff(w16[2], w16[6]))
01233                                                         {
01234                                                                 PIXEL01_10
01235                                                         }
01236                                                         else
01237                                                         {
01238                                                                 PIXEL01_70
01239                                                         }
01240                                                         PIXEL10_21
01241                                                                 if (Diff(w16[6], w16[8]))
01242                                                                 {
01243                                                                         PIXEL11_10
01244                                                                 }
01245                                                                 else
01246                                                                 {
01247                                                                         PIXEL11_70
01248                                                                 }
01249                                                                 break;
01250                                         }
01251                                 case 92:
01252                                         {
01253                                                 PIXEL00_21
01254                                                         PIXEL01_11
01255                                                         if (Diff(w16[8], w16[4]))
01256                                                         {
01257                                                                 PIXEL10_10
01258                                                         }
01259                                                         else
01260                                                         {
01261                                                                 PIXEL10_70
01262                                                         }
01263                                                         if (Diff(w16[6], w16[8]))
01264                                                         {
01265                                                                 PIXEL11_10
01266                                                         }
01267                                                         else
01268                                                         {
01269                                                                 PIXEL11_70
01270                                                         }
01271                                                         break;
01272                                         }
01273                                 case 202:
01274                                         {
01275                                                 if (Diff(w16[4], w16[2]))
01276                                                 {
01277                                                         PIXEL00_10
01278                                                 }
01279                                                 else
01280                                                 {
01281                                                         PIXEL00_70
01282                                                 }
01283                                                 PIXEL01_21
01284                                                         if (Diff(w16[8], w16[4]))
01285                                                         {
01286                                                                 PIXEL10_10
01287                                                         }
01288                                                         else
01289                                                         {
01290                                                                 PIXEL10_70
01291                                                         }
01292                                                         PIXEL11_11
01293                                                                 break;
01294                                         }
01295                                 case 78:
01296                                         {
01297                                                 if (Diff(w16[4], w16[2]))
01298                                                 {
01299                                                         PIXEL00_10
01300                                                 }
01301                                                 else
01302                                                 {
01303                                                         PIXEL00_70
01304                                                 }
01305                                                 PIXEL01_12
01306                                                         if (Diff(w16[8], w16[4]))
01307                                                         {
01308                                                                 PIXEL10_10
01309                                                         }
01310                                                         else
01311                                                         {
01312                                                                 PIXEL10_70
01313                                                         }
01314                                                         PIXEL11_22
01315                                                                 break;
01316                                         }
01317                                 case 154:
01318                                         {
01319                                                 if (Diff(w16[4], w16[2]))
01320                                                 {
01321                                                         PIXEL00_10
01322                                                 }
01323                                                 else
01324                                                 {
01325                                                         PIXEL00_70
01326                                                 }
01327                                                 if (Diff(w16[2], w16[6]))
01328                                                 {
01329                                                         PIXEL01_10
01330                                                 }
01331                                                 else
01332                                                 {
01333                                                         PIXEL01_70
01334                                                 }
01335                                                 PIXEL10_22
01336                                                         PIXEL11_12
01337                                                         break;
01338                                         }
01339                                 case 114:
01340                                         {
01341                                                 PIXEL00_22
01342                                                         if (Diff(w16[2], w16[6]))
01343                                                         {
01344                                                                 PIXEL01_10
01345                                                         }
01346                                                         else
01347                                                         {
01348                                                                 PIXEL01_70
01349                                                         }
01350                                                         PIXEL10_12
01351                                                                 if (Diff(w16[6], w16[8]))
01352                                                                 {
01353                                                                         PIXEL11_10
01354                                                                 }
01355                                                                 else
01356                                                                 {
01357                                                                         PIXEL11_70
01358                                                                 }
01359                                                                 break;
01360                                         }
01361                                 case 89:
01362                                         {
01363                                                 PIXEL00_12
01364                                                         PIXEL01_22
01365                                                         if (Diff(w16[8], w16[4]))
01366                                                         {
01367                                                                 PIXEL10_10
01368                                                         }
01369                                                         else
01370                                                         {
01371                                                                 PIXEL10_70
01372                                                         }
01373                                                         if (Diff(w16[6], w16[8]))
01374                                                         {
01375                                                                 PIXEL11_10
01376                                                         }
01377                                                         else
01378                                                         {
01379                                                                 PIXEL11_70
01380                                                         }
01381                                                         break;
01382                                         }
01383                                 case 90:
01384                                         {
01385                                                 if (Diff(w16[4], w16[2]))
01386                                                 {
01387                                                         PIXEL00_10
01388                                                 }
01389                                                 else
01390                                                 {
01391                                                         PIXEL00_70
01392                                                 }
01393                                                 if (Diff(w16[2], w16[6]))
01394                                                 {
01395                                                         PIXEL01_10
01396                                                 }
01397                                                 else
01398                                                 {
01399                                                         PIXEL01_70
01400                                                 }
01401                                                 if (Diff(w16[8], w16[4]))
01402                                                 {
01403                                                         PIXEL10_10
01404                                                 }
01405                                                 else
01406                                                 {
01407                                                         PIXEL10_70
01408                                                 }
01409                                                 if (Diff(w16[6], w16[8]))
01410                                                 {
01411                                                         PIXEL11_10
01412                                                 }
01413                                                 else
01414                                                 {
01415                                                         PIXEL11_70
01416                                                 }
01417                                                 break;
01418                                         }
01419                                 case 55:
01420                                 case 23:
01421                                         {
01422                                                 if (Diff(w16[2], w16[6]))
01423                                                 {
01424                                                         PIXEL00_11
01425                                                                 PIXEL01_0
01426                                                 }
01427                                                 else
01428                                                 {
01429                                                         PIXEL00_60
01430                                                                 PIXEL01_90
01431                                                 }
01432                                                 PIXEL10_20
01433                                                         PIXEL11_21
01434                                                         break;
01435                                         }
01436                                 case 182:
01437                                 case 150:
01438                                         {
01439                                                 PIXEL00_22
01440                                                         if (Diff(w16[2], w16[6]))
01441                                                         {
01442                                                                 PIXEL01_0
01443                                                                         PIXEL11_12
01444                                                         }
01445                                                         else
01446                                                         {
01447                                                                 PIXEL01_90
01448                                                                         PIXEL11_61
01449                                                         }
01450                                                         PIXEL10_20
01451                                                                 break;
01452                                         }
01453                                 case 213:
01454                                 case 212:
01455                                         {
01456                                                 PIXEL00_20
01457                                                         if (Diff(w16[6], w16[8]))
01458                                                         {
01459                                                                 PIXEL01_11
01460                                                                         PIXEL11_0
01461                                                         }
01462                                                         else
01463                                                         {
01464                                                                 PIXEL01_60
01465                                                                         PIXEL11_90
01466                                                         }
01467                                                         PIXEL10_21
01468                                                                 break;
01469                                         }
01470                                 case 241:
01471                                 case 240:
01472                                         {
01473                                                 PIXEL00_20
01474                                                         PIXEL01_22
01475                                                         if (Diff(w16[6], w16[8]))
01476                                                         {
01477                                                                 PIXEL10_12
01478                                                                         PIXEL11_0
01479                                                         }
01480                                                         else
01481                                                         {
01482                                                                 PIXEL10_61
01483                                                                         PIXEL11_90
01484                                                         }
01485                                                         break;
01486                                         }
01487                                 case 236:
01488                                 case 232:
01489                                         {
01490                                                 PIXEL00_21
01491                                                         PIXEL01_20
01492                                                         if (Diff(w16[8], w16[4]))
01493                                                         {
01494                                                                 PIXEL10_0
01495                                                                         PIXEL11_11
01496                                                         }
01497                                                         else
01498                                                         {
01499                                                                 PIXEL10_90
01500                                                                         PIXEL11_60
01501                                                         }
01502                                                         break;
01503                                         }
01504                                 case 109:
01505                                 case 105:
01506                                         {
01507                                                 if (Diff(w16[8], w16[4]))
01508                                                 {
01509                                                         PIXEL00_12
01510                                                                 PIXEL10_0
01511                                                 }
01512                                                 else
01513                                                 {
01514                                                         PIXEL00_61
01515                                                                 PIXEL10_90
01516                                                 }
01517                                                 PIXEL01_20
01518                                                         PIXEL11_22
01519                                                         break;
01520                                         }
01521                                 case 171:
01522                                 case 43:
01523                                         {
01524                                                 if (Diff(w16[4], w16[2]))
01525                                                 {
01526                                                         PIXEL00_0
01527                                                                 PIXEL10_11
01528                                                 }
01529                                                 else
01530                                                 {
01531                                                         PIXEL00_90
01532                                                                 PIXEL10_60
01533                                                 }
01534                                                 PIXEL01_21
01535                                                         PIXEL11_20
01536                                                         break;
01537                                         }
01538                                 case 143:
01539                                 case 15:
01540                                         {
01541                                                 if (Diff(w16[4], w16[2]))
01542                                                 {
01543                                                         PIXEL00_0
01544                                                                 PIXEL01_12
01545                                                 }
01546                                                 else
01547                                                 {
01548                                                         PIXEL00_90
01549                                                                 PIXEL01_61
01550                                                 }
01551                                                 PIXEL10_22
01552                                                         PIXEL11_20
01553                                                         break;
01554                                         }
01555                                 case 124:
01556                                         {
01557                                                 PIXEL00_21
01558                                                         PIXEL01_11
01559                                                         if (Diff(w16[8], w16[4]))
01560                                                         {
01561                                                                 PIXEL10_0
01562                                                         }
01563                                                         else
01564                                                         {
01565                                                                 PIXEL10_20
01566                                                         }
01567                                                         PIXEL11_10
01568                                                                 break;
01569                                         }
01570                                 case 203:
01571                                         {
01572                                                 if (Diff(w16[4], w16[2]))
01573                                                 {
01574                                                         PIXEL00_0
01575                                                 }
01576                                                 else
01577                                                 {
01578                                                         PIXEL00_20
01579                                                 }
01580                                                 PIXEL01_21
01581                                                         PIXEL10_10
01582                                                         PIXEL11_11
01583                                                         break;
01584                                         }
01585                                 case 62:
01586                                         {
01587                                                 PIXEL00_10
01588                                                         if (Diff(w16[2], w16[6]))
01589                                                         {
01590                                                                 PIXEL01_0
01591                                                         }
01592                                                         else
01593                                                         {
01594                                                                 PIXEL01_20
01595                                                         }
01596                                                         PIXEL10_11
01597                                                                 PIXEL11_21
01598                                                                 break;
01599                                         }
01600                                 case 211:
01601                                         {
01602                                                 PIXEL00_11
01603                                                         PIXEL01_10
01604                                                         PIXEL10_21
01605                                                         if (Diff(w16[6], w16[8]))
01606                                                         {
01607                                                                 PIXEL11_0
01608                                                         }
01609                                                         else
01610                                                         {
01611                                                                 PIXEL11_20
01612                                                         }
01613                                                         break;
01614                                         }
01615                                 case 118:
01616                                         {
01617                                                 PIXEL00_22
01618                                                         if (Diff(w16[2], w16[6]))
01619                                                         {
01620                                                                 PIXEL01_0
01621                                                         }
01622                                                         else
01623                                                         {
01624                                                                 PIXEL01_20
01625                                                         }
01626                                                         PIXEL10_12
01627                                                                 PIXEL11_10
01628                                                                 break;
01629                                         }
01630                                 case 217:
01631                                         {
01632                                                 PIXEL00_12
01633                                                         PIXEL01_22
01634                                                         PIXEL10_10
01635                                                         if (Diff(w16[6], w16[8]))
01636                                                         {
01637                                                                 PIXEL11_0
01638                                                         }
01639                                                         else
01640                                                         {
01641                                                                 PIXEL11_20
01642                                                         }
01643                                                         break;
01644                                         }
01645                                 case 110:
01646                                         {
01647                                                 PIXEL00_10
01648                                                         PIXEL01_12
01649                                                         if (Diff(w16[8], w16[4]))
01650                                                         {
01651                                                                 PIXEL10_0
01652                                                         }
01653                                                         else
01654                                                         {
01655                                                                 PIXEL10_20
01656                                                         }
01657                                                         PIXEL11_22
01658                                                                 break;
01659                                         }
01660                                 case 155:
01661                                         {
01662                                                 if (Diff(w16[4], w16[2]))
01663                                                 {
01664                                                         PIXEL00_0
01665                                                 }
01666                                                 else
01667                                                 {
01668                                                         PIXEL00_20
01669                                                 }
01670                                                 PIXEL01_10
01671                                                         PIXEL10_22
01672                                                         PIXEL11_12
01673                                                         break;
01674                                         }
01675                                 case 188:
01676                                         {
01677                                                 PIXEL00_21
01678                                                         PIXEL01_11
01679                                                         PIXEL10_11
01680                                                         PIXEL11_12
01681                                                         break;
01682                                         }
01683                                 case 185:
01684                                         {
01685                                                 PIXEL00_12
01686                                                         PIXEL01_22
01687                                                         PIXEL10_11
01688                                                         PIXEL11_12
01689                                                         break;
01690                                         }
01691                                 case 61:
01692                                         {
01693                                                 PIXEL00_12
01694                                                         PIXEL01_11
01695                                                         PIXEL10_11
01696                                                         PIXEL11_21
01697                                                         break;
01698                                         }
01699                                 case 157:
01700                                         {
01701                                                 PIXEL00_12
01702                                                         PIXEL01_11
01703                                                         PIXEL10_22
01704                                                         PIXEL11_12
01705                                                         break;
01706                                         }
01707                                 case 103:
01708                                         {
01709                                                 PIXEL00_11
01710                                                         PIXEL01_12
01711                                                         PIXEL10_12
01712                                                         PIXEL11_22
01713                                                         break;
01714                                         }
01715                                 case 227:
01716                                         {
01717                                                 PIXEL00_11
01718                                                         PIXEL01_21
01719                                                         PIXEL10_12
01720                                                         PIXEL11_11
01721                                                         break;
01722                                         }
01723                                 case 230:
01724                                         {
01725                                                 PIXEL00_22
01726                                                         PIXEL01_12
01727                                                         PIXEL10_12
01728                                                         PIXEL11_11
01729                                                         break;
01730                                         }
01731                                 case 199:
01732                                         {
01733                                                 PIXEL00_11
01734                                                         PIXEL01_12
01735                                                         PIXEL10_21
01736                                                         PIXEL11_11
01737                                                         break;
01738                                         }
01739                                 case 220:
01740                                         {
01741                                                 PIXEL00_21
01742                                                         PIXEL01_11
01743                                                         if (Diff(w16[8], w16[4]))
01744                                                         {
01745                                                                 PIXEL10_10
01746                                                         }
01747                                                         else
01748                                                         {
01749                                                                 PIXEL10_70
01750                                                         }
01751                                                         if (Diff(w16[6], w16[8]))
01752                                                         {
01753                                                                 PIXEL11_0
01754                                                         }
01755                                                         else
01756                                                         {
01757                                                                 PIXEL11_20
01758                                                         }
01759                                                         break;
01760                                         }
01761                                 case 158:
01762                                         {
01763                                                 if (Diff(w16[4], w16[2]))
01764                                                 {
01765                                                         PIXEL00_10
01766                                                 }
01767                                                 else
01768                                                 {
01769                                                         PIXEL00_70
01770                                                 }
01771                                                 if (Diff(w16[2], w16[6]))
01772                                                 {
01773                                                         PIXEL01_0
01774                                                 }
01775                                                 else
01776                                                 {
01777                                                         PIXEL01_20
01778                                                 }
01779                                                 PIXEL10_22
01780                                                         PIXEL11_12
01781                                                         break;
01782                                         }
01783                                 case 234:
01784                                         {
01785                                                 if (Diff(w16[4], w16[2]))
01786                                                 {
01787                                                         PIXEL00_10
01788                                                 }
01789                                                 else
01790                                                 {
01791                                                         PIXEL00_70
01792                                                 }
01793                                                 PIXEL01_21
01794                                                         if (Diff(w16[8], w16[4]))
01795                                                         {
01796                                                                 PIXEL10_0
01797                                                         }
01798                                                         else
01799                                                         {
01800                                                                 PIXEL10_20
01801                                                         }
01802                                                         PIXEL11_11
01803                                                                 break;
01804                                         }
01805                                 case 242:
01806                                         {
01807                                                 PIXEL00_22
01808                                                         if (Diff(w16[2], w16[6]))
01809                                                         {
01810                                                                 PIXEL01_10
01811                                                         }
01812                                                         else
01813                                                         {
01814                                                                 PIXEL01_70
01815                                                         }
01816                                                         PIXEL10_12
01817                                                                 if (Diff(w16[6], w16[8]))
01818                                                                 {
01819                                                                         PIXEL11_0
01820                                                                 }
01821                                                                 else
01822                                                                 {
01823                                                                         PIXEL11_20
01824                                                                 }
01825                                                                 break;
01826                                         }
01827                                 case 59:
01828                                         {
01829                                                 if (Diff(w16[4], w16[2]))
01830                                                 {
01831                                                         PIXEL00_0
01832                                                 }
01833                                                 else
01834                                                 {
01835                                                         PIXEL00_20
01836                                                 }
01837                                                 if (Diff(w16[2], w16[6]))
01838                                                 {
01839                                                         PIXEL01_10
01840                                                 }
01841                                                 else
01842                                                 {
01843                                                         PIXEL01_70
01844                                                 }
01845                                                 PIXEL10_11
01846                                                         PIXEL11_21
01847                                                         break;
01848                                         }
01849                                 case 121:
01850                                         {
01851                                                 PIXEL00_12
01852                                                         PIXEL01_22
01853                                                         if (Diff(w16[8], w16[4]))
01854                                                         {
01855                                                                 PIXEL10_0
01856                                                         }
01857                                                         else
01858                                                         {
01859                                                                 PIXEL10_20
01860                                                         }
01861                                                         if (Diff(w16[6], w16[8]))
01862                                                         {
01863                                                                 PIXEL11_10
01864                                                         }
01865                                                         else
01866                                                         {
01867                                                                 PIXEL11_70
01868                                                         }
01869                                                         break;
01870                                         }
01871                                 case 87:
01872                                         {
01873                                                 PIXEL00_11
01874                                                         if (Diff(w16[2], w16[6]))
01875                                                         {
01876                                                                 PIXEL01_0
01877                                                         }
01878                                                         else
01879                                                         {
01880                                                                 PIXEL01_20
01881                                                         }
01882                                                         PIXEL10_21
01883                                                                 if (Diff(w16[6], w16[8]))
01884                                                                 {
01885                                                                         PIXEL11_10
01886                                                                 }
01887                                                                 else
01888                                                                 {
01889                                                                         PIXEL11_70
01890                                                                 }
01891                                                                 break;
01892                                         }
01893                                 case 79:
01894                                         {
01895                                                 if (Diff(w16[4], w16[2]))
01896                                                 {
01897                                                         PIXEL00_0
01898                                                 }
01899                                                 else
01900                                                 {
01901                                                         PIXEL00_20
01902                                                 }
01903                                                 PIXEL01_12
01904                                                         if (Diff(w16[8], w16[4]))
01905                                                         {
01906                                                                 PIXEL10_10
01907                                                         }
01908                                                         else
01909                                                         {
01910                                                                 PIXEL10_70
01911                                                         }
01912                                                         PIXEL11_22
01913                                                                 break;
01914                                         }
01915                                 case 122:
01916                                         {
01917                                                 if (Diff(w16[4], w16[2]))
01918                                                 {
01919                                                         PIXEL00_10
01920                                                 }
01921                                                 else
01922                                                 {
01923                                                         PIXEL00_70
01924                                                 }
01925                                                 if (Diff(w16[2], w16[6]))
01926                                                 {
01927                                                         PIXEL01_10
01928                                                 }
01929                                                 else
01930                                                 {
01931                                                         PIXEL01_70
01932                                                 }
01933                                                 if (Diff(w16[8], w16[4]))
01934                                                 {
01935                                                         PIXEL10_0
01936                                                 }
01937                                                 else
01938                                                 {
01939                                                         PIXEL10_20
01940                                                 }
01941                                                 if (Diff(w16[6], w16[8]))
01942                                                 {
01943                                                         PIXEL11_10
01944                                                 }
01945                                                 else
01946                                                 {
01947                                                         PIXEL11_70
01948                                                 }
01949                                                 break;
01950                                         }
01951                                 case 94:
01952                                         {
01953                                                 if (Diff(w16[4], w16[2]))
01954                                                 {
01955                                                         PIXEL00_10
01956                                                 }
01957                                                 else
01958                                                 {
01959                                                         PIXEL00_70
01960                                                 }
01961                                                 if (Diff(w16[2], w16[6]))
01962                                                 {
01963                                                         PIXEL01_0
01964                                                 }
01965                                                 else
01966                                                 {
01967                                                         PIXEL01_20
01968                                                 }
01969                                                 if (Diff(w16[8], w16[4]))
01970                                                 {
01971                                                         PIXEL10_10
01972                                                 }
01973                                                 else
01974                                                 {
01975                                                         PIXEL10_70
01976                                                 }
01977                                                 if (Diff(w16[6], w16[8]))
01978                                                 {
01979                                                         PIXEL11_10
01980                                                 }
01981                                                 else
01982                                                 {
01983                                                         PIXEL11_70
01984                                                 }
01985                                                 break;
01986                                         }
01987                                 case 218:
01988                                         {
01989                                                 if (Diff(w16[4], w16[2]))
01990                                                 {
01991                                                         PIXEL00_10
01992                                                 }
01993                                                 else
01994                                                 {
01995                                                         PIXEL00_70
01996                                                 }
01997                                                 if (Diff(w16[2], w16[6]))
01998                                                 {
01999                                                         PIXEL01_10
02000                                                 }
02001                                                 else
02002                                                 {
02003                                                         PIXEL01_70
02004                                                 }
02005                                                 if (Diff(w16[8], w16[4]))
02006                                                 {
02007                                                         PIXEL10_10
02008                                                 }
02009                                                 else
02010                                                 {
02011                                                         PIXEL10_70
02012                                                 }
02013                                                 if (Diff(w16[6], w16[8]))
02014                                                 {
02015                                                         PIXEL11_0
02016                                                 }
02017                                                 else
02018                                                 {
02019                                                         PIXEL11_20
02020                                                 }
02021                                                 break;
02022                                         }
02023                                 case 91:
02024                                         {
02025                                                 if (Diff(w16[4], w16[2]))
02026                                                 {
02027                                                         PIXEL00_0
02028                                                 }
02029                                                 else
02030                                                 {
02031                                                         PIXEL00_20
02032                                                 }
02033                                                 if (Diff(w16[2], w16[6]))
02034                                                 {
02035                                                         PIXEL01_10
02036                                                 }
02037                                                 else
02038                                                 {
02039                                                         PIXEL01_70
02040                                                 }
02041                                                 if (Diff(w16[8], w16[4]))
02042                                                 {
02043                                                         PIXEL10_10
02044                                                 }
02045                                                 else
02046                                                 {
02047                                                         PIXEL10_70
02048                                                 }
02049                                                 if (Diff(w16[6], w16[8]))
02050                                                 {
02051                                                         PIXEL11_10
02052                                                 }
02053                                                 else
02054                                                 {
02055                                                         PIXEL11_70
02056                                                 }
02057                                                 break;
02058                                         }
02059                                 case 229:
02060                                         {
02061                                                 PIXEL00_20
02062                                                         PIXEL01_20
02063                                                         PIXEL10_12
02064                                                         PIXEL11_11
02065                                                         break;
02066                                         }
02067                                 case 167:
02068                                         {
02069                                                 PIXEL00_11
02070                                                         PIXEL01_12
02071                                                         PIXEL10_20
02072                                                         PIXEL11_20
02073                                                         break;
02074                                         }
02075                                 case 173:
02076                                         {
02077                                                 PIXEL00_12
02078                                                         PIXEL01_20
02079                                                         PIXEL10_11
02080                                                         PIXEL11_20
02081                                                         break;
02082                                         }
02083                                 case 181:
02084                                         {
02085                                                 PIXEL00_20
02086                                                         PIXEL01_11
02087                                                         PIXEL10_20
02088                                                         PIXEL11_12
02089                                                         break;
02090                                         }
02091                                 case 186:
02092                                         {
02093                                                 if (Diff(w16[4], w16[2]))
02094                                                 {
02095                                                         PIXEL00_10
02096                                                 }
02097                                                 else
02098                                                 {
02099                                                         PIXEL00_70
02100                                                 }
02101                                                 if (Diff(w16[2], w16[6]))
02102                                                 {
02103                                                         PIXEL01_10
02104                                                 }
02105                                                 else
02106                                                 {
02107                                                         PIXEL01_70
02108                                                 }
02109                                                 PIXEL10_11
02110                                                         PIXEL11_12
02111                                                         break;
02112                                         }
02113                                 case 115:
02114                                         {
02115                                                 PIXEL00_11
02116                                                         if (Diff(w16[2], w16[6]))
02117                                                         {
02118                                                                 PIXEL01_10
02119                                                         }
02120                                                         else
02121                                                         {
02122                                                                 PIXEL01_70
02123                                                         }
02124                                                         PIXEL10_12
02125                                                                 if (Diff(w16[6], w16[8]))
02126                                                                 {
02127                                                                         PIXEL11_10
02128                                                                 }
02129                                                                 else
02130                                                                 {
02131                                                                         PIXEL11_70
02132                                                                 }
02133                                                                 break;
02134                                         }
02135                                 case 93:
02136                                         {
02137                                                 PIXEL00_12
02138                                                         PIXEL01_11
02139                                                         if (Diff(w16[8], w16[4]))
02140                                                         {
02141                                                                 PIXEL10_10
02142                                                         }
02143                                                         else
02144                                                         {
02145                                                                 PIXEL10_70
02146                                                         }
02147                                                         if (Diff(w16[6], w16[8]))
02148                                                         {
02149                                                                 PIXEL11_10
02150                                                         }
02151                                                         else
02152                                                         {
02153                                                                 PIXEL11_70
02154                                                         }
02155                                                         break;
02156                                         }
02157                                 case 206:
02158                                         {
02159                                                 if (Diff(w16[4], w16[2]))
02160                                                 {
02161                                                         PIXEL00_10
02162                                                 }
02163                                                 else
02164                                                 {
02165                                                         PIXEL00_70
02166                                                 }
02167                                                 PIXEL01_12
02168                                                         if (Diff(w16[8], w16[4]))
02169                                                         {
02170                                                                 PIXEL10_10
02171                                                         }
02172                                                         else
02173                                                         {
02174                                                                 PIXEL10_70
02175                                                         }
02176                                                         PIXEL11_11
02177                                                                 break;
02178                                         }
02179                                 case 205:
02180                                 case 201:
02181                                         {
02182                                                 PIXEL00_12
02183                                                         PIXEL01_20
02184                                                         if (Diff(w16[8], w16[4]))
02185                                                         {
02186                                                                 PIXEL10_10
02187                                                         }
02188                                                         else
02189                                                         {
02190                                                                 PIXEL10_70
02191                                                         }
02192                                                         PIXEL11_11
02193                                                                 break;
02194                                         }
02195                                 case 174:
02196                                 case 46:
02197                                         {
02198                                                 if (Diff(w16[4], w16[2]))
02199                                                 {
02200                                                         PIXEL00_10
02201                                                 }
02202                                                 else
02203                                                 {
02204                                                         PIXEL00_70
02205                                                 }
02206                                                 PIXEL01_12
02207                                                         PIXEL10_11
02208                                                         PIXEL11_20
02209                                                         break;
02210                                         }
02211                                 case 179:
02212                                 case 147:
02213                                         {
02214                                                 PIXEL00_11
02215                                                         if (Diff(w16[2], w16[6]))
02216                                                         {
02217                                                                 PIXEL01_10
02218                                                         }
02219                                                         else
02220                                                         {
02221                                                                 PIXEL01_70
02222                                                         }
02223                                                         PIXEL10_20
02224                                                                 PIXEL11_12
02225                                                                 break;
02226                                         }
02227                                 case 117:
02228                                 case 116:
02229                                         {
02230                                                 PIXEL00_20
02231                                                         PIXEL01_11
02232                                                         PIXEL10_12
02233                                                         if (Diff(w16[6], w16[8]))
02234                                                         {
02235                                                                 PIXEL11_10
02236                                                         }
02237                                                         else
02238                                                         {
02239                                                                 PIXEL11_70
02240                                                         }
02241                                                         break;
02242                                         }
02243                                 case 189:
02244                                         {
02245                                                 PIXEL00_12
02246                                                         PIXEL01_11
02247                                                         PIXEL10_11
02248                                                         PIXEL11_12
02249                                                         break;
02250                                         }
02251                                 case 231:
02252                                         {
02253                                                 PIXEL00_11
02254                                                         PIXEL01_12
02255                                                         PIXEL10_12
02256                                                         PIXEL11_11
02257                                                         break;
02258                                         }
02259                                 case 126:
02260                                         {
02261                                                 PIXEL00_10
02262                                                         if (Diff(w16[2], w16[6]))
02263                                                         {
02264                                                                 PIXEL01_0
02265                                                         }
02266                                                         else
02267                                                         {
02268                                                                 PIXEL01_20
02269                                                         }
02270                                                         if (Diff(w16[8], w16[4]))
02271                                                         {
02272                                                                 PIXEL10_0
02273                                                         }
02274                                                         else
02275                                                         {
02276                                                                 PIXEL10_20
02277                                                         }
02278                                                         PIXEL11_10
02279                                                                 break;
02280                                         }
02281                                 case 219:
02282                                         {
02283                                                 if (Diff(w16[4], w16[2]))
02284                                                 {
02285                                                         PIXEL00_0
02286                                                 }
02287                                                 else
02288                                                 {
02289                                                         PIXEL00_20
02290                                                 }
02291                                                 PIXEL01_10
02292                                                         PIXEL10_10
02293                                                         if (Diff(w16[6], w16[8]))
02294                                                         {
02295                                                                 PIXEL11_0
02296                                                         }
02297                                                         else
02298                                                         {
02299                                                                 PIXEL11_20
02300                                                         }
02301                                                         break;
02302                                         }
02303                                 case 125:
02304                                         {
02305                                                 if (Diff(w16[8], w16[4]))
02306                                                 {
02307                                                         PIXEL00_12
02308                                                                 PIXEL10_0
02309                                                 }
02310                                                 else
02311                                                 {
02312                                                         PIXEL00_61
02313                                                                 PIXEL10_90
02314                                                 }
02315                                                 PIXEL01_11
02316                                                         PIXEL11_10
02317                                                         break;
02318                                         }
02319                                 case 221:
02320                                         {
02321                                                 PIXEL00_12
02322                                                         if (Diff(w16[6], w16[8]))
02323                                                         {
02324                                                                 PIXEL01_11
02325                                                                         PIXEL11_0
02326                                                         }
02327                                                         else
02328                                                         {
02329                                                                 PIXEL01_60
02330                                                                         PIXEL11_90
02331                                                         }
02332                                                         PIXEL10_10
02333                                                                 break;
02334                                         }
02335                                 case 207:
02336                                         {
02337                                                 if (Diff(w16[4], w16[2]))
02338                                                 {
02339                                                         PIXEL00_0
02340                                                                 PIXEL01_12
02341                                                 }
02342                                                 else
02343                                                 {
02344                                                         PIXEL00_90
02345                                                                 PIXEL01_61
02346                                                 }
02347                                                 PIXEL10_10
02348                                                         PIXEL11_11
02349                                                         break;
02350                                         }
02351                                 case 238:
02352                                         {
02353                                                 PIXEL00_10
02354                                                         PIXEL01_12
02355                                                         if (Diff(w16[8], w16[4]))
02356                                                         {
02357                                                                 PIXEL10_0
02358                                                                         PIXEL11_11
02359                                                         }
02360                                                         else
02361                                                         {
02362                                                                 PIXEL10_90
02363                                                                         PIXEL11_60
02364                                                         }
02365                                                         break;
02366                                         }
02367                                 case 190:
02368                                         {
02369                                                 PIXEL00_10
02370                                                         if (Diff(w16[2], w16[6]))
02371                                                         {
02372                                                                 PIXEL01_0
02373                                                                         PIXEL11_12
02374                                                         }
02375                                                         else
02376                                                         {
02377                                                                 PIXEL01_90
02378                                                                         PIXEL11_61
02379                                                         }
02380                                                         PIXEL10_11
02381                                                                 break;
02382                                         }
02383                                 case 187:
02384                                         {
02385                                                 if (Diff(w16[4], w16[2]))
02386                                                 {
02387                                                         PIXEL00_0
02388                                                                 PIXEL10_11
02389                                                 }
02390                                                 else
02391                                                 {
02392                                                         PIXEL00_90
02393                                                                 PIXEL10_60
02394                                                 }
02395                                                 PIXEL01_10
02396                                                         PIXEL11_12
02397                                                         break;
02398                                         }
02399                                 case 243:
02400                                         {
02401                                                 PIXEL00_11
02402                                                         PIXEL01_10
02403                                                         if (Diff(w16[6], w16[8]))
02404                                                         {
02405                                                                 PIXEL10_12
02406                                                                         PIXEL11_0
02407                                                         }
02408                                                         else
02409                                                         {
02410                                                                 PIXEL10_61
02411                                                                         PIXEL11_90
02412                                                         }
02413                                                         break;
02414                                         }
02415                                 case 119:
02416                                         {
02417                                                 if (Diff(w16[2], w16[6]))
02418                                                 {
02419                                                         PIXEL00_11
02420                                                                 PIXEL01_0
02421                                                 }
02422                                                 else
02423                                                 {
02424                                                         PIXEL00_60
02425                                                                 PIXEL01_90
02426                                                 }
02427                                                 PIXEL10_12
02428                                                         PIXEL11_10
02429                                                         break;
02430                                         }
02431                                 case 237:
02432                                 case 233:
02433                                         {
02434                                                 PIXEL00_12
02435                                                         PIXEL01_20
02436                                                         if (Diff(w16[8], w16[4]))
02437                                                         {
02438                                                                 PIXEL10_0
02439                                                         }
02440                                                         else
02441                                                         {
02442                                                                 PIXEL10_100
02443                                                         }
02444                                                         PIXEL11_11
02445                                                                 break;
02446                                         }
02447                                 case 175:
02448                                 case 47:
02449                                         {
02450                                                 if (Diff(w16[4], w16[2]))
02451                                                 {
02452                                                         PIXEL00_0
02453                                                 }
02454                                                 else
02455                                                 {
02456                                                         PIXEL00_100
02457                                                 }
02458                                                 PIXEL01_12
02459                                                         PIXEL10_11
02460                                                         PIXEL11_20
02461                                                         break;
02462                                         }
02463                                 case 183:
02464                                 case 151:
02465                                         {
02466                                                 PIXEL00_11
02467                                                         if (Diff(w16[2], w16[6]))
02468                                                         {
02469                                                                 PIXEL01_0
02470                                                         }
02471                                                         else
02472                                                         {
02473                                                                 PIXEL01_100
02474                                                         }
02475                                                         PIXEL10_20
02476                                                                 PIXEL11_12
02477                                                                 break;
02478                                         }
02479                                 case 245:
02480                                 case 244:
02481                                         {
02482                                                 PIXEL00_20
02483                                                         PIXEL01_11
02484                                                         PIXEL10_12
02485                                                         if (Diff(w16[6], w16[8]))
02486                                                         {
02487                                                                 PIXEL11_0
02488                                                         }
02489                                                         else
02490                                                         {
02491                                                                 PIXEL11_100
02492                                                         }
02493                                                         break;
02494                                         }
02495                                 case 250:
02496                                         {
02497                                                 PIXEL00_10
02498                                                         PIXEL01_10
02499                                                         if (Diff(w16[8], w16[4]))
02500                                                         {
02501                                                                 PIXEL10_0
02502                                                         }
02503                                                         else
02504                                                         {
02505                                                                 PIXEL10_20
02506                                                         }
02507                                                         if (Diff(w16[6], w16[8]))
02508                                                         {
02509                                                                 PIXEL11_0
02510                                                         }
02511                                                         else
02512                                                         {
02513                                                                 PIXEL11_20
02514                                                         }
02515                                                         break;
02516                                         }
02517                                 case 123:
02518                                         {
02519                                                 if (Diff(w16[4], w16[2]))
02520                                                 {
02521                                                         PIXEL00_0
02522                                                 }
02523                                                 else
02524                                                 {
02525                                                         PIXEL00_20
02526                                                 }
02527                                                 PIXEL01_10
02528                                                         if (Diff(w16[8], w16[4]))
02529                                                         {
02530                                                                 PIXEL10_0
02531                                                         }
02532                                                         else
02533                                                         {
02534                                                                 PIXEL10_20
02535                                                         }
02536                                                         PIXEL11_10
02537                                                                 break;
02538                                         }
02539                                 case 95:
02540                                         {
02541                                                 if (Diff(w16[4], w16[2]))
02542                                                 {
02543                                                         PIXEL00_0
02544                                                 }
02545                                                 else
02546                                                 {
02547                                                         PIXEL00_20
02548                                                 }
02549                                                 if (Diff(w16[2], w16[6]))
02550                                                 {
02551                                                         PIXEL01_0
02552                                                 }
02553                                                 else
02554                                                 {
02555                                                         PIXEL01_20
02556                                                 }
02557                                                 PIXEL10_10
02558                                                         PIXEL11_10
02559                                                         break;
02560                                         }
02561                                 case 222:
02562                                         {
02563                                                 PIXEL00_10
02564                                                         if (Diff(w16[2], w16[6]))
02565                                                         {
02566                                                                 PIXEL01_0
02567                                                         }
02568                                                         else
02569                                                         {
02570                                                                 PIXEL01_20
02571                                                         }
02572                                                         PIXEL10_10
02573                                                                 if (Diff(w16[6], w16[8]))
02574                                                                 {
02575                                                                         PIXEL11_0
02576                                                                 }
02577                                                                 else
02578                                                                 {
02579                                                                         PIXEL11_20
02580                                                                 }
02581                                                                 break;
02582                                         }
02583                                 case 252:
02584                                         {
02585                                                 PIXEL00_21
02586                                                         PIXEL01_11
02587                                                         if (Diff(w16[8], w16[4]))
02588                                                         {
02589                                                                 PIXEL10_0
02590                                                         }
02591                                                         else
02592                                                         {
02593                                                                 PIXEL10_20
02594                                                         }
02595                                                         if (Diff(w16[6], w16[8]))
02596                                                         {
02597                                                                 PIXEL11_0
02598                                                         }
02599                                                         else
02600                                                         {
02601                                                                 PIXEL11_100
02602                                                         }
02603                                                         break;
02604                                         }
02605                                 case 249:
02606                                         {
02607                                                 PIXEL00_12
02608                                                         PIXEL01_22
02609                                                         if (Diff(w16[8], w16[4]))
02610                                                         {
02611                                                                 PIXEL10_0
02612                                                         }
02613                                                         else
02614                                                         {
02615                                                                 PIXEL10_100
02616                                                         }
02617                                                         if (Diff(w16[6], w16[8]))
02618                                                         {
02619                                                                 PIXEL11_0
02620                                                         }
02621                                                         else
02622                                                         {
02623                                                                 PIXEL11_20
02624                                                         }
02625                                                         break;
02626                                         }
02627                                 case 235:
02628                                         {
02629                                                 if (Diff(w16[4], w16[2]))
02630                                                 {
02631                                                         PIXEL00_0
02632                                                 }
02633                                                 else
02634                                                 {
02635                                                         PIXEL00_20
02636                                                 }
02637                                                 PIXEL01_21
02638                                                         if (Diff(w16[8], w16[4]))
02639                                                         {
02640                                                                 PIXEL10_0
02641                                                         }
02642                                                         else
02643                                                         {
02644                                                                 PIXEL10_100
02645                                                         }
02646                                                         PIXEL11_11
02647                                                                 break;
02648                                         }
02649                                 case 111:
02650                                         {
02651                                                 if (Diff(w16[4], w16[2]))
02652                                                 {
02653                                                         PIXEL00_0
02654                                                 }
02655                                                 else
02656                                                 {
02657                                                         PIXEL00_100
02658                                                 }
02659                                                 PIXEL01_12
02660                                                         if (Diff(w16[8], w16[4]))
02661                                                         {
02662                                                                 PIXEL10_0
02663                                                         }
02664                                                         else
02665                                                         {
02666                                                                 PIXEL10_20
02667                                                         }
02668                                                         PIXEL11_22
02669                                                                 break;
02670                                         }
02671                                 case 63:
02672                                         {
02673                                                 if (Diff(w16[4], w16[2]))
02674                                                 {
02675                                                         PIXEL00_0
02676                                                 }
02677                                                 else
02678                                                 {
02679                                                         PIXEL00_100
02680                                                 }
02681                                                 if (Diff(w16[2], w16[6]))
02682                                                 {
02683                                                         PIXEL01_0
02684                                                 }
02685                                                 else
02686                                                 {
02687                                                         PIXEL01_20
02688                                                 }
02689                                                 PIXEL10_11
02690                                                         PIXEL11_21
02691                                                         break;
02692                                         }
02693                                 case 159:
02694                                         {
02695                                                 if (Diff(w16[4], w16[2]))
02696                                                 {
02697                                                         PIXEL00_0
02698                                                 }
02699                                                 else
02700                                                 {
02701                                                         PIXEL00_20
02702                                                 }
02703                                                 if (Diff(w16[2], w16[6]))
02704                                                 {
02705                                                         PIXEL01_0
02706                                                 }
02707                                                 else
02708                                                 {
02709                                                         PIXEL01_100
02710                                                 }
02711                                                 PIXEL10_22
02712                                                         PIXEL11_12
02713                                                         break;
02714                                         }
02715                                 case 215:
02716                                         {
02717                                                 PIXEL00_11
02718                                                         if (Diff(w16[2], w16[6]))
02719                                                         {
02720                                                                 PIXEL01_0
02721                                                         }
02722                                                         else
02723                                                         {
02724                                                                 PIXEL01_100
02725                                                         }
02726                                                         PIXEL10_21
02727                                                                 if (Diff(w16[6], w16[8]))
02728                                                                 {
02729                                                                         PIXEL11_0
02730                                                                 }
02731                                                                 else
02732                                                                 {
02733                                                                         PIXEL11_20
02734                                                                 }
02735                                                                 break;
02736                                         }
02737                                 case 246:
02738                                         {
02739                                                 PIXEL00_22
02740                                                         if (Diff(w16[2], w16[6]))
02741                                                         {
02742                                                                 PIXEL01_0
02743                                                         }
02744                                                         else
02745                                                         {
02746                                                                 PIXEL01_20
02747                                                         }
02748                                                         PIXEL10_12
02749                                                                 if (Diff(w16[6], w16[8]))
02750                                                                 {
02751                                                                         PIXEL11_0
02752                                                                 }
02753                                                                 else
02754                                                                 {
02755                                                                         PIXEL11_100
02756                                                                 }
02757                                                                 break;
02758                                         }
02759                                 case 254:
02760                                         {
02761                                                 PIXEL00_10
02762                                                         if (Diff(w16[2], w16[6]))
02763                                                         {
02764                                                                 PIXEL01_0
02765                                                         }
02766                                                         else
02767                                                         {
02768                                                                 PIXEL01_20
02769                                                         }
02770                                                         if (Diff(w16[8], w16[4]))
02771                                                         {
02772                                                                 PIXEL10_0
02773                                                         }
02774                                                         else
02775                                                         {
02776                                                                 PIXEL10_20
02777                                                         }
02778                                                         if (Diff(w16[6], w16[8]))
02779                                                         {
02780                                                                 PIXEL11_0
02781                                                         }
02782                                                         else
02783                                                         {
02784                                                                 PIXEL11_100
02785                                                         }
02786                                                         break;
02787                                         }
02788                                 case 253:
02789                                         {
02790                                                 PIXEL00_12
02791                                                         PIXEL01_11
02792                                                         if (Diff(w16[8], w16[4]))
02793                                                         {
02794                                                                 PIXEL10_0
02795                                                         }
02796                                                         else
02797                                                         {
02798                                                                 PIXEL10_100
02799                                                         }
02800                                                         if (Diff(w16[6], w16[8]))
02801                                                         {
02802                                                                 PIXEL11_0
02803                                                         }
02804                                                         else
02805                                                         {
02806                                                                 PIXEL11_100
02807                                                         }
02808                                                         break;
02809                                         }
02810                                 case 251:
02811                                         {
02812                                                 if (Diff(w16[4], w16[2]))
02813                                                 {
02814                                                         PIXEL00_0
02815                                                 }
02816                                                 else
02817                                                 {
02818                                                         PIXEL00_20
02819                                                 }
02820                                                 PIXEL01_10
02821                                                         if (Diff(w16[8], w16[4]))
02822                                                         {
02823                                                                 PIXEL10_0
02824                                                         }
02825                                                         else
02826                                                         {
02827                                                                 PIXEL10_100
02828                                                         }
02829                                                         if (Diff(w16[6], w16[8]))
02830                                                         {
02831                                                                 PIXEL11_0
02832                                                         }
02833                                                         else
02834                                                         {
02835                                                                 PIXEL11_20
02836                                                         }
02837                                                         break;
02838                                         }
02839                                 case 239:
02840                                         {
02841                                                 if (Diff(w16[4], w16[2]))
02842                                                 {
02843                                                         PIXEL00_0
02844                                                 }
02845                                                 else
02846                                                 {
02847                                                         PIXEL00_100
02848                                                 }
02849                                                 PIXEL01_12
02850                                                         if (Diff(w16[8], w16[4]))
02851                                                         {
02852                                                                 PIXEL10_0
02853                                                         }
02854                                                         else
02855                                                         {
02856                                                                 PIXEL10_100
02857                                                         }
02858                                                         PIXEL11_11
02859                                                                 break;
02860                                         }
02861                                 case 127:
02862                                         {
02863                                                 if (Diff(w16[4], w16[2]))
02864                                                 {
02865                                                         PIXEL00_0
02866                                                 }
02867                                                 else
02868                                                 {
02869                                                         PIXEL00_100
02870                                                 }
02871                                                 if (Diff(w16[2], w16[6]))
02872                                                 {
02873                                                         PIXEL01_0
02874                                                 }
02875                                                 else
02876                                                 {
02877                                                         PIXEL01_20
02878                                                 }
02879                                                 if (Diff(w16[8], w16[4]))
02880                                                 {
02881                                                         PIXEL10_0
02882                                                 }
02883                                                 else
02884                                                 {
02885                                                         PIXEL10_20
02886                                                 }
02887                                                 PIXEL11_10
02888                                                         break;
02889                                         }
02890                                 case 191:
02891                                         {
02892                                                 if (Diff(w16[4], w16[2]))
02893                                                 {
02894                                                         PIXEL00_0
02895                                                 }
02896                                                 else
02897                                                 {
02898                                                         PIXEL00_100
02899                                                 }
02900                                                 if (Diff(w16[2], w16[6]))
02901                                                 {
02902                                                         PIXEL01_0
02903                                                 }
02904                                                 else
02905                                                 {
02906                                                         PIXEL01_100
02907                                                 }
02908                                                 PIXEL10_11
02909                                                         PIXEL11_12
02910                                                         break;
02911                                         }
02912                                 case 223:
02913                                         {
02914                                                 if (Diff(w16[4], w16[2]))
02915                                                 {
02916                                                         PIXEL00_0
02917                                                 }
02918                                                 else
02919                                                 {
02920                                                         PIXEL00_20
02921                                                 }
02922                                                 if (Diff(w16[2], w16[6]))
02923                                                 {
02924                                                         PIXEL01_0
02925                                                 }
02926                                                 else
02927                                                 {
02928                                                         PIXEL01_100
02929                                                 }
02930                                                 PIXEL10_10
02931                                                         if (Diff(w16[6], w16[8]))
02932                                                         {
02933                                                                 PIXEL11_0
02934                                                         }
02935                                                         else
02936                                                         {
02937                                                                 PIXEL11_20
02938                                                         }
02939                                                         break;
02940                                         }
02941                                 case 247:
02942                                         {
02943                                                 PIXEL00_11
02944                                                         if (Diff(w16[2], w16[6]))
02945                                                         {
02946                                                                 PIXEL01_0
02947                                                         }
02948                                                         else
02949                                                         {
02950                                                                 PIXEL01_100
02951                                                         }
02952                                                         PIXEL10_12
02953                                                                 if (Diff(w16[6], w16[8]))
02954                                                                 {
02955                                                                         PIXEL11_0
02956                                                                 }
02957                                                                 else
02958                                                                 {
02959                                                                         PIXEL11_100
02960                                                                 }
02961                                                                 break;
02962                                         }
02963                                 case 255:
02964                                         {
02965                                                 if (Diff(w16[4], w16[2]))
02966                                                 {
02967                                                         PIXEL00_0
02968                                                 }
02969                                                 else
02970                                                 {
02971                                                         PIXEL00_100
02972                                                 }
02973                                                 if (Diff(w16[2], w16[6]))
02974                                                 {
02975                                                         PIXEL01_0
02976                                                 }
02977                                                 else
02978                                                 {
02979                                                         PIXEL01_100
02980                                                 }
02981                                                 if (Diff(w16[8], w16[4]))
02982                                                 {
02983                                                         PIXEL10_0
02984                                                 }
02985                                                 else
02986                                                 {
02987                                                         PIXEL10_100
02988                                                 }
02989                                                 if (Diff(w16[6], w16[8]))
02990                                                 {
02991                                                         PIXEL11_0
02992                                                 }
02993                                                 else
02994                                                 {
02995                                                         PIXEL11_100
02996                                                 }
02997                                                 break;
02998                                         }
02999                                 }
03000                                 pIn+=sizeof(uintS);
03001                                 pOut+=sizeof(uintX)*2;
03002                         }
03003                         pIn+=tex_diff;
03004                         pOut+=pix_diff;
03005                 }
03006 
03007                 return true;
03008         }
03009 
03010 };       // class
03011 
03012 hq2xScaler::hq2xScaler() : Scaler()
03013 {
03014         Scale16Nat = hq2xScalerInternal<uint16, Manip_Nat2Nat_16, uint16>::hq2x_32;
03015         Scale16Sta = hq2xScalerInternal<uint16, Manip_Sta2Nat_16, uint32>::hq2x_32;
03016 
03017         Scale32Nat = hq2xScalerInternal<uint32, Manip_Nat2Nat_32, uint32>::hq2x_32;
03018         Scale32Sta = hq2xScalerInternal<uint32, Manip_Sta2Nat_32, uint32>::hq2x_32;
03019         Scale32_A888 = hq2xScalerInternal<uint32, Manip_32_A888, uint32>::hq2x_32;
03020         Scale32_888A = hq2xScalerInternal<uint32, Manip_32_888A, uint32>::hq2x_32;
03021 }
03022 
03023 const uint32 hq2xScaler::ScaleBits() const { return 1<<2; }
03024 const bool hq2xScaler::ScaleArbitrary() const { return false; }
03025 
03026 const char *hq2xScaler::ScalerName() const { return "hq2x"; }
03027 const char *hq2xScaler::ScalerDesc() const { return "hq2x Magnification Filter"; }
03028 const char *hq2xScaler::ScalerCopyright() const { return "Copyright (C) 2003 MaxSt"; }
03029 
03030 const hq2xScaler hq2x_scaler;
03031 
03032 
03033 };      // namespace Pentagram
03034 
03035 #endif

Generated on Fri Jul 27 22:27:19 2007 for pentagram by  doxygen 1.4.7