/* ScummVM - Graphic Adventure Engine * * ScummVM is the legal property of its developers, whose names * are too numerous to list here. Please refer to the COPYRIGHT * file distributed with this source distribution. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * */ /* * Another edge-directed 2x/3x anti-aliasing scaler for ScummVM * * Author: Eric A. Welsh * * * Sharp, clean, anti-aliased image with very few artifacts. * Detects and appropriately handles mouse overlays with transparent pixels. * The Edge3x filter detects unchanged pixels and does not redraw them, * resulting in a considerable gain in speed when there are even a moderate * number of unchanged pixels. Edge3x and Edge2x anti-alias using nearest- * neighbor methods. Edge2xi interpolates. * * The really slow speed is mainly due to the edge detection algorithm. In * order to accurately detect the edge direction (and thus avoid artifacts * caused by mis-detection), the edge detection and refinement process is * rather long and involved. Speed must be sacrificed in order to avoid * artifacts :( If anyone is tempted to optimize using lower precision * math, such as converting some of the double math to fixed-point integer, * or lowering the number of significant bits used in the existing integer * math to squeeze it into accelerated 16-bit vector instructions, please do * not do this. Any loss in precision results in visibly degraded image * quality. I've tried integer conversions of various double math, and tried * reducing the number of significant digits I use in the integer math, and * it always results in less accurate edge detection and lower image quality. * If you're going to optimize, make sure you don't sacrifice any precision. * There may be a few places I could change the variable types from * int32 to int16 without introducing overflows, though. I should also * probably change some of the flags and arrays to bools or chars, rather * than ints, since they are only 0 or 1. * * It's a bit slow... but ScummVM runs most things fine on my 1.53 GHz Athlon. * Increasing the Win32 thread priority can help by forcing Windows not to * twiddle its thumbs and idle as much during heavy CPU load. The Dig * cutscene when the asteroid is activated is a little jerky, pans/fades in * Amazon Queen and Beneath a Steel Sky are slow. Faster machines probably * won't have a problem. I remember a time when my home machine was too slow * to run SNES emulators with 2xSaI filters, so I don't think speed is such a * big issue here. It won't be too long before the average home computer is * plenty fast enough to run this filter. * */ /* * Notes on handling overlays, mouse, transparencies, etc.: * * As I write this, the SDL backend does not call different filters based on * whether or not the bitmaps contain transparency. Bitmaps with transparency * need to be treated differently. 1) Interpolation needs to be disabled, * since interpolating with transparent pixels produces ugly smears around the * transparent areas. 2) Transparent pixels need to be treated differently * during edge detection, so that they appear to be as if they were colors * that would give maximal contrast in the current 3x3 window. * * Currently, the SDL backend calls anti-aliasing resize filters to either * resize the game screen or resize the mouse. The filter stores the src * array bounds whenever the width and height of the area to be resized are * equal to the width and height of the current game screen. If the current * src array is outside these bounds, then it is assumed that the mouse or * menu overlay is being drawn. This works perfectly for the current SDL * backend, but it is still a hack. If, in the future, the filter were to * to be used to resize a transparent overlay with dimensions equal to those * of the current game screen, that overlay would be resized without any * special transparency consideration. The same goes for a mouse pointer * that is equal to the size of the screen, but I don't forsee this ever * being a problem.... The correct solution would be to rewrite the backends * to call filters differently depending on whether or not the bitmap contains * transparent pixels, and whether or not the end result should be * interpolated or resized using nearest-neighbor. Until then, the array * bounds checking hack will have to do. * */ #include #include "common/scummsys.h" #include "common/system.h" #include "graphics/scaler/intern.h" #include "graphics/scaler/edge.h" /* Randomly XORs one of 2x2 or 3x3 resized pixels in order to indicate * which pixels have been redrawn. Useful for seeing which areas of * the screen are being redrawn. Good for seeing dirty rects, full screen * refreshes, etc.. Also good for seeing if the unchanged pixel detection is * working correctly or not :) */ #define DEBUG_REFRESH_RANDOM_XOR 0 /* debug redraws */ /* Use with DEBUG_REFRESH_RANDOM_XOR. Randomize the borders of the drawing * area, whether they are unchanged or not. Useful for visualizing the * borders of the drawing area. You might be surprised at which areas of the * screen get redraw requests, even areas with absolutely nothing moving, * or color cycling, or anything that would cause a dirty rect or require a * redraw.... */ #define DEBUG_DRAW_REFRESH_BORDERS 0 /* more redraw debug */ #define PARANOID_KNIGHTS 1 /* avoid artifacts */ #define PARANOID_ARROWS 1 /* avoid artifacts */ #define SIN45 0.7071067811865 /* sin of 45 degrees */ #define GREY_SHIFT 12 /* bit shift for greyscale precision */ #define RGB_SHIFT 13 /* bit shift for RGB precision */ #define SQRT2 1.41421356237309504880 static const int16 one_sqrt2 = (int16)(((int16)1 << GREY_SHIFT) / SQRT2 + 0.5); // static const int16 int32_sqrt3 = (int16)(((int16)1 << GREY_SHIFT) * sqrt(3.0) + 0.5); #define interpolate_1_1(a,b) (ColorMask::kBytesPerPixel == 2 ? interpolate16_1_1(a,b) : interpolate32_1_1(a,b)) #define interpolate_3_1(a,b) (ColorMask::kBytesPerPixel == 2 ? interpolate16_3_1(a,b) : interpolate32_3_1(a,b)) #define interpolate_2_1(a,b) (ColorMask::kBytesPerPixel == 2 ? interpolate16_2_1(a,b) : interpolate32_2_1(a,b)) #define interpolate_1_1_1(a,b,c) (ColorMask::kBytesPerPixel == 2 ? interpolate16_1_1_1(a,b,c) : interpolate32_1_1_1(a,b,c)) #if DEBUG_REFRESH_RANDOM_XOR /* Random number generators with very good randomness properties, far better * than the simple linear congruential generator in the ScummVM utils. * The RNG algorithms were developed by George Marsaglia, as published in his * "Xorshift RNGs" paper and various USENET postings. * * Marsaglia, George, 2003, "Xorshift RNGs", Journal of Statistical Software, * Volume 7, Issue 14 * * Note the comments in the code below about how many of the triplet and shift * combinations published in his paper and various USENET postings don't quite * work as expected (yes, I exhaustively tested all 648 of them with his test * suite). Only a few "magic" combinations actually produce good random * numbers. I suspect this is due to the numbers being shifted too far off * the ends of the registers? * * While numbers this highly random are overkill for our purposes, I already * had this code written for various scientific analysis programs, and I've * tested the generators with Marsaglia's comprehensive randomness test * suite, so I know that they have very good randomness. The simple single * seed algorithm does fail a few minor tests, but it is still LOADS better * than a linear congruential generator. The 4 seed RNG passes all tests * with flying colors and has a pretty big period to boot. I actually use * a 4096 seed RNG for my scientific work, but that is MAJOR overkill for * the simple purposes we require here, so I've not included it :) */ static uint32 seed0, seed1, seed2, seed3; /* period 2^32 - 1 */ /* fails Gorilla test, binary rank matrix */ /* the ONLY good triplet and shift combinations out of the list of 648: * * 3 7 13 >> >> << * 3 7 13 << << >> * 7 3 13 >> >> << * 7 3 13 << << >> * * 5 6 13 >> >> << * 5 6 13 << << >> * 6 5 13 >> >> << * 6 5 13 << << >> seems to be slightly "better" than the others? * * all others, including the "favorite" (13, 17, 5), fail some Monkey tests */ static uint32 xorshift32(void) { seed0 ^= seed0 << 6; seed0 ^= seed0 << 5; seed0 ^= seed0 >> 13; return(seed0); } /* period 2^128 - 1 */ /* None of the other published 2^128-1 xorshift RNGs passed OPERM5 */ static uint32 xorshift128(void) { uint32 temp; temp = (seed0 ^ (seed0 << 20)) ^ (seed1 ^ (seed1 >> 11)) ^ (seed2 ^ (seed2 << 27)) ^ (seed3 ^ (seed3 >> 6)); seed0 = seed1; seed1 = seed2; seed2 = seed3; seed3 = temp; return (temp); } /* return a random fraction over the range [0, 1) */ static double dxorshift128(void) { uint32 temp; temp = (seed0 ^ (seed0 << 20)) ^ (seed1 ^ (seed1 >> 11)) ^ (seed2 ^ (seed2 << 27)) ^ (seed3 ^ (seed3 >> 6)); seed0 = seed1; seed1 = seed2; seed2 = seed3; seed3 = temp; return (temp / 4294967296.0); } static void initializeXorshift128(uint32 seed) { /* seed0 needs to be initialized prior to calling xorshift32() */ seed0 = seed; /* initialize with xorshift32() */ seed0 = xorshift32(); seed1 = xorshift32(); seed2 = xorshift32(); seed3 = xorshift32(); } #endif /* * Faster than standard double atan(), |error| < 7E-6 * * Original equation from Ranko Bojanic in StuChat37: * * |x| <= 1: * * x + A*x3 A = 0.43157974, B = 0.76443945, C = 0.05831938 * --------------- * 1 + B*x2 + C*x4 * * * * After some optimizations: * * |x| <= 1: * * x * (E + F*x2) E = 1/C, F = A/C * ---------------- G = (B/C + sqrt(B2/C2 - 4/C)) / 2 * (G + x2)(H + x2) H = (B/C - sqrt(B2/C2 - 4/C)) / 2 * * E = 17.14695869537, F = 7.400279975541 * G = 11.63393762882, H = 1.473874045440 * * |x| > 1: pi/2 - * * x * (I + x2) I = A * ---------------- J = (B + sqrt(B2 - 4C)) / 2 * (J + x2)(K + x2) K = (B - sqrt(B2 - 4C)) / 2 * * I = 0.43157974 * J = 0.6784840295980, K = 0.0859554204018 * */ static double fastAtan(double x0) { double x2; double x; x = fabs(x0); x2 = x * x; if (x > 1) { x2 = 1.570796326795 - x * (0.43157974 + x2) / ((0.6784840295980 + x2) * (0.0859554204018 + x2)); if (x0 < 0) return -x2; return x2; } return x0 * (17.14695869537 + 7.400279975541 * x2) / ((11.63393762882 + x2) * (1.473874045440 + x2)); } /** * Convert a pixel to a 16bpp format. If called on * a 16bpp pixel, nothing happens and the call should * be removed at compile time by an optimizing compiler. * This allows 16 and 32 bit functions to easily share * the same code. */ template uint16 convertTo16Bit(const typename ColorMask::PixelType p) { if (sizeof(typename ColorMask::PixelType) == 2) return p; uint16 r, g, b; r = (ColorMask::kRedMask & (ColorMask::kRedMask << (8 - Graphics::ColorMasks<565>::kRedBits)) & p) >> (ColorMask::kRedShift + (8 - Graphics::ColorMasks<565>::kRedBits) - Graphics::ColorMasks<565>::kRedShift); g = (ColorMask::kGreenMask & (ColorMask::kGreenMask << (8 - Graphics::ColorMasks<565>::kGreenBits)) & p) >> (ColorMask::kGreenShift + (8 - Graphics::ColorMasks<565>::kGreenBits) - Graphics::ColorMasks<565>::kGreenShift); b = (ColorMask::kBlueMask & (ColorMask::kBlueMask << (8 - Graphics::ColorMasks<565>::kBlueBits)) & p) >> (ColorMask::kBlueShift + (8 - Graphics::ColorMasks<565>::kBlueBits) - Graphics::ColorMasks<565>::kBlueShift); return r | g | b; } template int16 *EdgeScaler::chooseGreyscale(typename ColorMask::PixelType *pixels) { int i, j; int32 scores[3]; for (i = 0; i < 3; i++) { int16 *diff_ptr; int16 *bptr; typename ColorMask::PixelType *pptr; int16 *grey_ptr; int16 center; int32 sum_diffs; sum_diffs = 0; grey_ptr = _greyscaleTable[i]; /* fill the 9 pixel window with greyscale values */ bptr = _bplanes[i]; pptr = pixels; for (j = 9; j; --j) *bptr++ = grey_ptr[convertTo16Bit(*pptr++)]; bptr = _bplanes[i]; center = grey_ptr[convertTo16Bit(pixels[4])]; diff_ptr = _greyscaleDiffs[i]; /* calculate the delta from center pixel */ diff_ptr[0] = bptr[0] - center; diff_ptr[1] = bptr[1] - center; diff_ptr[2] = bptr[2] - center; diff_ptr[3] = bptr[3] - center; diff_ptr[4] = bptr[5] - center; diff_ptr[5] = bptr[6] - center; diff_ptr[6] = bptr[7] - center; diff_ptr[7] = bptr[8] - center; /* calculate sum of squares distance */ for (j = 8; j; --j) { sum_diffs += *diff_ptr * *diff_ptr; ++diff_ptr; } scores[i] = sum_diffs; } /* choose greyscale with highest score, ties decided in GRB order */ if (scores[1] >= scores[0] && scores[1] >= scores[2]) { if (!scores[1]) return NULL; _chosenGreyscale = _greyscaleTable[1]; _bptr = _bplanes[1]; return _greyscaleDiffs[1]; } if (scores[0] >= scores[1] && scores[0] >= scores[2]) { if (!scores[0]) return NULL; _chosenGreyscale = _greyscaleTable[0]; _bptr = _bplanes[0]; return _greyscaleDiffs[0]; } if (!scores[2]) return NULL; _chosenGreyscale = _greyscaleTable[2]; _bptr = _bplanes[2]; return _greyscaleDiffs[2]; } template int32 EdgeScaler::calcPixelDiffNosqrt(typename ColorMask::PixelType pixel1, typename ColorMask::PixelType pixel2) { pixel1 = convertTo16Bit(pixel1); pixel2 = convertTo16Bit(pixel2); #if 1 /* distance between pixels, weighted by roughly luma proportions */ int32 sum = 0; int16 *rgb_ptr1 = _rgbTable[pixel1]; int16 *rgb_ptr2 = _rgbTable[pixel2]; int16 diff; diff = (*rgb_ptr1++ - *rgb_ptr2++) << 1; sum += diff * diff; diff = (*rgb_ptr1++ - *rgb_ptr2++) << 2; sum += diff * diff; diff = (*rgb_ptr1 - *rgb_ptr2); sum += diff * diff; return sum; #endif #if 0 /* distance between pixels, weighted by chosen greyscale proportions */ int32 sum = 0; int16 *rgb_ptr1 = _rgbTable[pixel1]; int16 *rgb_ptr2 = _rgbTable[pixel2]; int16 diff; int r_shift, g_shift, b_shift; if (_chosenGreyscale == _greyscaleTable[1]) { r_shift = 1; g_shift = 2; b_shift = 0; } else if (_chosenGreyscale == _greyscaleTable[0]) { r_shift = 2; g_shift = 1; b_shift = 0; } else { r_shift = 0; g_shift = 1; b_shift = 2; } diff = (*rgb_ptr1++ - *rgb_ptr2++) << r_shift; sum += diff * diff; diff = (*rgb_ptr1++ - *rgb_ptr2++) << g_shift; sum += diff * diff; diff = (*rgb_ptr1 - *rgb_ptr2) << b_shift; sum += diff * diff; return sum; #endif #if 0 /* distance between pixels, unweighted */ int32 sum = 0; int16 *rgb_ptr1 = _rgbTable[pixel1]; int16 *rgb_ptr2 = _rgbTable[pixel2]; int16 diff; diff = *rgb_ptr1++ - *rgb_ptr2++; sum += diff * diff; diff = *rgb_ptr1++ - *rgb_ptr2++; sum += diff * diff; diff = *rgb_ptr1 - *rgb_ptr2; sum += diff * diff; return sum; #endif #if 0 /* use the greyscale directly */ return labs(_chosenGreyscale[pixel1] - _chosenGreyscale[pixel2]); #endif } int EdgeScaler::findPrincipleAxis(int16 *diffs, int16 *bplane, int8 *sim, int32 *return_angle) { struct xy_point { int16 x, y; }; int i; int16 centx = 0, centy = 0; struct xy_point xy_points[9]; int angle; int reverse_flag = 1; int16 cutoff; int16 max_diff; double x, y; int32 half_matrix[3] = {0}; double eigenval1, eigenval2; double best_val; double a, b, c; double ratio; int32 colorScale; /* absolute value of differences */ for (i = 0; i < 8; i++) diffs[i] = labs(diffs[i]); /* find the max difference */ max_diff = *diffs; for (i = 1; i < 8; i++) if (diffs[i] > max_diff) max_diff = diffs[i]; /* exit early on uniform window */ /* already taken care of earlier elsewhere after greyscale assignment */ /* if (max_diff == 0) return '0'; */ /* normalize the differences */ colorScale = (1L << (GREY_SHIFT + GREY_SHIFT)) / max_diff; for (i = 0; i < 8; i++) diffs[i] = (diffs[i] * colorScale + ((int16)1 << (GREY_SHIFT - 1))) >> GREY_SHIFT; /* * Some pixel patterns need to NOT be reversed, since the pixels of * interest that form the edge to be detected are off-center. * */ /* calculate yes/no similarity matrix to center pixel */ /* store the number of similar pixels */ cutoff = ((int16)1 << (GREY_SHIFT - 3)); for (i = 0, _simSum = 0; i < 8; i++) _simSum += (sim[i] = (diffs[i] < cutoff)); /* don't reverse pattern for off-center knights and sharp corners */ if (_simSum >= 3 && _simSum <= 5) { /* |. */ /* '- */ if (sim[1] && sim[4] && sim[5] && !sim[3] && !sim[6] && (!sim[0] ^ !sim[7])) reverse_flag = 0; /* -. */ /* '| */ else if (sim[2] && sim[3] && sim[6] && !sim[1] && !sim[4] && (!sim[0] ^ !sim[7])) reverse_flag = 0; /* .- */ /* |' */ else if (sim[4] && sim[6] && sim[0] && !sim[1] && !sim[3] && (!sim[2] ^ !sim[5])) reverse_flag = 0; /* .| */ /* -' */ else if (sim[1] && sim[3] && sim[7] && !sim[4] && !sim[6] && (!sim[2] ^ !sim[5])) reverse_flag = 0; /* 90 degree corners */ else if (_simSum == 3) { if ((sim[0] && sim[1] && sim[3]) || (sim[1] && sim[2] && sim[4]) || (sim[3] && sim[5] && sim[6]) || (sim[4] && sim[6] && sim[7])) reverse_flag = 0; } } /* redo similarity array, less stringent for later checks */ cutoff = ((int16)1 << (GREY_SHIFT - 1)); for (i = 0, _simSum = 0; i < 8; i++) _simSum += (sim[i] = (diffs[i] < cutoff)); /* center pixel is different from all the others, not an edge */ if (_simSum == 0) return '0'; /* reverse the difference array, so most similar is closest to 1 */ if (reverse_flag) { diffs[0] = ((int16)1 << GREY_SHIFT) - diffs[0]; diffs[1] = ((int16)1 << GREY_SHIFT) - diffs[1]; diffs[2] = ((int16)1 << GREY_SHIFT) - diffs[2]; diffs[3] = ((int16)1 << GREY_SHIFT) - diffs[3]; diffs[4] = ((int16)1 << GREY_SHIFT) - diffs[4]; diffs[5] = ((int16)1 << GREY_SHIFT) - diffs[5]; diffs[6] = ((int16)1 << GREY_SHIFT) - diffs[6]; diffs[7] = ((int16)1 << GREY_SHIFT) - diffs[7]; } /* scale diagonals for projection onto axes */ diffs[0] = (diffs[0] * one_sqrt2 + ((int16)1 << (GREY_SHIFT - 1))) >> GREY_SHIFT; diffs[2] = (diffs[2] * one_sqrt2 + ((int16)1 << (GREY_SHIFT - 1))) >> GREY_SHIFT; diffs[5] = (diffs[5] * one_sqrt2 + ((int16)1 << (GREY_SHIFT - 1))) >> GREY_SHIFT; diffs[7] = (diffs[7] * one_sqrt2 + ((int16)1 << (GREY_SHIFT - 1))) >> GREY_SHIFT; /* create the vectors, centered at 0,0 */ xy_points[0].x = -diffs[0]; xy_points[0].y = diffs[0]; xy_points[1].x = 0; xy_points[1].y = diffs[1]; xy_points[2].x = xy_points[2].y = diffs[2]; xy_points[3].x = -diffs[3]; xy_points[3].y = 0; xy_points[4].x = 0; xy_points[4].y = 0; xy_points[5].x = diffs[4]; xy_points[5].y = 0; xy_points[6].x = xy_points[6].y = -diffs[5]; xy_points[7].x = 0; xy_points[7].y = -diffs[6]; xy_points[8].x = diffs[7]; xy_points[8].y = -diffs[7]; /* calculate the centroid of the points */ for (i = 0; i < 9; i++) { centx += xy_points[i].x; centy += xy_points[i].y; } centx /= 9; centy /= 9; /* translate centroid to 0,0 */ for (i = 0; i < 9; i++) { xy_points[i].x -= centx; xy_points[i].y -= centy; } /* fill inertia tensor 3x3 matrix */ for (i = 0; i < 9; i++) { half_matrix[0] += xy_points[i].x * xy_points[i].x; half_matrix[1] += xy_points[i].y * xy_points[i].x; half_matrix[2] += xy_points[i].y * xy_points[i].y; } /* calculate eigenvalues */ a = half_matrix[0] - half_matrix[2]; b = half_matrix[1] << 1; b = sqrt(b * b + a * a); a = half_matrix[0] + half_matrix[2]; eigenval1 = (a + b); eigenval2 = (a - b); /* find largest eigenvalue */ if (eigenval1 == eigenval2) /* X and + shapes */ return '*'; else if (eigenval1 > eigenval2) best_val = eigenval1; else best_val = eigenval2; /* white center pixel, black background */ if (!best_val) return '*'; /* divide eigenvalue by 2, postponed from when it should have been done during the eigenvalue calculation but was delayed for another early exit opportunity */ best_val *= 0.5; /* calculate eigenvectors */ c = best_val + half_matrix[1]; a = c - half_matrix[0]; b = c - half_matrix[2]; if (b) { x = 1.0; ratio = y = a / b; } else if (a) { y = 1.0; x = b / a; ratio = a / b; } else if (a == b) { *return_angle = 13500; return '\\'; } else return '*'; /* calculate angle in degrees * 100 */ if (x) { angle = (int32) floor(5729.577951307 * fastAtan(ratio) + 0.5); if (x < 0.0) angle += 18000; } else { if (y > 0.0) angle = 9000; else if (y < 0.0) angle = -9000; else return '0'; } /* force angle to lie between 0 to 360 */ if (angle < 0) angle += 36000; if (angle > 18000) angle -= 18000; *return_angle = angle; if (angle <= 2250) return '-'; if (angle < 6750) return '/'; if (angle <= 11250) return '|'; if (angle < 15750) return '\\'; return '-'; } template int EdgeScaler::checkArrows(int best_dir, Pixel *pixels, int8 *sim, int half_flag) { Pixel center = pixels[4]; if (center == pixels[0] && center == pixels[2] && center == pixels[6] && center == pixels[8]) { switch (best_dir) { case 5: if (center != pixels[5]) /* < */ return 0; break; case 6: if (center != pixels[3]) /* > */ return 0; break; case 7: if (center != pixels[7]) /* ^ */ return 0; break; case 8: if (center != pixels[1]) /* v */ return 0; break; } } switch (best_dir) { case 5: /* < */ if (center == pixels[2] && center == pixels[8] && pixels[1] == pixels[5] && pixels[5] == pixels[7] && (((center == pixels[0]) ^ (center == pixels[6])) || (center == pixels[0] && center == pixels[6] && pixels[1] != pixels[3]))) return 0; break; case 6: /* > */ if (center == pixels[0] && center == pixels[6] && pixels[1] == pixels[3] && pixels[3] == pixels[7] && (((center == pixels[2]) ^ (center == pixels[8])) || (center == pixels[2] && center == pixels[8] && pixels[1] != pixels[5]))) return 0; break; case 7: /* ^ */ if (center == pixels[6] && center == pixels[8] && pixels[3] == pixels[7] && pixels[7] == pixels[5] && (((center == pixels[0]) ^ (center == pixels[2])) || (center == pixels[0] && center == pixels[2] && pixels[3] != pixels[1]))) return 0; break; case 8: /* v */ if (center == pixels[0] && center == pixels[2] && pixels[1] == pixels[3] && pixels[1] == pixels[5] && (((center == pixels[6]) ^ (center == pixels[8])) || (center == pixels[6] && center == pixels[8] && pixels[3] != pixels[7]))) return 0; break; } switch (best_dir) { case 5: if (sim[0] == sim[5] && sim[1] == sim[3] && sim[3] == sim[6] && ((sim[2] && sim[7]) || (half_flag && _simSum == 2 && sim[4] && (sim[2] || sim[7])))) /* < */ return 1; break; case 6: if (sim[2] == sim[7] && sim[1] == sim[4] && sim[4] == sim[6] && ((sim[0] && sim[5]) || (half_flag && _simSum == 2 && sim[3] && (sim[0] || sim[5])))) /* > */ return 1; break; case 7: if (sim[0] == sim[2] && sim[1] == sim[3] && sim[3] == sim[4] && ((sim[5] && sim[7]) || (half_flag && _simSum == 2 && sim[6] && (sim[5] || sim[7])))) /* ^ */ return 1; break; case 8: if (sim[5] == sim[7] && sim[3] == sim[6] && sim[4] == sim[6] && ((sim[0] && sim[2]) || (half_flag && _simSum == 2 && sim[1] && (sim[0] || sim[2])))) /* v */ return 1; break; } return 0; } template int EdgeScaler::refineDirection(char edge_type, Pixel *pixels, int16 *bptr, int8 *sim, double angle) { int32 sums_dir[9] = { 0 }; int32 sum; int32 best_sum; int i, n, best_dir; int16 diff_array[26]; int ok_arrow_flag = 1; /* * - '- -. \ '| |. | |' .| / -' .- < > ^ v * * 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 * * \' .\ '/ /. * * 16 17 18 19 * */ switch (edge_type) { case '|': diff_array[0] = labs(bptr[4] - bptr[1]); diff_array[1] = labs(bptr[4] - bptr[7]); diff_array[2] = labs(bptr[3] - bptr[0]); diff_array[3] = labs(bptr[3] - bptr[6]); diff_array[4] = labs(bptr[5] - bptr[2]); diff_array[5] = labs(bptr[5] - bptr[8]); diff_array[6] = labs(bptr[4] - bptr[2]); diff_array[7] = labs(bptr[4] - bptr[8]); diff_array[8] = labs(bptr[3] - bptr[1]); diff_array[9] = labs(bptr[3] - bptr[7]); diff_array[10] = labs(bptr[4] - bptr[0]); diff_array[11] = labs(bptr[4] - bptr[6]); diff_array[12] = labs(bptr[5] - bptr[1]); diff_array[13] = labs(bptr[5] - bptr[7]); diff_array[14] = labs(bptr[0] - bptr[6]); diff_array[15] = labs(bptr[2] - bptr[8]); diff_array[16] = labs(bptr[1] - bptr[7]); diff_array[17] = labs(bptr[0] - bptr[1]); diff_array[18] = labs(bptr[2] - bptr[1]); diff_array[19] = labs(bptr[0] - bptr[2]); diff_array[20] = labs(bptr[3] - bptr[5]); diff_array[21] = labs(bptr[6] - bptr[8]); diff_array[22] = labs(bptr[6] - bptr[7]); diff_array[23] = labs(bptr[8] - bptr[7]); /* | vertical */ sums_dir[0] = diff_array[0] + diff_array[1] + diff_array[2] + diff_array[3] + diff_array[4] + diff_array[5]; /* << top */ sum = diff_array[8] + diff_array[9] + ((diff_array[6] + diff_array[7] + diff_array[12] + diff_array[13]) << 1) + diff_array[14] + diff_array[16] + diff_array[15]; sum = (sum * 6) / 13; sums_dir[5] = sum; /* >> top */ sum = diff_array[12] + diff_array[13] + ((diff_array[10] + diff_array[11] + diff_array[8] + diff_array[9]) << 1) + diff_array[15] + diff_array[16] + diff_array[14]; sum = (sum * 6) / 13; sums_dir[6] = sum; /* ^ bottom */ sum = diff_array[8] + diff_array[12] + ((diff_array[11] + diff_array[7]) << 1) + (diff_array[1] << 2) + diff_array[19] + diff_array[20] + diff_array[21]; sum = (sum * 6) / 13; sums_dir[7] = sum; /* v bottom */ sum = diff_array[9] + diff_array[13] + ((diff_array[10] + diff_array[6]) << 1) + (diff_array[0] << 2) + diff_array[21] + diff_array[20] + diff_array[19]; sum = (sum * 6) / 13; sums_dir[8] = sum; /* '| */ sums_dir[1] = diff_array[1] + diff_array[5] + diff_array[10] + diff_array[12] + (diff_array[3] << 1); /* '| alt */ sum = diff_array[10] + diff_array[1] + diff_array[18] + diff_array[4] + diff_array[5] + diff_array[14]; if (sum < sums_dir[1]) sums_dir[1] = sum; /* |. */ sums_dir[2] = diff_array[0] + diff_array[2] + diff_array[7] + diff_array[9] + (diff_array[4] << 1); /* |. alt */ sum = diff_array[0] + diff_array[7] + diff_array[22] + diff_array[3] + diff_array[2] + diff_array[15]; if (sum < sums_dir[2]) sums_dir[2] = sum; /* |' */ sums_dir[3] = diff_array[1] + diff_array[3] + diff_array[6] + diff_array[8] + (diff_array[5] << 1); /* |' alt */ sum = diff_array[6] + diff_array[1] + diff_array[17] + diff_array[2] + diff_array[3] + diff_array[15]; if (sum < sums_dir[3]) sums_dir[3] = sum; /* .| */ sums_dir[4] = diff_array[0] + diff_array[4] + diff_array[11] + diff_array[13] + (diff_array[2] << 1); /* .| alt */ sum = diff_array[11] + diff_array[0] + diff_array[23] + diff_array[5] + diff_array[4] + diff_array[14]; if (sum < sums_dir[4]) sums_dir[4] = sum; best_sum = sums_dir[0]; for (i = 1; i < 9; i++) if (sums_dir[i] < best_sum) best_sum = sums_dir[i]; if (best_sum == sums_dir[0]) return 6; /* | */ best_dir = 0; for (i = 0, n = 0; i < 9; i++) { if (sums_dir[i] == best_sum) { best_dir = i; n++; } } /* best direction uncertain, return original direction */ if (n > 1) return 6; /* | */ if (best_dir >= 5) ok_arrow_flag = checkArrows(best_dir, pixels, sim, 1); switch (best_dir) { case 1: return 4; /* '| */ break; case 2: return 5; /* |. */ break; case 3: return 7; /* |' */ break; case 4: return 8; /* .| */ break; case 5: if (ok_arrow_flag) return 12; /* < */ break; case 6: if (ok_arrow_flag) return 13; /* > */ break; case 7: if (ok_arrow_flag) return 14; /* ^ */ break; case 8: if (ok_arrow_flag) return 15; /* V */ break; case 0: default: return 6; /* | */ break; } break; case '-': diff_array[0] = labs(bptr[4] - bptr[3]); diff_array[1] = labs(bptr[4] - bptr[5]); diff_array[2] = labs(bptr[0] - bptr[1]); diff_array[3] = labs(bptr[1] - bptr[2]); diff_array[4] = labs(bptr[7] - bptr[6]); diff_array[5] = labs(bptr[7] - bptr[8]); diff_array[6] = labs(bptr[4] - bptr[6]); diff_array[7] = labs(bptr[4] - bptr[8]); diff_array[8] = labs(bptr[1] - bptr[3]); diff_array[9] = labs(bptr[1] - bptr[5]); diff_array[10] = labs(bptr[4] - bptr[0]); diff_array[11] = labs(bptr[4] - bptr[2]); diff_array[12] = labs(bptr[7] - bptr[3]); diff_array[13] = labs(bptr[7] - bptr[5]); diff_array[14] = labs(bptr[0] - bptr[2]); diff_array[15] = labs(bptr[6] - bptr[8]); diff_array[16] = labs(bptr[3] - bptr[5]); diff_array[17] = labs(bptr[0] - bptr[3]); diff_array[18] = labs(bptr[6] - bptr[3]); diff_array[19] = labs(bptr[0] - bptr[6]); diff_array[20] = labs(bptr[1] - bptr[7]); diff_array[21] = labs(bptr[2] - bptr[8]); diff_array[22] = labs(bptr[2] - bptr[5]); diff_array[23] = labs(bptr[8] - bptr[5]); /* - horizontal */ sums_dir[0] = diff_array[0] + diff_array[1] + diff_array[2] + diff_array[3] + diff_array[4] + diff_array[5]; /* << bottom */ sum = diff_array[8] + diff_array[12] + ((diff_array[11] + diff_array[7]) << 1) + (diff_array[1] << 2) + diff_array[19] + diff_array[20] + diff_array[21]; sum = (sum * 6) / 13; sums_dir[5] = sum; /* >> bottom */ sum = diff_array[9] + diff_array[13] + ((diff_array[10] + diff_array[6]) << 1) + (diff_array[0] << 2) + diff_array[21] + diff_array[20] + diff_array[19]; sum = (sum * 6) / 13; sums_dir[6] = sum; /* ^ top */ sum = diff_array[8] + diff_array[9] + ((diff_array[6] + diff_array[7] + diff_array[12] + diff_array[13]) << 1) + diff_array[14] + diff_array[16] + diff_array[15]; sum = (sum * 6) / 13; sums_dir[7] = sum; /* v top */ sum = diff_array[12] + diff_array[13] + ((diff_array[10] + diff_array[11] + diff_array[8] + diff_array[9]) << 1) + diff_array[15] + diff_array[16] + diff_array[14]; sum = (sum * 6) / 13; sums_dir[8] = sum; /* '- */ sums_dir[1] = diff_array[1] + diff_array[5] + diff_array[10] + diff_array[12] + (diff_array[3] << 1); /* '- alt */ sum = diff_array[10] + diff_array[1] + diff_array[18] + diff_array[4] + diff_array[5] + diff_array[14]; if (sum < sums_dir[1]) sums_dir[1] = sum; /* -. */ sums_dir[2] = diff_array[0] + diff_array[2] + diff_array[7] + diff_array[9] + (diff_array[4] << 1); /* -. alt */ sum = diff_array[0] + diff_array[7] + diff_array[22] + diff_array[3] + diff_array[2] + diff_array[15]; if (sum < sums_dir[2]) sums_dir[2] = sum; /* -' */ sums_dir[3] = diff_array[0] + diff_array[4] + diff_array[11] + diff_array[13] + (diff_array[2] << 1); /* -' alt */ sum = diff_array[11] + diff_array[0] + diff_array[23] + diff_array[5] + diff_array[4] + diff_array[14]; if (sum < sums_dir[3]) sums_dir[3] = sum; /* .- */ sums_dir[4] = diff_array[1] + diff_array[3] + diff_array[6] + diff_array[8] + (diff_array[5] << 1); /* .- alt */ sum = diff_array[6] + diff_array[1] + diff_array[17] + diff_array[2] + diff_array[3] + diff_array[15]; if (sum < sums_dir[4]) sums_dir[4] = sum; best_sum = sums_dir[0]; for (i = 1; i < 9; i++) if (sums_dir[i] < best_sum) best_sum = sums_dir[i]; if (best_sum == sums_dir[0]) return 0; /* - */ best_dir = 0; for (i = 0, n = 0; i < 9; i++) { if (sums_dir[i] == best_sum) { best_dir = i; n++; } } /* best direction uncertain, return original direction */ if (n > 1) return 0; /* - */ if (best_dir >= 5) ok_arrow_flag = checkArrows(best_dir, pixels, sim, 1); switch (best_dir) { case 1: return 1; /* '- */ break; case 2: return 2; /* -. */ break; case 3: return 10; /* -' */ break; case 4: return 11; /* .- */ break; case 5: if (ok_arrow_flag) return 12; /* < */ break; case 6: if (ok_arrow_flag) return 13; /* > */ break; case 7: if (ok_arrow_flag) return 14; /* ^ */ break; case 8: if (ok_arrow_flag) return 15; /* V */ break; case 0: default: return 0; /* - */ break; } break; case '\\': /* CHECK -- handle noisy half-diags */ if (_simSum == 1) { if (pixels[1] == pixels[3] && pixels[3] == pixels[5] && pixels[5] == pixels[7]) { if (pixels[2] != pixels[1] && pixels[6] != pixels[1]) { sum = labs(bptr[2] - bptr[4]) + labs(bptr[6] - bptr[4]); if (sim[0] && sum < (labs(bptr[8] - bptr[4]) << 1)) { if (bptr[4] > bptr[8]) { if (bptr[2] > bptr[4] && bptr[6] > bptr[4]) return 18; /* '/ */ } else { if (bptr[2] < bptr[4] && bptr[6] < bptr[4]) return 18; /* '/ */ } } if (sim[7] && sum < (labs(bptr[0] - bptr[4]) << 1)) { if (bptr[4] > bptr[0]) { if (bptr[2] > bptr[4] && bptr[6] > bptr[4]) return 19; /* /. */ } else { if (bptr[2] < bptr[4] && bptr[6] < bptr[4]) return 19; /* /. */ } } } } if (sim[0] && labs(bptr[4] - bptr[0]) < ((int16)1 << (GREY_SHIFT - 3))) return 3; /* \ */ if (sim[7] && labs(bptr[4] - bptr[8]) < ((int16)1 << (GREY_SHIFT - 3))) return 3; /* \ */ } diff_array[0] = labs(bptr[4] - bptr[0]); diff_array[1] = labs(bptr[4] - bptr[5]); diff_array[2] = labs(bptr[3] - bptr[7]); diff_array[3] = labs(bptr[7] - bptr[8]); diff_array[4] = labs(bptr[1] - bptr[2]); diff_array[5] = labs(bptr[4] - bptr[3]); diff_array[6] = labs(bptr[4] - bptr[8]); diff_array[7] = labs(bptr[0] - bptr[1]); diff_array[8] = labs(bptr[1] - bptr[5]); diff_array[9] = labs(bptr[6] - bptr[7]); diff_array[10] = labs(bptr[4] - bptr[7]); diff_array[11] = labs(bptr[5] - bptr[8]); diff_array[12] = labs(bptr[3] - bptr[6]); diff_array[13] = labs(bptr[4] - bptr[1]); diff_array[14] = labs(bptr[0] - bptr[3]); diff_array[15] = labs(bptr[2] - bptr[5]); diff_array[20] = labs(bptr[0] - bptr[2]); diff_array[21] = labs(bptr[6] - bptr[8]); diff_array[22] = labs(bptr[0] - bptr[6]); diff_array[23] = labs(bptr[2] - bptr[8]); diff_array[16] = labs(bptr[4] - bptr[2]); diff_array[18] = labs(bptr[4] - bptr[6]); /* '- */ sums_dir[1] = diff_array[0] + diff_array[1] + diff_array[2] + diff_array[3] + (diff_array[4] << 1); /* '- alt */ sum = diff_array[0] + diff_array[1] + diff_array[12] + diff_array[9] + diff_array[3] + diff_array[20]; if (sum < sums_dir[1]) sums_dir[1] = sum; /* -. */ sums_dir[2] = diff_array[5] + diff_array[6] + diff_array[7] + diff_array[8] + (diff_array[9] << 1); /* -. alt */ sum = diff_array[6] + diff_array[5] + diff_array[15] + diff_array[4] + diff_array[7] + diff_array[21]; if (sum < sums_dir[2]) sums_dir[2] = sum; /* '| */ sums_dir[3] = diff_array[0] + diff_array[8] + diff_array[10] + diff_array[11] + (diff_array[12] << 1); /* '| alt */ sum = diff_array[0] + diff_array[10] + diff_array[4] + diff_array[15] + diff_array[11] + diff_array[22]; if (sum < sums_dir[3]) sums_dir[3] = sum; /* |. */ sums_dir[4] = diff_array[2] + diff_array[6] + diff_array[13] + diff_array[14] + (diff_array[15] << 1); /* |. alt */ sum = diff_array[13] + diff_array[6] + diff_array[9] + diff_array[12] + diff_array[14] + diff_array[23]; if (sum < sums_dir[4]) sums_dir[4] = sum; /* \ 45 */ sums_dir[0] = diff_array[0] + diff_array[6] + (diff_array[2] << 1) + (diff_array[8] << 1); /* << top */ sum = labs(bptr[3] - bptr[1]) + labs(bptr[3] - bptr[7]) + ((labs(bptr[4] - bptr[2]) + labs(bptr[4] - bptr[8]) + labs(bptr[5] - bptr[1]) + labs(bptr[5] - bptr[7])) << 1) + labs(bptr[0] - bptr[6]) + labs(bptr[1] - bptr[7]) + labs(bptr[2] - bptr[8]); sum = (sum * 6) / 13; sums_dir[5] = sum; /* >> top */ sum = labs(bptr[5] - bptr[1]) + labs(bptr[5] - bptr[7]) + ((labs(bptr[4] - bptr[0]) + labs(bptr[4] - bptr[6]) + labs(bptr[3] - bptr[1]) + labs(bptr[3] - bptr[7])) << 1) + labs(bptr[2] - bptr[8]) + labs(bptr[1] - bptr[7]) + labs(bptr[0] - bptr[6]); sum = (sum * 6) / 13; sums_dir[6] = sum; /* ^ top */ sum = labs(bptr[1] - bptr[3]) + labs(bptr[1] - bptr[5]) + ((labs(bptr[4] - bptr[6]) + labs(bptr[4] - bptr[8]) + labs(bptr[7] - bptr[3]) + labs(bptr[7] - bptr[5])) << 1) + labs(bptr[0] - bptr[2]) + labs(bptr[3] - bptr[5]) + labs(bptr[6] - bptr[8]); sum = (sum * 6) / 13; sums_dir[7] = sum; /* v top */ sum = labs(bptr[7] - bptr[3]) + labs(bptr[7] - bptr[5]) + ((labs(bptr[4] - bptr[0]) + labs(bptr[4] - bptr[2]) + labs(bptr[1] - bptr[3]) + labs(bptr[1] - bptr[5])) << 1) + labs(bptr[6] - bptr[8]) + labs(bptr[3] - bptr[5]) + labs(bptr[0] - bptr[2]); sum = (sum * 6) / 13; sums_dir[8] = sum; best_sum = sums_dir[0]; for (i = 1; i < 9; i++) if (sums_dir[i] < best_sum) best_sum = sums_dir[i]; best_dir = 0; for (i = 0, n = 0; i < 9; i++) { if (sums_dir[i] == best_sum) { best_dir = i; n++; } } /* CHECK -- handle zig-zags */ if (_simSum == 3) { if ((best_dir == 0 || best_dir == 1) && sim[0] && sim[1] && sim[4]) return 1; /* '- */ if ((best_dir == 0 || best_dir == 2) && sim[3] && sim[6] && sim[7]) return 2; /* -. */ if ((best_dir == 0 || best_dir == 3) && sim[0] && sim[3] && sim[6]) return 4; /* '| */ if ((best_dir == 0 || best_dir == 4) && sim[1] && sim[4] && sim[7]) return 5; /* |. */ } if (n > 1 && best_sum == sums_dir[0]) return 3; /* \ */ /* best direction uncertain, return non-edge to avoid artifacts */ if (n > 1) return -1; /* CHECK -- diagonal intersections */ if (best_dir == 0 && (sim[1] == sim[4] || sim[3] == sim[6]) && (sim[1] == sim[3] || sim[4] == sim[6])) { if ((pixels[1] == pixels[3] || pixels[5] == pixels[7]) || ((pixels[0] == pixels[4]) ^ (pixels[8] == pixels[4]))) { if (pixels[2] == pixels[4]) return 16; /* \' */ if (pixels[6] == pixels[4]) return 17; /* .\ */ } if (_simSum == 3 && sim[0] && sim[7] && pixels[1] == pixels[3] && pixels[3] == pixels[5] && pixels[5] == pixels[7]) { if (sim[2]) return 16; /* \' */ if (sim[5]) return 17; /* .\ */ } if (_simSum == 3 && sim[2] && sim[5]) { if (sim[0]) return 18; /* '/ */ if (sim[7]) return 19; /* /. */ } } if (best_dir >= 5) ok_arrow_flag = checkArrows(best_dir, pixels, sim, 0); switch (best_dir) { case 1: return 1; /* '- */ break; case 2: return 2; /* -. */ break; case 3: return 4; /* '| */ break; case 4: return 5; /* |. */ break; case 5: if (ok_arrow_flag) return 12; /* < */ break; case 6: if (ok_arrow_flag) return 13; /* > */ break; case 7: if (ok_arrow_flag) return 14; /* ^ */ break; case 8: if (ok_arrow_flag) return 15; /* V */ break; case 0: default: return 3; /* \ */ break; } break; case '/': /* CHECK -- handle noisy half-diags */ if (_simSum == 1) { if (pixels[1] == pixels[3] && pixels[3] == pixels[5] && pixels[5] == pixels[7]) { if (pixels[0] != pixels[1] && pixels[8] != pixels[1]) { sum = labs(bptr[0] - bptr[4]) + labs(bptr[8] - bptr[4]); if (sim[2] && sum < (labs(bptr[6] - bptr[4]) << 1)) { if (bptr[4] > bptr[6]) { if (bptr[0] > bptr[4] && bptr[8] > bptr[4]) return 16; /* \' */ } else { if (bptr[0] < bptr[4] && bptr[8] < bptr[4]) return 16; /* \' */ } } if (sim[5] && sum < (labs(bptr[2] - bptr[4]) << 1)) { if (bptr[4] > bptr[2]) { if (bptr[0] > bptr[4] && bptr[8] > bptr[4]) { if (pixels[6] == pixels[4]) return 17; /* .\ */ return 3; /* \ */ } } else { if (bptr[0] < bptr[4] && bptr[8] < bptr[4]) { if (pixels[6] == pixels[4]) return 17; /* .\ */ return 3; /* \ */ } } } } } if (sim[2] && labs(bptr[4] - bptr[2]) < ((int16)1 << (GREY_SHIFT - 3))) return 9; /* / */ if (sim[5] && labs(bptr[4] - bptr[6]) < ((int16)1 << (GREY_SHIFT - 3))) return 9; /* / */ } diff_array[0] = labs(bptr[4] - bptr[0]); diff_array[1] = labs(bptr[4] - bptr[5]); diff_array[3] = labs(bptr[7] - bptr[8]); diff_array[4] = labs(bptr[1] - bptr[2]); diff_array[5] = labs(bptr[4] - bptr[3]); diff_array[6] = labs(bptr[4] - bptr[8]); diff_array[7] = labs(bptr[0] - bptr[1]); diff_array[9] = labs(bptr[6] - bptr[7]); diff_array[10] = labs(bptr[4] - bptr[7]); diff_array[11] = labs(bptr[5] - bptr[8]); diff_array[12] = labs(bptr[3] - bptr[6]); diff_array[13] = labs(bptr[4] - bptr[1]); diff_array[14] = labs(bptr[0] - bptr[3]); diff_array[15] = labs(bptr[2] - bptr[5]); diff_array[16] = labs(bptr[4] - bptr[2]); diff_array[17] = labs(bptr[1] - bptr[3]); diff_array[18] = labs(bptr[4] - bptr[6]); diff_array[19] = labs(bptr[5] - bptr[7]); diff_array[20] = labs(bptr[0] - bptr[2]); diff_array[21] = labs(bptr[6] - bptr[8]); diff_array[22] = labs(bptr[0] - bptr[6]); diff_array[23] = labs(bptr[2] - bptr[8]); /* |' */ sums_dir[1] = diff_array[10] + diff_array[12] + diff_array[16] + diff_array[17] + (diff_array[11] << 1); /* |' alt */ sum = diff_array[16] + diff_array[10] + diff_array[7] + diff_array[14] + diff_array[12] + diff_array[23]; if (sum < sums_dir[1]) sums_dir[1] = sum; /* .| */ sums_dir[2] = diff_array[13] + diff_array[15] + diff_array[18] + diff_array[19] + (diff_array[14] << 1); /* .| alt */ sum = diff_array[18] + diff_array[13] + diff_array[3] + diff_array[11] + diff_array[15] + diff_array[22]; if (sum < sums_dir[2]) sums_dir[2] = sum; /* -' */ sums_dir[3] = diff_array[5] + diff_array[9] + diff_array[16] + diff_array[19] + (diff_array[7] << 1); /* -' alt */ sum = diff_array[16] + diff_array[5] + diff_array[11] + diff_array[3] + diff_array[9] + diff_array[20]; if (sum < sums_dir[3]) sums_dir[3] = sum; /* .- */ sums_dir[4] = diff_array[1] + diff_array[4] + diff_array[17] + diff_array[18] + (diff_array[3] << 1); /* .- alt */ sum = diff_array[18] + diff_array[1] + diff_array[14] + diff_array[7] + diff_array[4] + diff_array[21]; if (sum < sums_dir[4]) sums_dir[4] = sum; /* / 135 */ sums_dir[0] = diff_array[16] + diff_array[18] + (diff_array[17] << 1) + (diff_array[19] << 1); /* << top */ sum = labs(bptr[3] - bptr[1]) + labs(bptr[3] - bptr[7]) + ((labs(bptr[4] - bptr[2]) + labs(bptr[4] - bptr[8]) + labs(bptr[5] - bptr[1]) + labs(bptr[5] - bptr[7])) << 1) + labs(bptr[0] - bptr[6]) + labs(bptr[1] - bptr[7]) + labs(bptr[2] - bptr[8]); sum = (sum * 6) / 13; sums_dir[5] = sum; /* >> top */ sum = labs(bptr[5] - bptr[1]) + labs(bptr[5] - bptr[7]) + ((labs(bptr[4] - bptr[0]) + labs(bptr[4] - bptr[6]) + labs(bptr[3] - bptr[1]) + labs(bptr[3] - bptr[7])) << 1) + labs(bptr[2] - bptr[8]) + labs(bptr[1] - bptr[7]) + labs(bptr[0] - bptr[6]); sum = (sum * 6) / 13; sums_dir[6] = sum; /* ^ top */ sum = labs(bptr[1] - bptr[3]) + labs(bptr[1] - bptr[5]) + ((labs(bptr[4] - bptr[6]) + labs(bptr[4] - bptr[8]) + labs(bptr[7] - bptr[3]) + labs(bptr[7] - bptr[5])) << 1) + labs(bptr[0] - bptr[2]) + labs(bptr[3] - bptr[5]) + labs(bptr[6] - bptr[8]); sum = (sum * 6) / 13; sums_dir[7] = sum; /* v top */ sum = labs(bptr[7] - bptr[3]) + labs(bptr[7] - bptr[5]) + ((labs(bptr[4] - bptr[0]) + labs(bptr[4] - bptr[2]) + labs(bptr[1] - bptr[3]) + labs(bptr[1] - bptr[5])) << 1) + labs(bptr[6] - bptr[8]) + labs(bptr[3] - bptr[5]) + labs(bptr[0] - bptr[2]); sum = (sum * 6) / 13; sums_dir[8] = sum; best_sum = sums_dir[0]; for (i = 1; i < 9; i++) if (sums_dir[i] < best_sum) best_sum = sums_dir[i]; best_dir = 0; for (i = 0, n = 0; i < 9; i++) { if (sums_dir[i] == best_sum) { best_dir = i; n++; } } /* CHECK -- handle zig-zags */ if (_simSum == 3) { if ((best_dir == 0 || best_dir == 1) && sim[2] && sim[4] && sim[6]) return 7; /* |' */ if ((best_dir == 0 || best_dir == 2) && sim[1] && sim[3] && sim[5]) return 8; /* .| */ if ((best_dir == 0 || best_dir == 3) && sim[1] && sim[2] && sim[3]) return 10; /* -' */ if ((best_dir == 0 || best_dir == 4) && sim[4] && sim[5] && sim[6]) return 11; /* .- */ } if (n > 1 && best_sum == sums_dir[0]) return 9; /* / */ /* best direction uncertain, return non-edge to avoid artifacts */ if (n > 1) return -1; /* CHECK -- diagonal intersections */ if (best_dir == 0 && (sim[1] == sim[3] || sim[4] == sim[6]) && (sim[1] == sim[4] || sim[3] == sim[6])) { if ((pixels[1] == pixels[5] || pixels[3] == pixels[7]) || ((pixels[2] == pixels[4]) ^ (pixels[6] == pixels[4]))) { if (pixels[0] == pixels[4]) return 18; /* '/ */ if (pixels[8] == pixels[4]) return 19; /* /. */ } if (_simSum == 3 && sim[2] && sim[5] && pixels[1] == pixels[3] && pixels[3] == pixels[5] && pixels[5] == pixels[7]) { if (sim[0]) return 18; /* '/ */ if (sim[7]) return 19; /* /. */ } if (_simSum == 3 && sim[0] && sim[7]) { if (sim[2]) return 16; /* \' */ if (sim[5]) return 17; /* .\ */ } } if (best_dir >= 5) ok_arrow_flag = checkArrows(best_dir, pixels, sim, 0); switch (best_dir) { case 1: return 7; /* |' */ break; case 2: return 8; /* .| */ break; case 3: return 10; /* -' */ break; case 4: return 11; /* .- */ break; case 5: if (ok_arrow_flag) return 12; /* < */ break; case 6: if (ok_arrow_flag) return 13; /* > */ break; case 7: if (ok_arrow_flag) return 14; /* ^ */ break; case 8: if (ok_arrow_flag) return 15; /* V */ break; break; case 0: default: return 9; /* / */ break; } break; case '*': return 127; break; case '0': default: return -1; break; } return -1; } template int EdgeScaler::fixKnights(int sub_type, Pixel *pixels, int8 *sim) { Pixel center = pixels[4]; int dir = sub_type; int n = 0; int flags[12] = {0}; int ok_orig_flag = 0; /* * - '- -. \ '| |. | |' .| / -' .- * * 0 1 2 3 4 5 6 7 8 9 10 11 * */ /* check to see if original knight is ok */ switch (sub_type) { case 1: /* '- */ if (sim[0] && sim[4] && !(_simSum == 3 && sim[5] && pixels[0] == pixels[4] && pixels[6] == pixels[4])) ok_orig_flag = 1; break; case 2: /* -. */ if (sim[3] && sim[7] && !(_simSum == 3 && sim[2] && pixels[2] == pixels[4] && pixels[8] == pixels[4])) ok_orig_flag = 1; break; case 4: /* '| */ if (sim[0] && sim[6] && !(_simSum == 3 && sim[2] && pixels[0] == pixels[4] && pixels[2] == pixels[4])) ok_orig_flag = 1; break; case 5: /* |. */ if (sim[1] && sim[7] && !(_simSum == 3 && sim[5] && pixels[6] == pixels[4] && pixels[8] == pixels[4])) ok_orig_flag = 1; break; case 7: /* |' */ if (sim[2] && sim[6] && !(_simSum == 3 && sim[0] && pixels[0] == pixels[4] && pixels[2] == pixels[4])) ok_orig_flag = 1; break; case 8: /* .| */ if (sim[1] && sim[5] && !(_simSum == 3 && sim[7] && pixels[6] == pixels[4] && pixels[8] == pixels[4])) ok_orig_flag = 1; break; case 10: /* -' */ if (sim[2] && sim[3] && !(_simSum == 3 && sim[7] && pixels[2] == pixels[4] && pixels[8] == pixels[4])) ok_orig_flag = 1; break; case 11: /* .- */ if (sim[4] && sim[5] && !(_simSum == 3 && sim[0] && pixels[0] == pixels[4] && pixels[6] == pixels[4])) ok_orig_flag = 1; break; default: /* not a knight */ return sub_type; break; } /* look for "better" knights */ if (center == pixels[0] && center == pixels[5]) { /* '- */ dir = 1; flags[dir] = 1; n++; } if (center == pixels[3] && center == pixels[8]) { /* -. */ dir = 2; flags[dir] = 1; n++; } if (center == pixels[0] && center == pixels[7]) { /* '| */ dir = 4; flags[dir] = 1; n++; } if (center == pixels[1] && center == pixels[8]) { /* |. */ dir = 5; flags[dir] = 1; n++; } if (center == pixels[2] && center == pixels[7]) { /* |' */ dir = 7; flags[dir] = 1; n++; } if (center == pixels[1] && center == pixels[6]) { /* .| */ dir = 8; flags[dir] = 1; n++; } if (center == pixels[3] && center == pixels[2]) { /* -' */ dir = 10; flags[dir] = 1; n++; } if (center == pixels[6] && center == pixels[5]) { /* .- */ dir = 11; flags[dir] = 1; n++; } if (n == 0) { if (ok_orig_flag) return sub_type; return -1; } if (n == 1) return dir; if (n == 2) { /* slanted W patterns */ if (flags[1] && flags[5]) return 3; /* \ */ if (flags[2] && flags[4]) return 3; /* \ */ if (flags[7] && flags[11]) return 9; /* / */ if (flags[8] && flags[10]) return 9; /* / */ } if (flags[sub_type] && ok_orig_flag) return sub_type; return -1; } /* From ScummVM HQ2x/HQ3x scalers (Maxim Stepin and Max Horn) */ #define highBits 0xF7DEF7DE #define lowBits 0x08210821 #define qhighBits 0xE79CE79C #define qlowBits 0x18631863 #define redblueMask 0xF81F #define greenMask 0x07E0 template void EdgeScaler::antiAliasGridClean3x(uint8 *dptr, int dstPitch, typename ColorMask::PixelType *pixels, int sub_type, int16 *bptr) { typedef typename ColorMask::PixelType Pixel; Pixel *dptr2; int16 tmp_grey; Pixel center = pixels[4]; int32 diff1, diff2, diff3; Pixel tmp[9]; Pixel *ptmp; int i; switch (sub_type) { case 1: /* '- */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[6] = interpolate_1_1_1(pixels[3], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[6])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[3]); diff2 = labs(bptr[4] - bptr[7]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[6] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[6], pixels[3]); diff2 = calcPixelDiffNosqrt(tmp[6], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[6], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[6] = pixels[3]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[6] = pixels[7]; else tmp[6] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[6])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[8]); if (diff1 <= diff2) tmp[7] = tmp[6]; } break; case 2: /* -. */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[2] = interpolate_1_1_1(pixels[1], pixels[5], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[5]); diff2 = labs(bptr[4] - bptr[1]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[2] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[2], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[2], pixels[5]); diff3 = calcPixelDiffNosqrt(tmp[2], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[2] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[2] = pixels[5]; else tmp[2] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[0]); if (diff1 <= diff2) tmp[1] = tmp[2]; } break; case 3: /* \ */ case 16: /* \' */ case 17: /* .\ */ for (i = 0; i < 9; i++) tmp[i] = center; if (sub_type != 16) { tmp[2] = interpolate_1_1_1(pixels[1], pixels[5], center); diff1 = calcPixelDiffNosqrt(tmp[2], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[2], pixels[5]); diff3 = calcPixelDiffNosqrt(tmp[2], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[2] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[2] = pixels[5]; else tmp[2] = pixels[4]; } if (sub_type != 17) { tmp[6] = interpolate_1_1_1(pixels[3], pixels[7], center); diff1 = calcPixelDiffNosqrt(tmp[6], pixels[3]); diff2 = calcPixelDiffNosqrt(tmp[6], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[6], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[6] = pixels[3]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[6] = pixels[7]; else tmp[6] = pixels[4]; } break; case 4: /* '| */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[2] = interpolate_1_1_1(pixels[1], pixels[5], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[1]); diff2 = labs(bptr[4] - bptr[5]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[2] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[2], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[2], pixels[5]); diff3 = calcPixelDiffNosqrt(tmp[2], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[2] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[2] = pixels[5]; else tmp[2] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[8]); if (diff1 <= diff2) tmp[5] = tmp[2]; } break; case 5: /* |. */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[6] = interpolate_1_1_1(pixels[3], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[6])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[7]); diff2 = labs(bptr[4] - bptr[3]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[6] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[6], pixels[3]); diff2 = calcPixelDiffNosqrt(tmp[6], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[6], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[6] = pixels[3]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[6] = pixels[7]; else tmp[6] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[6])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[0]); if (diff1 <= diff2) tmp[3] = tmp[6]; } break; case 7: /* |' */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[0] = interpolate_1_1_1(pixels[1], pixels[3], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[1]); diff2 = labs(bptr[4] - bptr[3]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[0] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[0], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[0], pixels[3]); diff3 = calcPixelDiffNosqrt(tmp[0], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[0] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[0] = pixels[3]; else tmp[0] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[6]); if (diff1 <= diff2) tmp[3] = tmp[0]; } break; case 8: /* .| */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[8] = interpolate_1_1_1(pixels[5], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[8])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[7]); diff2 = labs(bptr[4] - bptr[5]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[8] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[8], pixels[5]); diff2 = calcPixelDiffNosqrt(tmp[8], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[8], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[8] = pixels[5]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[8] = pixels[7]; else tmp[8] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[8])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[2]); if (diff1 <= diff2) tmp[5] = tmp[8]; } break; case 9: /* / */ case 18: /* '/ */ case 19: /* /. */ for (i = 0; i < 9; i++) tmp[i] = center; if (sub_type != 18) { tmp[0] = interpolate_1_1_1(pixels[1], pixels[3], center); diff1 = calcPixelDiffNosqrt(tmp[0], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[0], pixels[3]); diff3 = calcPixelDiffNosqrt(tmp[0], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[0] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[0] = pixels[3]; else tmp[0] = pixels[4]; } if (sub_type != 19) { tmp[8] = interpolate_1_1_1(pixels[5], pixels[7], center); diff1 = calcPixelDiffNosqrt(tmp[8], pixels[5]); diff2 = calcPixelDiffNosqrt(tmp[8], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[8], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[8] = pixels[5]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[8] = pixels[7]; else tmp[8] = pixels[4]; } break; case 10: /* -' */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[8] = interpolate_1_1_1(pixels[5], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[8])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[5]); diff2 = labs(bptr[4] - bptr[7]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[8] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[8], pixels[5]); diff2 = calcPixelDiffNosqrt(tmp[8], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[8], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[8] = pixels[5]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[8] = pixels[7]; else tmp[8] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[8])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[6]); if (diff1 <= diff2) tmp[7] = tmp[8]; } break; case 11: /* .- */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[0] = interpolate_1_1_1(pixels[1], pixels[3], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[3]); diff2 = labs(bptr[4] - bptr[1]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[0] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[0], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[0], pixels[3]); diff3 = calcPixelDiffNosqrt(tmp[0], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[0] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[0] = pixels[3]; else tmp[0] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[2]); if (diff1 <= diff2) tmp[1] = tmp[0]; } break; case 12: /* < */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[0] = interpolate_1_1_1(pixels[1], pixels[3], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[1]); diff2 = labs(bptr[4] - bptr[3]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[0] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[0], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[0], pixels[3]); diff3 = calcPixelDiffNosqrt(tmp[0], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[0] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[0] = pixels[3]; else tmp[0] = pixels[4]; } tmp[6] = interpolate_1_1_1(pixels[3], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[6])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[3]); diff2 = labs(bptr[4] - bptr[7]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[6] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[6], pixels[3]); diff2 = calcPixelDiffNosqrt(tmp[6], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[6], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[6] = pixels[3]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[6] = pixels[7]; else tmp[6] = pixels[4]; } break; case 13: /* > */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[2] = interpolate_1_1_1(pixels[1], pixels[5], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[5]); diff2 = labs(bptr[4] - bptr[1]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[2] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[2], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[2], pixels[5]); diff3 = calcPixelDiffNosqrt(tmp[2], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[2] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[2] = pixels[5]; else tmp[2] = pixels[4]; } tmp[8] = interpolate_1_1_1(pixels[5], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[8])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[7]); diff2 = labs(bptr[4] - bptr[5]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[8] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[8], pixels[5]); diff2 = calcPixelDiffNosqrt(tmp[8], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[8], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[8] = pixels[5]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[8] = pixels[7]; else tmp[8] = pixels[4]; } break; case 14: /* ^ */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[0] = interpolate_1_1_1(pixels[1], pixels[3], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[1]); diff2 = labs(bptr[4] - bptr[3]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[0] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[0], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[0], pixels[3]); diff3 = calcPixelDiffNosqrt(tmp[0], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[0] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[0] = pixels[3]; else tmp[0] = pixels[4]; } tmp[2] = interpolate_1_1_1(pixels[1], pixels[5], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[5]); diff2 = labs(bptr[4] - bptr[1]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[2] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[2], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[2], pixels[5]); diff3 = calcPixelDiffNosqrt(tmp[2], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[2] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[2] = pixels[5]; else tmp[2] = pixels[4]; } break; case 15: /* v */ for (i = 0; i < 9; i++) tmp[i] = center; tmp[6] = interpolate_1_1_1(pixels[3], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[6])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[3]); diff2 = labs(bptr[4] - bptr[7]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[6] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[6], pixels[3]); diff2 = calcPixelDiffNosqrt(tmp[6], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[6], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[6] = pixels[3]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[6] = pixels[7]; else tmp[6] = pixels[4]; } tmp[8] = interpolate_1_1_1(pixels[5], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[8])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[7]); diff2 = labs(bptr[4] - bptr[5]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[8] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[8], pixels[5]); diff2 = calcPixelDiffNosqrt(tmp[8], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[8], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[8] = pixels[5]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[8] = pixels[7]; else tmp[8] = pixels[4]; } break; case 127: /* * */ case -1: /* no edge */ case 0: /* - */ case 6: /* | */ default: dptr2 = ((Pixel *)(dptr - dstPitch)) - 1; *dptr2++ = center; *dptr2++ = center; *dptr2 = center; dptr2 = ((Pixel *) dptr) - 1; *dptr2++ = center; *dptr2++ = center; #if DEBUG_REFRESH_RANDOM_XOR *dptr2 = center ^ (Pixel)(dxorshift128() * (1L << 16)); #else *dptr2 = center; #endif dptr2 = ((Pixel *)(dptr + dstPitch)) - 1; *dptr2++ = center; *dptr2++ = center; *dptr2 = center; return; break; } ptmp = tmp; dptr2 = ((Pixel *)(dptr - dstPitch)) - 1; *dptr2++ = *ptmp++; *dptr2++ = *ptmp++; *dptr2 = *ptmp++; dptr2 = ((Pixel *) dptr) - 1; *dptr2++ = *ptmp++; *dptr2++ = *ptmp++; #if DEBUG_REFRESH_RANDOM_XOR *dptr2 = *ptmp++ ^ (Pixel)(dxorshift128() * (1L << 16)); #else *dptr2 = *ptmp++; #endif dptr2 = ((Pixel *)(dptr + dstPitch)) - 1; *dptr2++ = *ptmp++; *dptr2++ = *ptmp++; *dptr2 = *ptmp; } template void EdgeScaler::antiAliasGrid2x(uint8 *dptr, int dstPitch, typename ColorMask::PixelType *pixels, int sub_type, int16 *bptr, int8 *sim, int interpolate_2x) { typedef typename ColorMask::PixelType Pixel; Pixel *dptr2; Pixel center = pixels[4]; int32 diff1, diff2, diff3; int16 tmp_grey; Pixel tmp[4]; Pixel *ptmp; switch (sub_type) { case 1: /* '- */ tmp[0] = tmp[1] = tmp[3] = center; tmp[2] = interpolate_1_1_1(pixels[3], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[3]); diff2 = labs(bptr[4] - bptr[7]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[2] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[2], pixels[3]); diff2 = calcPixelDiffNosqrt(tmp[2], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[2], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[2] = pixels[3]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[2] = pixels[7]; else tmp[2] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[8]); if (diff1 <= diff2) { if (interpolate_2x) { Pixel tmp_pixel = tmp[2]; tmp[2] = interpolate_3_1(tmp_pixel, center); tmp[3] = interpolate_3_1(center, tmp_pixel); } } else { if (interpolate_2x) { tmp[2] = interpolate_1_1(tmp[2], center); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[2])]) tmp[2] = center; } } } break; case 2: /* -. */ tmp[0] = tmp[2] = tmp[3] = center; tmp[1] = interpolate_1_1_1(pixels[1], pixels[5], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[1])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[5]); diff2 = labs(bptr[4] - bptr[1]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[1] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[1], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[1], pixels[5]); diff3 = calcPixelDiffNosqrt(tmp[1], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[1] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[1] = pixels[5]; else tmp[1] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[1])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[0]); if (diff1 <= diff2) { if (interpolate_2x) { Pixel tmp_pixel = tmp[1]; tmp[1] = interpolate_3_1(tmp_pixel, center); tmp[0] = interpolate_3_1(center, tmp_pixel); } } else { if (interpolate_2x) { tmp[1] = interpolate_1_1(tmp[1], center); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[1])]) tmp[1] = center; } } } break; case 3: /* \ */ case 16: /* \' */ case 17: /* .\ */ tmp[0] = tmp[1] = tmp[2] = tmp[3] = center; if (sub_type != 16) { tmp[1] = interpolate_1_1_1(pixels[1], pixels[5], center); diff1 = calcPixelDiffNosqrt(tmp[1], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[1], pixels[5]); diff3 = calcPixelDiffNosqrt(tmp[1], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[1] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[1] = pixels[5]; else tmp[1] = pixels[4]; if (interpolate_2x) { tmp[1] = interpolate_1_1(tmp[1], center); } /* sim test is for hyper-cephalic kitten eyes and squeeze toy * mouse pointer in Sam&Max. Half-diags can be too thin in 2x * nearest-neighbor, so detect them and don't anti-alias them. */ else if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[1])] || (_simSum == 1 && (sim[0] || sim[7]) && pixels[1] == pixels[3] && pixels[5] == pixels[7])) tmp[1] = center; } if (sub_type != 17) { tmp[2] = interpolate_1_1_1(pixels[3], pixels[7], center); diff1 = calcPixelDiffNosqrt(tmp[2], pixels[3]); diff2 = calcPixelDiffNosqrt(tmp[2], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[2], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[2] = pixels[3]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[2] = pixels[7]; else tmp[2] = pixels[4]; if (interpolate_2x) { tmp[2] = interpolate_1_1(tmp[2], center); } /* sim test is for hyper-cephalic kitten eyes and squeeze toy * mouse pointer in Sam&Max. Half-diags can be too thin in 2x * nearest-neighbor, so detect them and don't anti-alias them. */ else if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[2])] || (_simSum == 1 && (sim[0] || sim[7]) && pixels[1] == pixels[3] && pixels[5] == pixels[7])) tmp[2] = center; } break; case 4: /* '| */ tmp[0] = tmp[2] = tmp[3] = center; tmp[1] = interpolate_1_1_1(pixels[1], pixels[5], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[1])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[1]); diff2 = labs(bptr[4] - bptr[5]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[1] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[1], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[1], pixels[5]); diff3 = calcPixelDiffNosqrt(tmp[1], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[1] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[1] = pixels[5]; else tmp[1] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[1])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[8]); if (diff1 <= diff2) { if (interpolate_2x) { Pixel tmp_pixel = tmp[1]; tmp[1] = interpolate_3_1(tmp_pixel, center); tmp[3] = interpolate_3_1(center, tmp_pixel); } } else { if (interpolate_2x) { tmp[1] = interpolate_1_1(tmp[1], center); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[1])]) tmp[1] = center; } } } break; case 5: /* |. */ tmp[0] = tmp[1] = tmp[3] = center; tmp[2] = interpolate_1_1_1(pixels[3], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[7]); diff2 = labs(bptr[4] - bptr[3]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[2] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[2], pixels[3]); diff2 = calcPixelDiffNosqrt(tmp[2], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[2], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[2] = pixels[3]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[2] = pixels[7]; else tmp[2] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[0]); if (diff1 <= diff2) { if (interpolate_2x) { Pixel tmp_pixel = tmp[2]; tmp[2] = interpolate_3_1(tmp_pixel, center); tmp[0] = interpolate_3_1(center, tmp_pixel); } } else { if (interpolate_2x) { tmp[2] = interpolate_1_1(tmp[2], center); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[2])]) tmp[2] = center; } } } break; case 7: /* |' */ tmp[1] = tmp[2] = tmp[3] = center; tmp[0] = interpolate_1_1_1(pixels[1], pixels[3], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[1]); diff2 = labs(bptr[4] - bptr[3]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[0] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[0], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[0], pixels[3]); diff3 = calcPixelDiffNosqrt(tmp[0], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[0] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[0] = pixels[3]; else tmp[0] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[6]); if (diff1 <= diff2) { if (interpolate_2x) { Pixel tmp_pixel = tmp[0]; tmp[0] = interpolate_3_1(tmp_pixel, center); tmp[2] = interpolate_3_1(center, tmp_pixel); } } else { if (interpolate_2x) { tmp[0] = interpolate_1_1(tmp[0], center); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[0])]) tmp[0] = center; } } } break; case 8: /* .| */ tmp[0] = tmp[1] = tmp[2] = center; tmp[3] = interpolate_1_1_1(pixels[5], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[3])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[7]); diff2 = labs(bptr[4] - bptr[5]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[3] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[3], pixels[5]); diff2 = calcPixelDiffNosqrt(tmp[3], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[3], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[3] = pixels[5]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[3] = pixels[7]; else tmp[3] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[3])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[2]); if (diff1 <= diff2) { if (interpolate_2x) { Pixel tmp_pixel = tmp[3]; tmp[3] = interpolate_3_1(tmp_pixel, center); tmp[1] = interpolate_3_1(center, tmp_pixel); } } else { if (interpolate_2x) { tmp[3] = interpolate_1_1(tmp[3], center); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[3])]) tmp[3] = center; } } } break; case 9: /* / */ case 18: /* '/ */ case 19: /* /. */ tmp[0] = tmp[1] = tmp[2] = tmp[3] = center; if (sub_type != 18) { tmp[0] = interpolate_1_1_1(pixels[1], pixels[3], center); diff1 = calcPixelDiffNosqrt(tmp[0], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[0], pixels[3]); diff3 = calcPixelDiffNosqrt(tmp[0], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[0] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[0] = pixels[3]; else tmp[0] = pixels[4]; if (interpolate_2x) { tmp[0] = interpolate_1_1(tmp[0], center); } /* sim test is for hyper-cephalic kitten eyes and squeeze toy * mouse pointer in Sam&Max. Half-diags can be too thin in 2x * nearest-neighbor, so detect them and don't anti-alias them. */ else if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[0])] || (_simSum == 1 && (sim[2] || sim[5]) && pixels[1] == pixels[5] && pixels[3] == pixels[7])) tmp[0] = center; } if (sub_type != 19) { tmp[3] = interpolate_1_1_1(pixels[5], pixels[7], center); diff1 = calcPixelDiffNosqrt(tmp[3], pixels[5]); diff2 = calcPixelDiffNosqrt(tmp[3], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[3], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[3] = pixels[5]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[3] = pixels[7]; else tmp[3] = pixels[4]; if (interpolate_2x) { tmp[3] = interpolate_1_1(tmp[3], center); } /* sim test is for hyper-cephalic kitten eyes and squeeze toy * mouse pointer in Sam&Max. Half-diags can be too thin in 2x * nearest-neighbor, so detect them and don't anti-alias them. */ else if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[3])] || (_simSum == 1 && (sim[2] || sim[5]) && pixels[1] == pixels[5] && pixels[3] == pixels[7])) tmp[3] = center; } break; case 10: /* -' */ tmp[0] = tmp[1] = tmp[2] = center; tmp[3] = interpolate_1_1_1(pixels[5], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[3])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[5]); diff2 = labs(bptr[4] - bptr[7]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[3] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[3], pixels[5]); diff2 = calcPixelDiffNosqrt(tmp[3], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[3], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[3] = pixels[5]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[3] = pixels[7]; else tmp[3] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[3])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[6]); if (diff1 <= diff2) { if (interpolate_2x) { Pixel tmp_pixel = tmp[3]; tmp[3] = interpolate_3_1(tmp_pixel, center); tmp[2] = interpolate_3_1(center, tmp_pixel); } } else { if (interpolate_2x) { tmp[3] = interpolate_1_1(tmp[3], center); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[3])]) tmp[3] = center; } } } break; case 11: /* .- */ tmp[1] = tmp[2] = tmp[3] = center; tmp[0] = interpolate_1_1_1(pixels[1], pixels[3], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; #if PARANOID_KNIGHTS diff1 = labs(bptr[4] - bptr[3]); diff2 = labs(bptr[4] - bptr[1]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[0] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[0], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[0], pixels[3]); diff3 = calcPixelDiffNosqrt(tmp[0], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[0] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[0] = pixels[3]; else tmp[0] = pixels[4]; tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; diff1 = labs(bptr[4] - tmp_grey); diff2 = labs(bptr[4] - bptr[2]); if (diff1 <= diff2) { if (interpolate_2x) { Pixel tmp_pixel = tmp[0]; tmp[0] = interpolate_3_1(tmp_pixel, center); tmp[1] = interpolate_3_1(center, tmp_pixel); } } else { if (interpolate_2x) { tmp[0] = interpolate_1_1(tmp[0], center); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[0])]) tmp[0] = center; } } } break; case 12: /* < */ tmp[0] = tmp[1] = tmp[2] = tmp[3] = center; tmp[0] = interpolate_1_1_1(pixels[1], pixels[3], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[1]); diff2 = labs(bptr[4] - bptr[3]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[0] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[0], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[0], pixels[3]); diff3 = calcPixelDiffNosqrt(tmp[0], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[0] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[0] = pixels[3]; else tmp[0] = pixels[4]; /* check for half-arrow */ if (_simSum == 2 && sim[4] && sim[2]) { if (interpolate_2x) { tmp[0] = interpolate_1_1(center, tmp[0]); tmp[2] = interpolate_2_1(center, tmp[0]); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[0])]) tmp[0] = center; } break; } if (interpolate_2x) tmp[0] = interpolate_2_1(center, tmp[0]); else tmp[0] = center; } tmp[2] = interpolate_1_1_1(pixels[3], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[3]); diff2 = labs(bptr[4] - bptr[7]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[2] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[2], pixels[3]); diff2 = calcPixelDiffNosqrt(tmp[2], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[2], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[2] = pixels[3]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[2] = pixels[7]; else tmp[2] = pixels[4]; /* check for half-arrow */ if (_simSum == 2 && sim[4] && sim[7]) { if (interpolate_2x) { tmp[2] = interpolate_1_1(center, tmp[2]); tmp[0] = interpolate_2_1(center, tmp[2]); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[2])]) tmp[2] = center; } break; } if (interpolate_2x) tmp[2] = interpolate_2_1(center, tmp[2]); else tmp[2] = center; } break; case 13: /* > */ tmp[0] = tmp[1] = tmp[2] = tmp[3] = center; tmp[1] = interpolate_1_1_1(pixels[1], pixels[5], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[1])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[5]); diff2 = labs(bptr[4] - bptr[1]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[1] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[1], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[1], pixels[5]); diff3 = calcPixelDiffNosqrt(tmp[1], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[1] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[1] = pixels[5]; else tmp[1] = pixels[4]; /* check for half-arrow */ if (_simSum == 2 && sim[3] && sim[0]) { if (interpolate_2x) { tmp[1] = interpolate_1_1(center, tmp[1]); tmp[3] = interpolate_2_1(center, tmp[1]); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[1])]) tmp[1] = center; } break; } if (interpolate_2x) tmp[1] = interpolate_2_1(center, tmp[1]); else tmp[1] = center; } tmp[3] = interpolate_1_1_1(pixels[5], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[3])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[7]); diff2 = labs(bptr[4] - bptr[5]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[3] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[3], pixels[5]); diff2 = calcPixelDiffNosqrt(tmp[3], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[3], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[3] = pixels[5]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[3] = pixels[7]; else tmp[3] = pixels[4]; /* check for half-arrow */ if (_simSum == 2 && sim[3] && sim[5]) { if (interpolate_2x) { tmp[3] = interpolate_1_1(center, tmp[3]); tmp[1] = interpolate_2_1(center, tmp[3]); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[3])]) tmp[3] = center; } break; } if (interpolate_2x) tmp[3] = interpolate_2_1(center, tmp[3]); else tmp[3] = center; } break; case 14: /* ^ */ tmp[0] = tmp[1] = tmp[2] = tmp[3] = center; tmp[0] = interpolate_1_1_1(pixels[1], pixels[3], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[0])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[1]); diff2 = labs(bptr[4] - bptr[3]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[0] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[0], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[0], pixels[3]); diff3 = calcPixelDiffNosqrt(tmp[0], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[0] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[0] = pixels[3]; else tmp[0] = pixels[4]; /* check for half-arrow */ if (_simSum == 2 && sim[6] && sim[5]) { if (interpolate_2x) { tmp[0] = interpolate_1_1(center, tmp[0]); tmp[1] = interpolate_2_1(center, tmp[0]); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[0])]) tmp[0] = center; } break; } if (interpolate_2x) tmp[0] = interpolate_2_1(center, tmp[0]); else tmp[0] = center; } tmp[1] = interpolate_1_1_1(pixels[1], pixels[5], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[1])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[5]); diff2 = labs(bptr[4] - bptr[1]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[1] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[1], pixels[1]); diff2 = calcPixelDiffNosqrt(tmp[1], pixels[5]); diff3 = calcPixelDiffNosqrt(tmp[1], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[1] = pixels[1]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[1] = pixels[5]; else tmp[1] = pixels[4]; /* check for half-arrow */ if (_simSum == 2 && sim[6] && sim[7]) { if (interpolate_2x) { tmp[1] = interpolate_1_1(center, tmp[1]); tmp[0] = interpolate_2_1(center, tmp[1]); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[1])]) tmp[1] = center; } break; } if (interpolate_2x) tmp[1] = interpolate_2_1(center, tmp[1]); else tmp[1] = center; } break; case 15: /* v */ tmp[0] = tmp[1] = tmp[2] = tmp[3] = center; tmp[2] = interpolate_1_1_1(pixels[3], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[2])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[3]); diff2 = labs(bptr[4] - bptr[7]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[2] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[2], pixels[3]); diff2 = calcPixelDiffNosqrt(tmp[2], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[2], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[2] = pixels[3]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[2] = pixels[7]; else tmp[2] = pixels[4]; /* check for half-arrow */ if (_simSum == 2 && sim[1] && sim[0]) { if (interpolate_2x) { tmp[2] = interpolate_1_1(center, tmp[2]); tmp[3] = interpolate_2_1(center, tmp[2]); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[2])]) tmp[2] = center; } break; } if (interpolate_2x) tmp[2] = interpolate_2_1(center, tmp[2]); else tmp[2] = center; } tmp[3] = interpolate_1_1_1(pixels[5], pixels[7], center); tmp_grey = _chosenGreyscale[convertTo16Bit(tmp[3])]; #if PARANOID_ARROWS diff1 = labs(bptr[4] - bptr[7]); diff2 = labs(bptr[4] - bptr[5]); diff3 = labs(bptr[4] - tmp_grey); if (diff1 < diff3 || diff2 < diff3) tmp[3] = center; else /* choose nearest pixel */ #endif { diff1 = calcPixelDiffNosqrt(tmp[3], pixels[5]); diff2 = calcPixelDiffNosqrt(tmp[3], pixels[7]); diff3 = calcPixelDiffNosqrt(tmp[3], pixels[4]); if (diff1 <= diff2 && diff1 <= diff3) tmp[3] = pixels[5]; else if (diff2 <= diff1 && diff2 <= diff3) tmp[3] = pixels[7]; else tmp[3] = pixels[4]; /* check for half-arrow */ if (_simSum == 2 && sim[1] && sim[2]) { if (interpolate_2x) { tmp[3] = interpolate_1_1(center, tmp[3]); tmp[2] = interpolate_2_1(center, tmp[3]); } else { if (bptr[4] > _chosenGreyscale[convertTo16Bit(tmp[3])]) tmp[3] = center; } break; } if (interpolate_2x) tmp[3] = interpolate_2_1(center, tmp[3]); else tmp[3] = center; } break; case -1: /* no edge */ case 0: /* - */ case 6: /* | */ case 127: /* * */ default: /* no edge */ dptr2 = (Pixel *) dptr; *dptr2++ = center; #if DEBUG_REFRESH_RANDOM_XOR *dptr2 = center ^ (Pixel)(dxorshift128() * (1L << 16)); #else *dptr2 = center; #endif dptr2 = (Pixel *)(dptr + dstPitch); *dptr2++ = center; *dptr2 = center; return; break; } ptmp = tmp; dptr2 = (Pixel *) dptr; *dptr2++ = *ptmp++; #if DEBUG_REFRESH_RANDOM_XOR *dptr2 = *ptmp++ ^ (Pixel)(dxorshift128() * (1L << 16)); #else *dptr2 = *ptmp++; #endif dptr2 = (Pixel *)(dptr + dstPitch); *dptr2++ = *ptmp++; *dptr2 = *ptmp; } /* Check for changed pixel grid, return 1 if unchanged. */ template int checkUnchangedPixels(const Pixel *old_src_ptr, const Pixel *pixels, int w) { const Pixel *dptr; dptr = old_src_ptr - w - 1; if (*dptr++ != pixels[0]) return 0; if (*dptr++ != pixels[1]) return 0; if (*dptr != pixels[2]) return 0; dptr += w - 2; if (*dptr != pixels[3]) return 0; dptr += 2; if (*dptr != pixels[5]) return 0; dptr += w - 2; if (*dptr++ != pixels[6]) return 0; if (*dptr++ != pixels[7]) return 0; if (*dptr != pixels[8]) return 0; return 1; } /* Draw unchanged pixel grid, 3x */ /* old_dptr starts in top left of grid, dptr in center */ template void drawUnchangedGrid3x(byte *dptr, int dstPitch, const byte *old_dptr, int old_dst_inc) { const Pixel *sp; Pixel *dp; sp = (const Pixel *)old_dptr; dp = (Pixel *)(dptr - dstPitch) - 1; *dp++ = *sp++; *dp++ = *sp++; *dp = *sp; sp = (const Pixel *)(old_dptr + old_dst_inc); dp = (Pixel *)dptr - 1; *dp++ = *sp++; *dp++ = *sp++; *dp = *sp; sp = (const Pixel *)(old_dptr + old_dst_inc + old_dst_inc); dp = (Pixel *)(dptr + dstPitch) - 1; *dp++ = *sp++; *dp++ = *sp++; *dp = *sp; } /* Draw unchanged pixel grid, 2x */ template void drawUnchangedGrid2x(byte *dptr, int dstPitch, const byte *old_dptr, int old_dst_inc) { const Pixel *sp; Pixel *dp; sp = (const Pixel *)old_dptr; dp = (Pixel *)dptr; *dp++ = *sp++; *dp = *sp; sp = (const Pixel *)(old_dptr + old_dst_inc); dp = (Pixel *)(dptr + dstPitch); *dp++ = *sp++; *dp = *sp; } template void EdgeScaler::antiAliasPass3x(const uint8 *src, uint8 *dst, int w, int h, int srcPitch, int dstPitch, bool haveOldSrc, const uint8* oldSrc, int oldPitch, const uint8 *buffer, int bufferPitch) { typedef typename ColorMask::PixelType Pixel; int x, y; const uint8 *sptr8 = src; uint8 *dptr8 = dst + dstPitch + sizeof(Pixel); const Pixel *sptr16; const Pixel *oldSptr; const Pixel *oldDptr; Pixel *dptr16; int16 *bplane; int8 sim[8]; int sub_type; int32 angle; int16 *diffs; int dstPitch3 = dstPitch * 3; int bufferPitch3 = bufferPitch * 3; for (y = 0; y < h; y++, sptr8 += srcPitch, dptr8 += dstPitch3, oldSrc += oldPitch, buffer += bufferPitch3) { for (x = 0, sptr16 = (const Pixel *) sptr8, oldSptr = (const Pixel *) oldSrc, oldDptr = (const Pixel *) buffer, dptr16 = (Pixel *) dptr8; x < w; x++, sptr16++, dptr16 += 3, oldDptr += 3, oldSptr++) { const Pixel *sptr2, *addr3; Pixel pixels[9]; char edge_type; sptr2 = ((const Pixel *)((const uint8 *) sptr16 - srcPitch)) - 1; addr3 = ((const Pixel *)((const uint8 *) sptr16 + srcPitch)) + 1; /* fill the 3x3 grid */ memcpy(pixels, sptr2, 3 * sizeof(Pixel)); memcpy(pixels + 3, sptr16 - 1, 3 * sizeof(Pixel)); memcpy(pixels + 6, addr3 - 2, 3 * sizeof(Pixel)); if (haveOldSrc) { /* skip interior unchanged 3x3 blocks */ if (*sptr16 == *oldSptr && #if DEBUG_DRAW_REFRESH_BORDERS x > 0 && x < w - 1 && y > 0 && y < h - 1 && #endif checkUnchangedPixels(oldSptr, pixels, oldPitch / sizeof(Pixel))) { drawUnchangedGrid3x((byte *)dptr16, dstPitch, (const byte *)oldDptr, bufferPitch); #if DEBUG_REFRESH_RANDOM_XOR *(dptr16 + 1) = 0; #endif continue; } } diffs = chooseGreyscale(pixels); /* block of solid color */ if (!diffs) { antiAliasGridClean3x((uint8 *) dptr16, dstPitch, pixels, 0, NULL); continue; } bplane = _bptr; edge_type = findPrincipleAxis(diffs, bplane, sim, &angle); sub_type = refineDirection(edge_type, pixels, bplane, sim, angle); if (sub_type >= 0) sub_type = fixKnights(sub_type, pixels, sim); antiAliasGridClean3x((uint8 *) dptr16, dstPitch, pixels, sub_type, bplane); } } } template void EdgeScaler::antiAliasPass2x(const uint8 *src, uint8 *dst, int w, int h, int srcPitch, int dstPitch, int interpolate_2x, bool haveOldSrc, const uint8 *oldSrc, int oldSrcPitch, const uint8 *buffer, int bufferPitch) { typedef typename ColorMask::PixelType Pixel; int x, y; const uint8 *sptr8 = src; uint8 *dptr8 = dst; const Pixel *sptr16; const Pixel *oldSptr; const Pixel *oldDptr; Pixel *dptr16; int16 *bplane; int8 sim[8]; int sub_type; int32 angle; int16 *diffs; int dstPitch2 = dstPitch << 1; int bufferPitch2 = bufferPitch * 2; for (y = 0; y < h; y++, sptr8 += srcPitch, dptr8 += dstPitch2, oldSrc += oldSrcPitch, buffer += bufferPitch2) { for (x = 0, sptr16 = (const Pixel *) sptr8, dptr16 = (Pixel *) dptr8, oldSptr = (const Pixel *) oldSrc, oldDptr = (const Pixel *) buffer; x < w; x++, sptr16++, dptr16 += 2, oldDptr += 2, oldSptr++) { const Pixel *sptr2, *addr3; Pixel pixels[9]; char edge_type; sptr2 = ((const Pixel *)((const uint8 *) sptr16 - srcPitch)) - 1; addr3 = ((const Pixel *)((const uint8 *) sptr16 + srcPitch)) + 1; /* fill the 3x3 grid */ memcpy(pixels, sptr2, 3 * sizeof(Pixel)); memcpy(pixels + 3, sptr16 - 1, 3 * sizeof(Pixel)); memcpy(pixels + 6, addr3 - 2, 3 * sizeof(Pixel)); if (haveOldSrc) { /* skip interior unchanged 3x3 blocks */ if (*sptr16 == *oldSptr && #if DEBUG_DRAW_REFRESH_BORDERS x > 0 && x < w - 1 && y > 0 && y < h - 1 && #endif checkUnchangedPixels(oldSptr, pixels, oldSrcPitch / sizeof(Pixel))) { drawUnchangedGrid2x((byte *)dptr16, dstPitch, (const byte *)oldDptr, bufferPitch); #if DEBUG_REFRESH_RANDOM_XOR *(dptr16 + 1) = 0; #endif continue; } } diffs = chooseGreyscale(pixels); /* block of solid color */ if (!diffs) { antiAliasGrid2x((uint8 *) dptr16, dstPitch, pixels, 0, NULL, NULL, 0); continue; } bplane = _bptr; edge_type = findPrincipleAxis(diffs, bplane, sim, &angle); sub_type = refineDirection(edge_type, pixels, bplane, sim, angle); if (sub_type >= 0) sub_type = fixKnights(sub_type, pixels, sim); antiAliasGrid2x((uint8 *) dptr16, dstPitch, pixels, sub_type, bplane, sim, interpolate_2x); } } } void EdgeScaler::initTables(const uint8 *srcPtr, uint32 srcPitch, int width, int height) { double r_float, g_float, b_float; int r, g, b; uint16 i; double val[3]; double intensity; int16 *rgb_ptr; #if DEBUG_REFRESH_RANDOM_XOR /* seed the random number generator, we don't care if the seed is random */ initializeXorshift128(42); #endif /* initialize greyscale table */ for (r = 0; r < 32; r++) { r_float = r / 31.0; for (g = 0; g < 64; g++) { g_float = g / 63.0; for (b = 0; b < 32; b++) { b_float = b / 31.0; intensity = (r_float + g_float + b_float) / 3; i = (r << 11) | (g << 5) | b; /* use luma-like weights for each color, 2x increments */ val[0] = 0.571 * r_float + 0.286 * g_float + 0.143 * b_float; val[1] = 0.286 * r_float + 0.571 * g_float + 0.143 * b_float; val[2] = 0.143 * r_float + 0.286 * g_float + 0.571 * b_float; /* factor in a little intensity too, it helps */ val[0] = (intensity + 9 * val[0]) / 10; val[1] = (intensity + 9 * val[1]) / 10; val[2] = (intensity + 9 * val[2]) / 10; /* store the greyscale tables */ _greyscaleTable[0][i] = (int16)(val[0] * ((int16)1 << GREY_SHIFT) + 0.5); _greyscaleTable[1][i] = (int16)(val[1] * ((int16)1 << GREY_SHIFT) + 0.5); _greyscaleTable[2][i] = (int16)(val[2] * ((int16)1 << GREY_SHIFT) + 0.5); /* normalized RGB channel lookups */ rgb_ptr = _rgbTable[(r << 11) | (g << 5) | b]; rgb_ptr[0] = (int16)(r_float * ((int16)1 << RGB_SHIFT) + 0.5); rgb_ptr[1] = (int16)(g_float * ((int16)1 << RGB_SHIFT) + 0.5); rgb_ptr[2] = (int16)(b_float * ((int16)1 << RGB_SHIFT) + 0.5); } } } } EdgeScaler::EdgeScaler(const Graphics::PixelFormat &format) : SourceScaler(format) { _factor = 2; initTables(0, 0, 0, 0); } #if 0 void EdgeScaler::scale(const uint8 *srcPtr, uint32 srcPitch, uint8 *dstPtr, uint32 dstPitch, int width, int height, int x, int y) { if (_format.bytesPerPixel == 2) { if (_factor == 2) { if (_format.gLoss == 2) antiAliasPass2x, uint16>(srcPtr, dstPtr, width, height, 2 * width, 2 * height, srcPitch, dstPitch, 1, false, NULL, 0); else antiAliasPass2x, uint16>(srcPtr, dstPtr, width, height, 2 * width, 2 * height, srcPitch, dstPitch, 1, false, NULL, 0); } else { if (_format.gLoss == 2) antiAliasPass3x, uint16>(srcPtr, dstPtr, width, height, 3 * width, 3 * height, srcPitch, dstPitch, false, NULL, 0); else antiAliasPass3x, uint16>(srcPtr, dstPtr, width, height, 3 * width, 3 * height, srcPitch, dstPitch, false, NULL, 0); } } else { if (_factor == 2) { if (_format.aLoss == 0) antiAliasPass2x, uint32>(srcPtr, dstPtr, width, height, 2 * width, 2 * height, srcPitch, dstPitch, 1, false, NULL, 0); else antiAliasPass2x, uint32>(srcPtr, dstPtr, width, height, 2 * width, 2 * height, srcPitch, dstPitch, 1, false, NULL, 0); } else { if (_format.aLoss == 0) antiAliasPass3x, uint32>(srcPtr, dstPtr, width, height, 3 * width, 3 * height, srcPitch, dstPitch, false, NULL, 0); else antiAliasPass3x, uint32>(srcPtr, dstPtr, width, height, 3 * width, 3 * height, srcPitch, dstPitch, false, NULL, 0); } } } #endif void EdgeScaler::internScale(const uint8 *srcPtr, uint32 srcPitch, uint8 *dstPtr, uint32 dstPitch, const uint8 *oldSrcPtr, uint32 oldSrcPitch, int width, int height, const uint8 *buffer, uint32 bufferPitch) { bool enable = oldSrcPtr != NULL; if (_format.bytesPerPixel == 2) { if (_factor == 2) { if (_format.gLoss == 2) antiAliasPass2x >(srcPtr, dstPtr, width, height, srcPitch, dstPitch, 1, enable, oldSrcPtr, oldSrcPitch, buffer, bufferPitch); else antiAliasPass2x >(srcPtr, dstPtr, width, height, srcPitch, dstPitch, 1, enable, oldSrcPtr, oldSrcPitch, buffer, bufferPitch); } else { if (_format.gLoss == 2) antiAliasPass3x >(srcPtr, dstPtr, width, height, srcPitch, dstPitch, enable, oldSrcPtr, oldSrcPitch, buffer, bufferPitch); else antiAliasPass3x >(srcPtr, dstPtr, width, height, srcPitch, dstPitch, enable, oldSrcPtr, oldSrcPitch, buffer, bufferPitch); } } else { if (_factor == 2) { if (_format.aLoss == 0) antiAliasPass2x >(srcPtr, dstPtr, width, height, srcPitch, dstPitch, 1, enable, oldSrcPtr, oldSrcPitch, buffer, bufferPitch); else antiAliasPass2x >(srcPtr, dstPtr, width, height, srcPitch, dstPitch, 1, enable, oldSrcPtr, oldSrcPitch, buffer, bufferPitch); } else { if (_format.aLoss == 0) antiAliasPass3x >(srcPtr, dstPtr, width, height, srcPitch, dstPitch, enable, oldSrcPtr, oldSrcPitch, buffer, bufferPitch); else antiAliasPass3x >(srcPtr, dstPtr, width, height, srcPitch, dstPitch, enable, oldSrcPtr, oldSrcPitch, buffer, bufferPitch); } } } uint EdgeScaler::increaseFactor() { if (_factor == 2) setFactor(_factor + 1); return _factor; } uint EdgeScaler::decreaseFactor() { if (_factor == 3) setFactor(_factor - 1); return _factor; } class EdgePlugin final : public ScalerPluginObject { public: EdgePlugin(); virtual Scaler *createInstance(const Graphics::PixelFormat &format) const override; virtual bool canDrawCursor() const override { return false; } virtual bool useOldSource() const override { return true; } virtual uint extraPixels() const override { return 1; } virtual const char *getName() const override; virtual const char *getPrettyName() const override; }; EdgePlugin::EdgePlugin() { _factors.push_back(2); _factors.push_back(3); } Scaler *EdgePlugin::createInstance(const Graphics::PixelFormat &format) const { return new EdgeScaler(format); } const char *EdgePlugin::getName() const { return "edge"; } const char *EdgePlugin::getPrettyName() const { return "Edge"; } REGISTER_PLUGIN_STATIC(EDGE, PLUGIN_TYPE_SCALER, EdgePlugin);