1 | diff -ruN -b backup_version/backends/platform/sdl/graphics.cpp new_version/backends/platform/sdl/graphics.cpp
|
---|
2 | --- backup_version/backends/platform/sdl/graphics.cpp 2006-07-30 00:48:50.000000000 -0500
|
---|
3 | +++ new_version/backends/platform/sdl/graphics.cpp 2006-07-31 22:21:00.000000000 -0500
|
---|
4 | @@ -43,6 +43,9 @@
|
---|
5 | #endif
|
---|
6 | {"tv2x", "TV2x", GFX_TV2X},
|
---|
7 | {"dotmatrix", "DotMatrix", GFX_DOTMATRIX},
|
---|
8 | + {"edge2x", "Edge2x", GFX_EDGE2X},
|
---|
9 | + {"edge2xi", "Edge2x_Interp", GFX_EDGE2X_INTERP},
|
---|
10 | + {"edge3x", "Edge3x", GFX_EDGE3X},
|
---|
11 | {0, 0, 0}
|
---|
12 | };
|
---|
13 |
|
---|
14 | @@ -50,7 +53,7 @@
|
---|
15 | // [definedScale - 1][_scaleFactor - 1]
|
---|
16 | static ScalerProc *scalersMagn[3][3] = {
|
---|
17 | #ifndef DISABLE_SCALERS
|
---|
18 | - { Normal1x, AdvMame2x, AdvMame3x },
|
---|
19 | + { Normal1x, Edge2x_Interp, Edge3x },
|
---|
20 | { Normal1x, Normal1x, Normal1o5x },
|
---|
21 | { Normal1x, Normal1x, Normal1x }
|
---|
22 | #else // remove dependencies on other scalers
|
---|
23 | @@ -68,7 +71,8 @@
|
---|
24 | { GFX_NORMAL, GFX_SUPER2XSAI, -1, -1 },
|
---|
25 | { GFX_NORMAL, GFX_SUPEREAGLE, -1, -1 },
|
---|
26 | { GFX_NORMAL, GFX_TV2X, -1, -1 },
|
---|
27 | - { GFX_NORMAL, GFX_DOTMATRIX, -1, -1 }
|
---|
28 | + { GFX_NORMAL, GFX_DOTMATRIX, -1, -1 },
|
---|
29 | + { GFX_NORMAL, GFX_EDGE2X_INTERP, GFX_EDGE3X, -1 }
|
---|
30 | };
|
---|
31 |
|
---|
32 | #ifndef DISABLE_SCALERS
|
---|
33 | @@ -201,6 +205,18 @@
|
---|
34 | newScaleFactor = 2;
|
---|
35 | newScalerProc = DotMatrix;
|
---|
36 | break;
|
---|
37 | + case GFX_EDGE2X:
|
---|
38 | + newScaleFactor = 2;
|
---|
39 | + newScalerProc = Edge2x;
|
---|
40 | + break;
|
---|
41 | + case GFX_EDGE2X_INTERP:
|
---|
42 | + newScaleFactor = 2;
|
---|
43 | + newScalerProc = Edge2x_Interp;
|
---|
44 | + break;
|
---|
45 | + case GFX_EDGE3X:
|
---|
46 | + newScaleFactor = 3;
|
---|
47 | + newScalerProc = Edge3x;
|
---|
48 | + break;
|
---|
49 | #endif // DISABLE_SCALERS
|
---|
50 |
|
---|
51 | default:
|
---|
52 | diff -ruN -b backup_version/backends/platform/sdl/sdl-common.h new_version/backends/platform/sdl/sdl-common.h
|
---|
53 | --- backup_version/backends/platform/sdl/sdl-common.h 2006-07-30 00:48:50.000000000 -0500
|
---|
54 | +++ new_version/backends/platform/sdl/sdl-common.h 2006-07-31 04:25:16.000000000 -0500
|
---|
55 | @@ -51,7 +51,10 @@
|
---|
56 | GFX_HQ2X = 8,
|
---|
57 | GFX_HQ3X = 9,
|
---|
58 | GFX_TV2X = 10,
|
---|
59 | - GFX_DOTMATRIX = 11
|
---|
60 | + GFX_DOTMATRIX = 11,
|
---|
61 | + GFX_EDGE2X = 12,
|
---|
62 | + GFX_EDGE2X_INTERP = 13,
|
---|
63 | + GFX_EDGE3X = 14
|
---|
64 | };
|
---|
65 |
|
---|
66 |
|
---|
67 | diff -ruN -b backup_version/base/commandLine.cpp new_version/base/commandLine.cpp
|
---|
68 | --- backup_version/base/commandLine.cpp 2006-07-30 00:48:42.000000000 -0500
|
---|
69 | +++ new_version/base/commandLine.cpp 2006-07-31 04:23:46.000000000 -0500
|
---|
70 | @@ -82,7 +82,7 @@
|
---|
71 | " -F, --no-fullscreen Force windowed mode\n"
|
---|
72 | " -g, --gfx-mode=MODE Select graphics scaler (normal,2x,3x,2xsai,\n"
|
---|
73 | " super2xsai,supereagle,advmame2x,advmame3x,hq2x,\n"
|
---|
74 | - " hq3x,tv2x,dotmatrix)\n"
|
---|
75 | + " hq3x,tv2x,dotmatrix,edge2x,edge2xi,edge3x)\n"
|
---|
76 | " --gui-theme=THEME Select GUI theme (default, modern, classic)\n"
|
---|
77 | " --themepath=PATH Path to where GUI themes are stored\n"
|
---|
78 | " -e, --music-driver=MODE Select music driver (see README for details)\n"
|
---|
79 | diff -ruN -b backup_version/graphics/module.mk new_version/graphics/module.mk
|
---|
80 | --- backup_version/graphics/module.mk 2006-07-30 00:48:00.000000000 -0500
|
---|
81 | +++ new_version/graphics/module.mk 2006-07-31 04:56:50.000000000 -0500
|
---|
82 | @@ -25,7 +25,8 @@
|
---|
83 | scaler/aspect.o \
|
---|
84 | scaler/scale2x.o \
|
---|
85 | scaler/scale3x.o \
|
---|
86 | - scaler/scalebit.o
|
---|
87 | + scaler/scalebit.o \
|
---|
88 | + scaler/edge3x.o
|
---|
89 |
|
---|
90 | ifndef DISABLE_HQ_SCALERS
|
---|
91 | MODULE_OBJS += \
|
---|
92 | diff -ruN -b backup_version/graphics/scaler/edge3x.cpp new_version/graphics/scaler/edge3x.cpp
|
---|
93 | --- backup_version/graphics/scaler/edge3x.cpp 1969-12-31 18:00:00.000000000 -0600
|
---|
94 | +++ new_version/graphics/scaler/edge3x.cpp 2006-10-03 23:03:26.000000000 -0500
|
---|
95 | @@ -0,0 +1,4564 @@
|
---|
96 | +/* ScummVM - Scumm Interpreter
|
---|
97 | + * Copyright (C) 2001 Ludvig Strigeus
|
---|
98 | + * Copyright (C) 2001-2006 The ScummVM project
|
---|
99 | + *
|
---|
100 | + * This program is free software; you can redistribute it and/or
|
---|
101 | + * modify it under the terms of the GNU General Public License
|
---|
102 | + * as published by the Free Software Foundation; either version 2
|
---|
103 | + * of the License, or (at your option) any later version.
|
---|
104 | + *
|
---|
105 | + * This program is distributed in the hope that it will be useful,
|
---|
106 | + * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
107 | + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
108 | + * GNU General Public License for more details.
|
---|
109 | + *
|
---|
110 | + * You should have received a copy of the GNU General Public License
|
---|
111 | + * along with this program; if not, write to the Free Software
|
---|
112 | + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
---|
113 | + *
|
---|
114 | + */
|
---|
115 | +
|
---|
116 | +/*
|
---|
117 | + * Another edge-directed 2x/3x anti-aliasing scaler for ScummVM
|
---|
118 | + *
|
---|
119 | + * Author: Eric A. Welsh
|
---|
120 | + *
|
---|
121 | + * INTERPOLATE/Q_INTERPOLATE macros taken from HQ2x/HQ3x scalers
|
---|
122 | + * (Authors: Maxim Stepin and Max Horn)
|
---|
123 | + *
|
---|
124 | + *
|
---|
125 | + * Sharp, clean, anti-aliased image with very few artifacts.
|
---|
126 | + * Detects and appropriately handles mouse overlays with transparent pixels.
|
---|
127 | + * The Edge3x filter detects unchanged pixels and does not redraw them,
|
---|
128 | + * resulting in a considerable gain in speed when there are even a moderate
|
---|
129 | + * number of unchanged pixels. Edge3x and Edge2x anti-alias using nearest-
|
---|
130 | + * neighbor methods. Edge2xi interpolates.
|
---|
131 | + *
|
---|
132 | + * The really slow speed is mainly due to the edge detection algorithm. In
|
---|
133 | + * order to accurately detect the edge direction (and thus avoid artifacts
|
---|
134 | + * caused by mis-detection), the edge detection and refinement process is
|
---|
135 | + * rather long and involved. Speed must be sacrificed in order to avoid
|
---|
136 | + * artifacts :( If anyone is tempted to optimize using lower precision
|
---|
137 | + * math, such as converting some of the double math to fixed-point integer,
|
---|
138 | + * or lowering the number of significant bits used in the existing integer
|
---|
139 | + * math to squeeze it into accelerated 16-bit vector instructions, please do
|
---|
140 | + * not do this. Any loss in precision results in visibly degraded image
|
---|
141 | + * quality. I've tried integer conversions of various double math, and tried
|
---|
142 | + * reducing the number of significant digits I use in the integer math, and
|
---|
143 | + * it always results in less accurate edge detection and lower image quality.
|
---|
144 | + * If you're going to optimize, make sure you don't sacrifice any precision.
|
---|
145 | + * There may be a few places I could change the variable types from
|
---|
146 | + * int32 to int16 without introducing overflows, though. I should also
|
---|
147 | + * probably change some of the flags and arrays to bools or chars, rather
|
---|
148 | + * than ints, since they are only 0 or 1.
|
---|
149 | + *
|
---|
150 | + * It's a bit slow... but ScummVM runs most things fine on my 1.53 GHz Athlon.
|
---|
151 | + * Increasing the Win32 thread priority can help by forcing Windows not to
|
---|
152 | + * twiddle its thumbs and idle as much during heavy CPU load. The Dig
|
---|
153 | + * cutscene when the asteroid is activated is a little jerky, pans/fades in
|
---|
154 | + * Amazon Queen and Beneath a Steel Sky are slow. Faster machines probably
|
---|
155 | + * won't have a problem. I remember a time when my home machine was too slow
|
---|
156 | + * to run SNES emulators with 2xSaI filters, so I don't think speed is such a
|
---|
157 | + * big issue here. It won't be too long before the average home computer is
|
---|
158 | + * plenty fast enough to run this filter.
|
---|
159 | + *
|
---|
160 | + */
|
---|
161 | +
|
---|
162 | +/*
|
---|
163 | + * Notes on handling overlays, mouse, transparencies, etc.:
|
---|
164 | + *
|
---|
165 | + * As I write this, the SDL backend does not call different filters based on
|
---|
166 | + * whether or not the bitmaps contain transparency. Bitmaps with transparency
|
---|
167 | + * need to be treated differently. 1) Interpolation needs to be disabled,
|
---|
168 | + * since interpolating with transparent pixels produces ugly smears around the
|
---|
169 | + * transparent areas. 2) Transparent pixels need to be treated differently
|
---|
170 | + * during edge detection, so that they appear to be as if they were colors
|
---|
171 | + * that would give maximal contrast in the current 3x3 window.
|
---|
172 | + *
|
---|
173 | + * Currently, the SDL backend calls anti-aliasing resize filters to either
|
---|
174 | + * resize the game screen or resize the mouse. The filter stores the src
|
---|
175 | + * array bounds whenever the width and height of the area to be resized are
|
---|
176 | + * equal to the width and height of the current game screen. If the current
|
---|
177 | + * src array is outside these bounds, then it is assumed that the mouse or
|
---|
178 | + * menu overlay is being drawn. This works perfectly for the current SDL
|
---|
179 | + * backend, but it is still a hack. If, in the future, the filter were to
|
---|
180 | + * to be used to resize a transparent overlay with dimensions equal to those
|
---|
181 | + * of the current game screen, that overlay would be resized without any
|
---|
182 | + * special transparency consideration. The same goes for a mouse pointer
|
---|
183 | + * that is equal to the size of the screen, but I don't forsee this ever
|
---|
184 | + * being a problem.... The correct solution would be to rewrite the backends
|
---|
185 | + * to call filters differently depending on whether or not the bitmap contains
|
---|
186 | + * transparent pixels, and whether or not the end result should be
|
---|
187 | + * interpolated or resized using nearest-neighbor. Until then, the array
|
---|
188 | + * bounds checking hack will have to do.
|
---|
189 | + *
|
---|
190 | + */
|
---|
191 | +
|
---|
192 | +#include <math.h>
|
---|
193 | +#include "common/stdafx.h"
|
---|
194 | +#include "common/scummsys.h"
|
---|
195 | +#include "common/system.h"
|
---|
196 | +
|
---|
197 | +/* Randomly XORs one of 2x2 or 3x3 resized pixels in order to indicate
|
---|
198 | + * which pixels have been redrawn. Useful for seeing which areas of
|
---|
199 | + * the screen are being redrawn. Good for seeing dirty rects, full screen
|
---|
200 | + * refreshes, etc.. Also good for seeing if the unchanged pixel detection is
|
---|
201 | + * working correctly or not :)
|
---|
202 | + */
|
---|
203 | +#define DEBUG_REFRESH_RANDOM_XOR 0 /* debug redraws */
|
---|
204 | +
|
---|
205 | +/* Use with DEBUG_REFRESH_RANDOM_XOR. Randomize the borders of the drawing
|
---|
206 | + * area, whether they are unchanged or not. Useful for visualizing the
|
---|
207 | + * borders of the drawing area. You might be surprised at which areas of the
|
---|
208 | + * screen get redraw requests, even areas with absolutely nothing moving,
|
---|
209 | + * or color cycling, or anything that would cause a dirty rect or require a
|
---|
210 | + * redraw....
|
---|
211 | + */
|
---|
212 | +#define DEBUG_DRAW_REFRESH_BORDERS 0 /* more redraw debug */
|
---|
213 | +
|
---|
214 | +#define INCREASE_WIN32_PRIORITY 0 /* 1 for slow CPUs */
|
---|
215 | +#define PARANOID_KNIGHTS 1 /* avoid artifacts */
|
---|
216 | +#define PARANOID_ARROWS 1 /* avoid artifacts */
|
---|
217 | +#define HANDLE_TRANSPARENT_OVERLAYS 1 /* as it says */
|
---|
218 | +
|
---|
219 | +#define SIN45 0.7071067811865 /* sin of 45 degrees */
|
---|
220 | +#define GREY_SHIFT 12 /* bit shift for greyscale precision */
|
---|
221 | +#define RGB_SHIFT 13 /* bit shift for RGB precision */
|
---|
222 | +
|
---|
223 | +const int16 one_sqrt2 = (int16) (((int16)1<<GREY_SHIFT) / sqrt(2.0) + 0.5);
|
---|
224 | +int16 rgb_table[65536][3] = {0}; /* table lookup for RGB */
|
---|
225 | +int16 greyscale_table[3][65536] = {0}; /* greyscale tables */
|
---|
226 | +int16 *chosen_greyscale; /* pointer to chosen greyscale table */
|
---|
227 | +int16 *bptr_global; /* too awkward to pass variables */
|
---|
228 | +int8 sim_sum; /* sum of similarity matrix */
|
---|
229 | +
|
---|
230 | +uint16 div3[189]; /* tables for pixel interpolation */
|
---|
231 | +uint16 div9[567];
|
---|
232 | +
|
---|
233 | +int32 max_old_src_size = 0; /* maximum observed rectangle size */
|
---|
234 | +int32 max_overlay_size = 0; /* maximum observed overlay size */
|
---|
235 | +int32 max_old_dst_size = 0;
|
---|
236 | +int32 max_dst_overlay_size = 0;
|
---|
237 | +uint16 *old_src = NULL; /* old src array */
|
---|
238 | +uint16 *old_overlay = NULL; /* holds the old overlay */
|
---|
239 | +uint16 *old_dst = NULL; /* old dst array */
|
---|
240 | +uint16 *old_dst_overlay = NULL; /* old dst overlay array */
|
---|
241 | +
|
---|
242 | +int cur_screen_width = 0; /* current game screen w and h */
|
---|
243 | +int cur_screen_height = 0;
|
---|
244 | +int old_screen_width = 0; /* previous game screen w and h */
|
---|
245 | +int old_screen_height = 0;
|
---|
246 | +int cur_dst_screen_width = 0; /* scaled dst w and h */
|
---|
247 | +int cur_dst_screen_height = 0;
|
---|
248 | +int old_dst_screen_width = 0;
|
---|
249 | +int old_dst_screen_height = 0;
|
---|
250 | +int cur_overlay_width = 0;
|
---|
251 | +int cur_overlay_height = 0;
|
---|
252 | +int old_overlay_width = 0;
|
---|
253 | +int old_overlay_height = 0;
|
---|
254 | +int cur_dst_overlay_width = 0;
|
---|
255 | +int cur_dst_overlay_height = 0;
|
---|
256 | +int old_dst_overlay_width = 0;
|
---|
257 | +int old_dst_overlay_height = 0;
|
---|
258 | +int max_scale = -1; /* used for dst buffer arrays */
|
---|
259 | +
|
---|
260 | +int init_flag = 0; /* have the tables been initialized? */
|
---|
261 | +const uint16 *src_addr_min = NULL; /* start of src screen array */
|
---|
262 | +const uint16 *src_addr_max = NULL; /* end of src screen array */
|
---|
263 | +
|
---|
264 | +const int16 int32_sqrt3 = (int16) (((int16)1<<GREY_SHIFT) * sqrt(3.0) + 0.5);
|
---|
265 | +
|
---|
266 | +
|
---|
267 | +
|
---|
268 | +#if DEBUG_REFRESH_RANDOM_XOR
|
---|
269 | +/* Random number generators with very good randomness properties, far better
|
---|
270 | + * than the simple linear congruential generator in the ScummVM utils.
|
---|
271 | + * The RNG algorithms were developed by George Marsaglia, as published in his
|
---|
272 | + * "Xorshift RNGs" paper and various USENET postings.
|
---|
273 | + *
|
---|
274 | + * Marsaglia, George, 2003, "Xorshift RNGs", Journal of Statistical Software,
|
---|
275 | + * Volume 7, Issue 14
|
---|
276 | + *
|
---|
277 | + * Note the comments in the code below about how many of the triplet and shift
|
---|
278 | + * combinations published in his paper and various USENET postings don't quite
|
---|
279 | + * work as expected (yes, I exhaustively tested all 648 of them with his test
|
---|
280 | + * suite). Only a few "magic" combinations actually produce good random
|
---|
281 | + * numbers. I suspect this is due to the numbers being shifted too far off
|
---|
282 | + * the ends of the registers?
|
---|
283 | + *
|
---|
284 | + * While numbers this highly random are overkill for our purposes, I already
|
---|
285 | + * had this code written for various scientific analysis programs, and I've
|
---|
286 | + * tested the generators with Marsaglia's comprehensive randomness test
|
---|
287 | + * suite, so I know that they have very good randomness. The simple single
|
---|
288 | + * seed algorithm does fail a few minor tests, but it is still LOADS better
|
---|
289 | + * than a linear congruential generator. The 4 seed RNG passes all tests
|
---|
290 | + * with flying colors and has a pretty big period to boot. I actually use
|
---|
291 | + * a 4096 seed RNG for my scientific work, but that is MAJOR overkill for
|
---|
292 | + * the simple purposes we require here, so I've not included it :)
|
---|
293 | + */
|
---|
294 | +
|
---|
295 | +uint32 seed0, seed1, seed2, seed3;
|
---|
296 | +
|
---|
297 | +/* period 2^32 - 1 */
|
---|
298 | +/* fails Gorilla test, binary rank matrix */
|
---|
299 | +/* the ONLY good triplet and shift combinations out of the list of 648:
|
---|
300 | + *
|
---|
301 | + * 3 7 13 >> >> <<
|
---|
302 | + * 3 7 13 << << >>
|
---|
303 | + * 7 3 13 >> >> <<
|
---|
304 | + * 7 3 13 << << >>
|
---|
305 | + *
|
---|
306 | + * 5 6 13 >> >> <<
|
---|
307 | + * 5 6 13 << << >>
|
---|
308 | + * 6 5 13 >> >> <<
|
---|
309 | + * 6 5 13 << << >> seems to be slightly "better" than the others?
|
---|
310 | + *
|
---|
311 | + * all others, including the "favorite" (13, 17, 5), fail some Monkey tests
|
---|
312 | + */
|
---|
313 | +uint32 xorshift_32(void)
|
---|
314 | +{
|
---|
315 | + seed0 ^= seed0 << 6;
|
---|
316 | + seed0 ^= seed0 << 5;
|
---|
317 | + seed0 ^= seed0 >> 13;
|
---|
318 | +
|
---|
319 | + return(seed0);
|
---|
320 | +}
|
---|
321 | +
|
---|
322 | +/* period 2^128 - 1 */
|
---|
323 | +/* None of the other published 2^128-1 xorshift RNGs passed OPERM5 */
|
---|
324 | +uint32 xorshift_128(void)
|
---|
325 | +{
|
---|
326 | + uint32 temp;
|
---|
327 | +
|
---|
328 | + temp = (seed0 ^ (seed0 << 20)) ^ (seed1 ^ (seed1 >> 11)) ^
|
---|
329 | + (seed2 ^ (seed2 << 27)) ^ (seed3 ^ (seed3 >> 6));
|
---|
330 | + seed0 = seed1;
|
---|
331 | + seed1 = seed2;
|
---|
332 | + seed2 = seed3;
|
---|
333 | + seed3 = temp;
|
---|
334 | +
|
---|
335 | + return (temp);
|
---|
336 | +}
|
---|
337 | +
|
---|
338 | +/* return a random fraction over the range [0, 1) */
|
---|
339 | +double dxorshift_128(void)
|
---|
340 | +{
|
---|
341 | + uint32 temp;
|
---|
342 | +
|
---|
343 | + temp = (seed0 ^ (seed0 << 20)) ^ (seed1 ^ (seed1 >> 11)) ^
|
---|
344 | + (seed2 ^ (seed2 << 27)) ^ (seed3 ^ (seed3 >> 6));
|
---|
345 | + seed0 = seed1;
|
---|
346 | + seed1 = seed2;
|
---|
347 | + seed2 = seed3;
|
---|
348 | + seed3 = temp;
|
---|
349 | +
|
---|
350 | + return (temp / 4294967296.0);
|
---|
351 | +}
|
---|
352 | +
|
---|
353 | +void initialize_xorshift_128(uint32 seed)
|
---|
354 | +{
|
---|
355 | + /* seed0 needs to be initialized prior to calling xorshift_32() */
|
---|
356 | + seed0 = seed;
|
---|
357 | +
|
---|
358 | + /* initialize with xorshift_32() */
|
---|
359 | + seed0 = xorshift_32();
|
---|
360 | + seed1 = xorshift_32();
|
---|
361 | + seed2 = xorshift_32();
|
---|
362 | + seed3 = xorshift_32();
|
---|
363 | +}
|
---|
364 | +#endif
|
---|
365 | +
|
---|
366 | +
|
---|
367 | +
|
---|
368 | +/*
|
---|
369 | + * Faster than standard double atan(), |error| < 7E-6
|
---|
370 | + *
|
---|
371 | + * Original equation from Ranko Bojanic in StuChat37:
|
---|
372 | + *
|
---|
373 | + * |x| <= 1:
|
---|
374 | + *
|
---|
375 | + * x + A*x3 A = 0.43157974, B = 0.76443945, C = 0.05831938
|
---|
376 | + * ---------------
|
---|
377 | + * 1 + B*x2 + C*x4
|
---|
378 | + *
|
---|
379 | + *
|
---|
380 | + *
|
---|
381 | + * After some optimizations:
|
---|
382 | + *
|
---|
383 | + * |x| <= 1:
|
---|
384 | + *
|
---|
385 | + * x * (E + F*x2) E = 1/C, F = A/C
|
---|
386 | + * ---------------- G = (B/C + sqrt(B2/C2 - 4/C)) / 2
|
---|
387 | + * (G + x2)(H + x2) H = (B/C - sqrt(B2/C2 - 4/C)) / 2
|
---|
388 | + *
|
---|
389 | + * E = 17.14695869537, F = 7.400279975541
|
---|
390 | + * G = 11.63393762882, H = 1.473874045440
|
---|
391 | + *
|
---|
392 | + * |x| > 1: pi/2 -
|
---|
393 | + *
|
---|
394 | + * x * (I + x2) I = A
|
---|
395 | + * ---------------- J = (B + sqrt(B2 - 4C)) / 2
|
---|
396 | + * (J + x2)(K + x2) K = (B - sqrt(B2 - 4C)) / 2
|
---|
397 | + *
|
---|
398 | + * I = 0.43157974
|
---|
399 | + * J = 0.6784840295980, K = 0.0859554204018
|
---|
400 | + *
|
---|
401 | + */
|
---|
402 | +double fast_atan(double x0)
|
---|
403 | +{
|
---|
404 | + double x2;
|
---|
405 | + double x;
|
---|
406 | +
|
---|
407 | + x = fabs(x0);
|
---|
408 | + x2 = x*x;
|
---|
409 | + if (x > 1)
|
---|
410 | + {
|
---|
411 | + x2 = 1.570796326795 -
|
---|
412 | + x * (0.43157974 + x2) /
|
---|
413 | + ((0.6784840295980 + x2) * (0.0859554204018 + x2));
|
---|
414 | + if (x0 < 0) return -x2;
|
---|
415 | + return x2;
|
---|
416 | + }
|
---|
417 | +
|
---|
418 | + return x0 * (17.14695869537 + 7.400279975541 * x2) /
|
---|
419 | + ((11.63393762882 + x2) * (1.473874045440 + x2));
|
---|
420 | +}
|
---|
421 | +
|
---|
422 | +
|
---|
423 | +
|
---|
424 | +/*
|
---|
425 | + * Choose greyscale bitplane to use, return diff array. Exit early and
|
---|
426 | + * return NULL for a block of solid color (all diffs zero).
|
---|
427 | + *
|
---|
428 | + * No matter how you do it, mapping 3 bitplanes into a single greyscale
|
---|
429 | + * bitplane will always result in colors which are very different mapping to
|
---|
430 | + * the same greyscale value. Inevitably, these pixels will appear next to
|
---|
431 | + * each other at some point in some image, and edge detection on a single
|
---|
432 | + * bitplane will behave quite strangely due to them having the same or nearly
|
---|
433 | + * the same greyscale values. Calculating distances between pixels using all
|
---|
434 | + * three RGB bitplanes is *way* too time consuming, so single bitplane
|
---|
435 | + * edge detection is used for speed's sake. In order to try to avoid the
|
---|
436 | + * color mapping problems of using a single bitplane, 3 different greyscale
|
---|
437 | + * mappings are tested for each 3x3 grid, and the one with the most "signal"
|
---|
438 | + * (sum of squares difference from center pixel) is chosen. This usually
|
---|
439 | + * results in useable contrast within the 3x3 grid.
|
---|
440 | + *
|
---|
441 | + * This results in a whopping 25% increase in overall runtime of the filter
|
---|
442 | + * over simply using luma or some other single greyscale bitplane, but it
|
---|
443 | + * does greatly reduce the amount of errors due to greyscale mapping
|
---|
444 | + * problems. I think this is the best compromise between accuracy and
|
---|
445 | + * speed, and is still a lot faster than edge detecting over all three RGB
|
---|
446 | + * bitplanes. The increase in image quality is well worth the speed hit.
|
---|
447 | + *
|
---|
448 | + */
|
---|
449 | +int16 * choose_greyscale(uint16 *pixels)
|
---|
450 | +{
|
---|
451 | + static int16 greyscale_diffs[3][8];
|
---|
452 | + static int16 bplanes[3][9];
|
---|
453 | + int i, j;
|
---|
454 | + int32 scores[3];
|
---|
455 | +
|
---|
456 | + for (i = 0; i < 3; i++)
|
---|
457 | + {
|
---|
458 | + int16 *diff_ptr;
|
---|
459 | + int16 *bptr;
|
---|
460 | + uint16 *pptr;
|
---|
461 | + int16 *grey_ptr;
|
---|
462 | + int16 center;
|
---|
463 | + int32 sum_diffs;
|
---|
464 | +
|
---|
465 | + sum_diffs = 0;
|
---|
466 | +
|
---|
467 | + grey_ptr = greyscale_table[i];
|
---|
468 | +
|
---|
469 | + /* fill the 9 pixel window with greyscale values */
|
---|
470 | + bptr = bplanes[i];
|
---|
471 | + pptr = pixels;
|
---|
472 | + for (j = 9; j; --j)
|
---|
473 | + *bptr++ = grey_ptr[*pptr++];
|
---|
474 | + bptr = bplanes[i];
|
---|
475 | +
|
---|
476 | + center = grey_ptr[pixels[4]];
|
---|
477 | + diff_ptr = greyscale_diffs[i];
|
---|
478 | +
|
---|
479 | + /* calculate the delta from center pixel */
|
---|
480 | + diff_ptr[0] = bptr[0] - center;
|
---|
481 | + diff_ptr[1] = bptr[1] - center;
|
---|
482 | + diff_ptr[2] = bptr[2] - center;
|
---|
483 | + diff_ptr[3] = bptr[3] - center;
|
---|
484 | + diff_ptr[4] = bptr[5] - center;
|
---|
485 | + diff_ptr[5] = bptr[6] - center;
|
---|
486 | + diff_ptr[6] = bptr[7] - center;
|
---|
487 | + diff_ptr[7] = bptr[8] - center;
|
---|
488 | +
|
---|
489 | + /* calculate sum of squares distance */
|
---|
490 | + for (j = 8; j; --j)
|
---|
491 | + sum_diffs += *diff_ptr * *diff_ptr++;
|
---|
492 | +
|
---|
493 | + scores[i] = sum_diffs;
|
---|
494 | + }
|
---|
495 | +
|
---|
496 | + /* choose greyscale with highest score, ties decided in GRB order */
|
---|
497 | +
|
---|
498 | + if (scores[1] >= scores[0] && scores[1] >= scores[2])
|
---|
499 | + {
|
---|
500 | + if (!scores[1]) return NULL;
|
---|
501 | +
|
---|
502 | + chosen_greyscale = greyscale_table[1];
|
---|
503 | + bptr_global = bplanes[1];
|
---|
504 | + return greyscale_diffs[1];
|
---|
505 | + }
|
---|
506 | +
|
---|
507 | + if (scores[0] >= scores[1] && scores[0] >= scores[2])
|
---|
508 | + {
|
---|
509 | + if (!scores[0]) return NULL;
|
---|
510 | +
|
---|
511 | + chosen_greyscale = greyscale_table[0];
|
---|
512 | + bptr_global = bplanes[0];
|
---|
513 | + return greyscale_diffs[0];
|
---|
514 | + }
|
---|
515 | +
|
---|
516 | + if (!scores[2]) return NULL;
|
---|
517 | +
|
---|
518 | + chosen_greyscale = greyscale_table[2];
|
---|
519 | + bptr_global = bplanes[2];
|
---|
520 | + return greyscale_diffs[2];
|
---|
521 | +}
|
---|
522 | +
|
---|
523 | +
|
---|
524 | +
|
---|
525 | +/*
|
---|
526 | + * Calculate the distance between pixels in RGB space. Greyscale isn't
|
---|
527 | + * accurate enough for choosing nearest-neighbors :( Luma-like weighting
|
---|
528 | + * of the individual bitplane distances prior to squaring gives the most
|
---|
529 | + * useful results.
|
---|
530 | + *
|
---|
531 | + */
|
---|
532 | +int32 calc_pixel_diff_nosqrt(uint16 pixel1, uint16 pixel2)
|
---|
533 | +{
|
---|
534 | +
|
---|
535 | +#if 1 /* distance between pixels, weighted by roughly luma proportions */
|
---|
536 | + int32 sum = 0;
|
---|
537 | + int16 *rgb_ptr1 = rgb_table[pixel1];
|
---|
538 | + int16 *rgb_ptr2 = rgb_table[pixel2];
|
---|
539 | + int16 diff;
|
---|
540 | +
|
---|
541 | + diff = (*rgb_ptr1++ - *rgb_ptr2++) << 1;
|
---|
542 | + sum += diff * diff;
|
---|
543 | + diff = (*rgb_ptr1++ - *rgb_ptr2++) << 2;
|
---|
544 | + sum += diff * diff;
|
---|
545 | + diff = (*rgb_ptr1 - *rgb_ptr2);
|
---|
546 | + sum += diff * diff;
|
---|
547 | +
|
---|
548 | + return sum;
|
---|
549 | +#endif
|
---|
550 | +
|
---|
551 | +#if 0 /* distance between pixels, weighted by chosen greyscale proportions */
|
---|
552 | + int32 sum = 0;
|
---|
553 | + int16 *rgb_ptr1 = rgb_table[pixel1];
|
---|
554 | + int16 *rgb_ptr2 = rgb_table[pixel2];
|
---|
555 | + int16 diff;
|
---|
556 | + int r_shift, g_shift, b_shift;
|
---|
557 | +
|
---|
558 | + if (chosen_greyscale == greyscale_table[1])
|
---|
559 | + {
|
---|
560 | + r_shift = 1;
|
---|
561 | + g_shift = 2;
|
---|
562 | + b_shift = 0;
|
---|
563 | + }
|
---|
564 | + else if (chosen_greyscale == greyscale_table[0])
|
---|
565 | + {
|
---|
566 | + r_shift = 2;
|
---|
567 | + g_shift = 1;
|
---|
568 | + b_shift = 0;
|
---|
569 | + }
|
---|
570 | + else
|
---|
571 | + {
|
---|
572 | + r_shift = 0;
|
---|
573 | + g_shift = 1;
|
---|
574 | + b_shift = 2;
|
---|
575 | + }
|
---|
576 | +
|
---|
577 | + diff = (*rgb_ptr1++ - *rgb_ptr2++) << r_shift;
|
---|
578 | + sum += diff * diff;
|
---|
579 | + diff = (*rgb_ptr1++ - *rgb_ptr2++) << g_shift;
|
---|
580 | + sum += diff * diff;
|
---|
581 | + diff = (*rgb_ptr1 - *rgb_ptr2) << b_shift;
|
---|
582 | + sum += diff * diff;
|
---|
583 | +
|
---|
584 | + return sum;
|
---|
585 | +#endif
|
---|
586 | +
|
---|
587 | +#if 0 /* distance between pixels, unweighted */
|
---|
588 | + int32 sum = 0;
|
---|
589 | + int16 *rgb_ptr1 = rgb_table[pixel1];
|
---|
590 | + int16 *rgb_ptr2 = rgb_table[pixel2];
|
---|
591 | + int16 diff;
|
---|
592 | +
|
---|
593 | + diff = *rgb_ptr1++ - *rgb_ptr2++;
|
---|
594 | + sum += diff * diff;
|
---|
595 | + diff = *rgb_ptr1++ - *rgb_ptr2++;
|
---|
596 | + sum += diff * diff;
|
---|
597 | + diff = *rgb_ptr1 - *rgb_ptr2;
|
---|
598 | + sum += diff * diff;
|
---|
599 | +
|
---|
600 | + return sum;
|
---|
601 | +#endif
|
---|
602 | +
|
---|
603 | +#if 0 /* use the greyscale directly */
|
---|
604 | + return labs(chosen_greyscale[pixel1] - chosen_greyscale[pixel2]);
|
---|
605 | +#endif
|
---|
606 | +}
|
---|
607 | +
|
---|
608 | +
|
---|
609 | +
|
---|
610 | +/*
|
---|
611 | + * Create vectors of all delta grey values from center pixel, with magnitudes
|
---|
612 | + * ranging from [1.0, 0.0] (zero difference, maximum difference). Find
|
---|
613 | + * the two principle axes of the grid by calculating the eigenvalues and
|
---|
614 | + * eigenvectors of the inertia tensor. Use the eigenvectors to calculate the
|
---|
615 | + * edge direction. In other words, find the angle of the line that optimally
|
---|
616 | + * passes through the 3x3 pattern of pixels.
|
---|
617 | + *
|
---|
618 | + * Return horizontal (-), vertical (|), diagonal (/,\), multi (*), or none '0'
|
---|
619 | + *
|
---|
620 | + * Don't replace any of the double math with integer-based approximations,
|
---|
621 | + * since everything I have tried has lead to slight mis-detection errors.
|
---|
622 | + *
|
---|
623 | + */
|
---|
624 | +int find_principle_axis(uint16 *pixels, int16 *diffs, int16 *bplane,
|
---|
625 | + int8 *sim,
|
---|
626 | + int32 *return_angle)
|
---|
627 | +{
|
---|
628 | + struct xy_point
|
---|
629 | + {
|
---|
630 | + int16 x, y;
|
---|
631 | + };
|
---|
632 | +
|
---|
633 | + int i;
|
---|
634 | + int16 centx = 0, centy = 0;
|
---|
635 | + struct xy_point xy_points[9];
|
---|
636 | + int angle;
|
---|
637 | + int reverse_flag = 1;
|
---|
638 | + int16 cutoff;
|
---|
639 | + int16 max_diff;
|
---|
640 | +
|
---|
641 | + double x, y;
|
---|
642 | + int32 half_matrix[3] = {0};
|
---|
643 | +
|
---|
644 | + double eigenval1, eigenval2;
|
---|
645 | + double best_val;
|
---|
646 | + double a, b, c;
|
---|
647 | + double ratio;
|
---|
648 | + int32 scale;
|
---|
649 | +
|
---|
650 | + /* absolute value of differences */
|
---|
651 | + for (i = 0; i < 8; i++)
|
---|
652 | + diffs[i] = labs(diffs[i]);
|
---|
653 | +
|
---|
654 | + /* find the max difference */
|
---|
655 | + max_diff = *diffs;
|
---|
656 | + for (i = 1; i < 8; i++)
|
---|
657 | + if (diffs[i] > max_diff) max_diff = diffs[i];
|
---|
658 | +
|
---|
659 | + /* exit early on uniform window */
|
---|
660 | + /* already taken care of earlier elsewhere after greyscale assignment */
|
---|
661 | + /* if (max_diff == 0) return '0'; */
|
---|
662 | +
|
---|
663 | + /* normalize the differences */
|
---|
664 | + scale = (1L<<(GREY_SHIFT+GREY_SHIFT)) / max_diff;
|
---|
665 | + for (i = 0; i < 8; i++)
|
---|
666 | + diffs[i] = (diffs[i] * scale + ((int16)1<<(GREY_SHIFT-1))) >> GREY_SHIFT;
|
---|
667 | +
|
---|
668 | + /*
|
---|
669 | + * Some pixel patterns need to NOT be reversed, since the pixels of
|
---|
670 | + * interest that form the edge to be detected are off-center.
|
---|
671 | + *
|
---|
672 | + */
|
---|
673 | +
|
---|
674 | + /* calculate yes/no similarity matrix to center pixel */
|
---|
675 | + /* store the number of similar pixels */
|
---|
676 | + cutoff = ((int16)1<<(GREY_SHIFT-3));
|
---|
677 | + for (i = 0, sim_sum = 0; i < 8; i++)
|
---|
678 | + sim_sum += (sim[i] = (diffs[i] < cutoff));
|
---|
679 | +
|
---|
680 | + /* don't reverse pattern for off-center knights and sharp corners */
|
---|
681 | + if (sim_sum >= 3 && sim_sum <= 5)
|
---|
682 | + {
|
---|
683 | + /* |. */ /* '- */
|
---|
684 | + if (sim[1] && sim[4] && sim[5] && !sim[3] && !sim[6] &&
|
---|
685 | + (!sim[0] ^ !sim[7]))
|
---|
686 | + reverse_flag = 0;
|
---|
687 | +
|
---|
688 | + /* -. */ /* '| */
|
---|
689 | + else if (sim[2] && sim[3] && sim[6] && !sim[1] && !sim[4] &&
|
---|
690 | + (!sim[0] ^ !sim[7]))
|
---|
691 | + reverse_flag = 0;
|
---|
692 | +
|
---|
693 | + /* .- */ /* |' */
|
---|
694 | + else if (sim[4] && sim[6] && sim[0] && !sim[1] && !sim[3] &&
|
---|
695 | + (!sim[2] ^ !sim[5]))
|
---|
696 | + reverse_flag = 0;
|
---|
697 | +
|
---|
698 | + /* .| */ /* -' */
|
---|
699 | + else if (sim[1] && sim[3] && sim[7] && !sim[4] && !sim[6] &&
|
---|
700 | + (!sim[2] ^ !sim[5]))
|
---|
701 | + reverse_flag = 0;
|
---|
702 | +
|
---|
703 | + /* 90 degree corners */
|
---|
704 | + else if (sim_sum == 3)
|
---|
705 | + {
|
---|
706 | + if ((sim[0] && sim[1] && sim[3]) ||
|
---|
707 | + (sim[1] && sim[2] && sim[4]) ||
|
---|
708 | + (sim[3] && sim[5] && sim[6]) ||
|
---|
709 | + (sim[4] && sim[6] && sim[7]))
|
---|
710 | + reverse_flag = 0;
|
---|
711 | + }
|
---|
712 | + }
|
---|
713 | +
|
---|
714 | + /* redo similarity array, less stringent for later checks */
|
---|
715 | + cutoff = ((int16)1<<(GREY_SHIFT-1));
|
---|
716 | + for (i = 0, sim_sum = 0; i < 8; i++)
|
---|
717 | + sim_sum += (sim[i] = (diffs[i] < cutoff));
|
---|
718 | +
|
---|
719 | + /* center pixel is different from all the others, not an edge */
|
---|
720 | + if (sim_sum == 0) return '0';
|
---|
721 | +
|
---|
722 | + /* reverse the difference array, so most similar is closest to 1 */
|
---|
723 | + if (reverse_flag)
|
---|
724 | + {
|
---|
725 | + diffs[0] = ((int16)1<<GREY_SHIFT) - diffs[0];
|
---|
726 | + diffs[1] = ((int16)1<<GREY_SHIFT) - diffs[1];
|
---|
727 | + diffs[2] = ((int16)1<<GREY_SHIFT) - diffs[2];
|
---|
728 | + diffs[3] = ((int16)1<<GREY_SHIFT) - diffs[3];
|
---|
729 | + diffs[4] = ((int16)1<<GREY_SHIFT) - diffs[4];
|
---|
730 | + diffs[5] = ((int16)1<<GREY_SHIFT) - diffs[5];
|
---|
731 | + diffs[6] = ((int16)1<<GREY_SHIFT) - diffs[6];
|
---|
732 | + diffs[7] = ((int16)1<<GREY_SHIFT) - diffs[7];
|
---|
733 | + }
|
---|
734 | +
|
---|
735 | + /* scale diagonals for projection onto axes */
|
---|
736 | + diffs[0] = (diffs[0] * one_sqrt2 + ((int16)1<<(GREY_SHIFT-1))) >> GREY_SHIFT;
|
---|
737 | + diffs[2] = (diffs[2] * one_sqrt2 + ((int16)1<<(GREY_SHIFT-1))) >> GREY_SHIFT;
|
---|
738 | + diffs[5] = (diffs[5] * one_sqrt2 + ((int16)1<<(GREY_SHIFT-1))) >> GREY_SHIFT;
|
---|
739 | + diffs[7] = (diffs[7] * one_sqrt2 + ((int16)1<<(GREY_SHIFT-1))) >> GREY_SHIFT;
|
---|
740 | +
|
---|
741 | + /* create the vectors, centered at 0,0 */
|
---|
742 | + xy_points[0].x = -diffs[0];
|
---|
743 | + xy_points[0].y = diffs[0];
|
---|
744 | + xy_points[1].x = 0;
|
---|
745 | + xy_points[1].y = diffs[1];
|
---|
746 | + xy_points[2].x = xy_points[2].y = diffs[2];
|
---|
747 | + xy_points[3].x = -diffs[3];
|
---|
748 | + xy_points[3].y = 0;
|
---|
749 | + xy_points[4].x = 0;
|
---|
750 | + xy_points[4].y = 0;
|
---|
751 | + xy_points[5].x = diffs[4];
|
---|
752 | + xy_points[5].y = 0;
|
---|
753 | + xy_points[6].x = xy_points[6].y = -diffs[5];
|
---|
754 | + xy_points[7].x = 0;
|
---|
755 | + xy_points[7].y = -diffs[6];
|
---|
756 | + xy_points[8].x = diffs[7];
|
---|
757 | + xy_points[8].y = -diffs[7];
|
---|
758 | +
|
---|
759 | + /* calculate the centroid of the points */
|
---|
760 | + for (i = 0; i < 9; i++)
|
---|
761 | + {
|
---|
762 | + centx += xy_points[i].x;
|
---|
763 | + centy += xy_points[i].y;
|
---|
764 | + }
|
---|
765 | + centx /= 9;
|
---|
766 | + centy /= 9;
|
---|
767 | +
|
---|
768 | + /* translate centroid to 0,0 */
|
---|
769 | + for (i = 0; i < 9; i++)
|
---|
770 | + {
|
---|
771 | + xy_points[i].x -= centx;
|
---|
772 | + xy_points[i].y -= centy;
|
---|
773 | + }
|
---|
774 | +
|
---|
775 | + /* fill inertia tensor 3x3 matrix */
|
---|
776 | + for (i = 0; i < 9; i++)
|
---|
777 | + {
|
---|
778 | + half_matrix[0] += xy_points[i].x * xy_points[i].x;
|
---|
779 | + half_matrix[1] += xy_points[i].y * xy_points[i].x;
|
---|
780 | + half_matrix[2] += xy_points[i].y * xy_points[i].y;
|
---|
781 | + }
|
---|
782 | +
|
---|
783 | + /* calculate eigenvalues */
|
---|
784 | + a = half_matrix[0] - half_matrix[2];
|
---|
785 | + b = half_matrix[1] << 1;
|
---|
786 | + b = sqrt(b*b + a*a);
|
---|
787 | + a = half_matrix[0] + half_matrix[2];
|
---|
788 | + eigenval1 = (a + b);
|
---|
789 | + eigenval2 = (a - b);
|
---|
790 | +
|
---|
791 | + /* find largest eigenvalue */
|
---|
792 | + if (eigenval1 == eigenval2) /* X and + shapes */
|
---|
793 | + return '*';
|
---|
794 | + else if (eigenval1 > eigenval2)
|
---|
795 | + best_val = eigenval1;
|
---|
796 | + else
|
---|
797 | + best_val = eigenval2;
|
---|
798 | +
|
---|
799 | + /* white center pixel, black background */
|
---|
800 | + if (!best_val)
|
---|
801 | + return '*';
|
---|
802 | +
|
---|
803 | + /* divide eigenvalue by 2, postponed from when it should have been
|
---|
804 | + done during the eigenvalue calculation but was delayed for
|
---|
805 | + another early exit opportunity */
|
---|
806 | + best_val *= 0.5;
|
---|
807 | +
|
---|
808 | + /* calculate eigenvectors */
|
---|
809 | + c = best_val + half_matrix[1];
|
---|
810 | + a = c - half_matrix[0];
|
---|
811 | + b = c - half_matrix[2];
|
---|
812 | + if (b)
|
---|
813 | + {
|
---|
814 | + x = 1.0;
|
---|
815 | + ratio = y = a / b;
|
---|
816 | + }
|
---|
817 | + else if (a)
|
---|
818 | + {
|
---|
819 | + y = 1.0;
|
---|
820 | + x = b / a;
|
---|
821 | + ratio = a / b;
|
---|
822 | + }
|
---|
823 | + else if (a == b)
|
---|
824 | + {
|
---|
825 | + *return_angle = 13500;
|
---|
826 | + return '\\';
|
---|
827 | + }
|
---|
828 | + else
|
---|
829 | + return '*';
|
---|
830 | +
|
---|
831 | + /* calculate angle in degrees * 100 */
|
---|
832 | + if (x)
|
---|
833 | + {
|
---|
834 | + angle = (int32) floor(5729.577951307 * fast_atan(ratio) + 0.5);
|
---|
835 | + if (x < 0.0) angle += 18000;
|
---|
836 | + }
|
---|
837 | + else
|
---|
838 | + {
|
---|
839 | + if (y > 0.0) angle = 9000;
|
---|
840 | + else if (y < 0.0) angle = -9000;
|
---|
841 | + else return '0';
|
---|
842 | + }
|
---|
843 | +
|
---|
844 | + /* force angle to lie between 0 to 360 */
|
---|
845 | + if (angle < 0) angle += 36000;
|
---|
846 | + if (angle > 18000) angle -= 18000;
|
---|
847 | + *return_angle = angle;
|
---|
848 | +
|
---|
849 | + if (angle <= 2250)
|
---|
850 | + return '-';
|
---|
851 | +
|
---|
852 | + if (angle < 6750)
|
---|
853 | + return '/';
|
---|
854 | +
|
---|
855 | + if (angle <= 11250)
|
---|
856 | + return '|';
|
---|
857 | +
|
---|
858 | + if (angle < 15750)
|
---|
859 | + return '\\';
|
---|
860 | +
|
---|
861 | + return '-';
|
---|
862 | +}
|
---|
863 | +
|
---|
864 | +
|
---|
865 | +
|
---|
866 | +/* Check for mis-detected arrow patterns. Return 1 (good), 0 (bad). */
|
---|
867 | +int check_arrows(int best_dir, uint16 *pixels, int8 *sim, int half_flag)
|
---|
868 | +{
|
---|
869 | + uint16 center = pixels[4];
|
---|
870 | +
|
---|
871 | + if (center == pixels[0] && center == pixels[2] &&
|
---|
872 | + center == pixels[6] && center == pixels[8])
|
---|
873 | + {
|
---|
874 | + switch(best_dir)
|
---|
875 | + {
|
---|
876 | + case 5:
|
---|
877 | + if (center != pixels[5]) /* < */
|
---|
878 | + return 0;
|
---|
879 | + break;
|
---|
880 | + case 6:
|
---|
881 | + if (center != pixels[3]) /* > */
|
---|
882 | + return 0;
|
---|
883 | + break;
|
---|
884 | + case 7:
|
---|
885 | + if (center != pixels[7]) /* ^ */
|
---|
886 | + return 0;
|
---|
887 | + break;
|
---|
888 | + case 8:
|
---|
889 | + if (center != pixels[1]) /* v */
|
---|
890 | + return 0;
|
---|
891 | + break;
|
---|
892 | + }
|
---|
893 | + }
|
---|
894 | +
|
---|
895 | + switch(best_dir)
|
---|
896 | + {
|
---|
897 | + case 5: /* < */
|
---|
898 | + if (center == pixels[2] && center == pixels[8] &&
|
---|
899 | + pixels[1] == pixels[5] && pixels[5] == pixels[7] &&
|
---|
900 | + (((center == pixels[0]) ^ (center == pixels[6])) ||
|
---|
901 | + (center == pixels[0] && center == pixels[6] &&
|
---|
902 | + pixels[1] != pixels[3])))
|
---|
903 | + return 0;
|
---|
904 | + break;
|
---|
905 | +
|
---|
906 | + case 6: /* > */
|
---|
907 | + if (center == pixels[0] && center == pixels[6] &&
|
---|
908 | + pixels[1] == pixels[3] && pixels[3] == pixels[7] &&
|
---|
909 | + (((center == pixels[2]) ^ (center == pixels[8])) ||
|
---|
910 | + (center == pixels[2] && center == pixels[8] &&
|
---|
911 | + pixels[1] != pixels[5])))
|
---|
912 | + return 0;
|
---|
913 | + break;
|
---|
914 | +
|
---|
915 | + case 7: /* ^ */
|
---|
916 | + if (center == pixels[6] && center == pixels[8] &&
|
---|
917 | + pixels[3] == pixels[7] && pixels[7] == pixels[5] &&
|
---|
918 | + (((center == pixels[0]) ^ (center == pixels[2])) ||
|
---|
919 | + (center == pixels[0] && center == pixels[2] &&
|
---|
920 | + pixels[3] != pixels[1])))
|
---|
921 | + return 0;
|
---|
922 | + break;
|
---|
923 | +
|
---|
924 | + case 8: /* v */
|
---|
925 | + if (center == pixels[0] && center == pixels[2] &&
|
---|
926 | + pixels[1] == pixels[3] && pixels[1] == pixels[5] &&
|
---|
927 | + (((center == pixels[6]) ^ (center == pixels[8])) ||
|
---|
928 | + (center == pixels[6] && center == pixels[8] &&
|
---|
929 | + pixels[3] != pixels[7])))
|
---|
930 | + return 0;
|
---|
931 | + break;
|
---|
932 | + }
|
---|
933 | +
|
---|
934 | + switch(best_dir)
|
---|
935 | + {
|
---|
936 | + case 5:
|
---|
937 | + if (sim[0] == sim[5] &&
|
---|
938 | + sim[1] == sim[3] &&
|
---|
939 | + sim[3] == sim[6] &&
|
---|
940 | + ((sim[2] && sim[7]) ||
|
---|
941 | + (half_flag && sim_sum == 2 && sim[4] &&
|
---|
942 | + (sim[2] || sim[7])))) /* < */
|
---|
943 | + return 1;
|
---|
944 | + break;
|
---|
945 | + case 6:
|
---|
946 | + if (sim[2] == sim[7] &&
|
---|
947 | + sim[1] == sim[4] &&
|
---|
948 | + sim[4] == sim[6] &&
|
---|
949 | + ((sim[0] && sim[5]) ||
|
---|
950 | + (half_flag && sim_sum == 2 && sim[3] &&
|
---|
951 | + (sim[0] || sim[5])))) /* > */
|
---|
952 | + return 1;
|
---|
953 | + break;
|
---|
954 | + case 7:
|
---|
955 | + if (sim[0] == sim[2] &&
|
---|
956 | + sim[1] == sim[3] &&
|
---|
957 | + sim[3] == sim[4] &&
|
---|
958 | + ((sim[5] && sim[7]) ||
|
---|
959 | + (half_flag && sim_sum == 2 && sim[6] &&
|
---|
960 | + (sim[5] || sim[7])))) /* ^ */
|
---|
961 | + return 1;
|
---|
962 | + break;
|
---|
963 | + case 8:
|
---|
964 | + if (sim[5] == sim[7] &&
|
---|
965 | + sim[3] == sim[6] &&
|
---|
966 | + sim[4] == sim[6] &&
|
---|
967 | + ((sim[0] && sim[2]) ||
|
---|
968 | + (half_flag && sim_sum == 2 && sim[1] &&
|
---|
969 | + (sim[0] || sim[2])))) /* v */
|
---|
970 | + return 1;
|
---|
971 | + break;
|
---|
972 | + }
|
---|
973 | +
|
---|
974 | + return 0;
|
---|
975 | +}
|
---|
976 | +
|
---|
977 | +
|
---|
978 | +
|
---|
979 | +/*
|
---|
980 | + * Take original direction, refine it by testing different pixel difference
|
---|
981 | + * patterns based on the initial gross edge direction.
|
---|
982 | + *
|
---|
983 | + * The angle value is not currently used, but may be useful for future
|
---|
984 | + * refinement algorithms.
|
---|
985 | + *
|
---|
986 | + */
|
---|
987 | +int refine_direction(char edge_type, uint16 *pixels, int16 *bptr,
|
---|
988 | + int8 *sim, double angle)
|
---|
989 | +{
|
---|
990 | + int32 sums_dir[9] = { 0 };
|
---|
991 | + int32 sum;
|
---|
992 | + int32 best_sum;
|
---|
993 | + int i, n, best_dir;
|
---|
994 | + int16 diff_array[26];
|
---|
995 | + int ok_arrow_flag = 1;
|
---|
996 | +
|
---|
997 | + /*
|
---|
998 | + * - '- -. \ '| |. | |' .| / -' .- < > ^ v
|
---|
999 | + *
|
---|
1000 | + * 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|
---|
1001 | + *
|
---|
1002 | + * \' .\ '/ /.
|
---|
1003 | + *
|
---|
1004 | + * 16 17 18 19
|
---|
1005 | + *
|
---|
1006 | + */
|
---|
1007 | +
|
---|
1008 | + switch(edge_type)
|
---|
1009 | + {
|
---|
1010 | + case '|':
|
---|
1011 | + diff_array[0] = labs(bptr[4] - bptr[1]);
|
---|
1012 | + diff_array[1] = labs(bptr[4] - bptr[7]);
|
---|
1013 | + diff_array[2] = labs(bptr[3] - bptr[0]);
|
---|
1014 | + diff_array[3] = labs(bptr[3] - bptr[6]);
|
---|
1015 | + diff_array[4] = labs(bptr[5] - bptr[2]);
|
---|
1016 | + diff_array[5] = labs(bptr[5] - bptr[8]);
|
---|
1017 | + diff_array[6] = labs(bptr[4] - bptr[2]);
|
---|
1018 | + diff_array[7] = labs(bptr[4] - bptr[8]);
|
---|
1019 | + diff_array[8] = labs(bptr[3] - bptr[1]);
|
---|
1020 | + diff_array[9] = labs(bptr[3] - bptr[7]);
|
---|
1021 | + diff_array[10] = labs(bptr[4] - bptr[0]);
|
---|
1022 | + diff_array[11] = labs(bptr[4] - bptr[6]);
|
---|
1023 | + diff_array[12] = labs(bptr[5] - bptr[1]);
|
---|
1024 | + diff_array[13] = labs(bptr[5] - bptr[7]);
|
---|
1025 | + diff_array[14] = labs(bptr[0] - bptr[6]);
|
---|
1026 | + diff_array[15] = labs(bptr[2] - bptr[8]);
|
---|
1027 | + diff_array[16] = labs(bptr[1] - bptr[7]);
|
---|
1028 | + diff_array[17] = labs(bptr[0] - bptr[1]);
|
---|
1029 | + diff_array[18] = labs(bptr[2] - bptr[1]);
|
---|
1030 | + diff_array[19] = labs(bptr[0] - bptr[2]);
|
---|
1031 | + diff_array[20] = labs(bptr[3] - bptr[5]);
|
---|
1032 | + diff_array[21] = labs(bptr[6] - bptr[8]);
|
---|
1033 | + diff_array[22] = labs(bptr[6] - bptr[7]);
|
---|
1034 | + diff_array[23] = labs(bptr[8] - bptr[7]);
|
---|
1035 | +
|
---|
1036 | + /* | vertical */
|
---|
1037 | + sums_dir[0] = diff_array[0] + diff_array[1] + diff_array[2] +
|
---|
1038 | + diff_array[3] + diff_array[4] + diff_array[5];
|
---|
1039 | +
|
---|
1040 | + /* << top */
|
---|
1041 | + sum = diff_array[8] + diff_array[9] +
|
---|
1042 | + ((diff_array[6] + diff_array[7] +
|
---|
1043 | + diff_array[12] + diff_array[13]) << 1) +
|
---|
1044 | + diff_array[14] + diff_array[16] + diff_array[15];
|
---|
1045 | + sum = (sum * 6) / 13;
|
---|
1046 | + sums_dir[5] = sum;
|
---|
1047 | +
|
---|
1048 | + /* >> top */
|
---|
1049 | + sum = diff_array[12] + diff_array[13] +
|
---|
1050 | + ((diff_array[10] + diff_array[11] +
|
---|
1051 | + diff_array[8] + diff_array[9]) << 1) +
|
---|
1052 | + diff_array[15] + diff_array[16] + diff_array[14];
|
---|
1053 | + sum = (sum * 6) / 13;
|
---|
1054 | + sums_dir[6] = sum;
|
---|
1055 | +
|
---|
1056 | + /* ^ bottom */
|
---|
1057 | + sum = diff_array[8] + diff_array[12] +
|
---|
1058 | + ((diff_array[11] + diff_array[7]) << 1) +
|
---|
1059 | + (diff_array[1] << 2) +
|
---|
1060 | + diff_array[19] + diff_array[20] + diff_array[21];
|
---|
1061 | + sum = (sum * 6) / 13;
|
---|
1062 | + sums_dir[7] = sum;
|
---|
1063 | +
|
---|
1064 | + /* v bottom */
|
---|
1065 | + sum = diff_array[9] + diff_array[13] +
|
---|
1066 | + ((diff_array[10] + diff_array[6]) << 1) +
|
---|
1067 | + (diff_array[0] << 2) +
|
---|
1068 | + diff_array[21] + diff_array[20] + diff_array[19];
|
---|
1069 | + sum = (sum * 6) / 13;
|
---|
1070 | + sums_dir[8] = sum;
|
---|
1071 | +
|
---|
1072 | + /* '| */
|
---|
1073 | + sums_dir[1] = diff_array[1] + diff_array[5] + diff_array[10] +
|
---|
1074 | + diff_array[12] + (diff_array[3] << 1);
|
---|
1075 | + /* '| alt */
|
---|
1076 | + sum = diff_array[10] + diff_array[1] + diff_array[18] +
|
---|
1077 | + diff_array[4] + diff_array[5] + diff_array[14];
|
---|
1078 | + if (sum < sums_dir[1])
|
---|
1079 | + sums_dir[1] = sum;
|
---|
1080 | +
|
---|
1081 | + /* |. */
|
---|
1082 | + sums_dir[2] = diff_array[0] + diff_array[2] + diff_array[7] +
|
---|
1083 | + diff_array[9] + (diff_array[4] << 1);
|
---|
1084 | + /* |. alt */
|
---|
1085 | + sum = diff_array[0] + diff_array[7] + diff_array[22] +
|
---|
1086 | + diff_array[3] + diff_array[2] + diff_array[15];
|
---|
1087 | + if (sum < sums_dir[2])
|
---|
1088 | + sums_dir[2] = sum;
|
---|
1089 | +
|
---|
1090 | + /* |' */
|
---|
1091 | + sums_dir[3] = diff_array[1] + diff_array[3] + diff_array[6] +
|
---|
1092 | + diff_array[8] + (diff_array[5] << 1);
|
---|
1093 | + /* |' alt */
|
---|
1094 | + sum = diff_array[6] + diff_array[1] + diff_array[17] +
|
---|
1095 | + diff_array[2] + diff_array[3] + diff_array[15];
|
---|
1096 | + if (sum < sums_dir[3])
|
---|
1097 | + sums_dir[3] = sum;
|
---|
1098 | +
|
---|
1099 | + /* .| */
|
---|
1100 | + sums_dir[4] = diff_array[0] + diff_array[4] + diff_array[11] +
|
---|
1101 | + diff_array[13] + (diff_array[2] << 1);
|
---|
1102 | + /* .| alt */
|
---|
1103 | + sum = diff_array[11] + diff_array[0] + diff_array[23] +
|
---|
1104 | + diff_array[5] + diff_array[4] + diff_array[14];
|
---|
1105 | + if (sum < sums_dir[4])
|
---|
1106 | + sums_dir[4] = sum;
|
---|
1107 | +
|
---|
1108 | + best_sum = sums_dir[0];
|
---|
1109 | + for (i = 1; i < 9; i++)
|
---|
1110 | + if (sums_dir[i] < best_sum) best_sum = sums_dir[i];
|
---|
1111 | + if (best_sum == sums_dir[0]) return 6; /* | */
|
---|
1112 | +
|
---|
1113 | + best_dir = 0;
|
---|
1114 | + for (i = 0, n = 0; i < 9; i++)
|
---|
1115 | + {
|
---|
1116 | + if (sums_dir[i] == best_sum)
|
---|
1117 | + {
|
---|
1118 | + best_dir = i;
|
---|
1119 | + n++;
|
---|
1120 | + }
|
---|
1121 | + }
|
---|
1122 | +
|
---|
1123 | + /* best direction uncertain, return original direction */
|
---|
1124 | + if (n > 1) return 6; /* | */
|
---|
1125 | +
|
---|
1126 | + if (best_dir >= 5)
|
---|
1127 | + ok_arrow_flag = check_arrows(best_dir, pixels, sim, 1);
|
---|
1128 | +
|
---|
1129 | + switch(best_dir)
|
---|
1130 | + {
|
---|
1131 | + case 1:
|
---|
1132 | + return 4; /* '| */
|
---|
1133 | + break;
|
---|
1134 | + case 2:
|
---|
1135 | + return 5; /* |. */
|
---|
1136 | + break;
|
---|
1137 | + case 3:
|
---|
1138 | + return 7; /* |' */
|
---|
1139 | + break;
|
---|
1140 | + case 4:
|
---|
1141 | + return 8; /* .| */
|
---|
1142 | + break;
|
---|
1143 | + case 5:
|
---|
1144 | + if (ok_arrow_flag)
|
---|
1145 | + return 12; /* < */
|
---|
1146 | + break;
|
---|
1147 | + case 6:
|
---|
1148 | + if (ok_arrow_flag)
|
---|
1149 | + return 13; /* > */
|
---|
1150 | + break;
|
---|
1151 | + case 7:
|
---|
1152 | + if (ok_arrow_flag)
|
---|
1153 | + return 14; /* ^ */
|
---|
1154 | + break;
|
---|
1155 | + case 8:
|
---|
1156 | + if (ok_arrow_flag)
|
---|
1157 | + return 15; /* V */
|
---|
1158 | + break;
|
---|
1159 | + case 0:
|
---|
1160 | + default:
|
---|
1161 | + return 6; /* | */
|
---|
1162 | + break;
|
---|
1163 | + }
|
---|
1164 | +
|
---|
1165 | + break;
|
---|
1166 | +
|
---|
1167 | + case '-':
|
---|
1168 | + diff_array[0] = labs(bptr[4] - bptr[3]);
|
---|
1169 | + diff_array[1] = labs(bptr[4] - bptr[5]);
|
---|
1170 | + diff_array[2] = labs(bptr[0] - bptr[1]);
|
---|
1171 | + diff_array[3] = labs(bptr[1] - bptr[2]);
|
---|
1172 | + diff_array[4] = labs(bptr[7] - bptr[6]);
|
---|
1173 | + diff_array[5] = labs(bptr[7] - bptr[8]);
|
---|
1174 | + diff_array[6] = labs(bptr[4] - bptr[6]);
|
---|
1175 | + diff_array[7] = labs(bptr[4] - bptr[8]);
|
---|
1176 | + diff_array[8] = labs(bptr[1] - bptr[3]);
|
---|
1177 | + diff_array[9] = labs(bptr[1] - bptr[5]);
|
---|
1178 | + diff_array[10] = labs(bptr[4] - bptr[0]);
|
---|
1179 | + diff_array[11] = labs(bptr[4] - bptr[2]);
|
---|
1180 | + diff_array[12] = labs(bptr[7] - bptr[3]);
|
---|
1181 | + diff_array[13] = labs(bptr[7] - bptr[5]);
|
---|
1182 | + diff_array[14] = labs(bptr[0] - bptr[2]);
|
---|
1183 | + diff_array[15] = labs(bptr[6] - bptr[8]);
|
---|
1184 | + diff_array[16] = labs(bptr[3] - bptr[5]);
|
---|
1185 | + diff_array[17] = labs(bptr[0] - bptr[3]);
|
---|
1186 | + diff_array[18] = labs(bptr[6] - bptr[3]);
|
---|
1187 | + diff_array[19] = labs(bptr[0] - bptr[6]);
|
---|
1188 | + diff_array[20] = labs(bptr[1] - bptr[7]);
|
---|
1189 | + diff_array[21] = labs(bptr[2] - bptr[8]);
|
---|
1190 | + diff_array[22] = labs(bptr[2] - bptr[5]);
|
---|
1191 | + diff_array[23] = labs(bptr[8] - bptr[5]);
|
---|
1192 | +
|
---|
1193 | + /* - horizontal */
|
---|
1194 | + sums_dir[0] = diff_array[0] + diff_array[1] + diff_array[2] +
|
---|
1195 | + diff_array[3] + diff_array[4] + diff_array[5];
|
---|
1196 | +
|
---|
1197 | + /* << bottom */
|
---|
1198 | + sum = diff_array[8] + diff_array[12] +
|
---|
1199 | + ((diff_array[11] + diff_array[7]) << 1) +
|
---|
1200 | + (diff_array[1] << 2) +
|
---|
1201 | + diff_array[19] + diff_array[20] + diff_array[21];
|
---|
1202 | + sum = (sum * 6) / 13;
|
---|
1203 | + sums_dir[5] = sum;
|
---|
1204 | +
|
---|
1205 | + /* >> bottom */
|
---|
1206 | + sum = diff_array[9] + diff_array[13] +
|
---|
1207 | + ((diff_array[10] + diff_array[6]) << 1) +
|
---|
1208 | + (diff_array[0] << 2) +
|
---|
1209 | + diff_array[21] + diff_array[20] + diff_array[19];
|
---|
1210 | + sum = (sum * 6) / 13;
|
---|
1211 | + sums_dir[6] = sum;
|
---|
1212 | +
|
---|
1213 | + /* ^ top */
|
---|
1214 | + sum = diff_array[8] + diff_array[9] +
|
---|
1215 | + ((diff_array[6] + diff_array[7] +
|
---|
1216 | + diff_array[12] + diff_array[13]) << 1) +
|
---|
1217 | + diff_array[14] + diff_array[16] + diff_array[15];
|
---|
1218 | + sum = (sum * 6) / 13;
|
---|
1219 | + sums_dir[7] = sum;
|
---|
1220 | +
|
---|
1221 | + /* v top */
|
---|
1222 | + sum = diff_array[12] + diff_array[13] +
|
---|
1223 | + ((diff_array[10] + diff_array[11] +
|
---|
1224 | + diff_array[8] + diff_array[9]) << 1) +
|
---|
1225 | + diff_array[15] + diff_array[16] + diff_array[14];
|
---|
1226 | + sum = (sum * 6) / 13;
|
---|
1227 | + sums_dir[8] = sum;
|
---|
1228 | +
|
---|
1229 | + /* '- */
|
---|
1230 | + sums_dir[1] = diff_array[1] + diff_array[5] + diff_array[10] +
|
---|
1231 | + diff_array[12] + (diff_array[3] << 1);
|
---|
1232 | + /* '- alt */
|
---|
1233 | + sum = diff_array[10] + diff_array[1] + diff_array[18] +
|
---|
1234 | + diff_array[4] + diff_array[5] + diff_array[14];
|
---|
1235 | + if (sum < sums_dir[1])
|
---|
1236 | + sums_dir[1] = sum;
|
---|
1237 | +
|
---|
1238 | + /* -. */
|
---|
1239 | + sums_dir[2] = diff_array[0] + diff_array[2] + diff_array[7] +
|
---|
1240 | + diff_array[9] + (diff_array[4] << 1);
|
---|
1241 | + /* -. alt */
|
---|
1242 | + sum = diff_array[0] + diff_array[7] + diff_array[22] +
|
---|
1243 | + diff_array[3] + diff_array[2] + diff_array[15];
|
---|
1244 | + if (sum < sums_dir[2])
|
---|
1245 | + sums_dir[2] = sum;
|
---|
1246 | +
|
---|
1247 | + /* -' */
|
---|
1248 | + sums_dir[3] = diff_array[0] + diff_array[4] + diff_array[11] +
|
---|
1249 | + diff_array[13] + (diff_array[2] << 1);
|
---|
1250 | + /* -' alt */
|
---|
1251 | + sum = diff_array[11] + diff_array[0] + diff_array[23] +
|
---|
1252 | + diff_array[5] + diff_array[4] + diff_array[14];
|
---|
1253 | + if (sum < sums_dir[3])
|
---|
1254 | + sums_dir[3] = sum;
|
---|
1255 | +
|
---|
1256 | + /* .- */
|
---|
1257 | + sums_dir[4] = diff_array[1] + diff_array[3] + diff_array[6] +
|
---|
1258 | + diff_array[8] + (diff_array[5] << 1);
|
---|
1259 | + /* .- alt */
|
---|
1260 | + sum = diff_array[6] + diff_array[1] + diff_array[17] +
|
---|
1261 | + diff_array[2] + diff_array[3] + diff_array[15];
|
---|
1262 | + if (sum < sums_dir[4])
|
---|
1263 | + sums_dir[4] = sum;
|
---|
1264 | +
|
---|
1265 | + best_sum = sums_dir[0];
|
---|
1266 | + for (i = 1; i < 9; i++)
|
---|
1267 | + if (sums_dir[i] < best_sum) best_sum = sums_dir[i];
|
---|
1268 | + if (best_sum == sums_dir[0]) return 0; /* - */
|
---|
1269 | +
|
---|
1270 | + best_dir = 0;
|
---|
1271 | + for (i = 0, n = 0; i < 9; i++)
|
---|
1272 | + {
|
---|
1273 | + if (sums_dir[i] == best_sum)
|
---|
1274 | + {
|
---|
1275 | + best_dir = i;
|
---|
1276 | + n++;
|
---|
1277 | + }
|
---|
1278 | + }
|
---|
1279 | +
|
---|
1280 | + /* best direction uncertain, return original direction */
|
---|
1281 | + if (n > 1) return 0; /* - */
|
---|
1282 | +
|
---|
1283 | + if (best_dir >= 5)
|
---|
1284 | + ok_arrow_flag = check_arrows(best_dir, pixels, sim, 1);
|
---|
1285 | +
|
---|
1286 | + switch(best_dir)
|
---|
1287 | + {
|
---|
1288 | + case 1:
|
---|
1289 | + return 1; /* '- */
|
---|
1290 | + break;
|
---|
1291 | + case 2:
|
---|
1292 | + return 2; /* -. */
|
---|
1293 | + break;
|
---|
1294 | + case 3:
|
---|
1295 | + return 10; /* -' */
|
---|
1296 | + break;
|
---|
1297 | + case 4:
|
---|
1298 | + return 11; /* .- */
|
---|
1299 | + break;
|
---|
1300 | + case 5:
|
---|
1301 | + if (ok_arrow_flag)
|
---|
1302 | + return 12; /* < */
|
---|
1303 | + break;
|
---|
1304 | + case 6:
|
---|
1305 | + if (ok_arrow_flag)
|
---|
1306 | + return 13; /* > */
|
---|
1307 | + break;
|
---|
1308 | + case 7:
|
---|
1309 | + if (ok_arrow_flag)
|
---|
1310 | + return 14; /* ^ */
|
---|
1311 | + break;
|
---|
1312 | + case 8:
|
---|
1313 | + if (ok_arrow_flag)
|
---|
1314 | + return 15; /* V */
|
---|
1315 | + break;
|
---|
1316 | + case 0:
|
---|
1317 | + default:
|
---|
1318 | + return 0; /* - */
|
---|
1319 | + break;
|
---|
1320 | + }
|
---|
1321 | +
|
---|
1322 | + break;
|
---|
1323 | +
|
---|
1324 | + case '\\':
|
---|
1325 | +
|
---|
1326 | + /* CHECK -- handle noisy half-diags */
|
---|
1327 | + if (sim_sum == 1)
|
---|
1328 | + {
|
---|
1329 | + if (pixels[1] == pixels[3] && pixels[3] == pixels[5] &&
|
---|
1330 | + pixels[5] == pixels[7])
|
---|
1331 | + {
|
---|
1332 | + if (pixels[2] != pixels[1] && pixels[6] != pixels[1])
|
---|
1333 | + {
|
---|
1334 | + sum = labs(bptr[2] - bptr[4]) +
|
---|
1335 | + labs(bptr[6] - bptr[4]);
|
---|
1336 | +
|
---|
1337 | + if (sim[0] && sum < (labs(bptr[8] - bptr[4]) << 1))
|
---|
1338 | + {
|
---|
1339 | + if (bptr[4] > bptr[8])
|
---|
1340 | + {
|
---|
1341 | + if (bptr[2] > bptr[4] &&
|
---|
1342 | + bptr[6] > bptr[4])
|
---|
1343 | + return 18; /* '/ */
|
---|
1344 | + }
|
---|
1345 | + else
|
---|
1346 | + {
|
---|
1347 | + if (bptr[2] < bptr[4] &&
|
---|
1348 | + bptr[6] < bptr[4])
|
---|
1349 | + return 18; /* '/ */
|
---|
1350 | + }
|
---|
1351 | + }
|
---|
1352 | +
|
---|
1353 | + if (sim[7] && sum < (labs(bptr[0] - bptr[4]) << 1))
|
---|
1354 | + {
|
---|
1355 | + if (bptr[4] > bptr[0])
|
---|
1356 | + {
|
---|
1357 | + if (bptr[2] > bptr[4] &&
|
---|
1358 | + bptr[6] > bptr[4])
|
---|
1359 | + return 19; /* /. */
|
---|
1360 | + }
|
---|
1361 | + else
|
---|
1362 | + {
|
---|
1363 | + if (bptr[2] < bptr[4] &&
|
---|
1364 | + bptr[6] < bptr[4])
|
---|
1365 | + return 19; /* /. */
|
---|
1366 | + }
|
---|
1367 | + }
|
---|
1368 | + }
|
---|
1369 | + }
|
---|
1370 | +
|
---|
1371 | + if (sim[0] &&
|
---|
1372 | + labs(bptr[4] - bptr[0]) < ((int16)1<<(GREY_SHIFT-3)))
|
---|
1373 | + return 3; /* \ */
|
---|
1374 | + if (sim[7] &&
|
---|
1375 | + labs(bptr[4] - bptr[8]) < ((int16)1<<(GREY_SHIFT-3)))
|
---|
1376 | + return 3; /* \ */
|
---|
1377 | + }
|
---|
1378 | +
|
---|
1379 | + diff_array[0] = labs(bptr[4] - bptr[0]);
|
---|
1380 | + diff_array[1] = labs(bptr[4] - bptr[5]);
|
---|
1381 | + diff_array[2] = labs(bptr[3] - bptr[7]);
|
---|
1382 | + diff_array[3] = labs(bptr[7] - bptr[8]);
|
---|
1383 | + diff_array[4] = labs(bptr[1] - bptr[2]);
|
---|
1384 | + diff_array[5] = labs(bptr[4] - bptr[3]);
|
---|
1385 | + diff_array[6] = labs(bptr[4] - bptr[8]);
|
---|
1386 | + diff_array[7] = labs(bptr[0] - bptr[1]);
|
---|
1387 | + diff_array[8] = labs(bptr[1] - bptr[5]);
|
---|
1388 | + diff_array[9] = labs(bptr[6] - bptr[7]);
|
---|
1389 | + diff_array[10] = labs(bptr[4] - bptr[7]);
|
---|
1390 | + diff_array[11] = labs(bptr[5] - bptr[8]);
|
---|
1391 | + diff_array[12] = labs(bptr[3] - bptr[6]);
|
---|
1392 | + diff_array[13] = labs(bptr[4] - bptr[1]);
|
---|
1393 | + diff_array[14] = labs(bptr[0] - bptr[3]);
|
---|
1394 | + diff_array[15] = labs(bptr[2] - bptr[5]);
|
---|
1395 | + diff_array[20] = labs(bptr[0] - bptr[2]);
|
---|
1396 | + diff_array[21] = labs(bptr[6] - bptr[8]);
|
---|
1397 | + diff_array[22] = labs(bptr[0] - bptr[6]);
|
---|
1398 | + diff_array[23] = labs(bptr[2] - bptr[8]);
|
---|
1399 | + diff_array[16] = labs(bptr[4] - bptr[2]);
|
---|
1400 | + diff_array[18] = labs(bptr[4] - bptr[6]);
|
---|
1401 | +
|
---|
1402 | + /* '- */
|
---|
1403 | + sums_dir[1] = diff_array[0] + diff_array[1] + diff_array[2] +
|
---|
1404 | + diff_array[3] + (diff_array[4] << 1);
|
---|
1405 | + /* '- alt */
|
---|
1406 | + sum = diff_array[0] + diff_array[1] + diff_array[12] +
|
---|
1407 | + diff_array[9] + diff_array[3] + diff_array[20];
|
---|
1408 | + if (sum < sums_dir[1])
|
---|
1409 | + sums_dir[1] = sum;
|
---|
1410 | +
|
---|
1411 | + /* -. */
|
---|
1412 | + sums_dir[2] = diff_array[5] + diff_array[6] + diff_array[7] +
|
---|
1413 | + diff_array[8] + (diff_array[9] << 1);
|
---|
1414 | + /* -. alt */
|
---|
1415 | + sum = diff_array[6] + diff_array[5] + diff_array[15] +
|
---|
1416 | + diff_array[4] + diff_array[7] + diff_array[21];
|
---|
1417 | + if (sum < sums_dir[2])
|
---|
1418 | + sums_dir[2] = sum;
|
---|
1419 | +
|
---|
1420 | + /* '| */
|
---|
1421 | + sums_dir[3] = diff_array[0] + diff_array[8] + diff_array[10] +
|
---|
1422 | + diff_array[11] + (diff_array[12] << 1);
|
---|
1423 | + /* '| alt */
|
---|
1424 | + sum = diff_array[0] + diff_array[10] + diff_array[4] +
|
---|
1425 | + diff_array[15] + diff_array[11] + diff_array[22];
|
---|
1426 | + if (sum < sums_dir[3])
|
---|
1427 | + sums_dir[3] = sum;
|
---|
1428 | +
|
---|
1429 | + /* |. */
|
---|
1430 | + sums_dir[4] = diff_array[2] + diff_array[6] + diff_array[13] +
|
---|
1431 | + diff_array[14] + (diff_array[15] << 1);
|
---|
1432 | + /* |. alt */
|
---|
1433 | + sum = diff_array[13] + diff_array[6] + diff_array[9] +
|
---|
1434 | + diff_array[12] + diff_array[14] + diff_array[23];
|
---|
1435 | + if (sum < sums_dir[4])
|
---|
1436 | + sums_dir[4] = sum;
|
---|
1437 | +
|
---|
1438 | + /* \ 45 */
|
---|
1439 | + sums_dir[0] = diff_array[0] + diff_array[6] +
|
---|
1440 | + (diff_array[2] << 1) + (diff_array[8] << 1);
|
---|
1441 | +
|
---|
1442 | + /* << top */
|
---|
1443 | + sum = labs(bptr[3] - bptr[1]) + labs(bptr[3] - bptr[7]) +
|
---|
1444 | + ((labs(bptr[4] - bptr[2]) + labs(bptr[4] - bptr[8]) +
|
---|
1445 | + labs(bptr[5] - bptr[1]) + labs(bptr[5] - bptr[7])) << 1) +
|
---|
1446 | + labs(bptr[0] - bptr[6]) + labs(bptr[1] - bptr[7]) +
|
---|
1447 | + labs(bptr[2] - bptr[8]);
|
---|
1448 | + sum = (sum * 6) / 13;
|
---|
1449 | + sums_dir[5] = sum;
|
---|
1450 | +
|
---|
1451 | + /* >> top */
|
---|
1452 | + sum = labs(bptr[5] - bptr[1]) + labs(bptr[5] - bptr[7]) +
|
---|
1453 | + ((labs(bptr[4] - bptr[0]) + labs(bptr[4] - bptr[6]) +
|
---|
1454 | + labs(bptr[3] - bptr[1]) + labs(bptr[3] - bptr[7])) << 1) +
|
---|
1455 | + labs(bptr[2] - bptr[8]) + labs(bptr[1] - bptr[7]) +
|
---|
1456 | + labs(bptr[0] - bptr[6]);
|
---|
1457 | + sum = (sum * 6) / 13;
|
---|
1458 | + sums_dir[6] = sum;
|
---|
1459 | +
|
---|
1460 | + /* ^ top */
|
---|
1461 | + sum = labs(bptr[1] - bptr[3]) + labs(bptr[1] - bptr[5]) +
|
---|
1462 | + ((labs(bptr[4] - bptr[6]) + labs(bptr[4] - bptr[8]) +
|
---|
1463 | + labs(bptr[7] - bptr[3]) + labs(bptr[7] - bptr[5])) << 1) +
|
---|
1464 | + labs(bptr[0] - bptr[2]) + labs(bptr[3] - bptr[5]) +
|
---|
1465 | + labs(bptr[6] - bptr[8]);
|
---|
1466 | + sum = (sum * 6) / 13;
|
---|
1467 | + sums_dir[7] = sum;
|
---|
1468 | +
|
---|
1469 | + /* v top */
|
---|
1470 | + sum = labs(bptr[7] - bptr[3]) + labs(bptr[7] - bptr[5]) +
|
---|
1471 | + ((labs(bptr[4] - bptr[0]) + labs(bptr[4] - bptr[2]) +
|
---|
1472 | + labs(bptr[1] - bptr[3]) + labs(bptr[1] - bptr[5])) << 1) +
|
---|
1473 | + labs(bptr[6] - bptr[8]) + labs(bptr[3] - bptr[5]) +
|
---|
1474 | + labs(bptr[0] - bptr[2]);
|
---|
1475 | + sum = (sum * 6) / 13;
|
---|
1476 | + sums_dir[8] = sum;
|
---|
1477 | +
|
---|
1478 | + best_sum = sums_dir[0];
|
---|
1479 | + for (i = 1; i < 9; i++)
|
---|
1480 | + if (sums_dir[i] < best_sum) best_sum = sums_dir[i];
|
---|
1481 | +
|
---|
1482 | + best_dir = 0;
|
---|
1483 | + for (i = 0, n = 0; i < 9; i++)
|
---|
1484 | + {
|
---|
1485 | + if (sums_dir[i] == best_sum)
|
---|
1486 | + {
|
---|
1487 | + best_dir = i;
|
---|
1488 | + n++;
|
---|
1489 | + }
|
---|
1490 | + }
|
---|
1491 | +
|
---|
1492 | + /* CHECK -- handle zig-zags */
|
---|
1493 | + if (sim_sum == 3)
|
---|
1494 | + {
|
---|
1495 | + if ((best_dir == 0 || best_dir == 1) &&
|
---|
1496 | + sim[0] && sim[1] && sim[4])
|
---|
1497 | + return 1; /* '- */
|
---|
1498 | + if ((best_dir == 0 || best_dir == 2) &&
|
---|
1499 | + sim[3] && sim[6] && sim[7])
|
---|
1500 | + return 2; /* -. */
|
---|
1501 | + if ((best_dir == 0 || best_dir == 3) &&
|
---|
1502 | + sim[0] && sim[3] && sim[6])
|
---|
1503 | + return 4; /* '| */
|
---|
1504 | + if ((best_dir == 0 || best_dir == 4) &&
|
---|
1505 | + sim[1] && sim[4] && sim[7])
|
---|
1506 | + return 5; /* |. */
|
---|
1507 | + }
|
---|
1508 | +
|
---|
1509 | + if (n > 1 && best_sum == sums_dir[0]) return 3; /* \ */
|
---|
1510 | +
|
---|
1511 | + /* best direction uncertain, return non-edge to avoid artifacts */
|
---|
1512 | + if (n > 1) return -1;
|
---|
1513 | +
|
---|
1514 | + /* CHECK -- diagonal intersections */
|
---|
1515 | + if (best_dir == 0 &&
|
---|
1516 | + (sim[1] == sim[4] || sim[3] == sim[6]) &&
|
---|
1517 | + (sim[1] == sim[3] || sim[4] == sim[6]))
|
---|
1518 | + {
|
---|
1519 | + if ((pixels[1] == pixels[3] || pixels[5] == pixels[7]) ||
|
---|
1520 | + ((pixels[0] == pixels[4]) ^ (pixels[8] == pixels[4])))
|
---|
1521 | + {
|
---|
1522 | + if (pixels[2] == pixels[4])
|
---|
1523 | + return 16; /* \' */
|
---|
1524 | + if (pixels[6] == pixels[4])
|
---|
1525 | + return 17; /* .\ */
|
---|
1526 | + }
|
---|
1527 | +
|
---|
1528 | + if (sim_sum == 3 && sim[0] && sim[7] &&
|
---|
1529 | + pixels[1] == pixels[3] && pixels[3] == pixels[5] &&
|
---|
1530 | + pixels[5] == pixels[7])
|
---|
1531 | + {
|
---|
1532 | + if (sim[2])
|
---|
1533 | + return 16; /* \' */
|
---|
1534 | + if (sim[5])
|
---|
1535 | + return 17; /* .\ */
|
---|
1536 | + }
|
---|
1537 | +
|
---|
1538 | + if (sim_sum == 3 && sim[2] && sim[5])
|
---|
1539 | + {
|
---|
1540 | + if (sim[0])
|
---|
1541 | + return 18; /* '/ */
|
---|
1542 | + if (sim[7])
|
---|
1543 | + return 19; /* /. */
|
---|
1544 | + }
|
---|
1545 | + }
|
---|
1546 | +
|
---|
1547 | + if (best_dir >= 5)
|
---|
1548 | + ok_arrow_flag = check_arrows(best_dir, pixels, sim, 0);
|
---|
1549 | +
|
---|
1550 | + switch(best_dir)
|
---|
1551 | + {
|
---|
1552 | + case 1:
|
---|
1553 | + return 1; /* '- */
|
---|
1554 | + break;
|
---|
1555 | + case 2:
|
---|
1556 | + return 2; /* -. */
|
---|
1557 | + break;
|
---|
1558 | + case 3:
|
---|
1559 | + return 4; /* '| */
|
---|
1560 | + break;
|
---|
1561 | + case 4:
|
---|
1562 | + return 5; /* |. */
|
---|
1563 | + break;
|
---|
1564 | + case 5:
|
---|
1565 | + if (ok_arrow_flag)
|
---|
1566 | + return 12; /* < */
|
---|
1567 | + break;
|
---|
1568 | + case 6:
|
---|
1569 | + if (ok_arrow_flag)
|
---|
1570 | + return 13; /* > */
|
---|
1571 | + break;
|
---|
1572 | + case 7:
|
---|
1573 | + if (ok_arrow_flag)
|
---|
1574 | + return 14; /* ^ */
|
---|
1575 | + break;
|
---|
1576 | + case 8:
|
---|
1577 | + if (ok_arrow_flag)
|
---|
1578 | + return 15; /* V */
|
---|
1579 | + break;
|
---|
1580 | + case 0:
|
---|
1581 | + default:
|
---|
1582 | + return 3; /* \ */
|
---|
1583 | + break;
|
---|
1584 | + }
|
---|
1585 | +
|
---|
1586 | + break;
|
---|
1587 | +
|
---|
1588 | + case '/':
|
---|
1589 | +
|
---|
1590 | + /* CHECK -- handle noisy half-diags */
|
---|
1591 | + if (sim_sum == 1)
|
---|
1592 | + {
|
---|
1593 | + if (pixels[1] == pixels[3] && pixels[3] == pixels[5] &&
|
---|
1594 | + pixels[5] == pixels[7])
|
---|
1595 | + {
|
---|
1596 | + if (pixels[0] != pixels[1] && pixels[8] != pixels[1])
|
---|
1597 | + {
|
---|
1598 | + sum = labs(bptr[0] - bptr[4]) +
|
---|
1599 | + labs(bptr[8] - bptr[4]);
|
---|
1600 | +
|
---|
1601 | + if (sim[2] && sum < (labs(bptr[6] - bptr[4]) << 1))
|
---|
1602 | + {
|
---|
1603 | + if (bptr[4] > bptr[6])
|
---|
1604 | + {
|
---|
1605 | + if (bptr[0] > bptr[4] &&
|
---|
1606 | + bptr[8] > bptr[4])
|
---|
1607 | + return 16; /* \' */
|
---|
1608 | + }
|
---|
1609 | + else
|
---|
1610 | + {
|
---|
1611 | + if (bptr[0] < bptr[4] &&
|
---|
1612 | + bptr[8] < bptr[4])
|
---|
1613 | + return 16; /* \' */
|
---|
1614 | + }
|
---|
1615 | + }
|
---|
1616 | +
|
---|
1617 | + if (sim[5] && sum < (labs(bptr[2] - bptr[4]) << 1))
|
---|
1618 | + {
|
---|
1619 | + if (bptr[4] > bptr[2])
|
---|
1620 | + {
|
---|
1621 | + if (bptr[0] > bptr[4] &&
|
---|
1622 | + bptr[8] > bptr[4])
|
---|
1623 | + {
|
---|
1624 | + if (pixels[6] == pixels[4])
|
---|
1625 | + return 17; /* .\ */
|
---|
1626 | + return 3; /* \ */
|
---|
1627 | + }
|
---|
1628 | + }
|
---|
1629 | + else
|
---|
1630 | + {
|
---|
1631 | + if (bptr[0] < bptr[4] &&
|
---|
1632 | + bptr[8] < bptr[4])
|
---|
1633 | + {
|
---|
1634 | + if (pixels[6] == pixels[4])
|
---|
1635 | + return 17; /* .\ */
|
---|
1636 | + return 3; /* \ */
|
---|
1637 | + }
|
---|
1638 | + }
|
---|
1639 | + }
|
---|
1640 | + }
|
---|
1641 | + }
|
---|
1642 | +
|
---|
1643 | + if (sim[2] &&
|
---|
1644 | + labs(bptr[4] - bptr[2]) < ((int16)1<<(GREY_SHIFT-3)))
|
---|
1645 | + return 9; /* / */
|
---|
1646 | + if (sim[5] &&
|
---|
1647 | + labs(bptr[4] - bptr[6]) < ((int16)1<<(GREY_SHIFT-3)))
|
---|
1648 | + return 9; /* / */
|
---|
1649 | + }
|
---|
1650 | +
|
---|
1651 | + diff_array[0] = labs(bptr[4] - bptr[0]);
|
---|
1652 | + diff_array[1] = labs(bptr[4] - bptr[5]);
|
---|
1653 | + diff_array[3] = labs(bptr[7] - bptr[8]);
|
---|
1654 | + diff_array[4] = labs(bptr[1] - bptr[2]);
|
---|
1655 | + diff_array[5] = labs(bptr[4] - bptr[3]);
|
---|
1656 | + diff_array[6] = labs(bptr[4] - bptr[8]);
|
---|
1657 | + diff_array[7] = labs(bptr[0] - bptr[1]);
|
---|
1658 | + diff_array[9] = labs(bptr[6] - bptr[7]);
|
---|
1659 | + diff_array[10] = labs(bptr[4] - bptr[7]);
|
---|
1660 | + diff_array[11] = labs(bptr[5] - bptr[8]);
|
---|
1661 | + diff_array[12] = labs(bptr[3] - bptr[6]);
|
---|
1662 | + diff_array[13] = labs(bptr[4] - bptr[1]);
|
---|
1663 | + diff_array[14] = labs(bptr[0] - bptr[3]);
|
---|
1664 | + diff_array[15] = labs(bptr[2] - bptr[5]);
|
---|
1665 | + diff_array[16] = labs(bptr[4] - bptr[2]);
|
---|
1666 | + diff_array[17] = labs(bptr[1] - bptr[3]);
|
---|
1667 | + diff_array[18] = labs(bptr[4] - bptr[6]);
|
---|
1668 | + diff_array[19] = labs(bptr[5] - bptr[7]);
|
---|
1669 | + diff_array[20] = labs(bptr[0] - bptr[2]);
|
---|
1670 | + diff_array[21] = labs(bptr[6] - bptr[8]);
|
---|
1671 | + diff_array[22] = labs(bptr[0] - bptr[6]);
|
---|
1672 | + diff_array[23] = labs(bptr[2] - bptr[8]);
|
---|
1673 | +
|
---|
1674 | + /* |' */
|
---|
1675 | + sums_dir[1] = diff_array[10] + diff_array[12] + diff_array[16] +
|
---|
1676 | + diff_array[17] + (diff_array[11] << 1);
|
---|
1677 | + /* |' alt */
|
---|
1678 | + sum = diff_array[16] + diff_array[10] + diff_array[7] +
|
---|
1679 | + diff_array[14] + diff_array[12] + diff_array[23];
|
---|
1680 | + if (sum < sums_dir[1])
|
---|
1681 | + sums_dir[1] = sum;
|
---|
1682 | +
|
---|
1683 | + /* .| */
|
---|
1684 | + sums_dir[2] = diff_array[13] + diff_array[15] + diff_array[18] +
|
---|
1685 | + diff_array[19] + (diff_array[14] << 1);
|
---|
1686 | + /* .| alt */
|
---|
1687 | + sum = diff_array[18] + diff_array[13] + diff_array[3] +
|
---|
1688 | + diff_array[11] + diff_array[15] + diff_array[22];
|
---|
1689 | + if (sum < sums_dir[2])
|
---|
1690 | + sums_dir[2] = sum;
|
---|
1691 | +
|
---|
1692 | + /* -' */
|
---|
1693 | + sums_dir[3] = diff_array[5] + diff_array[9] + diff_array[16] +
|
---|
1694 | + diff_array[19] + (diff_array[7] << 1);
|
---|
1695 | + /* -' alt */
|
---|
1696 | + sum = diff_array[16] + diff_array[5] + diff_array[11] +
|
---|
1697 | + diff_array[3] + diff_array[9] + diff_array[20];
|
---|
1698 | + if (sum < sums_dir[3])
|
---|
1699 | + sums_dir[3] = sum;
|
---|
1700 | +
|
---|
1701 | + /* .- */
|
---|
1702 | + sums_dir[4] = diff_array[1] + diff_array[4] + diff_array[17] +
|
---|
1703 | + diff_array[18] + (diff_array[3] << 1);
|
---|
1704 | + /* .- alt */
|
---|
1705 | + sum = diff_array[18] + diff_array[1] + diff_array[14] +
|
---|
1706 | + diff_array[7] + diff_array[4] + diff_array[21];
|
---|
1707 | + if (sum < sums_dir[4])
|
---|
1708 | + sums_dir[4] = sum;
|
---|
1709 | +
|
---|
1710 | + /* / 135 */
|
---|
1711 | + sums_dir[0] = diff_array[16] + diff_array[18] +
|
---|
1712 | + (diff_array[17] << 1) + (diff_array[19] << 1);
|
---|
1713 | +
|
---|
1714 | + /* << top */
|
---|
1715 | + sum = labs(bptr[3] - bptr[1]) + labs(bptr[3] - bptr[7]) +
|
---|
1716 | + ((labs(bptr[4] - bptr[2]) + labs(bptr[4] - bptr[8]) +
|
---|
1717 | + labs(bptr[5] - bptr[1]) + labs(bptr[5] - bptr[7])) << 1) +
|
---|
1718 | + labs(bptr[0] - bptr[6]) + labs(bptr[1] - bptr[7]) +
|
---|
1719 | + labs(bptr[2] - bptr[8]);
|
---|
1720 | + sum = (sum * 6) / 13;
|
---|
1721 | + sums_dir[5] = sum;
|
---|
1722 | +
|
---|
1723 | + /* >> top */
|
---|
1724 | + sum = labs(bptr[5] - bptr[1]) + labs(bptr[5] - bptr[7]) +
|
---|
1725 | + ((labs(bptr[4] - bptr[0]) + labs(bptr[4] - bptr[6]) +
|
---|
1726 | + labs(bptr[3] - bptr[1]) + labs(bptr[3] - bptr[7])) << 1) +
|
---|
1727 | + labs(bptr[2] - bptr[8]) + labs(bptr[1] - bptr[7]) +
|
---|
1728 | + labs(bptr[0] - bptr[6]);
|
---|
1729 | + sum = (sum * 6) / 13;
|
---|
1730 | + sums_dir[6] = sum;
|
---|
1731 | +
|
---|
1732 | + /* ^ top */
|
---|
1733 | + sum = labs(bptr[1] - bptr[3]) + labs(bptr[1] - bptr[5]) +
|
---|
1734 | + ((labs(bptr[4] - bptr[6]) + labs(bptr[4] - bptr[8]) +
|
---|
1735 | + labs(bptr[7] - bptr[3]) + labs(bptr[7] - bptr[5])) << 1) +
|
---|
1736 | + labs(bptr[0] - bptr[2]) + labs(bptr[3] - bptr[5]) +
|
---|
1737 | + labs(bptr[6] - bptr[8]);
|
---|
1738 | + sum = (sum * 6) / 13;
|
---|
1739 | + sums_dir[7] = sum;
|
---|
1740 | +
|
---|
1741 | + /* v top */
|
---|
1742 | + sum = labs(bptr[7] - bptr[3]) + labs(bptr[7] - bptr[5]) +
|
---|
1743 | + ((labs(bptr[4] - bptr[0]) + labs(bptr[4] - bptr[2]) +
|
---|
1744 | + labs(bptr[1] - bptr[3]) + labs(bptr[1] - bptr[5])) << 1) +
|
---|
1745 | + labs(bptr[6] - bptr[8]) + labs(bptr[3] - bptr[5]) +
|
---|
1746 | + labs(bptr[0] - bptr[2]);
|
---|
1747 | + sum = (sum * 6) / 13;
|
---|
1748 | + sums_dir[8] = sum;
|
---|
1749 | +
|
---|
1750 | + best_sum = sums_dir[0];
|
---|
1751 | + for (i = 1; i < 9; i++)
|
---|
1752 | + if (sums_dir[i] < best_sum) best_sum = sums_dir[i];
|
---|
1753 | +
|
---|
1754 | + best_dir = 0;
|
---|
1755 | + for (i = 0, n = 0; i < 9; i++)
|
---|
1756 | + {
|
---|
1757 | + if (sums_dir[i] == best_sum)
|
---|
1758 | + {
|
---|
1759 | + best_dir = i;
|
---|
1760 | + n++;
|
---|
1761 | + }
|
---|
1762 | + }
|
---|
1763 | +
|
---|
1764 | + /* CHECK -- handle zig-zags */
|
---|
1765 | + if (sim_sum == 3)
|
---|
1766 | + {
|
---|
1767 | + if ((best_dir == 0 || best_dir == 1) &&
|
---|
1768 | + sim[2] && sim[4] && sim[6])
|
---|
1769 | + return 7; /* |' */
|
---|
1770 | + if ((best_dir == 0 || best_dir == 2) &&
|
---|
1771 | + sim[1] && sim[3] && sim[5])
|
---|
1772 | + return 8; /* .| */
|
---|
1773 | + if ((best_dir == 0 || best_dir == 3) &&
|
---|
1774 | + sim[1] && sim[2] && sim[3])
|
---|
1775 | + return 10; /* -' */
|
---|
1776 | + if ((best_dir == 0 || best_dir == 4) &&
|
---|
1777 | + sim[4] && sim[5] && sim[6])
|
---|
1778 | + return 11; /* .- */
|
---|
1779 | + }
|
---|
1780 | +
|
---|
1781 | + if (n > 1 && best_sum == sums_dir[0]) return 9; /* / */
|
---|
1782 | +
|
---|
1783 | + /* best direction uncertain, return non-edge to avoid artifacts */
|
---|
1784 | + if (n > 1) return -1;
|
---|
1785 | +
|
---|
1786 | + /* CHECK -- diagonal intersections */
|
---|
1787 | + if (best_dir == 0 &&
|
---|
1788 | + (sim[1] == sim[3] || sim[4] == sim[6]) &&
|
---|
1789 | + (sim[1] == sim[4] || sim[3] == sim[6]))
|
---|
1790 | + {
|
---|
1791 | + if ((pixels[1] == pixels[5] || pixels[3] == pixels[7]) ||
|
---|
1792 | + ((pixels[2] == pixels[4]) ^ (pixels[6] == pixels[4])))
|
---|
1793 | + {
|
---|
1794 | + if (pixels[0] == pixels[4])
|
---|
1795 | + return 18; /* '/ */
|
---|
1796 | + if (pixels[8] == pixels[4])
|
---|
1797 | + return 19; /* /. */
|
---|
1798 | + }
|
---|
1799 | +
|
---|
1800 | + if (sim_sum == 3 && sim[2] && sim[5] &&
|
---|
1801 | + pixels[1] == pixels[3] && pixels[3] == pixels[5] &&
|
---|
1802 | + pixels[5] == pixels[7])
|
---|
1803 | + {
|
---|
1804 | + if (sim[0])
|
---|
1805 | + return 18; /* '/ */
|
---|
1806 | + if (sim[7])
|
---|
1807 | + return 19; /* /. */
|
---|
1808 | + }
|
---|
1809 | +
|
---|
1810 | + if (sim_sum == 3 && sim[0] && sim[7])
|
---|
1811 | + {
|
---|
1812 | + if (sim[2])
|
---|
1813 | + return 16; /* \' */
|
---|
1814 | + if (sim[5])
|
---|
1815 | + return 17; /* .\ */
|
---|
1816 | + }
|
---|
1817 | + }
|
---|
1818 | +
|
---|
1819 | + if (best_dir >= 5)
|
---|
1820 | + ok_arrow_flag = check_arrows(best_dir, pixels, sim, 0);
|
---|
1821 | +
|
---|
1822 | + switch(best_dir)
|
---|
1823 | + {
|
---|
1824 | + case 1:
|
---|
1825 | + return 7; /* |' */
|
---|
1826 | + break;
|
---|
1827 | + case 2:
|
---|
1828 | + return 8; /* .| */
|
---|
1829 | + break;
|
---|
1830 | + case 3:
|
---|
1831 | + return 10; /* -' */
|
---|
1832 | + break;
|
---|
1833 | + case 4:
|
---|
1834 | + return 11; /* .- */
|
---|
1835 | + break;
|
---|
1836 | + case 5:
|
---|
1837 | + if (ok_arrow_flag)
|
---|
1838 | + return 12; /* < */
|
---|
1839 | + break;
|
---|
1840 | + case 6:
|
---|
1841 | + if (ok_arrow_flag)
|
---|
1842 | + return 13; /* > */
|
---|
1843 | + break;
|
---|
1844 | + case 7:
|
---|
1845 | + if (ok_arrow_flag)
|
---|
1846 | + return 14; /* ^ */
|
---|
1847 | + break;
|
---|
1848 | + case 8:
|
---|
1849 | + if (ok_arrow_flag)
|
---|
1850 | + return 15; /* V */
|
---|
1851 | + break;
|
---|
1852 | + break;
|
---|
1853 | + case 0:
|
---|
1854 | + default:
|
---|
1855 | + return 9; /* / */
|
---|
1856 | + break;
|
---|
1857 | + }
|
---|
1858 | +
|
---|
1859 | + break;
|
---|
1860 | +
|
---|
1861 | + case '*':
|
---|
1862 | + return 127;
|
---|
1863 | + break;
|
---|
1864 | +
|
---|
1865 | + case '0':
|
---|
1866 | + default:
|
---|
1867 | + return -1;
|
---|
1868 | + break;
|
---|
1869 | + }
|
---|
1870 | +
|
---|
1871 | + return -1;
|
---|
1872 | +}
|
---|
1873 | +
|
---|
1874 | +
|
---|
1875 | +
|
---|
1876 | +/* "Chess Knight" patterns can be mis-detected, fix easy cases. */
|
---|
1877 | +int fix_knights(int sub_type, uint16 *pixels, int8 *sim)
|
---|
1878 | +{
|
---|
1879 | + uint16 center = pixels[4];
|
---|
1880 | + int dir = sub_type;
|
---|
1881 | + int n = 0;
|
---|
1882 | + int flags[12] = {0};
|
---|
1883 | + int ok_orig_flag = 0;
|
---|
1884 | +
|
---|
1885 | + /*
|
---|
1886 | + * - '- -. \ '| |. | |' .| / -' .-
|
---|
1887 | + *
|
---|
1888 | + * 0 1 2 3 4 5 6 7 8 9 10 11
|
---|
1889 | + *
|
---|
1890 | + */
|
---|
1891 | +
|
---|
1892 | + /* check to see if original knight is ok */
|
---|
1893 | + switch(sub_type)
|
---|
1894 | + {
|
---|
1895 | + case 1: /* '- */
|
---|
1896 | + if (sim[0] && sim[4] &&
|
---|
1897 | + !(sim_sum == 3 && sim[5] &&
|
---|
1898 | + pixels[0] == pixels[4] && pixels[6] == pixels[4]))
|
---|
1899 | + ok_orig_flag = 1;
|
---|
1900 | + break;
|
---|
1901 | +
|
---|
1902 | + case 2: /* -. */
|
---|
1903 | + if (sim[3] && sim[7] &&
|
---|
1904 | + !(sim_sum == 3 && sim[2] &&
|
---|
1905 | + pixels[2] == pixels[4] && pixels[8] == pixels[4]))
|
---|
1906 | + ok_orig_flag = 1;
|
---|
1907 | + break;
|
---|
1908 | +
|
---|
1909 | + case 4: /* '| */
|
---|
1910 | + if (sim[0] && sim[6] &&
|
---|
1911 | + !(sim_sum == 3 && sim[2] &&
|
---|
1912 | + pixels[0] == pixels[4] && pixels[2] == pixels[4]))
|
---|
1913 | + ok_orig_flag = 1;
|
---|
1914 | + break;
|
---|
1915 | +
|
---|
1916 | + case 5: /* |. */
|
---|
1917 | + if (sim[1] && sim[7] &&
|
---|
1918 | + !(sim_sum == 3 && sim[5] &&
|
---|
1919 | + pixels[6] == pixels[4] && pixels[8] == pixels[4]))
|
---|
1920 | + ok_orig_flag = 1;
|
---|
1921 | + break;
|
---|
1922 | +
|
---|
1923 | + case 7: /* |' */
|
---|
1924 | + if (sim[2] && sim[6] &&
|
---|
1925 | + !(sim_sum == 3 && sim[0] &&
|
---|
1926 | + pixels[0] == pixels[4] && pixels[2] == pixels[4]))
|
---|
1927 | + ok_orig_flag = 1;
|
---|
1928 | + break;
|
---|
1929 | +
|
---|
1930 | + case 8: /* .| */
|
---|
1931 | + if (sim[1] && sim[5] &&
|
---|
1932 | + !(sim_sum == 3 && sim[7] &&
|
---|
1933 | + pixels[6] == pixels[4] && pixels[8] == pixels[4]))
|
---|
1934 | + ok_orig_flag = 1;
|
---|
1935 | + break;
|
---|
1936 | +
|
---|
1937 | + case 10: /* -' */
|
---|
1938 | + if (sim[2] && sim[3] &&
|
---|
1939 | + !(sim_sum == 3 && sim[7] &&
|
---|
1940 | + pixels[2] == pixels[4] && pixels[8] == pixels[4]))
|
---|
1941 | + ok_orig_flag = 1;
|
---|
1942 | + break;
|
---|
1943 | +
|
---|
1944 | + case 11: /* .- */
|
---|
1945 | + if (sim[4] && sim[5] &&
|
---|
1946 | + !(sim_sum == 3 && sim[0] &&
|
---|
1947 | + pixels[0] == pixels[4] && pixels[6] == pixels[4]))
|
---|
1948 | + ok_orig_flag = 1;
|
---|
1949 | + break;
|
---|
1950 | +
|
---|
1951 | + default: /* not a knight */
|
---|
1952 | + return sub_type;
|
---|
1953 | + break;
|
---|
1954 | + }
|
---|
1955 | +
|
---|
1956 | + /* look for "better" knights */
|
---|
1957 | + if (center == pixels[0] && center == pixels[5]) /* '- */
|
---|
1958 | + {
|
---|
1959 | + dir = 1;
|
---|
1960 | + flags[dir] = 1;
|
---|
1961 | + n++;
|
---|
1962 | + }
|
---|
1963 | + if (center == pixels[3] && center == pixels[8]) /* -. */
|
---|
1964 | + {
|
---|
1965 | + dir = 2;
|
---|
1966 | + flags[dir] = 1;
|
---|
1967 | + n++;
|
---|
1968 | + }
|
---|
1969 | + if (center == pixels[0] && center == pixels[7]) /* '| */
|
---|
1970 | + {
|
---|
1971 | + dir = 4;
|
---|
1972 | + flags[dir] = 1;
|
---|
1973 | + n++;
|
---|
1974 | + }
|
---|
1975 | + if (center == pixels[1] && center == pixels[8]) /* |. */
|
---|
1976 | + {
|
---|
1977 | + dir = 5;
|
---|
1978 | + flags[dir] = 1;
|
---|
1979 | + n++;
|
---|
1980 | + }
|
---|
1981 | + if (center == pixels[2] && center == pixels[7]) /* |' */
|
---|
1982 | + {
|
---|
1983 | + dir = 7;
|
---|
1984 | + flags[dir] = 1;
|
---|
1985 | + n++;
|
---|
1986 | + }
|
---|
1987 | + if (center == pixels[1] && center == pixels[6]) /* .| */
|
---|
1988 | + {
|
---|
1989 | + dir = 8;
|
---|
1990 | + flags[dir] = 1;
|
---|
1991 | + n++;
|
---|
1992 | + }
|
---|
1993 | + if (center == pixels[3] && center == pixels[2]) /* -' */
|
---|
1994 | + {
|
---|
1995 | + dir = 10;
|
---|
1996 | + flags[dir] = 1;
|
---|
1997 | + n++;
|
---|
1998 | + }
|
---|
1999 | + if (center == pixels[6] && center == pixels[5]) /* .- */
|
---|
2000 | + {
|
---|
2001 | + dir = 11;
|
---|
2002 | + flags[dir] = 1;
|
---|
2003 | + n++;
|
---|
2004 | + }
|
---|
2005 | +
|
---|
2006 | + if (n == 0)
|
---|
2007 | + {
|
---|
2008 | + if (ok_orig_flag) return sub_type;
|
---|
2009 | + return -1;
|
---|
2010 | + }
|
---|
2011 | + if (n == 1) return dir;
|
---|
2012 | + if (n == 2)
|
---|
2013 | + {
|
---|
2014 | + /* slanted W patterns */
|
---|
2015 | + if (flags[1] && flags[5]) return 3; /* \ */
|
---|
2016 | + if (flags[2] && flags[4]) return 3; /* \ */
|
---|
2017 | + if (flags[7] && flags[11]) return 9; /* / */
|
---|
2018 | + if (flags[8] && flags[10]) return 9; /* / */
|
---|
2019 | + }
|
---|
2020 | + if (flags[sub_type] && ok_orig_flag) return sub_type;
|
---|
2021 | +
|
---|
2022 | + return -1;
|
---|
2023 | +}
|
---|
2024 | +
|
---|
2025 | +
|
---|
2026 | +
|
---|
2027 | +/* From ScummVM HQ2x/HQ3x scalers (Maxim Stepin and Max Horn) */
|
---|
2028 | +#define highBits 0xF7DEF7DE
|
---|
2029 | +#define lowBits 0x08210821
|
---|
2030 | +#define qhighBits 0xE79CE79C
|
---|
2031 | +#define qlowBits 0x18631863
|
---|
2032 | +#define redblueMask 0xF81F
|
---|
2033 | +#define greenMask 0x07E0
|
---|
2034 | +
|
---|
2035 | +/* From ScummVM HQ2x/HQ3x scalers (Maxim Stepin and Max Horn) */
|
---|
2036 | +/**
|
---|
2037 | + * Interpolate two 16 bit pixel pairs at once with equal weights 1.
|
---|
2038 | + * In particular, A and B can contain two pixels/each in the upper
|
---|
2039 | + * and lower halves.
|
---|
2040 | + */
|
---|
2041 | +uint32 INTERPOLATE(uint32 A, uint32 B)
|
---|
2042 | +{
|
---|
2043 | + return (((A & highBits) >> 1) + ((B & highBits) >> 1) + (A & B & lowBits));
|
---|
2044 | +}
|
---|
2045 | +
|
---|
2046 | +/* From ScummVM HQ2x/HQ3x scalers (Maxim Stepin and Max Horn) */
|
---|
2047 | +/**
|
---|
2048 | + * Interpolate four 16 bit pixel pairs at once with equal weights 1.
|
---|
2049 | + * In particular, A and B can contain two pixels/each in the upper
|
---|
2050 | + * and lower halves.
|
---|
2051 | + */
|
---|
2052 | +uint32 Q_INTERPOLATE(uint32 A, uint32 B, uint32 C, uint32 D)
|
---|
2053 | +{
|
---|
2054 | + uint32 x = ((A & qhighBits) >> 2) + ((B & qhighBits) >> 2) + ((C & qhighBits) >> 2) + ((D & qhighBits) >> 2);
|
---|
2055 | + uint32 y = ((A & qlowBits) + (B & qlowBits) + (C & qlowBits) + (D & qlowBits)) >> 2;
|
---|
2056 | +
|
---|
2057 | + y &= qlowBits;
|
---|
2058 | + return x + y;
|
---|
2059 | +}
|
---|
2060 | +
|
---|
2061 | +
|
---|
2062 | +
|
---|
2063 | +/* Average three pixels together */
|
---|
2064 | +uint16 average_three_pixels(uint16 pixel1, uint16 pixel2, uint16 pixel3)
|
---|
2065 | +{
|
---|
2066 | + uint32 rsum;
|
---|
2067 | + uint16 gsum, bsum;
|
---|
2068 | +
|
---|
2069 | + rsum = (pixel1 & 0xF800);
|
---|
2070 | + rsum += (pixel2 & 0xF800);
|
---|
2071 | + rsum += (pixel3 & 0xF800);
|
---|
2072 | + rsum = div3[rsum >> 11];
|
---|
2073 | +
|
---|
2074 | + gsum = (pixel1 & 0x07E0);
|
---|
2075 | + gsum += (pixel2 & 0x07E0);
|
---|
2076 | + gsum += (pixel3 & 0x07E0);
|
---|
2077 | + gsum = div3[gsum >> 5];
|
---|
2078 | +
|
---|
2079 | + bsum = (pixel1 & 0x001F);
|
---|
2080 | + bsum += (pixel2 & 0x001F);
|
---|
2081 | + bsum += (pixel3 & 0x001F);
|
---|
2082 | + bsum = div3[bsum];
|
---|
2083 | +
|
---|
2084 | + return ((rsum << 11) | (gsum << 5) | bsum);
|
---|
2085 | +}
|
---|
2086 | +
|
---|
2087 | +
|
---|
2088 | +
|
---|
2089 | +/* Interpolate 1/3rd of the way between two pixels */
|
---|
2090 | +uint16 average_one_third(uint16 pixel1, uint16 pixel2)
|
---|
2091 | +{
|
---|
2092 | + uint32 rsum;
|
---|
2093 | + uint16 gsum, bsum;
|
---|
2094 | +
|
---|
2095 | + rsum = (pixel1 & 0xF800) << 1;
|
---|
2096 | + rsum += (pixel2 & 0xF800);
|
---|
2097 | + rsum = div3[rsum >> 11];
|
---|
2098 | +
|
---|
2099 | + gsum = (pixel1 & 0x07E0) << 1;
|
---|
2100 | + gsum += (pixel2 & 0x07E0);
|
---|
2101 | + gsum = div3[gsum >> 5];
|
---|
2102 | +
|
---|
2103 | + bsum = (pixel1 & 0x001F) << 1;
|
---|
2104 | + bsum += (pixel2 & 0x001F);
|
---|
2105 | + bsum = div3[bsum];
|
---|
2106 | +
|
---|
2107 | + return ((rsum << 11) | (gsum << 5) | bsum);
|
---|
2108 | +}
|
---|
2109 | +
|
---|
2110 | +
|
---|
2111 | +
|
---|
2112 | +/* Fill pixel grid without interpolation, using the detected edge */
|
---|
2113 | +void anti_alias_grid_clean_3x(uint8 *dptr, int dstPitch,
|
---|
2114 | + uint16 *pixels, int sub_type, int16 *bptr)
|
---|
2115 | +{
|
---|
2116 | + uint16 *dptr2;
|
---|
2117 | + int16 tmp_grey;
|
---|
2118 | + uint16 center = pixels[4];
|
---|
2119 | + int32 diff1, diff2, diff3;
|
---|
2120 | + uint16 tmp[9];
|
---|
2121 | + uint16 *ptmp;
|
---|
2122 | + int i;
|
---|
2123 | +
|
---|
2124 | + switch (sub_type)
|
---|
2125 | + {
|
---|
2126 | + case 1: /* '- */
|
---|
2127 | + for (i = 0; i < 9; i++)
|
---|
2128 | + tmp[i] = center;
|
---|
2129 | +
|
---|
2130 | + tmp[6] = average_three_pixels(pixels[3], pixels[7], center);
|
---|
2131 | + tmp_grey = chosen_greyscale[tmp[6]];
|
---|
2132 | +#if PARANOID_KNIGHTS
|
---|
2133 | + diff1 = labs(bptr[4] - bptr[3]);
|
---|
2134 | + diff2 = labs(bptr[4] - bptr[7]);
|
---|
2135 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2136 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2137 | + tmp[6] = center;
|
---|
2138 | + else /* choose nearest pixel */
|
---|
2139 | +#endif
|
---|
2140 | + {
|
---|
2141 | + diff1 = calc_pixel_diff_nosqrt(tmp[6], pixels[3]);
|
---|
2142 | + diff2 = calc_pixel_diff_nosqrt(tmp[6], pixels[7]);
|
---|
2143 | + diff3 = calc_pixel_diff_nosqrt(tmp[6], pixels[4]);
|
---|
2144 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2145 | + tmp[6] = pixels[3];
|
---|
2146 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2147 | + tmp[6] = pixels[7];
|
---|
2148 | + else
|
---|
2149 | + tmp[6] = pixels[4];
|
---|
2150 | +
|
---|
2151 | + tmp_grey = chosen_greyscale[tmp[6]];
|
---|
2152 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2153 | + diff2 = labs(bptr[4] - bptr[8]);
|
---|
2154 | + if (diff1 <= diff2)
|
---|
2155 | + tmp[7] = tmp[6];
|
---|
2156 | + }
|
---|
2157 | +
|
---|
2158 | + break;
|
---|
2159 | +
|
---|
2160 | + case 2: /* -. */
|
---|
2161 | + for (i = 0; i < 9; i++)
|
---|
2162 | + tmp[i] = center;
|
---|
2163 | +
|
---|
2164 | + tmp[2] = average_three_pixels(pixels[1], pixels[5], center);
|
---|
2165 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
2166 | +#if PARANOID_KNIGHTS
|
---|
2167 | + diff1 = labs(bptr[4] - bptr[5]);
|
---|
2168 | + diff2 = labs(bptr[4] - bptr[1]);
|
---|
2169 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2170 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2171 | + tmp[2] = center;
|
---|
2172 | + else /* choose nearest pixel */
|
---|
2173 | +#endif
|
---|
2174 | + {
|
---|
2175 | + diff1 = calc_pixel_diff_nosqrt(tmp[2], pixels[1]);
|
---|
2176 | + diff2 = calc_pixel_diff_nosqrt(tmp[2], pixels[5]);
|
---|
2177 | + diff3 = calc_pixel_diff_nosqrt(tmp[2], pixels[4]);
|
---|
2178 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2179 | + tmp[2] = pixels[1];
|
---|
2180 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2181 | + tmp[2] = pixels[5];
|
---|
2182 | + else
|
---|
2183 | + tmp[2] = pixels[4];
|
---|
2184 | +
|
---|
2185 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
2186 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2187 | + diff2 = labs(bptr[4] - bptr[0]);
|
---|
2188 | + if (diff1 <= diff2)
|
---|
2189 | + tmp[1] = tmp[2];
|
---|
2190 | + }
|
---|
2191 | +
|
---|
2192 | + break;
|
---|
2193 | +
|
---|
2194 | + case 3: /* \ */
|
---|
2195 | + case 16: /* \' */
|
---|
2196 | + case 17: /* .\ */
|
---|
2197 | + for (i = 0; i < 9; i++)
|
---|
2198 | + tmp[i] = center;
|
---|
2199 | +
|
---|
2200 | + if (sub_type != 16)
|
---|
2201 | + {
|
---|
2202 | + tmp[2] = average_three_pixels(pixels[1], pixels[5], center);
|
---|
2203 | + diff1 = calc_pixel_diff_nosqrt(tmp[2], pixels[1]);
|
---|
2204 | + diff2 = calc_pixel_diff_nosqrt(tmp[2], pixels[5]);
|
---|
2205 | + diff3 = calc_pixel_diff_nosqrt(tmp[2], pixels[4]);
|
---|
2206 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2207 | + tmp[2] = pixels[1];
|
---|
2208 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2209 | + tmp[2] = pixels[5];
|
---|
2210 | + else
|
---|
2211 | + tmp[2] = pixels[4];
|
---|
2212 | + }
|
---|
2213 | +
|
---|
2214 | + if (sub_type != 17)
|
---|
2215 | + {
|
---|
2216 | + tmp[6] = average_three_pixels(pixels[3], pixels[7], center);
|
---|
2217 | + diff1 = calc_pixel_diff_nosqrt(tmp[6], pixels[3]);
|
---|
2218 | + diff2 = calc_pixel_diff_nosqrt(tmp[6], pixels[7]);
|
---|
2219 | + diff3 = calc_pixel_diff_nosqrt(tmp[6], pixels[4]);
|
---|
2220 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2221 | + tmp[6] = pixels[3];
|
---|
2222 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2223 | + tmp[6] = pixels[7];
|
---|
2224 | + else
|
---|
2225 | + tmp[6] = pixels[4];
|
---|
2226 | + }
|
---|
2227 | +
|
---|
2228 | + break;
|
---|
2229 | +
|
---|
2230 | + case 4: /* '| */
|
---|
2231 | + for (i = 0; i < 9; i++)
|
---|
2232 | + tmp[i] = center;
|
---|
2233 | +
|
---|
2234 | + tmp[2] = average_three_pixels(pixels[1], pixels[5], center);
|
---|
2235 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
2236 | +#if PARANOID_KNIGHTS
|
---|
2237 | + diff1 = labs(bptr[4] - bptr[1]);
|
---|
2238 | + diff2 = labs(bptr[4] - bptr[5]);
|
---|
2239 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2240 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2241 | + tmp[2] = center;
|
---|
2242 | + else /* choose nearest pixel */
|
---|
2243 | +#endif
|
---|
2244 | + {
|
---|
2245 | + diff1 = calc_pixel_diff_nosqrt(tmp[2], pixels[1]);
|
---|
2246 | + diff2 = calc_pixel_diff_nosqrt(tmp[2], pixels[5]);
|
---|
2247 | + diff3 = calc_pixel_diff_nosqrt(tmp[2], pixels[4]);
|
---|
2248 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2249 | + tmp[2] = pixels[1];
|
---|
2250 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2251 | + tmp[2] = pixels[5];
|
---|
2252 | + else
|
---|
2253 | + tmp[2] = pixels[4];
|
---|
2254 | +
|
---|
2255 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
2256 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2257 | + diff2 = labs(bptr[4] - bptr[8]);
|
---|
2258 | + if (diff1 <= diff2)
|
---|
2259 | + tmp[5] = tmp[2];
|
---|
2260 | + }
|
---|
2261 | +
|
---|
2262 | + break;
|
---|
2263 | +
|
---|
2264 | + case 5: /* |. */
|
---|
2265 | + for (i = 0; i < 9; i++)
|
---|
2266 | + tmp[i] = center;
|
---|
2267 | +
|
---|
2268 | + tmp[6] = average_three_pixels(pixels[3], pixels[7], center);
|
---|
2269 | + tmp_grey = chosen_greyscale[tmp[6]];
|
---|
2270 | +#if PARANOID_KNIGHTS
|
---|
2271 | + diff1 = labs(bptr[4] - bptr[7]);
|
---|
2272 | + diff2 = labs(bptr[4] - bptr[3]);
|
---|
2273 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2274 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2275 | + tmp[6] = center;
|
---|
2276 | + else /* choose nearest pixel */
|
---|
2277 | +#endif
|
---|
2278 | + {
|
---|
2279 | + diff1 = calc_pixel_diff_nosqrt(tmp[6], pixels[3]);
|
---|
2280 | + diff2 = calc_pixel_diff_nosqrt(tmp[6], pixels[7]);
|
---|
2281 | + diff3 = calc_pixel_diff_nosqrt(tmp[6], pixels[4]);
|
---|
2282 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2283 | + tmp[6] = pixels[3];
|
---|
2284 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2285 | + tmp[6] = pixels[7];
|
---|
2286 | + else
|
---|
2287 | + tmp[6] = pixels[4];
|
---|
2288 | +
|
---|
2289 | + tmp_grey = chosen_greyscale[tmp[6]];
|
---|
2290 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2291 | + diff2 = labs(bptr[4] - bptr[0]);
|
---|
2292 | + if (diff1 <= diff2)
|
---|
2293 | + tmp[3] = tmp[6];
|
---|
2294 | + }
|
---|
2295 | +
|
---|
2296 | + break;
|
---|
2297 | +
|
---|
2298 | + case 7: /* |' */
|
---|
2299 | + for (i = 0; i < 9; i++)
|
---|
2300 | + tmp[i] = center;
|
---|
2301 | +
|
---|
2302 | + tmp[0] = average_three_pixels(pixels[1], pixels[3], center);
|
---|
2303 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
2304 | +#if PARANOID_KNIGHTS
|
---|
2305 | + diff1 = labs(bptr[4] - bptr[1]);
|
---|
2306 | + diff2 = labs(bptr[4] - bptr[3]);
|
---|
2307 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2308 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2309 | + tmp[0] = center;
|
---|
2310 | + else /* choose nearest pixel */
|
---|
2311 | +#endif
|
---|
2312 | + {
|
---|
2313 | + diff1 = calc_pixel_diff_nosqrt(tmp[0], pixels[1]);
|
---|
2314 | + diff2 = calc_pixel_diff_nosqrt(tmp[0], pixels[3]);
|
---|
2315 | + diff3 = calc_pixel_diff_nosqrt(tmp[0], pixels[4]);
|
---|
2316 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2317 | + tmp[0] = pixels[1];
|
---|
2318 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2319 | + tmp[0] = pixels[3];
|
---|
2320 | + else
|
---|
2321 | + tmp[0] = pixels[4];
|
---|
2322 | +
|
---|
2323 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
2324 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2325 | + diff2 = labs(bptr[4] - bptr[6]);
|
---|
2326 | + if (diff1 <= diff2)
|
---|
2327 | + tmp[3] = tmp[0];
|
---|
2328 | + }
|
---|
2329 | +
|
---|
2330 | + break;
|
---|
2331 | +
|
---|
2332 | + case 8: /* .| */
|
---|
2333 | + for (i = 0; i < 9; i++)
|
---|
2334 | + tmp[i] = center;
|
---|
2335 | +
|
---|
2336 | + tmp[8] = average_three_pixels(pixels[5], pixels[7], center);
|
---|
2337 | + tmp_grey = chosen_greyscale[tmp[8]];
|
---|
2338 | +#if PARANOID_KNIGHTS
|
---|
2339 | + diff1 = labs(bptr[4] - bptr[7]);
|
---|
2340 | + diff2 = labs(bptr[4] - bptr[5]);
|
---|
2341 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2342 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2343 | + tmp[8] = center;
|
---|
2344 | + else /* choose nearest pixel */
|
---|
2345 | +#endif
|
---|
2346 | + {
|
---|
2347 | + diff1 = calc_pixel_diff_nosqrt(tmp[8], pixels[5]);
|
---|
2348 | + diff2 = calc_pixel_diff_nosqrt(tmp[8], pixels[7]);
|
---|
2349 | + diff3 = calc_pixel_diff_nosqrt(tmp[8], pixels[4]);
|
---|
2350 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2351 | + tmp[8] = pixels[5];
|
---|
2352 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2353 | + tmp[8] = pixels[7];
|
---|
2354 | + else
|
---|
2355 | + tmp[8] = pixels[4];
|
---|
2356 | +
|
---|
2357 | + tmp_grey = chosen_greyscale[tmp[8]];
|
---|
2358 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2359 | + diff2 = labs(bptr[4] - bptr[2]);
|
---|
2360 | + if (diff1 <= diff2)
|
---|
2361 | + tmp[5] = tmp[8];
|
---|
2362 | + }
|
---|
2363 | +
|
---|
2364 | + break;
|
---|
2365 | +
|
---|
2366 | + case 9: /* / */
|
---|
2367 | + case 18: /* '/ */
|
---|
2368 | + case 19: /* /. */
|
---|
2369 | + for (i = 0; i < 9; i++)
|
---|
2370 | + tmp[i] = center;
|
---|
2371 | +
|
---|
2372 | + if (sub_type != 18)
|
---|
2373 | + {
|
---|
2374 | + tmp[0] = average_three_pixels(pixels[1], pixels[3], center);
|
---|
2375 | + diff1 = calc_pixel_diff_nosqrt(tmp[0], pixels[1]);
|
---|
2376 | + diff2 = calc_pixel_diff_nosqrt(tmp[0], pixels[3]);
|
---|
2377 | + diff3 = calc_pixel_diff_nosqrt(tmp[0], pixels[4]);
|
---|
2378 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2379 | + tmp[0] = pixels[1];
|
---|
2380 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2381 | + tmp[0] = pixels[3];
|
---|
2382 | + else
|
---|
2383 | + tmp[0] = pixels[4];
|
---|
2384 | + }
|
---|
2385 | +
|
---|
2386 | + if (sub_type != 19)
|
---|
2387 | + {
|
---|
2388 | + tmp[8] = average_three_pixels(pixels[5], pixels[7], center);
|
---|
2389 | + diff1 = calc_pixel_diff_nosqrt(tmp[8], pixels[5]);
|
---|
2390 | + diff2 = calc_pixel_diff_nosqrt(tmp[8], pixels[7]);
|
---|
2391 | + diff3 = calc_pixel_diff_nosqrt(tmp[8], pixels[4]);
|
---|
2392 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2393 | + tmp[8] = pixels[5];
|
---|
2394 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2395 | + tmp[8] = pixels[7];
|
---|
2396 | + else
|
---|
2397 | + tmp[8] = pixels[4];
|
---|
2398 | + }
|
---|
2399 | +
|
---|
2400 | + break;
|
---|
2401 | +
|
---|
2402 | + case 10: /* -' */
|
---|
2403 | + for (i = 0; i < 9; i++)
|
---|
2404 | + tmp[i] = center;
|
---|
2405 | +
|
---|
2406 | + tmp[8] = average_three_pixels(pixels[5], pixels[7], center);
|
---|
2407 | + tmp_grey = chosen_greyscale[tmp[8]];
|
---|
2408 | +#if PARANOID_KNIGHTS
|
---|
2409 | + diff1 = labs(bptr[4] - bptr[5]);
|
---|
2410 | + diff2 = labs(bptr[4] - bptr[7]);
|
---|
2411 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2412 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2413 | + tmp[8] = center;
|
---|
2414 | + else /* choose nearest pixel */
|
---|
2415 | +#endif
|
---|
2416 | + {
|
---|
2417 | + diff1 = calc_pixel_diff_nosqrt(tmp[8], pixels[5]);
|
---|
2418 | + diff2 = calc_pixel_diff_nosqrt(tmp[8], pixels[7]);
|
---|
2419 | + diff3 = calc_pixel_diff_nosqrt(tmp[8], pixels[4]);
|
---|
2420 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2421 | + tmp[8] = pixels[5];
|
---|
2422 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2423 | + tmp[8] = pixels[7];
|
---|
2424 | + else
|
---|
2425 | + tmp[8] = pixels[4];
|
---|
2426 | +
|
---|
2427 | + tmp_grey = chosen_greyscale[tmp[8]];
|
---|
2428 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2429 | + diff2 = labs(bptr[4] - bptr[6]);
|
---|
2430 | + if (diff1 <= diff2)
|
---|
2431 | + tmp[7] = tmp[8];
|
---|
2432 | + }
|
---|
2433 | +
|
---|
2434 | + break;
|
---|
2435 | +
|
---|
2436 | + case 11: /* .- */
|
---|
2437 | + for (i = 0; i < 9; i++)
|
---|
2438 | + tmp[i] = center;
|
---|
2439 | +
|
---|
2440 | + tmp[0] = average_three_pixels(pixels[1], pixels[3], center);
|
---|
2441 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
2442 | +#if PARANOID_KNIGHTS
|
---|
2443 | + diff1 = labs(bptr[4] - bptr[3]);
|
---|
2444 | + diff2 = labs(bptr[4] - bptr[1]);
|
---|
2445 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2446 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2447 | + tmp[0] = center;
|
---|
2448 | + else /* choose nearest pixel */
|
---|
2449 | +#endif
|
---|
2450 | + {
|
---|
2451 | + diff1 = calc_pixel_diff_nosqrt(tmp[0], pixels[1]);
|
---|
2452 | + diff2 = calc_pixel_diff_nosqrt(tmp[0], pixels[3]);
|
---|
2453 | + diff3 = calc_pixel_diff_nosqrt(tmp[0], pixels[4]);
|
---|
2454 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2455 | + tmp[0] = pixels[1];
|
---|
2456 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2457 | + tmp[0] = pixels[3];
|
---|
2458 | + else
|
---|
2459 | + tmp[0] = pixels[4];
|
---|
2460 | +
|
---|
2461 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
2462 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2463 | + diff2 = labs(bptr[4] - bptr[2]);
|
---|
2464 | + if (diff1 <= diff2)
|
---|
2465 | + tmp[1] = tmp[0];
|
---|
2466 | + }
|
---|
2467 | +
|
---|
2468 | + break;
|
---|
2469 | +
|
---|
2470 | + case 12: /* < */
|
---|
2471 | + for (i = 0; i < 9; i++)
|
---|
2472 | + tmp[i] = center;
|
---|
2473 | +
|
---|
2474 | + tmp[0] = average_three_pixels(pixels[1], pixels[3], center);
|
---|
2475 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
2476 | +#if PARANOID_ARROWS
|
---|
2477 | + diff1 = labs(bptr[4] - bptr[1]);
|
---|
2478 | + diff2 = labs(bptr[4] - bptr[3]);
|
---|
2479 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2480 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2481 | + tmp[0] = center;
|
---|
2482 | + else /* choose nearest pixel */
|
---|
2483 | +#endif
|
---|
2484 | + {
|
---|
2485 | + diff1 = calc_pixel_diff_nosqrt(tmp[0], pixels[1]);
|
---|
2486 | + diff2 = calc_pixel_diff_nosqrt(tmp[0], pixels[3]);
|
---|
2487 | + diff3 = calc_pixel_diff_nosqrt(tmp[0], pixels[4]);
|
---|
2488 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2489 | + tmp[0] = pixels[1];
|
---|
2490 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2491 | + tmp[0] = pixels[3];
|
---|
2492 | + else
|
---|
2493 | + tmp[0] = pixels[4];
|
---|
2494 | + }
|
---|
2495 | +
|
---|
2496 | + tmp[6] = average_three_pixels(pixels[3], pixels[7], center);
|
---|
2497 | + tmp_grey = chosen_greyscale[tmp[6]];
|
---|
2498 | +#if PARANOID_ARROWS
|
---|
2499 | + diff1 = labs(bptr[4] - bptr[3]);
|
---|
2500 | + diff2 = labs(bptr[4] - bptr[7]);
|
---|
2501 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2502 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2503 | + tmp[6] = center;
|
---|
2504 | + else /* choose nearest pixel */
|
---|
2505 | +#endif
|
---|
2506 | + {
|
---|
2507 | + diff1 = calc_pixel_diff_nosqrt(tmp[6], pixels[3]);
|
---|
2508 | + diff2 = calc_pixel_diff_nosqrt(tmp[6], pixels[7]);
|
---|
2509 | + diff3 = calc_pixel_diff_nosqrt(tmp[6], pixels[4]);
|
---|
2510 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2511 | + tmp[6] = pixels[3];
|
---|
2512 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2513 | + tmp[6] = pixels[7];
|
---|
2514 | + else
|
---|
2515 | + tmp[6] = pixels[4];
|
---|
2516 | + }
|
---|
2517 | +
|
---|
2518 | + break;
|
---|
2519 | +
|
---|
2520 | + case 13: /* > */
|
---|
2521 | + for (i = 0; i < 9; i++)
|
---|
2522 | + tmp[i] = center;
|
---|
2523 | +
|
---|
2524 | + tmp[2] = average_three_pixels(pixels[1], pixels[5], center);
|
---|
2525 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
2526 | +#if PARANOID_ARROWS
|
---|
2527 | + diff1 = labs(bptr[4] - bptr[5]);
|
---|
2528 | + diff2 = labs(bptr[4] - bptr[1]);
|
---|
2529 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2530 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2531 | + tmp[2] = center;
|
---|
2532 | + else /* choose nearest pixel */
|
---|
2533 | +#endif
|
---|
2534 | + {
|
---|
2535 | + diff1 = calc_pixel_diff_nosqrt(tmp[2], pixels[1]);
|
---|
2536 | + diff2 = calc_pixel_diff_nosqrt(tmp[2], pixels[5]);
|
---|
2537 | + diff3 = calc_pixel_diff_nosqrt(tmp[2], pixels[4]);
|
---|
2538 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2539 | + tmp[2] = pixels[1];
|
---|
2540 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2541 | + tmp[2] = pixels[5];
|
---|
2542 | + else
|
---|
2543 | + tmp[2] = pixels[4];
|
---|
2544 | + }
|
---|
2545 | +
|
---|
2546 | + tmp[8] = average_three_pixels(pixels[5], pixels[7], center);
|
---|
2547 | + tmp_grey = chosen_greyscale[tmp[8]];
|
---|
2548 | +#if PARANOID_ARROWS
|
---|
2549 | + diff1 = labs(bptr[4] - bptr[7]);
|
---|
2550 | + diff2 = labs(bptr[4] - bptr[5]);
|
---|
2551 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2552 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2553 | + tmp[8] = center;
|
---|
2554 | + else /* choose nearest pixel */
|
---|
2555 | +#endif
|
---|
2556 | + {
|
---|
2557 | + diff1 = calc_pixel_diff_nosqrt(tmp[8], pixels[5]);
|
---|
2558 | + diff2 = calc_pixel_diff_nosqrt(tmp[8], pixels[7]);
|
---|
2559 | + diff3 = calc_pixel_diff_nosqrt(tmp[8], pixels[4]);
|
---|
2560 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2561 | + tmp[8] = pixels[5];
|
---|
2562 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2563 | + tmp[8] = pixels[7];
|
---|
2564 | + else
|
---|
2565 | + tmp[8] = pixels[4];
|
---|
2566 | + }
|
---|
2567 | +
|
---|
2568 | + break;
|
---|
2569 | +
|
---|
2570 | + case 14: /* ^ */
|
---|
2571 | + for (i = 0; i < 9; i++)
|
---|
2572 | + tmp[i] = center;
|
---|
2573 | +
|
---|
2574 | + tmp[0] = average_three_pixels(pixels[1], pixels[3], center);
|
---|
2575 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
2576 | +#if PARANOID_ARROWS
|
---|
2577 | + diff1 = labs(bptr[4] - bptr[1]);
|
---|
2578 | + diff2 = labs(bptr[4] - bptr[3]);
|
---|
2579 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2580 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2581 | + tmp[0] = center;
|
---|
2582 | + else /* choose nearest pixel */
|
---|
2583 | +#endif
|
---|
2584 | + {
|
---|
2585 | + diff1 = calc_pixel_diff_nosqrt(tmp[0], pixels[1]);
|
---|
2586 | + diff2 = calc_pixel_diff_nosqrt(tmp[0], pixels[3]);
|
---|
2587 | + diff3 = calc_pixel_diff_nosqrt(tmp[0], pixels[4]);
|
---|
2588 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2589 | + tmp[0] = pixels[1];
|
---|
2590 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2591 | + tmp[0] = pixels[3];
|
---|
2592 | + else
|
---|
2593 | + tmp[0] = pixels[4];
|
---|
2594 | + }
|
---|
2595 | +
|
---|
2596 | + tmp[2] = average_three_pixels(pixels[1], pixels[5], center);
|
---|
2597 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
2598 | +#if PARANOID_ARROWS
|
---|
2599 | + diff1 = labs(bptr[4] - bptr[5]);
|
---|
2600 | + diff2 = labs(bptr[4] - bptr[1]);
|
---|
2601 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2602 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2603 | + tmp[2] = center;
|
---|
2604 | + else /* choose nearest pixel */
|
---|
2605 | +#endif
|
---|
2606 | + {
|
---|
2607 | + diff1 = calc_pixel_diff_nosqrt(tmp[2], pixels[1]);
|
---|
2608 | + diff2 = calc_pixel_diff_nosqrt(tmp[2], pixels[5]);
|
---|
2609 | + diff3 = calc_pixel_diff_nosqrt(tmp[2], pixels[4]);
|
---|
2610 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2611 | + tmp[2] = pixels[1];
|
---|
2612 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2613 | + tmp[2] = pixels[5];
|
---|
2614 | + else
|
---|
2615 | + tmp[2] = pixels[4];
|
---|
2616 | + }
|
---|
2617 | +
|
---|
2618 | + break;
|
---|
2619 | +
|
---|
2620 | + case 15: /* v */
|
---|
2621 | + for (i = 0; i < 9; i++)
|
---|
2622 | + tmp[i] = center;
|
---|
2623 | +
|
---|
2624 | + tmp[6] = average_three_pixels(pixels[3], pixels[7], center);
|
---|
2625 | + tmp_grey = chosen_greyscale[tmp[6]];
|
---|
2626 | +#if PARANOID_ARROWS
|
---|
2627 | + diff1 = labs(bptr[4] - bptr[3]);
|
---|
2628 | + diff2 = labs(bptr[4] - bptr[7]);
|
---|
2629 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2630 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2631 | + tmp[6] = center;
|
---|
2632 | + else /* choose nearest pixel */
|
---|
2633 | +#endif
|
---|
2634 | + {
|
---|
2635 | + diff1 = calc_pixel_diff_nosqrt(tmp[6], pixels[3]);
|
---|
2636 | + diff2 = calc_pixel_diff_nosqrt(tmp[6], pixels[7]);
|
---|
2637 | + diff3 = calc_pixel_diff_nosqrt(tmp[6], pixels[4]);
|
---|
2638 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2639 | + tmp[6] = pixels[3];
|
---|
2640 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2641 | + tmp[6] = pixels[7];
|
---|
2642 | + else
|
---|
2643 | + tmp[6] = pixels[4];
|
---|
2644 | + }
|
---|
2645 | +
|
---|
2646 | + tmp[8] = average_three_pixels(pixels[5], pixels[7], center);
|
---|
2647 | + tmp_grey = chosen_greyscale[tmp[8]];
|
---|
2648 | +#if PARANOID_ARROWS
|
---|
2649 | + diff1 = labs(bptr[4] - bptr[7]);
|
---|
2650 | + diff2 = labs(bptr[4] - bptr[5]);
|
---|
2651 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2652 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2653 | + tmp[8] = center;
|
---|
2654 | + else /* choose nearest pixel */
|
---|
2655 | +#endif
|
---|
2656 | + {
|
---|
2657 | + diff1 = calc_pixel_diff_nosqrt(tmp[8], pixels[5]);
|
---|
2658 | + diff2 = calc_pixel_diff_nosqrt(tmp[8], pixels[7]);
|
---|
2659 | + diff3 = calc_pixel_diff_nosqrt(tmp[8], pixels[4]);
|
---|
2660 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2661 | + tmp[8] = pixels[5];
|
---|
2662 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2663 | + tmp[8] = pixels[7];
|
---|
2664 | + else
|
---|
2665 | + tmp[8] = pixels[4];
|
---|
2666 | + }
|
---|
2667 | +
|
---|
2668 | + break;
|
---|
2669 | +
|
---|
2670 | + case 127: /* * */
|
---|
2671 | + case -1: /* no edge */
|
---|
2672 | + case 0: /* - */
|
---|
2673 | + case 6: /* | */
|
---|
2674 | + default:
|
---|
2675 | + dptr2 = ((uint16 *) (dptr - dstPitch)) - 1;
|
---|
2676 | + *dptr2++ = center;
|
---|
2677 | + *dptr2++ = center;
|
---|
2678 | + *dptr2 = center;
|
---|
2679 | + dptr2 = ((uint16 *) dptr) - 1;
|
---|
2680 | + *dptr2++ = center;
|
---|
2681 | + *dptr2++ = center;
|
---|
2682 | +#if DEBUG_REFRESH_RANDOM_XOR
|
---|
2683 | + *dptr2 = center ^ (uint16) (dxorshift_128() * (1L<<16));
|
---|
2684 | +#else
|
---|
2685 | + *dptr2 = center;
|
---|
2686 | +#endif
|
---|
2687 | + dptr2 = ((uint16 *) (dptr + dstPitch)) - 1;
|
---|
2688 | + *dptr2++ = center;
|
---|
2689 | + *dptr2++ = center;
|
---|
2690 | + *dptr2 = center;
|
---|
2691 | +
|
---|
2692 | + return;
|
---|
2693 | +
|
---|
2694 | + break;
|
---|
2695 | + }
|
---|
2696 | +
|
---|
2697 | + ptmp = tmp;
|
---|
2698 | + dptr2 = ((uint16 *) (dptr - dstPitch)) - 1;
|
---|
2699 | + *dptr2++ = *ptmp++;
|
---|
2700 | + *dptr2++ = *ptmp++;
|
---|
2701 | + *dptr2 = *ptmp++;
|
---|
2702 | + dptr2 = ((uint16 *) dptr) - 1;
|
---|
2703 | + *dptr2++ = *ptmp++;
|
---|
2704 | + *dptr2++ = *ptmp++;
|
---|
2705 | +#if DEBUG_REFRESH_RANDOM_XOR
|
---|
2706 | + *dptr2 = *ptmp++ ^ (uint16) (dxorshift_128() * (1L<<16));
|
---|
2707 | +#else
|
---|
2708 | + *dptr2 = *ptmp++;
|
---|
2709 | +#endif
|
---|
2710 | + dptr2 = ((uint16 *) (dptr + dstPitch)) - 1;
|
---|
2711 | + *dptr2++ = *ptmp++;
|
---|
2712 | + *dptr2++ = *ptmp++;
|
---|
2713 | + *dptr2 = *ptmp;
|
---|
2714 | +}
|
---|
2715 | +
|
---|
2716 | +
|
---|
2717 | +
|
---|
2718 | +/* Fill pixel grid with or without interpolation, using the detected edge */
|
---|
2719 | +void anti_alias_grid_2x(uint8 *dptr, int dstPitch,
|
---|
2720 | + uint16 *pixels, int sub_type, int16 *bptr,
|
---|
2721 | + int8 *sim,
|
---|
2722 | + int interpolate_2x)
|
---|
2723 | +{
|
---|
2724 | + uint16 *dptr2;
|
---|
2725 | + uint16 center = pixels[4];
|
---|
2726 | + int32 diff1, diff2, diff3;
|
---|
2727 | + int16 tmp_grey;
|
---|
2728 | + uint16 tmp[4];
|
---|
2729 | + uint16 *ptmp;
|
---|
2730 | +
|
---|
2731 | + switch (sub_type)
|
---|
2732 | + {
|
---|
2733 | + case 1: /* '- */
|
---|
2734 | + tmp[0] = tmp[1] = tmp[3] = center;
|
---|
2735 | +
|
---|
2736 | + tmp[2] = average_three_pixels(pixels[3], pixels[7], center);
|
---|
2737 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
2738 | +#if PARANOID_KNIGHTS
|
---|
2739 | + diff1 = labs(bptr[4] - bptr[3]);
|
---|
2740 | + diff2 = labs(bptr[4] - bptr[7]);
|
---|
2741 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2742 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2743 | + tmp[2] = center;
|
---|
2744 | + else /* choose nearest pixel */
|
---|
2745 | +#endif
|
---|
2746 | + {
|
---|
2747 | + diff1 = calc_pixel_diff_nosqrt(tmp[2], pixels[3]);
|
---|
2748 | + diff2 = calc_pixel_diff_nosqrt(tmp[2], pixels[7]);
|
---|
2749 | + diff3 = calc_pixel_diff_nosqrt(tmp[2], pixels[4]);
|
---|
2750 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2751 | + tmp[2] = pixels[3];
|
---|
2752 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2753 | + tmp[2] = pixels[7];
|
---|
2754 | + else
|
---|
2755 | + tmp[2] = pixels[4];
|
---|
2756 | +
|
---|
2757 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
2758 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2759 | + diff2 = labs(bptr[4] - bptr[8]);
|
---|
2760 | + if (diff1 <= diff2)
|
---|
2761 | + {
|
---|
2762 | + if (interpolate_2x)
|
---|
2763 | + {
|
---|
2764 | + uint16 tmp_pixel = tmp[2];
|
---|
2765 | + tmp[2] = Q_INTERPOLATE(tmp_pixel, tmp_pixel,
|
---|
2766 | + tmp_pixel, center);
|
---|
2767 | + tmp[3] = Q_INTERPOLATE(center, center, center, tmp_pixel);
|
---|
2768 | + }
|
---|
2769 | + }
|
---|
2770 | + else
|
---|
2771 | + {
|
---|
2772 | + if (interpolate_2x)
|
---|
2773 | + {
|
---|
2774 | + tmp[2] = INTERPOLATE(tmp[2], center);
|
---|
2775 | + }
|
---|
2776 | + else
|
---|
2777 | + {
|
---|
2778 | + if (bptr[4] > chosen_greyscale[tmp[2]])
|
---|
2779 | + tmp[2] = center;
|
---|
2780 | + }
|
---|
2781 | + }
|
---|
2782 | + }
|
---|
2783 | +
|
---|
2784 | + break;
|
---|
2785 | +
|
---|
2786 | + case 2: /* -. */
|
---|
2787 | + tmp[0] = tmp[2] = tmp[3] = center;
|
---|
2788 | +
|
---|
2789 | + tmp[1] = average_three_pixels(pixels[1], pixels[5], center);
|
---|
2790 | + tmp_grey = chosen_greyscale[tmp[1]];
|
---|
2791 | +#if PARANOID_KNIGHTS
|
---|
2792 | + diff1 = labs(bptr[4] - bptr[5]);
|
---|
2793 | + diff2 = labs(bptr[4] - bptr[1]);
|
---|
2794 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2795 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2796 | + tmp[1] = center;
|
---|
2797 | + else /* choose nearest pixel */
|
---|
2798 | +#endif
|
---|
2799 | + {
|
---|
2800 | + diff1 = calc_pixel_diff_nosqrt(tmp[1], pixels[1]);
|
---|
2801 | + diff2 = calc_pixel_diff_nosqrt(tmp[1], pixels[5]);
|
---|
2802 | + diff3 = calc_pixel_diff_nosqrt(tmp[1], pixels[4]);
|
---|
2803 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2804 | + tmp[1] = pixels[1];
|
---|
2805 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2806 | + tmp[1] = pixels[5];
|
---|
2807 | + else
|
---|
2808 | + tmp[1] = pixels[4];
|
---|
2809 | +
|
---|
2810 | + tmp_grey = chosen_greyscale[tmp[1]];
|
---|
2811 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2812 | + diff2 = labs(bptr[4] - bptr[0]);
|
---|
2813 | + if (diff1 <= diff2)
|
---|
2814 | + {
|
---|
2815 | + if (interpolate_2x)
|
---|
2816 | + {
|
---|
2817 | + uint16 tmp_pixel = tmp[1];
|
---|
2818 | + tmp[1] = Q_INTERPOLATE(tmp_pixel, tmp_pixel,
|
---|
2819 | + tmp_pixel, center);
|
---|
2820 | + tmp[0] = Q_INTERPOLATE(center, center, center, tmp_pixel);
|
---|
2821 | + }
|
---|
2822 | + }
|
---|
2823 | + else
|
---|
2824 | + {
|
---|
2825 | + if (interpolate_2x)
|
---|
2826 | + {
|
---|
2827 | + tmp[1] = INTERPOLATE(tmp[1], center);
|
---|
2828 | + }
|
---|
2829 | + else
|
---|
2830 | + {
|
---|
2831 | + if (bptr[4] > chosen_greyscale[tmp[1]])
|
---|
2832 | + tmp[1] = center;
|
---|
2833 | + }
|
---|
2834 | + }
|
---|
2835 | + }
|
---|
2836 | +
|
---|
2837 | + break;
|
---|
2838 | +
|
---|
2839 | + case 3: /* \ */
|
---|
2840 | + case 16: /* \' */
|
---|
2841 | + case 17: /* .\ */
|
---|
2842 | + tmp[0] = tmp[1] = tmp[2] = tmp[3] = center;
|
---|
2843 | +
|
---|
2844 | + if (sub_type != 16)
|
---|
2845 | + {
|
---|
2846 | + tmp[1] = average_three_pixels(pixels[1], pixels[5], center);
|
---|
2847 | + diff1 = calc_pixel_diff_nosqrt(tmp[1], pixels[1]);
|
---|
2848 | + diff2 = calc_pixel_diff_nosqrt(tmp[1], pixels[5]);
|
---|
2849 | + diff3 = calc_pixel_diff_nosqrt(tmp[1], pixels[4]);
|
---|
2850 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2851 | + tmp[1] = pixels[1];
|
---|
2852 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2853 | + tmp[1] = pixels[5];
|
---|
2854 | + else
|
---|
2855 | + tmp[1] = pixels[4];
|
---|
2856 | +
|
---|
2857 | + if (interpolate_2x)
|
---|
2858 | + {
|
---|
2859 | + tmp[1] = INTERPOLATE(tmp[1], center);
|
---|
2860 | + }
|
---|
2861 | + /* sim test is for hyper-cephalic kitten eyes and squeeze toy
|
---|
2862 | + * mouse pointer in Sam&Max. Half-diags can be too thin in 2x
|
---|
2863 | + * nearest-neighbor, so detect them and don't anti-alias them.
|
---|
2864 | + */
|
---|
2865 | + else if (bptr[4] > chosen_greyscale[tmp[1]] ||
|
---|
2866 | + (sim_sum == 1 && (sim[0] || sim[7]) &&
|
---|
2867 | + pixels[1] == pixels[3] && pixels[5] == pixels[7]))
|
---|
2868 | + tmp[1] = center;
|
---|
2869 | + }
|
---|
2870 | +
|
---|
2871 | + if (sub_type != 17)
|
---|
2872 | + {
|
---|
2873 | + tmp[2] = average_three_pixels(pixels[3], pixels[7], center);
|
---|
2874 | + diff1 = calc_pixel_diff_nosqrt(tmp[2], pixels[3]);
|
---|
2875 | + diff2 = calc_pixel_diff_nosqrt(tmp[2], pixels[7]);
|
---|
2876 | + diff3 = calc_pixel_diff_nosqrt(tmp[2], pixels[4]);
|
---|
2877 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2878 | + tmp[2] = pixels[3];
|
---|
2879 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2880 | + tmp[2] = pixels[7];
|
---|
2881 | + else
|
---|
2882 | + tmp[2] = pixels[4];
|
---|
2883 | +
|
---|
2884 | + if (interpolate_2x)
|
---|
2885 | + {
|
---|
2886 | + tmp[2] = INTERPOLATE(tmp[2], center);
|
---|
2887 | + }
|
---|
2888 | + /* sim test is for hyper-cephalic kitten eyes and squeeze toy
|
---|
2889 | + * mouse pointer in Sam&Max. Half-diags can be too thin in 2x
|
---|
2890 | + * nearest-neighbor, so detect them and don't anti-alias them.
|
---|
2891 | + */
|
---|
2892 | + else if (bptr[4] > chosen_greyscale[tmp[2]] ||
|
---|
2893 | + (sim_sum == 1 && (sim[0] || sim[7]) &&
|
---|
2894 | + pixels[1] == pixels[3] && pixels[5] == pixels[7]))
|
---|
2895 | + tmp[2] = center;
|
---|
2896 | + }
|
---|
2897 | +
|
---|
2898 | + break;
|
---|
2899 | +
|
---|
2900 | + case 4: /* '| */
|
---|
2901 | + tmp[0] = tmp[2] = tmp[3] = center;
|
---|
2902 | +
|
---|
2903 | + tmp[1] = average_three_pixels(pixels[1], pixels[5], center);
|
---|
2904 | + tmp_grey = chosen_greyscale[tmp[1]];
|
---|
2905 | +#if PARANOID_KNIGHTS
|
---|
2906 | + diff1 = labs(bptr[4] - bptr[1]);
|
---|
2907 | + diff2 = labs(bptr[4] - bptr[5]);
|
---|
2908 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2909 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2910 | + tmp[1] = center;
|
---|
2911 | + else /* choose nearest pixel */
|
---|
2912 | +#endif
|
---|
2913 | + {
|
---|
2914 | + diff1 = calc_pixel_diff_nosqrt(tmp[1], pixels[1]);
|
---|
2915 | + diff2 = calc_pixel_diff_nosqrt(tmp[1], pixels[5]);
|
---|
2916 | + diff3 = calc_pixel_diff_nosqrt(tmp[1], pixels[4]);
|
---|
2917 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2918 | + tmp[1] = pixels[1];
|
---|
2919 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2920 | + tmp[1] = pixels[5];
|
---|
2921 | + else
|
---|
2922 | + tmp[1] = pixels[4];
|
---|
2923 | +
|
---|
2924 | + tmp_grey = chosen_greyscale[tmp[1]];
|
---|
2925 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2926 | + diff2 = labs(bptr[4] - bptr[8]);
|
---|
2927 | + if (diff1 <= diff2)
|
---|
2928 | + {
|
---|
2929 | + if (interpolate_2x)
|
---|
2930 | + {
|
---|
2931 | + uint16 tmp_pixel = tmp[1];
|
---|
2932 | + tmp[1] = Q_INTERPOLATE(tmp_pixel, tmp_pixel,
|
---|
2933 | + tmp_pixel, center);
|
---|
2934 | + tmp[3] = Q_INTERPOLATE(center, center, center, tmp_pixel);
|
---|
2935 | + }
|
---|
2936 | + }
|
---|
2937 | + else
|
---|
2938 | + {
|
---|
2939 | + if (interpolate_2x)
|
---|
2940 | + {
|
---|
2941 | + tmp[1] = INTERPOLATE(tmp[1], center);
|
---|
2942 | + }
|
---|
2943 | + else
|
---|
2944 | + {
|
---|
2945 | + if (bptr[4] > chosen_greyscale[tmp[1]])
|
---|
2946 | + tmp[1] = center;
|
---|
2947 | + }
|
---|
2948 | + }
|
---|
2949 | + }
|
---|
2950 | +
|
---|
2951 | + break;
|
---|
2952 | +
|
---|
2953 | + case 5: /* |. */
|
---|
2954 | + tmp[0] = tmp[1] = tmp[3] = center;
|
---|
2955 | +
|
---|
2956 | + tmp[2] = average_three_pixels(pixels[3], pixels[7], center);
|
---|
2957 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
2958 | +#if PARANOID_KNIGHTS
|
---|
2959 | + diff1 = labs(bptr[4] - bptr[7]);
|
---|
2960 | + diff2 = labs(bptr[4] - bptr[3]);
|
---|
2961 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
2962 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
2963 | + tmp[2] = center;
|
---|
2964 | + else /* choose nearest pixel */
|
---|
2965 | +#endif
|
---|
2966 | + {
|
---|
2967 | + diff1 = calc_pixel_diff_nosqrt(tmp[2], pixels[3]);
|
---|
2968 | + diff2 = calc_pixel_diff_nosqrt(tmp[2], pixels[7]);
|
---|
2969 | + diff3 = calc_pixel_diff_nosqrt(tmp[2], pixels[4]);
|
---|
2970 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
2971 | + tmp[2] = pixels[3];
|
---|
2972 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
2973 | + tmp[2] = pixels[7];
|
---|
2974 | + else
|
---|
2975 | + tmp[2] = pixels[4];
|
---|
2976 | +
|
---|
2977 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
2978 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
2979 | + diff2 = labs(bptr[4] - bptr[0]);
|
---|
2980 | + if (diff1 <= diff2)
|
---|
2981 | + {
|
---|
2982 | + if (interpolate_2x)
|
---|
2983 | + {
|
---|
2984 | + uint16 tmp_pixel = tmp[2];
|
---|
2985 | + tmp[2] = Q_INTERPOLATE(tmp_pixel, tmp_pixel,
|
---|
2986 | + tmp_pixel, center);
|
---|
2987 | + tmp[0] = Q_INTERPOLATE(center, center, center, tmp_pixel);
|
---|
2988 | + }
|
---|
2989 | + }
|
---|
2990 | + else
|
---|
2991 | + {
|
---|
2992 | + if (interpolate_2x)
|
---|
2993 | + {
|
---|
2994 | + tmp[2] = INTERPOLATE(tmp[2], center);
|
---|
2995 | + }
|
---|
2996 | + else
|
---|
2997 | + {
|
---|
2998 | + if (bptr[4] > chosen_greyscale[tmp[2]])
|
---|
2999 | + tmp[2] = center;
|
---|
3000 | + }
|
---|
3001 | + }
|
---|
3002 | + }
|
---|
3003 | +
|
---|
3004 | + break;
|
---|
3005 | +
|
---|
3006 | + case 7: /* |' */
|
---|
3007 | + tmp[1] = tmp[2] = tmp[3] = center;
|
---|
3008 | +
|
---|
3009 | + tmp[0] = average_three_pixels(pixels[1], pixels[3], center);
|
---|
3010 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
3011 | +#if PARANOID_KNIGHTS
|
---|
3012 | + diff1 = labs(bptr[4] - bptr[1]);
|
---|
3013 | + diff2 = labs(bptr[4] - bptr[3]);
|
---|
3014 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3015 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3016 | + tmp[0] = center;
|
---|
3017 | + else /* choose nearest pixel */
|
---|
3018 | +#endif
|
---|
3019 | + {
|
---|
3020 | + diff1 = calc_pixel_diff_nosqrt(tmp[0], pixels[1]);
|
---|
3021 | + diff2 = calc_pixel_diff_nosqrt(tmp[0], pixels[3]);
|
---|
3022 | + diff3 = calc_pixel_diff_nosqrt(tmp[0], pixels[4]);
|
---|
3023 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3024 | + tmp[0] = pixels[1];
|
---|
3025 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3026 | + tmp[0] = pixels[3];
|
---|
3027 | + else
|
---|
3028 | + tmp[0] = pixels[4];
|
---|
3029 | +
|
---|
3030 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
3031 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
3032 | + diff2 = labs(bptr[4] - bptr[6]);
|
---|
3033 | + if (diff1 <= diff2)
|
---|
3034 | + {
|
---|
3035 | + if (interpolate_2x)
|
---|
3036 | + {
|
---|
3037 | + uint16 tmp_pixel = tmp[0];
|
---|
3038 | + tmp[0] = Q_INTERPOLATE(tmp_pixel, tmp_pixel,
|
---|
3039 | + tmp_pixel, center);
|
---|
3040 | + tmp[2] = Q_INTERPOLATE(center, center, center, tmp_pixel);
|
---|
3041 | + }
|
---|
3042 | + }
|
---|
3043 | + else
|
---|
3044 | + {
|
---|
3045 | + if (interpolate_2x)
|
---|
3046 | + {
|
---|
3047 | + tmp[0] = INTERPOLATE(tmp[0], center);
|
---|
3048 | + }
|
---|
3049 | + else
|
---|
3050 | + {
|
---|
3051 | + if (bptr[4] > chosen_greyscale[tmp[0]])
|
---|
3052 | + tmp[0] = center;
|
---|
3053 | + }
|
---|
3054 | + }
|
---|
3055 | + }
|
---|
3056 | +
|
---|
3057 | + break;
|
---|
3058 | +
|
---|
3059 | + case 8: /* .| */
|
---|
3060 | + tmp[0] = tmp[1] = tmp[2] = center;
|
---|
3061 | +
|
---|
3062 | + tmp[3] = average_three_pixels(pixels[5], pixels[7], center);
|
---|
3063 | + tmp_grey = chosen_greyscale[tmp[3]];
|
---|
3064 | +#if PARANOID_KNIGHTS
|
---|
3065 | + diff1 = labs(bptr[4] - bptr[7]);
|
---|
3066 | + diff2 = labs(bptr[4] - bptr[5]);
|
---|
3067 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3068 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3069 | + tmp[3] = center;
|
---|
3070 | + else /* choose nearest pixel */
|
---|
3071 | +#endif
|
---|
3072 | + {
|
---|
3073 | + diff1 = calc_pixel_diff_nosqrt(tmp[3], pixels[5]);
|
---|
3074 | + diff2 = calc_pixel_diff_nosqrt(tmp[3], pixels[7]);
|
---|
3075 | + diff3 = calc_pixel_diff_nosqrt(tmp[3], pixels[4]);
|
---|
3076 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3077 | + tmp[3] = pixels[5];
|
---|
3078 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3079 | + tmp[3] = pixels[7];
|
---|
3080 | + else
|
---|
3081 | + tmp[3] = pixels[4];
|
---|
3082 | +
|
---|
3083 | + tmp_grey = chosen_greyscale[tmp[3]];
|
---|
3084 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
3085 | + diff2 = labs(bptr[4] - bptr[2]);
|
---|
3086 | + if (diff1 <= diff2)
|
---|
3087 | + {
|
---|
3088 | + if (interpolate_2x)
|
---|
3089 | + {
|
---|
3090 | + uint16 tmp_pixel = tmp[3];
|
---|
3091 | + tmp[3] = Q_INTERPOLATE(tmp_pixel, tmp_pixel,
|
---|
3092 | + tmp_pixel, center);
|
---|
3093 | + tmp[1] = Q_INTERPOLATE(center, center, center, tmp_pixel);
|
---|
3094 | + }
|
---|
3095 | + }
|
---|
3096 | + else
|
---|
3097 | + {
|
---|
3098 | + if (interpolate_2x)
|
---|
3099 | + {
|
---|
3100 | + tmp[3] = INTERPOLATE(tmp[3], center);
|
---|
3101 | + }
|
---|
3102 | + else
|
---|
3103 | + {
|
---|
3104 | + if (bptr[4] > chosen_greyscale[tmp[3]])
|
---|
3105 | + tmp[3] = center;
|
---|
3106 | + }
|
---|
3107 | + }
|
---|
3108 | + }
|
---|
3109 | +
|
---|
3110 | + break;
|
---|
3111 | +
|
---|
3112 | + case 9: /* / */
|
---|
3113 | + case 18: /* '/ */
|
---|
3114 | + case 19: /* /. */
|
---|
3115 | + tmp[0] = tmp[1] = tmp[2] = tmp[3] = center;
|
---|
3116 | +
|
---|
3117 | + if (sub_type != 18)
|
---|
3118 | + {
|
---|
3119 | + tmp[0] = average_three_pixels(pixels[1], pixels[3], center);
|
---|
3120 | + diff1 = calc_pixel_diff_nosqrt(tmp[0], pixels[1]);
|
---|
3121 | + diff2 = calc_pixel_diff_nosqrt(tmp[0], pixels[3]);
|
---|
3122 | + diff3 = calc_pixel_diff_nosqrt(tmp[0], pixels[4]);
|
---|
3123 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3124 | + tmp[0] = pixels[1];
|
---|
3125 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3126 | + tmp[0] = pixels[3];
|
---|
3127 | + else
|
---|
3128 | + tmp[0] = pixels[4];
|
---|
3129 | +
|
---|
3130 | + if (interpolate_2x)
|
---|
3131 | + {
|
---|
3132 | + tmp[0] = INTERPOLATE(tmp[0], center);
|
---|
3133 | + }
|
---|
3134 | + /* sim test is for hyper-cephalic kitten eyes and squeeze toy
|
---|
3135 | + * mouse pointer in Sam&Max. Half-diags can be too thin in 2x
|
---|
3136 | + * nearest-neighbor, so detect them and don't anti-alias them.
|
---|
3137 | + */
|
---|
3138 | + else if (bptr[4] > chosen_greyscale[tmp[0]] ||
|
---|
3139 | + (sim_sum == 1 && (sim[2] || sim[5]) &&
|
---|
3140 | + pixels[1] == pixels[5] && pixels[3] == pixels[7]))
|
---|
3141 | + tmp[0] = center;
|
---|
3142 | + }
|
---|
3143 | +
|
---|
3144 | + if (sub_type != 19)
|
---|
3145 | + {
|
---|
3146 | + tmp[3] = average_three_pixels(pixels[5], pixels[7], center);
|
---|
3147 | + diff1 = calc_pixel_diff_nosqrt(tmp[3], pixels[5]);
|
---|
3148 | + diff2 = calc_pixel_diff_nosqrt(tmp[3], pixels[7]);
|
---|
3149 | + diff3 = calc_pixel_diff_nosqrt(tmp[3], pixels[4]);
|
---|
3150 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3151 | + tmp[3] = pixels[5];
|
---|
3152 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3153 | + tmp[3] = pixels[7];
|
---|
3154 | + else
|
---|
3155 | + tmp[3] = pixels[4];
|
---|
3156 | +
|
---|
3157 | + if (interpolate_2x)
|
---|
3158 | + {
|
---|
3159 | + tmp[3] = INTERPOLATE(tmp[3], center);
|
---|
3160 | + }
|
---|
3161 | + /* sim test is for hyper-cephalic kitten eyes and squeeze toy
|
---|
3162 | + * mouse pointer in Sam&Max. Half-diags can be too thin in 2x
|
---|
3163 | + * nearest-neighbor, so detect them and don't anti-alias them.
|
---|
3164 | + */
|
---|
3165 | + else if (bptr[4] > chosen_greyscale[tmp[3]] ||
|
---|
3166 | + (sim_sum == 1 && (sim[2] || sim[5]) &&
|
---|
3167 | + pixels[1] == pixels[5] && pixels[3] == pixels[7]))
|
---|
3168 | + tmp[3] = center;
|
---|
3169 | + }
|
---|
3170 | +
|
---|
3171 | + break;
|
---|
3172 | +
|
---|
3173 | + case 10: /* -' */
|
---|
3174 | + tmp[0] = tmp[1] = tmp[2] = center;
|
---|
3175 | +
|
---|
3176 | + tmp[3] = average_three_pixels(pixels[5], pixels[7], center);
|
---|
3177 | + tmp_grey = chosen_greyscale[tmp[3]];
|
---|
3178 | +#if PARANOID_KNIGHTS
|
---|
3179 | + diff1 = labs(bptr[4] - bptr[5]);
|
---|
3180 | + diff2 = labs(bptr[4] - bptr[7]);
|
---|
3181 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3182 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3183 | + tmp[3] = center;
|
---|
3184 | + else /* choose nearest pixel */
|
---|
3185 | +#endif
|
---|
3186 | + {
|
---|
3187 | + diff1 = calc_pixel_diff_nosqrt(tmp[3], pixels[5]);
|
---|
3188 | + diff2 = calc_pixel_diff_nosqrt(tmp[3], pixels[7]);
|
---|
3189 | + diff3 = calc_pixel_diff_nosqrt(tmp[3], pixels[4]);
|
---|
3190 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3191 | + tmp[3] = pixels[5];
|
---|
3192 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3193 | + tmp[3] = pixels[7];
|
---|
3194 | + else
|
---|
3195 | + tmp[3] = pixels[4];
|
---|
3196 | +
|
---|
3197 | + tmp_grey = chosen_greyscale[tmp[3]];
|
---|
3198 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
3199 | + diff2 = labs(bptr[4] - bptr[6]);
|
---|
3200 | + if (diff1 <= diff2)
|
---|
3201 | + {
|
---|
3202 | + if (interpolate_2x)
|
---|
3203 | + {
|
---|
3204 | + uint16 tmp_pixel = tmp[3];
|
---|
3205 | + tmp[3] = Q_INTERPOLATE(tmp_pixel, tmp_pixel,
|
---|
3206 | + tmp_pixel, center);
|
---|
3207 | + tmp[2] = Q_INTERPOLATE(center, center, center, tmp_pixel);
|
---|
3208 | + }
|
---|
3209 | + }
|
---|
3210 | + else
|
---|
3211 | + {
|
---|
3212 | + if (interpolate_2x)
|
---|
3213 | + {
|
---|
3214 | + tmp[3] = INTERPOLATE(tmp[3], center);
|
---|
3215 | + }
|
---|
3216 | + else
|
---|
3217 | + {
|
---|
3218 | + if (bptr[4] > chosen_greyscale[tmp[3]])
|
---|
3219 | + tmp[3] = center;
|
---|
3220 | + }
|
---|
3221 | + }
|
---|
3222 | + }
|
---|
3223 | +
|
---|
3224 | + break;
|
---|
3225 | +
|
---|
3226 | + case 11: /* .- */
|
---|
3227 | + tmp[1] = tmp[2] = tmp[3] = center;
|
---|
3228 | +
|
---|
3229 | + tmp[0] = average_three_pixels(pixels[1], pixels[3], center);
|
---|
3230 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
3231 | +#if PARANOID_KNIGHTS
|
---|
3232 | + diff1 = labs(bptr[4] - bptr[3]);
|
---|
3233 | + diff2 = labs(bptr[4] - bptr[1]);
|
---|
3234 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3235 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3236 | + tmp[0] = center;
|
---|
3237 | + else /* choose nearest pixel */
|
---|
3238 | +#endif
|
---|
3239 | + {
|
---|
3240 | + diff1 = calc_pixel_diff_nosqrt(tmp[0], pixels[1]);
|
---|
3241 | + diff2 = calc_pixel_diff_nosqrt(tmp[0], pixels[3]);
|
---|
3242 | + diff3 = calc_pixel_diff_nosqrt(tmp[0], pixels[4]);
|
---|
3243 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3244 | + tmp[0] = pixels[1];
|
---|
3245 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3246 | + tmp[0] = pixels[3];
|
---|
3247 | + else
|
---|
3248 | + tmp[0] = pixels[4];
|
---|
3249 | +
|
---|
3250 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
3251 | + diff1 = labs(bptr[4] - tmp_grey);
|
---|
3252 | + diff2 = labs(bptr[4] - bptr[2]);
|
---|
3253 | + if (diff1 <= diff2)
|
---|
3254 | + {
|
---|
3255 | + if (interpolate_2x)
|
---|
3256 | + {
|
---|
3257 | + uint16 tmp_pixel = tmp[0];
|
---|
3258 | + tmp[0] = Q_INTERPOLATE(tmp_pixel, tmp_pixel,
|
---|
3259 | + tmp_pixel, center);
|
---|
3260 | + tmp[1] = Q_INTERPOLATE(center, center, center, tmp_pixel);
|
---|
3261 | + }
|
---|
3262 | + }
|
---|
3263 | + else
|
---|
3264 | + {
|
---|
3265 | + if (interpolate_2x)
|
---|
3266 | + {
|
---|
3267 | + tmp[0] = INTERPOLATE(tmp[0], center);
|
---|
3268 | + }
|
---|
3269 | + else
|
---|
3270 | + {
|
---|
3271 | + if (bptr[4] > chosen_greyscale[tmp[0]])
|
---|
3272 | + tmp[0] = center;
|
---|
3273 | + }
|
---|
3274 | + }
|
---|
3275 | + }
|
---|
3276 | +
|
---|
3277 | + break;
|
---|
3278 | +
|
---|
3279 | + case 12: /* < */
|
---|
3280 | + tmp[0] = tmp[1] = tmp[2] = tmp[3] = center;
|
---|
3281 | +
|
---|
3282 | + tmp[0] = average_three_pixels(pixels[1], pixels[3], center);
|
---|
3283 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
3284 | +#if PARANOID_ARROWS
|
---|
3285 | + diff1 = labs(bptr[4] - bptr[1]);
|
---|
3286 | + diff2 = labs(bptr[4] - bptr[3]);
|
---|
3287 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3288 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3289 | + tmp[0] = center;
|
---|
3290 | + else /* choose nearest pixel */
|
---|
3291 | +#endif
|
---|
3292 | + {
|
---|
3293 | + diff1 = calc_pixel_diff_nosqrt(tmp[0], pixels[1]);
|
---|
3294 | + diff2 = calc_pixel_diff_nosqrt(tmp[0], pixels[3]);
|
---|
3295 | + diff3 = calc_pixel_diff_nosqrt(tmp[0], pixels[4]);
|
---|
3296 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3297 | + tmp[0] = pixels[1];
|
---|
3298 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3299 | + tmp[0] = pixels[3];
|
---|
3300 | + else
|
---|
3301 | + tmp[0] = pixels[4];
|
---|
3302 | +
|
---|
3303 | + /* check for half-arrow */
|
---|
3304 | + if (sim_sum == 2 && sim[4] && sim[2])
|
---|
3305 | + {
|
---|
3306 | + if (interpolate_2x)
|
---|
3307 | + {
|
---|
3308 | + tmp[0] = INTERPOLATE(center, tmp[0]);
|
---|
3309 | + tmp[2] = average_one_third(center, tmp[0]);
|
---|
3310 | + }
|
---|
3311 | + else
|
---|
3312 | + {
|
---|
3313 | + if (bptr[4] > chosen_greyscale[tmp[0]])
|
---|
3314 | + tmp[0] = center;
|
---|
3315 | + }
|
---|
3316 | +
|
---|
3317 | + break;
|
---|
3318 | + }
|
---|
3319 | +
|
---|
3320 | + if (interpolate_2x)
|
---|
3321 | + tmp[0] = average_one_third(center, tmp[0]);
|
---|
3322 | + else
|
---|
3323 | + tmp[0] = center;
|
---|
3324 | + }
|
---|
3325 | +
|
---|
3326 | + tmp[2] = average_three_pixels(pixels[3], pixels[7], center);
|
---|
3327 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
3328 | +#if PARANOID_ARROWS
|
---|
3329 | + diff1 = labs(bptr[4] - bptr[3]);
|
---|
3330 | + diff2 = labs(bptr[4] - bptr[7]);
|
---|
3331 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3332 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3333 | + tmp[2] = center;
|
---|
3334 | + else /* choose nearest pixel */
|
---|
3335 | +#endif
|
---|
3336 | + {
|
---|
3337 | + diff1 = calc_pixel_diff_nosqrt(tmp[2], pixels[3]);
|
---|
3338 | + diff2 = calc_pixel_diff_nosqrt(tmp[2], pixels[7]);
|
---|
3339 | + diff3 = calc_pixel_diff_nosqrt(tmp[2], pixels[4]);
|
---|
3340 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3341 | + tmp[2] = pixels[3];
|
---|
3342 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3343 | + tmp[2] = pixels[7];
|
---|
3344 | + else
|
---|
3345 | + tmp[2] = pixels[4];
|
---|
3346 | +
|
---|
3347 | + /* check for half-arrow */
|
---|
3348 | + if (sim_sum == 2 && sim[4] && sim[7])
|
---|
3349 | + {
|
---|
3350 | + if (interpolate_2x)
|
---|
3351 | + {
|
---|
3352 | + tmp[2] = INTERPOLATE(center, tmp[2]);
|
---|
3353 | + tmp[0] = average_one_third(center, tmp[2]);
|
---|
3354 | + }
|
---|
3355 | + else
|
---|
3356 | + {
|
---|
3357 | + if (bptr[4] > chosen_greyscale[tmp[2]])
|
---|
3358 | + tmp[2] = center;
|
---|
3359 | + }
|
---|
3360 | +
|
---|
3361 | + break;
|
---|
3362 | + }
|
---|
3363 | +
|
---|
3364 | + if (interpolate_2x)
|
---|
3365 | + tmp[2] = average_one_third(center, tmp[2]);
|
---|
3366 | + else
|
---|
3367 | + tmp[2] = center;
|
---|
3368 | + }
|
---|
3369 | +
|
---|
3370 | + break;
|
---|
3371 | +
|
---|
3372 | + case 13: /* > */
|
---|
3373 | + tmp[0] = tmp[1] = tmp[2] = tmp[3] = center;
|
---|
3374 | +
|
---|
3375 | + tmp[1] = average_three_pixels(pixels[1], pixels[5], center);
|
---|
3376 | + tmp_grey = chosen_greyscale[tmp[1]];
|
---|
3377 | +#if PARANOID_ARROWS
|
---|
3378 | + diff1 = labs(bptr[4] - bptr[5]);
|
---|
3379 | + diff2 = labs(bptr[4] - bptr[1]);
|
---|
3380 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3381 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3382 | + tmp[1] = center;
|
---|
3383 | + else /* choose nearest pixel */
|
---|
3384 | +#endif
|
---|
3385 | + {
|
---|
3386 | + diff1 = calc_pixel_diff_nosqrt(tmp[1], pixels[1]);
|
---|
3387 | + diff2 = calc_pixel_diff_nosqrt(tmp[1], pixels[5]);
|
---|
3388 | + diff3 = calc_pixel_diff_nosqrt(tmp[1], pixels[4]);
|
---|
3389 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3390 | + tmp[1] = pixels[1];
|
---|
3391 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3392 | + tmp[1] = pixels[5];
|
---|
3393 | + else
|
---|
3394 | + tmp[1] = pixels[4];
|
---|
3395 | +
|
---|
3396 | + /* check for half-arrow */
|
---|
3397 | + if (sim_sum == 2 && sim[3] && sim[0])
|
---|
3398 | + {
|
---|
3399 | + if (interpolate_2x)
|
---|
3400 | + {
|
---|
3401 | + tmp[1] = INTERPOLATE(center, tmp[1]);
|
---|
3402 | + tmp[3] = average_one_third(center, tmp[1]);
|
---|
3403 | + }
|
---|
3404 | + else
|
---|
3405 | + {
|
---|
3406 | + if (bptr[4] > chosen_greyscale[tmp[1]])
|
---|
3407 | + tmp[1] = center;
|
---|
3408 | + }
|
---|
3409 | +
|
---|
3410 | + break;
|
---|
3411 | + }
|
---|
3412 | +
|
---|
3413 | + if (interpolate_2x)
|
---|
3414 | + tmp[1] = average_one_third(center, tmp[1]);
|
---|
3415 | + else
|
---|
3416 | + tmp[1] = center;
|
---|
3417 | + }
|
---|
3418 | +
|
---|
3419 | + tmp[3] = average_three_pixels(pixels[5], pixels[7], center);
|
---|
3420 | + tmp_grey = chosen_greyscale[tmp[3]];
|
---|
3421 | +#if PARANOID_ARROWS
|
---|
3422 | + diff1 = labs(bptr[4] - bptr[7]);
|
---|
3423 | + diff2 = labs(bptr[4] - bptr[5]);
|
---|
3424 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3425 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3426 | + tmp[3] = center;
|
---|
3427 | + else /* choose nearest pixel */
|
---|
3428 | +#endif
|
---|
3429 | + {
|
---|
3430 | + diff1 = calc_pixel_diff_nosqrt(tmp[3], pixels[5]);
|
---|
3431 | + diff2 = calc_pixel_diff_nosqrt(tmp[3], pixels[7]);
|
---|
3432 | + diff3 = calc_pixel_diff_nosqrt(tmp[3], pixels[4]);
|
---|
3433 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3434 | + tmp[3] = pixels[5];
|
---|
3435 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3436 | + tmp[3] = pixels[7];
|
---|
3437 | + else
|
---|
3438 | + tmp[3] = pixels[4];
|
---|
3439 | +
|
---|
3440 | + /* check for half-arrow */
|
---|
3441 | + if (sim_sum == 2 && sim[3] && sim[5])
|
---|
3442 | + {
|
---|
3443 | + if (interpolate_2x)
|
---|
3444 | + {
|
---|
3445 | + tmp[3] = INTERPOLATE(center, tmp[3]);
|
---|
3446 | + tmp[1] = average_one_third(center, tmp[3]);
|
---|
3447 | + }
|
---|
3448 | + else
|
---|
3449 | + {
|
---|
3450 | + if (bptr[4] > chosen_greyscale[tmp[3]])
|
---|
3451 | + tmp[3] = center;
|
---|
3452 | + }
|
---|
3453 | +
|
---|
3454 | + break;
|
---|
3455 | + }
|
---|
3456 | +
|
---|
3457 | + if (interpolate_2x)
|
---|
3458 | + tmp[3] = average_one_third(center, tmp[3]);
|
---|
3459 | + else
|
---|
3460 | + tmp[3] = center;
|
---|
3461 | + }
|
---|
3462 | +
|
---|
3463 | + break;
|
---|
3464 | +
|
---|
3465 | + case 14: /* ^ */
|
---|
3466 | + tmp[0] = tmp[1] = tmp[2] = tmp[3] = center;
|
---|
3467 | +
|
---|
3468 | + tmp[0] = average_three_pixels(pixels[1], pixels[3], center);
|
---|
3469 | + tmp_grey = chosen_greyscale[tmp[0]];
|
---|
3470 | +#if PARANOID_ARROWS
|
---|
3471 | + diff1 = labs(bptr[4] - bptr[1]);
|
---|
3472 | + diff2 = labs(bptr[4] - bptr[3]);
|
---|
3473 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3474 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3475 | + tmp[0] = center;
|
---|
3476 | + else /* choose nearest pixel */
|
---|
3477 | +#endif
|
---|
3478 | + {
|
---|
3479 | + diff1 = calc_pixel_diff_nosqrt(tmp[0], pixels[1]);
|
---|
3480 | + diff2 = calc_pixel_diff_nosqrt(tmp[0], pixels[3]);
|
---|
3481 | + diff3 = calc_pixel_diff_nosqrt(tmp[0], pixels[4]);
|
---|
3482 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3483 | + tmp[0] = pixels[1];
|
---|
3484 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3485 | + tmp[0] = pixels[3];
|
---|
3486 | + else
|
---|
3487 | + tmp[0] = pixels[4];
|
---|
3488 | +
|
---|
3489 | + /* check for half-arrow */
|
---|
3490 | + if (sim_sum == 2 && sim[6] && sim[5])
|
---|
3491 | + {
|
---|
3492 | + if (interpolate_2x)
|
---|
3493 | + {
|
---|
3494 | + tmp[0] = INTERPOLATE(center, tmp[0]);
|
---|
3495 | + tmp[1] = average_one_third(center, tmp[0]);
|
---|
3496 | + }
|
---|
3497 | + else
|
---|
3498 | + {
|
---|
3499 | + if (bptr[4] > chosen_greyscale[tmp[0]])
|
---|
3500 | + tmp[0] = center;
|
---|
3501 | + }
|
---|
3502 | +
|
---|
3503 | + break;
|
---|
3504 | + }
|
---|
3505 | +
|
---|
3506 | + if (interpolate_2x)
|
---|
3507 | + tmp[0] = average_one_third(center, tmp[0]);
|
---|
3508 | + else
|
---|
3509 | + tmp[0] = center;
|
---|
3510 | + }
|
---|
3511 | +
|
---|
3512 | + tmp[1] = average_three_pixels(pixels[1], pixels[5], center);
|
---|
3513 | + tmp_grey = chosen_greyscale[tmp[1]];
|
---|
3514 | +#if PARANOID_ARROWS
|
---|
3515 | + diff1 = labs(bptr[4] - bptr[5]);
|
---|
3516 | + diff2 = labs(bptr[4] - bptr[1]);
|
---|
3517 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3518 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3519 | + tmp[1] = center;
|
---|
3520 | + else /* choose nearest pixel */
|
---|
3521 | +#endif
|
---|
3522 | + {
|
---|
3523 | + diff1 = calc_pixel_diff_nosqrt(tmp[1], pixels[1]);
|
---|
3524 | + diff2 = calc_pixel_diff_nosqrt(tmp[1], pixels[5]);
|
---|
3525 | + diff3 = calc_pixel_diff_nosqrt(tmp[1], pixels[4]);
|
---|
3526 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3527 | + tmp[1] = pixels[1];
|
---|
3528 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3529 | + tmp[1] = pixels[5];
|
---|
3530 | + else
|
---|
3531 | + tmp[1] = pixels[4];
|
---|
3532 | +
|
---|
3533 | + /* check for half-arrow */
|
---|
3534 | + if (sim_sum == 2 && sim[6] && sim[7])
|
---|
3535 | + {
|
---|
3536 | + if (interpolate_2x)
|
---|
3537 | + {
|
---|
3538 | + tmp[1] = INTERPOLATE(center, tmp[1]);
|
---|
3539 | + tmp[0] = average_one_third(center, tmp[1]);
|
---|
3540 | + }
|
---|
3541 | + else
|
---|
3542 | + {
|
---|
3543 | + if (bptr[4] > chosen_greyscale[tmp[1]])
|
---|
3544 | + tmp[1] = center;
|
---|
3545 | + }
|
---|
3546 | +
|
---|
3547 | + break;
|
---|
3548 | + }
|
---|
3549 | +
|
---|
3550 | + if (interpolate_2x)
|
---|
3551 | + tmp[1] = average_one_third(center, tmp[1]);
|
---|
3552 | + else
|
---|
3553 | + tmp[1] = center;
|
---|
3554 | + }
|
---|
3555 | +
|
---|
3556 | + break;
|
---|
3557 | +
|
---|
3558 | + case 15: /* v */
|
---|
3559 | + tmp[0] = tmp[1] = tmp[2] = tmp[3] = center;
|
---|
3560 | +
|
---|
3561 | + tmp[2] = average_three_pixels(pixels[3], pixels[7], center);
|
---|
3562 | + tmp_grey = chosen_greyscale[tmp[2]];
|
---|
3563 | +#if PARANOID_ARROWS
|
---|
3564 | + diff1 = labs(bptr[4] - bptr[3]);
|
---|
3565 | + diff2 = labs(bptr[4] - bptr[7]);
|
---|
3566 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3567 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3568 | + tmp[2] = center;
|
---|
3569 | + else /* choose nearest pixel */
|
---|
3570 | +#endif
|
---|
3571 | + {
|
---|
3572 | + diff1 = calc_pixel_diff_nosqrt(tmp[2], pixels[3]);
|
---|
3573 | + diff2 = calc_pixel_diff_nosqrt(tmp[2], pixels[7]);
|
---|
3574 | + diff3 = calc_pixel_diff_nosqrt(tmp[2], pixels[4]);
|
---|
3575 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3576 | + tmp[2] = pixels[3];
|
---|
3577 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3578 | + tmp[2] = pixels[7];
|
---|
3579 | + else
|
---|
3580 | + tmp[2] = pixels[4];
|
---|
3581 | +
|
---|
3582 | + /* check for half-arrow */
|
---|
3583 | + if (sim_sum == 2 && sim[1] && sim[0])
|
---|
3584 | + {
|
---|
3585 | + if (interpolate_2x)
|
---|
3586 | + {
|
---|
3587 | + tmp[2] = INTERPOLATE(center, tmp[2]);
|
---|
3588 | + tmp[3] = average_one_third(center, tmp[2]);
|
---|
3589 | + }
|
---|
3590 | + else
|
---|
3591 | + {
|
---|
3592 | + if (bptr[4] > chosen_greyscale[tmp[2]])
|
---|
3593 | + tmp[2] = center;
|
---|
3594 | + }
|
---|
3595 | +
|
---|
3596 | + break;
|
---|
3597 | + }
|
---|
3598 | +
|
---|
3599 | + if (interpolate_2x)
|
---|
3600 | + tmp[2] = average_one_third(center, tmp[2]);
|
---|
3601 | + else
|
---|
3602 | + tmp[2] = center;
|
---|
3603 | + }
|
---|
3604 | +
|
---|
3605 | + tmp[3] = average_three_pixels(pixels[5], pixels[7], center);
|
---|
3606 | + tmp_grey = chosen_greyscale[tmp[3]];
|
---|
3607 | +#if PARANOID_ARROWS
|
---|
3608 | + diff1 = labs(bptr[4] - bptr[7]);
|
---|
3609 | + diff2 = labs(bptr[4] - bptr[5]);
|
---|
3610 | + diff3 = labs(bptr[4] - tmp_grey);
|
---|
3611 | + if (diff1 < diff3 || diff2 < diff3)
|
---|
3612 | + tmp[3] = center;
|
---|
3613 | + else /* choose nearest pixel */
|
---|
3614 | +#endif
|
---|
3615 | + {
|
---|
3616 | + diff1 = calc_pixel_diff_nosqrt(tmp[3], pixels[5]);
|
---|
3617 | + diff2 = calc_pixel_diff_nosqrt(tmp[3], pixels[7]);
|
---|
3618 | + diff3 = calc_pixel_diff_nosqrt(tmp[3], pixels[4]);
|
---|
3619 | + if (diff1 <= diff2 && diff1 <= diff3)
|
---|
3620 | + tmp[3] = pixels[5];
|
---|
3621 | + else if (diff2 <= diff1 && diff2 <= diff3)
|
---|
3622 | + tmp[3] = pixels[7];
|
---|
3623 | + else
|
---|
3624 | + tmp[3] = pixels[4];
|
---|
3625 | +
|
---|
3626 | + /* check for half-arrow */
|
---|
3627 | + if (sim_sum == 2 && sim[1] && sim[2])
|
---|
3628 | + {
|
---|
3629 | + if (interpolate_2x)
|
---|
3630 | + {
|
---|
3631 | + tmp[3] = INTERPOLATE(center, tmp[3]);
|
---|
3632 | + tmp[2] = average_one_third(center, tmp[3]);
|
---|
3633 | + }
|
---|
3634 | + else
|
---|
3635 | + {
|
---|
3636 | + if (bptr[4] > chosen_greyscale[tmp[3]])
|
---|
3637 | + tmp[3] = center;
|
---|
3638 | + }
|
---|
3639 | +
|
---|
3640 | + break;
|
---|
3641 | + }
|
---|
3642 | +
|
---|
3643 | + if (interpolate_2x)
|
---|
3644 | + tmp[3] = average_one_third(center, tmp[3]);
|
---|
3645 | + else
|
---|
3646 | + tmp[3] = center;
|
---|
3647 | + }
|
---|
3648 | +
|
---|
3649 | + break;
|
---|
3650 | +
|
---|
3651 | + case -1: /* no edge */
|
---|
3652 | + case 0: /* - */
|
---|
3653 | + case 6: /* | */
|
---|
3654 | + case 127: /* * */
|
---|
3655 | + default: /* no edge */
|
---|
3656 | + dptr2 = (uint16 *) dptr;
|
---|
3657 | + *dptr2++ = center;
|
---|
3658 | +#if DEBUG_REFRESH_RANDOM_XOR
|
---|
3659 | + *dptr2 = center ^ (uint16) (dxorshift_128() * (1L<<16));
|
---|
3660 | +#else
|
---|
3661 | + *dptr2 = center;
|
---|
3662 | +#endif
|
---|
3663 | + dptr2 = (uint16 *) (dptr + dstPitch);
|
---|
3664 | + *dptr2++ = center;
|
---|
3665 | + *dptr2 = center;
|
---|
3666 | +
|
---|
3667 | + return;
|
---|
3668 | +
|
---|
3669 | + break;
|
---|
3670 | + }
|
---|
3671 | +
|
---|
3672 | + ptmp = tmp;
|
---|
3673 | + dptr2 = (uint16 *) dptr;
|
---|
3674 | + *dptr2++ = *ptmp++;
|
---|
3675 | +#if DEBUG_REFRESH_RANDOM_XOR
|
---|
3676 | + *dptr2 = *ptmp++ ^ (uint16) (dxorshift_128() * (1L<<16));
|
---|
3677 | +#else
|
---|
3678 | + *dptr2 = *ptmp++;
|
---|
3679 | +#endif
|
---|
3680 | + dptr2 = (uint16 *) (dptr + dstPitch);
|
---|
3681 | + *dptr2++ = *ptmp++;
|
---|
3682 | + *dptr2 = *ptmp;
|
---|
3683 | +}
|
---|
3684 | +
|
---|
3685 | +
|
---|
3686 | +
|
---|
3687 | +#if HANDLE_TRANSPARENT_OVERLAYS
|
---|
3688 | +/* Deal with transparent pixels */
|
---|
3689 | +void handle_transparent_overlay(uint16 transp, uint16 *pixels,
|
---|
3690 | + int16 *bplane, int16 *diffs)
|
---|
3691 | +{
|
---|
3692 | + int16 tmp_grey;
|
---|
3693 | + int16 max_diff;
|
---|
3694 | + int16 min_grey = ((int16)1<<RGB_SHIFT);
|
---|
3695 | + int16 max_grey = 0;
|
---|
3696 | + int i;
|
---|
3697 | +
|
---|
3698 | + /* find min and max grey values in window */
|
---|
3699 | + for (i = 0; i < 9; i++)
|
---|
3700 | + {
|
---|
3701 | + if (bplane[i] < min_grey) min_grey = bplane[i];
|
---|
3702 | + if (bplane[i] > max_grey) max_grey = bplane[i];
|
---|
3703 | + }
|
---|
3704 | +
|
---|
3705 | + /* treat transparent pixels as the average of min_grey and max_grey */
|
---|
3706 | + /* set diff from center pixel to maximum difference within the window */
|
---|
3707 | + tmp_grey = (min_grey + max_grey + 1) >> 1;
|
---|
3708 | + max_diff = max_grey - min_grey;
|
---|
3709 | +
|
---|
3710 | + if (pixels[4] == transp) /* center pixel is transparent */
|
---|
3711 | + {
|
---|
3712 | + /* set all transparent pixels to middle grey */
|
---|
3713 | + if (pixels[0] == transp) bplane[0] = tmp_grey;
|
---|
3714 | + if (pixels[1] == transp) bplane[1] = tmp_grey;
|
---|
3715 | + if (pixels[2] == transp) bplane[2] = tmp_grey;
|
---|
3716 | + if (pixels[3] == transp) bplane[3] = tmp_grey;
|
---|
3717 | + if (pixels[4] == transp) bplane[4] = tmp_grey;
|
---|
3718 | + if (pixels[5] == transp) bplane[5] = tmp_grey;
|
---|
3719 | + if (pixels[6] == transp) bplane[6] = tmp_grey;
|
---|
3720 | + if (pixels[7] == transp) bplane[7] = tmp_grey;
|
---|
3721 | + if (pixels[8] == transp) bplane[8] = tmp_grey;
|
---|
3722 | +
|
---|
3723 | + /* set all diffs to non-transparent pixels to max diff */
|
---|
3724 | + if (pixels[0] != transp) diffs[0] = max_diff;
|
---|
3725 | + if (pixels[1] != transp) diffs[1] = max_diff;
|
---|
3726 | + if (pixels[2] != transp) diffs[2] = max_diff;
|
---|
3727 | + if (pixels[3] != transp) diffs[3] = max_diff;
|
---|
3728 | + if (pixels[5] != transp) diffs[4] = max_diff;
|
---|
3729 | + if (pixels[6] != transp) diffs[5] = max_diff;
|
---|
3730 | + if (pixels[7] != transp) diffs[6] = max_diff;
|
---|
3731 | + if (pixels[8] != transp) diffs[7] = max_diff;
|
---|
3732 | + }
|
---|
3733 | + else /* center pixel is non-transparent */
|
---|
3734 | + {
|
---|
3735 | + /* choose transparent grey value to give largest contrast */
|
---|
3736 | + tmp_grey = (bplane[4] >= tmp_grey) ? min_grey : max_grey;
|
---|
3737 | +
|
---|
3738 | + /* set new transparent pixel values and diffs */
|
---|
3739 | + if (pixels[0] == transp)
|
---|
3740 | + {
|
---|
3741 | + bplane[0] = tmp_grey;
|
---|
3742 | + diffs[0] = max_diff;
|
---|
3743 | + }
|
---|
3744 | + if (pixels[1] == transp)
|
---|
3745 | + {
|
---|
3746 | + bplane[1] = tmp_grey;
|
---|
3747 | + diffs[1] = max_diff;
|
---|
3748 | + }
|
---|
3749 | + if (pixels[2] == transp)
|
---|
3750 | + {
|
---|
3751 | + bplane[2] = tmp_grey;
|
---|
3752 | + diffs[2] = max_diff;
|
---|
3753 | + }
|
---|
3754 | + if (pixels[3] == transp)
|
---|
3755 | + {
|
---|
3756 | + bplane[3] = tmp_grey;
|
---|
3757 | + diffs[3] = max_diff;
|
---|
3758 | + }
|
---|
3759 | + if (pixels[5] == transp)
|
---|
3760 | + {
|
---|
3761 | + bplane[5] = tmp_grey;
|
---|
3762 | + diffs[4] = max_diff;
|
---|
3763 | + }
|
---|
3764 | + if (pixels[6] == transp)
|
---|
3765 | + {
|
---|
3766 | + bplane[6] = tmp_grey;
|
---|
3767 | + diffs[5] = max_diff;
|
---|
3768 | + }
|
---|
3769 | + if (pixels[7] == transp)
|
---|
3770 | + {
|
---|
3771 | + bplane[7] = tmp_grey;
|
---|
3772 | + diffs[6] = max_diff;
|
---|
3773 | + }
|
---|
3774 | + if (pixels[8] == transp)
|
---|
3775 | + {
|
---|
3776 | + bplane[8] = tmp_grey;
|
---|
3777 | + diffs[7] = max_diff;
|
---|
3778 | + }
|
---|
3779 | + }
|
---|
3780 | +}
|
---|
3781 | +#endif
|
---|
3782 | +
|
---|
3783 | +
|
---|
3784 | +
|
---|
3785 | +/* Check for changed pixel grid, return 1 if unchanged. */
|
---|
3786 | +int check_unchanged_pixels(uint16 *old_src_ptr, uint16 *pixels, int w)
|
---|
3787 | +{
|
---|
3788 | + uint16 *dptr16;
|
---|
3789 | +
|
---|
3790 | + dptr16 = old_src_ptr - w - 1;
|
---|
3791 | + if (*dptr16++ != pixels[0]) return 0;
|
---|
3792 | + if (*dptr16++ != pixels[1]) return 0;
|
---|
3793 | + if (*dptr16 != pixels[2]) return 0;
|
---|
3794 | +
|
---|
3795 | + dptr16 += w - 2;
|
---|
3796 | + if (*dptr16 != pixels[3]) return 0;
|
---|
3797 | + dptr16 += 2;
|
---|
3798 | + if (*dptr16 != pixels[5]) return 0;
|
---|
3799 | +
|
---|
3800 | + dptr16 += w - 2;
|
---|
3801 | + if (*dptr16++ != pixels[6]) return 0;
|
---|
3802 | + if (*dptr16++ != pixels[7]) return 0;
|
---|
3803 | + if (*dptr16 != pixels[8]) return 0;
|
---|
3804 | +
|
---|
3805 | + return 1;
|
---|
3806 | +}
|
---|
3807 | +
|
---|
3808 | +
|
---|
3809 | +/* Draw unchanged pixel grid, 3x */
|
---|
3810 | +/* old_dptr16 starts in top left of grid, dptr16 in center */
|
---|
3811 | +void draw_unchanged_grid_3x(uint16 *dptr16, int dstPitch,
|
---|
3812 | + uint16 *old_dptr16, int old_dst_inc)
|
---|
3813 | +{
|
---|
3814 | + uint16 *sptr;
|
---|
3815 | + uint16 *dptr;
|
---|
3816 | + uint8 *dptr8 = (uint8 *) dptr16;
|
---|
3817 | +
|
---|
3818 | + sptr = old_dptr16;
|
---|
3819 | + dptr = (uint16 *) (dptr8 - dstPitch) - 1;
|
---|
3820 | + *dptr++ = *sptr++;
|
---|
3821 | + *dptr++ = *sptr++;
|
---|
3822 | + *dptr = *sptr;
|
---|
3823 | +
|
---|
3824 | + sptr = old_dptr16 + old_dst_inc;
|
---|
3825 | + dptr = dptr16 - 1;
|
---|
3826 | + *dptr++ = *sptr++;
|
---|
3827 | + *dptr++ = *sptr++;
|
---|
3828 | + *dptr = *sptr;
|
---|
3829 | +
|
---|
3830 | + sptr = old_dptr16 + old_dst_inc + old_dst_inc;
|
---|
3831 | + dptr = (uint16 *) (dptr8 + dstPitch) - 1;
|
---|
3832 | + *dptr++ = *sptr++;
|
---|
3833 | + *dptr++ = *sptr++;
|
---|
3834 | + *dptr = *sptr;
|
---|
3835 | +}
|
---|
3836 | +
|
---|
3837 | +
|
---|
3838 | +
|
---|
3839 | +/* Draw unchanged pixel grid, 2x */
|
---|
3840 | +void draw_unchanged_grid_2x(uint16 *dptr16, int dstPitch,
|
---|
3841 | + uint16 *old_dptr16, int old_dst_inc)
|
---|
3842 | +{
|
---|
3843 | + uint16 *sptr;
|
---|
3844 | + uint16 *dptr;
|
---|
3845 | + uint8 *dptr8 = (uint8 *) dptr16;
|
---|
3846 | +
|
---|
3847 | + sptr = old_dptr16;
|
---|
3848 | + dptr = dptr16;
|
---|
3849 | + *dptr++ = *sptr++;
|
---|
3850 | + *dptr = *sptr;
|
---|
3851 | +
|
---|
3852 | + sptr = old_dptr16 + old_dst_inc;
|
---|
3853 | + dptr = (uint16 *) (dptr8 + dstPitch);
|
---|
3854 | + *dptr++ = *sptr++;
|
---|
3855 | + *dptr = *sptr;
|
---|
3856 | +}
|
---|
3857 | +
|
---|
3858 | +
|
---|
3859 | +/* Perform edge detection, draw the new 3x pixels */
|
---|
3860 | +void anti_alias_pass_3x(const uint8 *src, uint8 *dst,
|
---|
3861 | + int w, int h, int w_new, int h_new,
|
---|
3862 | + int srcPitch, int dstPitch,
|
---|
3863 | + int overlay_flag)
|
---|
3864 | +{
|
---|
3865 | + int x, y;
|
---|
3866 | + int w2 = w + 2;
|
---|
3867 | + const uint8 *sptr8 = src;
|
---|
3868 | + uint8 *dptr8 = dst + dstPitch + 2;
|
---|
3869 | + const uint16 *sptr16;
|
---|
3870 | + uint16 *dptr16;
|
---|
3871 | + int16 *bplane;
|
---|
3872 | + int8 sim[8];
|
---|
3873 | + int sub_type;
|
---|
3874 | + int32 angle;
|
---|
3875 | + int16 *diffs;
|
---|
3876 | + int dstPitch3 = dstPitch * 3;
|
---|
3877 | +
|
---|
3878 | + uint16 *old_src_ptr, *old_dst_ptr;
|
---|
3879 | + uint16 *old_sptr16, *old_dptr16;
|
---|
3880 | + int32 dist, old_src_y, old_src_x;
|
---|
3881 | + int old_src_inc;
|
---|
3882 | + int old_dst_inc, old_dst_inc3;
|
---|
3883 | +
|
---|
3884 | + if (overlay_flag)
|
---|
3885 | + {
|
---|
3886 | + old_src_ptr = old_overlay + w2 + 1;
|
---|
3887 | + old_src_inc = w2;
|
---|
3888 | +
|
---|
3889 | + old_dst_ptr = old_dst_overlay;
|
---|
3890 | + old_dst_inc = w_new;
|
---|
3891 | + }
|
---|
3892 | + else
|
---|
3893 | + {
|
---|
3894 | + dist = src - (const uint8 *) src_addr_min;
|
---|
3895 | + old_src_y = dist / srcPitch;
|
---|
3896 | + old_src_x = (dist - old_src_y * srcPitch) >> 1;
|
---|
3897 | +
|
---|
3898 | + old_src_inc = cur_screen_width + 2;
|
---|
3899 | + old_src_ptr = old_src + (old_src_y + 1) * old_src_inc + old_src_x + 1;
|
---|
3900 | +
|
---|
3901 | + old_dst_inc = 3 * cur_screen_width;
|
---|
3902 | + old_dst_ptr = old_dst + 3 * (old_src_y * old_dst_inc + old_src_x);
|
---|
3903 | + }
|
---|
3904 | +
|
---|
3905 | + old_dst_inc3 = 3 * old_dst_inc;
|
---|
3906 | +
|
---|
3907 | +#if HANDLE_TRANSPARENT_OVERLAYS
|
---|
3908 | + uint16 transp = 0; /* transparent color */
|
---|
3909 | +
|
---|
3910 | + /* assume bitmap is padded by a transparent border, take src-1 pixel */
|
---|
3911 | + if (overlay_flag) transp = *((const uint16 *) src - 1);
|
---|
3912 | +#endif
|
---|
3913 | +
|
---|
3914 | + /* The dirty rects optimizer in the SDL backend is helpful for frames
|
---|
3915 | + * with few changes, but _REALLY_ bogs things down when the whole screen
|
---|
3916 | + * changes. Overall, the dirty rects optimizer isn't worth it, since
|
---|
3917 | + * the Edge2x/3x unchanged pixel detection is far faster than full blown
|
---|
3918 | + * dirty rects optimization.
|
---|
3919 | + */
|
---|
3920 | + g_system->setFeatureState(g_system->kFeatureAutoComputeDirtyRects, 0);
|
---|
3921 | +
|
---|
3922 | + for (y = 0; y < h; y++, sptr8 += srcPitch, dptr8 += dstPitch3,
|
---|
3923 | + old_src_ptr += old_src_inc, old_dst_ptr += old_dst_inc3)
|
---|
3924 | + {
|
---|
3925 | + for (x = 0,
|
---|
3926 | + sptr16 = (const uint16 *) sptr8,
|
---|
3927 | + dptr16 = (uint16 *) dptr8,
|
---|
3928 | + old_sptr16 = old_src_ptr,
|
---|
3929 | + old_dptr16 = old_dst_ptr;
|
---|
3930 | + x < w; x++, sptr16++, dptr16 += 3, old_sptr16++, old_dptr16 += 3)
|
---|
3931 | + {
|
---|
3932 | + const uint16 *sptr2, *addr3;
|
---|
3933 | + uint16 pixels[9];
|
---|
3934 | + char edge_type;
|
---|
3935 | +
|
---|
3936 | + sptr2 = ((const uint16 *) ((const uint8 *) sptr16 - srcPitch)) - 1;
|
---|
3937 | + addr3 = ((const uint16 *) ((const uint8 *) sptr16 + srcPitch)) + 1;
|
---|
3938 | +
|
---|
3939 | + /* fill the 3x3 grid */
|
---|
3940 | + memcpy(pixels, sptr2, 3*sizeof(uint16));
|
---|
3941 | + memcpy(pixels+3, sptr16 - 1, 3*sizeof(uint16));
|
---|
3942 | + memcpy(pixels+6, addr3 - 2, 3*sizeof(uint16));
|
---|
3943 | +
|
---|
3944 | + /* skip interior unchanged 3x3 blocks */
|
---|
3945 | + if (*sptr16 == *old_sptr16 &&
|
---|
3946 | +#if DEBUG_DRAW_REFRESH_BORDERS
|
---|
3947 | + x > 0 && x < w - 1 && y > 0 && y < h - 1 &&
|
---|
3948 | +#endif
|
---|
3949 | + check_unchanged_pixels(old_sptr16, pixels, old_src_inc))
|
---|
3950 | + {
|
---|
3951 | + draw_unchanged_grid_3x(dptr16, dstPitch, old_dptr16,
|
---|
3952 | + old_dst_inc);
|
---|
3953 | +
|
---|
3954 | +#if DEBUG_REFRESH_RANDOM_XOR
|
---|
3955 | + *(dptr16 + 1) = 0;
|
---|
3956 | +#endif
|
---|
3957 | + continue;
|
---|
3958 | + }
|
---|
3959 | +
|
---|
3960 | + diffs = choose_greyscale(pixels);
|
---|
3961 | +
|
---|
3962 | + /* block of solid color */
|
---|
3963 | + if (!diffs)
|
---|
3964 | + {
|
---|
3965 | + anti_alias_grid_clean_3x((uint8 *) dptr16, dstPitch, pixels,
|
---|
3966 | + 0, NULL);
|
---|
3967 | + continue;
|
---|
3968 | + }
|
---|
3969 | +
|
---|
3970 | + bplane = bptr_global;
|
---|
3971 | +
|
---|
3972 | +#if HANDLE_TRANSPARENT_OVERLAYS
|
---|
3973 | + if (overlay_flag)
|
---|
3974 | + handle_transparent_overlay(transp, pixels, bplane, diffs);
|
---|
3975 | +#endif
|
---|
3976 | +
|
---|
3977 | + edge_type = find_principle_axis(pixels, diffs, bplane,
|
---|
3978 | + sim, &angle);
|
---|
3979 | + sub_type = refine_direction(edge_type, pixels, bplane,
|
---|
3980 | + sim, angle);
|
---|
3981 | + if (sub_type >= 0)
|
---|
3982 | + sub_type = fix_knights(sub_type, pixels, sim);
|
---|
3983 | +
|
---|
3984 | + anti_alias_grid_clean_3x((uint8 *) dptr16, dstPitch, pixels,
|
---|
3985 | + sub_type, bplane);
|
---|
3986 | + }
|
---|
3987 | + }
|
---|
3988 | +}
|
---|
3989 | +
|
---|
3990 | +
|
---|
3991 | +
|
---|
3992 | +/* Perform edge detection, draw the new 2x pixels */
|
---|
3993 | +void anti_alias_pass_2x(const uint8 *src, uint8 *dst,
|
---|
3994 | + int w, int h, int w_new, int h_new,
|
---|
3995 | + int srcPitch, int dstPitch,
|
---|
3996 | + int overlay_flag,
|
---|
3997 | + int interpolate_2x)
|
---|
3998 | +{
|
---|
3999 | + int x, y;
|
---|
4000 | + int w2 = w + 2;
|
---|
4001 | + const uint8 *sptr8 = src;
|
---|
4002 | + uint8 *dptr8 = dst;
|
---|
4003 | + const uint16 *sptr16;
|
---|
4004 | + uint16 *dptr16;
|
---|
4005 | + int16 *bplane;
|
---|
4006 | + int8 sim[8];
|
---|
4007 | + int sub_type;
|
---|
4008 | + int32 angle;
|
---|
4009 | + int16 *diffs;
|
---|
4010 | + int dstPitch2 = dstPitch << 1;
|
---|
4011 | +
|
---|
4012 | + uint16 *old_src_ptr, *old_dst_ptr;
|
---|
4013 | + uint16 *old_sptr16, *old_dptr16;
|
---|
4014 | + int32 dist, old_src_y, old_src_x;
|
---|
4015 | + int old_src_inc;
|
---|
4016 | + int old_dst_inc, old_dst_inc2;
|
---|
4017 | +
|
---|
4018 | + if (overlay_flag)
|
---|
4019 | + {
|
---|
4020 | + old_src_ptr = old_overlay + w2 + 1;
|
---|
4021 | + old_src_inc = w2;
|
---|
4022 | +
|
---|
4023 | + old_dst_ptr = old_dst_overlay;
|
---|
4024 | + old_dst_inc = w_new;
|
---|
4025 | + }
|
---|
4026 | + else
|
---|
4027 | + {
|
---|
4028 | + dist = src - (const uint8 *) src_addr_min;
|
---|
4029 | + old_src_y = dist / srcPitch;
|
---|
4030 | + old_src_x = (dist - old_src_y * srcPitch) >> 1;
|
---|
4031 | +
|
---|
4032 | + old_src_inc = cur_screen_width + 2;
|
---|
4033 | + old_src_ptr = old_src + (old_src_y + 1) * old_src_inc + old_src_x + 1;
|
---|
4034 | +
|
---|
4035 | + old_dst_inc = 2 * cur_screen_width;
|
---|
4036 | + old_dst_ptr = old_dst + 2 * (old_src_y * old_dst_inc + old_src_x);
|
---|
4037 | + }
|
---|
4038 | +
|
---|
4039 | + old_dst_inc2 = 2 * old_dst_inc;
|
---|
4040 | +
|
---|
4041 | +#if HANDLE_TRANSPARENT_OVERLAYS
|
---|
4042 | + uint16 transp = 0; /* transparent color */
|
---|
4043 | +
|
---|
4044 | + /* assume bitmap is padded by a transparent border, take src-1 pixel */
|
---|
4045 | + if (overlay_flag) transp = *((const uint16 *) src - 1);
|
---|
4046 | +#endif
|
---|
4047 | +
|
---|
4048 | + /* The dirty rects optimizer in the SDL backend is helpful for frames
|
---|
4049 | + * with few changes, but _REALLY_ bogs things down when the whole screen
|
---|
4050 | + * changes. Overall, the dirty rects optimizer isn't worth it, since
|
---|
4051 | + * the Edge2x/3x unchanged pixel detection is far faster than full blown
|
---|
4052 | + * dirty rects optimization.
|
---|
4053 | + */
|
---|
4054 | + g_system->setFeatureState(g_system->kFeatureAutoComputeDirtyRects, 0);
|
---|
4055 | +
|
---|
4056 | + for (y = 0; y < h; y++, sptr8 += srcPitch, dptr8 += dstPitch2,
|
---|
4057 | + old_src_ptr += old_src_inc, old_dst_ptr += old_dst_inc2)
|
---|
4058 | + {
|
---|
4059 | + for (x = 0,
|
---|
4060 | + sptr16 = (const uint16 *) sptr8,
|
---|
4061 | + dptr16 = (uint16 *) dptr8,
|
---|
4062 | + old_sptr16 = old_src_ptr,
|
---|
4063 | + old_dptr16 = old_dst_ptr;
|
---|
4064 | + x < w; x++, sptr16++, dptr16 += 2, old_sptr16++, old_dptr16 += 2)
|
---|
4065 | + {
|
---|
4066 | + const uint16 *sptr2, *addr3;
|
---|
4067 | + uint16 pixels[9];
|
---|
4068 | + char edge_type;
|
---|
4069 | +
|
---|
4070 | + sptr2 = ((const uint16 *) ((const uint8 *) sptr16 - srcPitch)) - 1;
|
---|
4071 | + addr3 = ((const uint16 *) ((const uint8 *) sptr16 + srcPitch)) + 1;
|
---|
4072 | +
|
---|
4073 | + /* fill the 3x3 grid */
|
---|
4074 | + memcpy(pixels, sptr2, 3*sizeof(uint16));
|
---|
4075 | + memcpy(pixels+3, sptr16 - 1, 3*sizeof(uint16));
|
---|
4076 | + memcpy(pixels+6, addr3 - 2, 3*sizeof(uint16));
|
---|
4077 | +
|
---|
4078 | + /* skip interior unchanged 3x3 blocks */
|
---|
4079 | + if (*sptr16 == *old_sptr16 &&
|
---|
4080 | +#if DEBUG_DRAW_REFRESH_BORDERS
|
---|
4081 | + x > 0 && x < w - 1 && y > 0 && y < h - 1 &&
|
---|
4082 | +#endif
|
---|
4083 | + check_unchanged_pixels(old_sptr16, pixels, old_src_inc))
|
---|
4084 | + {
|
---|
4085 | + draw_unchanged_grid_2x(dptr16, dstPitch, old_dptr16,
|
---|
4086 | + old_dst_inc);
|
---|
4087 | +
|
---|
4088 | +#if DEBUG_REFRESH_RANDOM_XOR
|
---|
4089 | + *(dptr16 + 1) = 0;
|
---|
4090 | +#endif
|
---|
4091 | + continue;
|
---|
4092 | + }
|
---|
4093 | +
|
---|
4094 | + diffs = choose_greyscale(pixels);
|
---|
4095 | +
|
---|
4096 | + /* block of solid color */
|
---|
4097 | + if (!diffs)
|
---|
4098 | + {
|
---|
4099 | + anti_alias_grid_2x((uint8 *) dptr16, dstPitch, pixels,
|
---|
4100 | + 0, NULL, NULL, 0);
|
---|
4101 | + continue;
|
---|
4102 | + }
|
---|
4103 | +
|
---|
4104 | + bplane = bptr_global;
|
---|
4105 | +
|
---|
4106 | +#if HANDLE_TRANSPARENT_OVERLAYS
|
---|
4107 | + if (overlay_flag)
|
---|
4108 | + handle_transparent_overlay(transp, pixels, bplane, diffs);
|
---|
4109 | +#endif
|
---|
4110 | +
|
---|
4111 | + edge_type = find_principle_axis(pixels, diffs, bplane,
|
---|
4112 | + sim, &angle);
|
---|
4113 | + sub_type = refine_direction(edge_type, pixels, bplane,
|
---|
4114 | + sim, angle);
|
---|
4115 | + if (sub_type >= 0)
|
---|
4116 | + sub_type = fix_knights(sub_type, pixels, sim);
|
---|
4117 | +
|
---|
4118 | + anti_alias_grid_2x((uint8 *) dptr16, dstPitch, pixels,
|
---|
4119 | + sub_type, bplane, sim,
|
---|
4120 | + interpolate_2x);
|
---|
4121 | + }
|
---|
4122 | + }
|
---|
4123 | +}
|
---|
4124 | +
|
---|
4125 | +
|
---|
4126 | +
|
---|
4127 | +/* Initialize various lookup tables */
|
---|
4128 | +void init_tables(const uint8 *srcPtr, uint32 srcPitch,
|
---|
4129 | + int width, int height)
|
---|
4130 | +{
|
---|
4131 | + double r_float, g_float, b_float;
|
---|
4132 | + int r, g, b;
|
---|
4133 | + uint16 i;
|
---|
4134 | + double val[3];
|
---|
4135 | + double intensity;
|
---|
4136 | + int16 *rgb_ptr;
|
---|
4137 | +
|
---|
4138 | +#if DEBUG_REFRESH_RANDOM_XOR
|
---|
4139 | + /* seed the random number generator, we don't care if the seed is random */
|
---|
4140 | + initialize_xorshift_128(42);
|
---|
4141 | +#endif
|
---|
4142 | +
|
---|
4143 | + /* initialize greyscale table */
|
---|
4144 | + for (r = 0; r < 32; r++)
|
---|
4145 | + {
|
---|
4146 | + r_float = r / 31.0;
|
---|
4147 | +
|
---|
4148 | + for (g = 0; g < 64; g++)
|
---|
4149 | + {
|
---|
4150 | + g_float = g / 63.0;
|
---|
4151 | +
|
---|
4152 | + for (b = 0; b < 32; b++)
|
---|
4153 | + {
|
---|
4154 | + b_float = b / 31.0;
|
---|
4155 | +
|
---|
4156 | + intensity = (r_float + g_float + b_float) / 3;
|
---|
4157 | +
|
---|
4158 | + i = (r << 11) | (g << 5) | b;
|
---|
4159 | +
|
---|
4160 | + /* use luma-like weights for each color, 2x increments */
|
---|
4161 | + val[0] = 0.571 * r_float + 0.286 * g_float + 0.143 * b_float;
|
---|
4162 | + val[1] = 0.286 * r_float + 0.571 * g_float + 0.143 * b_float;
|
---|
4163 | + val[2] = 0.143 * r_float + 0.286 * g_float + 0.571 * b_float;
|
---|
4164 | +
|
---|
4165 | + /* factor in a little intensity too, it helps */
|
---|
4166 | + val[0] = (intensity + 9*val[0]) / 10;
|
---|
4167 | + val[1] = (intensity + 9*val[1]) / 10;
|
---|
4168 | + val[2] = (intensity + 9*val[2]) / 10;
|
---|
4169 | +
|
---|
4170 | + /* store the greyscale tables */
|
---|
4171 | + greyscale_table[0][i] = (int16) (val[0] * ((int16)1<<GREY_SHIFT) + 0.5);
|
---|
4172 | + greyscale_table[1][i] = (int16) (val[1] * ((int16)1<<GREY_SHIFT) + 0.5);
|
---|
4173 | + greyscale_table[2][i] = (int16) (val[2] * ((int16)1<<GREY_SHIFT) + 0.5);
|
---|
4174 | +
|
---|
4175 | + /* normalized RGB channel lookups */
|
---|
4176 | + rgb_ptr = rgb_table[(r << 11) | (g << 5) | b];
|
---|
4177 | + rgb_ptr[0] = (int16) (r_float * ((int16)1<<RGB_SHIFT) + 0.5);
|
---|
4178 | + rgb_ptr[1] = (int16) (g_float * ((int16)1<<RGB_SHIFT) + 0.5);
|
---|
4179 | + rgb_ptr[2] = (int16) (b_float * ((int16)1<<RGB_SHIFT) + 0.5);
|
---|
4180 | + }
|
---|
4181 | + }
|
---|
4182 | + }
|
---|
4183 | +
|
---|
4184 | + /* initialize interpolation division tables */
|
---|
4185 | + for (r = 0; r <= 189; r++)
|
---|
4186 | + div3[r] = ((r<<1)+3) / 6;
|
---|
4187 | + for (r = 0; r <= 567; r++)
|
---|
4188 | + div9[r] = ((r<<1)+9) / 18;
|
---|
4189 | +
|
---|
4190 | +#if INCREASE_WIN32_PRIORITY
|
---|
4191 | +/*
|
---|
4192 | + * Greatly increase thread and process priority under Win32.
|
---|
4193 | + *
|
---|
4194 | + * -- WARNING -- WinXP has a rather poor priority system, it's basicly
|
---|
4195 | + * "largely ignore me", "normal", or "interfere with some system processes".
|
---|
4196 | + * At least Win9x/ME had "increased" and "decreased" modes, but now those API
|
---|
4197 | + * functions aren't "supported" in WinNT/2K/XP, and we're stuck with the mess
|
---|
4198 | + * we have now. "Normal" is preempted by so much other unimportant stuff,
|
---|
4199 | + * including the idle process, that ScummVM never gets above 75% CPU usage,
|
---|
4200 | + * even when the filter is overworked and the frame rate is getting jerky.
|
---|
4201 | + * Massively increasing BOTH the process and thread priorities (need to boost
|
---|
4202 | + * the process priority to keep audio in sync with the increased thread
|
---|
4203 | + * priority when the frame rate gets jerky) beats Windows into giving the
|
---|
4204 | + * program the time it needs, however, doing things outside ScummVM may be
|
---|
4205 | + * sluggish. I recommend pausing ScummVM prior to shrinking from full-screen
|
---|
4206 | + * to a window, or before switching from ScummVM to some other task. Other
|
---|
4207 | + * than the above mentioned sluggishness, I have not seen any other sort of
|
---|
4208 | + * system instability while running with increased priorities.
|
---|
4209 | + *
|
---|
4210 | + */
|
---|
4211 | +
|
---|
4212 | +/* Rather than check for all Win32 compiler flavors, just check for WIN32 and
|
---|
4213 | + * PRIORITY defines.
|
---|
4214 | + */
|
---|
4215 | +#if defined WIN32 && defined(HIGH_PRIORITY_CLASS) && defined(THREAD_PRIORITY_TIME_CRITICAL)
|
---|
4216 | +
|
---|
4217 | + /* Raise task and thread priority under Win32 */
|
---|
4218 | + SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
|
---|
4219 | + SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
|
---|
4220 | +#endif
|
---|
4221 | +#endif
|
---|
4222 | +}
|
---|
4223 | +
|
---|
4224 | +
|
---|
4225 | +
|
---|
4226 | +/*
|
---|
4227 | + * Resize old src and dst arrays. Also check for problems that require full
|
---|
4228 | + * redraws, rather than using the unchanged pixel buffering. If the ScummVM
|
---|
4229 | + * backend evolves to draw even more things outside the filter than it
|
---|
4230 | + * currently does, some more checks may need to be added, or external flags
|
---|
4231 | + * set in the backend to tell the filter to redraw everything without using
|
---|
4232 | + * the unchanged pixel buffers. The current checks seem to catch everything
|
---|
4233 | + * for now....
|
---|
4234 | + *
|
---|
4235 | + */
|
---|
4236 | +void resize_old_arrays(const uint8 *src, uint8 *dst,
|
---|
4237 | + int w, int h, int scale)
|
---|
4238 | +{
|
---|
4239 | + int w2, h2;
|
---|
4240 | + int32 size, max_scaled_size;
|
---|
4241 | + const uint16 *sptr16 = (const uint16 *) src;
|
---|
4242 | + int overlay_flag = 0;
|
---|
4243 | + int skip_unchanged_pixels_flag;
|
---|
4244 | +
|
---|
4245 | + if (sptr16 < src_addr_min || sptr16 > src_addr_max)
|
---|
4246 | + overlay_flag = 1;
|
---|
4247 | +
|
---|
4248 | + if (scale > max_scale) max_scale = scale;
|
---|
4249 | +
|
---|
4250 | + /* Deal with overlays */
|
---|
4251 | + if (overlay_flag)
|
---|
4252 | + {
|
---|
4253 | + skip_unchanged_pixels_flag = 1;
|
---|
4254 | +
|
---|
4255 | + w2 = w + 2;
|
---|
4256 | + h2 = h + 2;
|
---|
4257 | + size = w2 * h2;
|
---|
4258 | +
|
---|
4259 | + if (size > max_overlay_size)
|
---|
4260 | + {
|
---|
4261 | + max_overlay_size = size;
|
---|
4262 | + old_overlay = (uint16 *) realloc(old_overlay,
|
---|
4263 | + size * sizeof(uint16));
|
---|
4264 | +
|
---|
4265 | + skip_unchanged_pixels_flag = 0;
|
---|
4266 | + }
|
---|
4267 | +
|
---|
4268 | + max_scaled_size = max_scale * max_scale * max_overlay_size;
|
---|
4269 | +
|
---|
4270 | + if (max_scaled_size > max_dst_overlay_size)
|
---|
4271 | + {
|
---|
4272 | + max_dst_overlay_size = max_scaled_size;
|
---|
4273 | + old_dst_overlay = (uint16 *) realloc(old_dst_overlay,
|
---|
4274 | + max_scaled_size * sizeof(uint16));
|
---|
4275 | +
|
---|
4276 | + skip_unchanged_pixels_flag = 0;
|
---|
4277 | + }
|
---|
4278 | +
|
---|
4279 | + cur_overlay_width = w;
|
---|
4280 | + cur_overlay_height = h;
|
---|
4281 | + cur_dst_overlay_width = w * scale;
|
---|
4282 | + cur_dst_overlay_height = h * scale;
|
---|
4283 | + if (cur_overlay_width != old_overlay_width ||
|
---|
4284 | + cur_overlay_height != old_overlay_height ||
|
---|
4285 | + cur_dst_overlay_width != old_dst_overlay_width ||
|
---|
4286 | + cur_dst_overlay_height != old_dst_overlay_height)
|
---|
4287 | + {
|
---|
4288 | + skip_unchanged_pixels_flag = 0;
|
---|
4289 | + }
|
---|
4290 | + old_overlay_width = cur_overlay_width;
|
---|
4291 | + old_overlay_height = cur_overlay_height;
|
---|
4292 | + old_dst_overlay_width = cur_dst_overlay_width;
|
---|
4293 | + old_dst_overlay_height = cur_dst_overlay_height;
|
---|
4294 | +
|
---|
4295 | + if (skip_unchanged_pixels_flag == 0)
|
---|
4296 | + {
|
---|
4297 | + memset(old_overlay, 0, max_overlay_size * sizeof(uint16));
|
---|
4298 | + memset(old_dst_overlay, 0, max_dst_overlay_size * sizeof(uint16));
|
---|
4299 | + }
|
---|
4300 | + }
|
---|
4301 | + else
|
---|
4302 | + {
|
---|
4303 | + w2 = cur_screen_width + 2;
|
---|
4304 | + h2 = cur_screen_height + 2;
|
---|
4305 | + size = w2 * h2;
|
---|
4306 | + }
|
---|
4307 | +
|
---|
4308 | + skip_unchanged_pixels_flag = 1;
|
---|
4309 | +
|
---|
4310 | + if (overlay_flag == 0 && size > max_old_src_size)
|
---|
4311 | + {
|
---|
4312 | + max_old_src_size = size;
|
---|
4313 | + old_src = (uint16 *) realloc(old_src, size * sizeof(uint16));
|
---|
4314 | +
|
---|
4315 | + skip_unchanged_pixels_flag = 0;
|
---|
4316 | + }
|
---|
4317 | +
|
---|
4318 | + max_scaled_size = max_scale * max_scale * max_old_src_size;
|
---|
4319 | +
|
---|
4320 | + if (overlay_flag == 0 && max_scaled_size > max_old_dst_size)
|
---|
4321 | + {
|
---|
4322 | + max_old_dst_size = max_scaled_size;
|
---|
4323 | + old_dst = (uint16 *) realloc(old_dst,
|
---|
4324 | + max_scaled_size * sizeof(uint16));
|
---|
4325 | +
|
---|
4326 | + skip_unchanged_pixels_flag = 0;
|
---|
4327 | + }
|
---|
4328 | +
|
---|
4329 | + /* screen dimensions have changed */
|
---|
4330 | + if (cur_screen_width != old_screen_width ||
|
---|
4331 | + cur_screen_height != old_screen_height)
|
---|
4332 | + {
|
---|
4333 | + skip_unchanged_pixels_flag = 0;
|
---|
4334 | + }
|
---|
4335 | + old_screen_width = cur_screen_width;
|
---|
4336 | + old_screen_height = cur_screen_height;
|
---|
4337 | +
|
---|
4338 | + cur_dst_screen_width = cur_screen_width * scale;
|
---|
4339 | + cur_dst_screen_height = cur_screen_height * scale;
|
---|
4340 | + if (cur_dst_screen_width != old_dst_screen_width ||
|
---|
4341 | + cur_dst_screen_height != old_dst_screen_height)
|
---|
4342 | + {
|
---|
4343 | + skip_unchanged_pixels_flag = 0;
|
---|
4344 | + }
|
---|
4345 | + old_dst_screen_width = cur_dst_screen_width;
|
---|
4346 | + old_dst_screen_height = cur_dst_screen_height;
|
---|
4347 | +
|
---|
4348 | + /* set all the buffers to 0, so that everything gets redrawn */
|
---|
4349 | + if (skip_unchanged_pixels_flag == 0)
|
---|
4350 | + {
|
---|
4351 | + memset(old_src, 0, max_old_src_size * sizeof(uint16));
|
---|
4352 | + memset(old_dst, 0, max_old_dst_size * sizeof(uint16));
|
---|
4353 | + memset(old_overlay, 0, max_overlay_size * sizeof(uint16));
|
---|
4354 | + memset(old_dst_overlay, 0, max_dst_overlay_size * sizeof(uint16));
|
---|
4355 | + }
|
---|
4356 | +}
|
---|
4357 | +
|
---|
4358 | +
|
---|
4359 | +
|
---|
4360 | +/* Fill old src array, which is used in checking for unchanged pixels */
|
---|
4361 | +void fill_old_src(const uint8 *src, int srcPitch, int w, int h)
|
---|
4362 | +{
|
---|
4363 | + int x, y;
|
---|
4364 | + int x2, y2;
|
---|
4365 | + const uint16 *sptr16 = (const uint16 *) src;
|
---|
4366 | + const uint16 *sptr2;
|
---|
4367 | + uint16 *optr16;
|
---|
4368 | + int32 screen_width2 = cur_screen_width + 2;
|
---|
4369 | + int32 dist = src - (const uint8 *) src_addr_min;
|
---|
4370 | + int32 x_fudge;
|
---|
4371 | + int32 src_fudge;
|
---|
4372 | +
|
---|
4373 | + /* Deal with overlays */
|
---|
4374 | + if (sptr16 < src_addr_min || sptr16 > src_addr_max)
|
---|
4375 | + {
|
---|
4376 | + w += 2;
|
---|
4377 | + h += 2;
|
---|
4378 | +
|
---|
4379 | + optr16 = old_overlay;
|
---|
4380 | + sptr2 = (const uint16 *) (src - srcPitch) - 1;
|
---|
4381 | +
|
---|
4382 | + x_fudge = 0;
|
---|
4383 | + src_fudge = srcPitch - w - w;
|
---|
4384 | + }
|
---|
4385 | + else
|
---|
4386 | + {
|
---|
4387 | + y = dist / srcPitch;
|
---|
4388 | + x = (dist - y * srcPitch) >> 1;
|
---|
4389 | +
|
---|
4390 | + optr16 = old_src + (y + 1) * screen_width2 + x + 1;
|
---|
4391 | + sptr2 = (const uint16 *) src;
|
---|
4392 | +
|
---|
4393 | + x_fudge = screen_width2 - w;
|
---|
4394 | + src_fudge = srcPitch - w - w;
|
---|
4395 | + }
|
---|
4396 | +
|
---|
4397 | + for (y2 = 0; y2 < h; y2++)
|
---|
4398 | + {
|
---|
4399 | + for (x2 = 0; x2 < w; x2++)
|
---|
4400 | + *optr16++ = *sptr2++;
|
---|
4401 | +
|
---|
4402 | + optr16 += x_fudge;
|
---|
4403 | + sptr2 = (const uint16 *) ((const uint8 *) sptr2 + src_fudge);
|
---|
4404 | + }
|
---|
4405 | +}
|
---|
4406 | +
|
---|
4407 | +
|
---|
4408 | +
|
---|
4409 | +/* Fill old dst array, which is used in drawing unchanged pixels */
|
---|
4410 | +void fill_old_dst(const uint8 *src, uint8 *dst, int srcPitch, int dstPitch,
|
---|
4411 | + int w, int h, int scale)
|
---|
4412 | +{
|
---|
4413 | + int x, y;
|
---|
4414 | + int x2, y2;
|
---|
4415 | +
|
---|
4416 | + const uint16 *sptr16 = (const uint16 *) src;
|
---|
4417 | + uint16 *dptr2;
|
---|
4418 | + uint16 *optr16;
|
---|
4419 | + int32 screen_width_scaled = cur_screen_width * scale;
|
---|
4420 | + int32 dist;
|
---|
4421 | + int w_new = w * scale;
|
---|
4422 | + int h_new = h * scale;
|
---|
4423 | + int32 x_fudge;
|
---|
4424 | + int32 dst_fudge;
|
---|
4425 | +
|
---|
4426 | + /* Deal with overlays */
|
---|
4427 | + if (sptr16 < src_addr_min || sptr16 > src_addr_max)
|
---|
4428 | + {
|
---|
4429 | + optr16 = old_dst_overlay;
|
---|
4430 | + dptr2 = (uint16 *) dst;
|
---|
4431 | + x_fudge = 0;
|
---|
4432 | + dst_fudge = dstPitch - w_new - w_new;
|
---|
4433 | + }
|
---|
4434 | + else
|
---|
4435 | + {
|
---|
4436 | + dist = src - (const uint8 *) src_addr_min;
|
---|
4437 | + y = dist / srcPitch;
|
---|
4438 | + x = (dist - y * srcPitch) >> 1;
|
---|
4439 | +
|
---|
4440 | + optr16 = old_dst + scale * (y * screen_width_scaled + x);
|
---|
4441 | + dptr2 = (uint16 *) dst;
|
---|
4442 | +
|
---|
4443 | + x_fudge = screen_width_scaled - w_new;
|
---|
4444 | + dst_fudge = dstPitch - w_new - w_new;
|
---|
4445 | + }
|
---|
4446 | +
|
---|
4447 | + for (y2 = 0; y2 < h_new; y2++)
|
---|
4448 | + {
|
---|
4449 | + for (x2 = 0; x2 < w_new; x2++)
|
---|
4450 | + *optr16++ = *dptr2++;
|
---|
4451 | +
|
---|
4452 | + optr16 += x_fudge;
|
---|
4453 | + dptr2 = (uint16 *) ((uint8 *) dptr2 + dst_fudge);
|
---|
4454 | + }
|
---|
4455 | +}
|
---|
4456 | +
|
---|
4457 | +
|
---|
4458 | +
|
---|
4459 | +/* 3x anti-aliased resize filter, nearest-neighbor anti-aliasing */
|
---|
4460 | +void Edge3x(const uint8 *srcPtr, uint32 srcPitch,
|
---|
4461 | + uint8 *dstPtr, uint32 dstPitch, int width, int height)
|
---|
4462 | +{
|
---|
4463 | + /* Initialize stuff */
|
---|
4464 | + if (!init_flag)
|
---|
4465 | + {
|
---|
4466 | + cur_screen_width = g_system->getWidth();
|
---|
4467 | + cur_screen_height = g_system->getHeight();
|
---|
4468 | +
|
---|
4469 | + /* set initial best guess on min/max screen addresses */
|
---|
4470 | + /* indent by 1 in case only the mouse is ever drawn */
|
---|
4471 | + src_addr_min = (const uint16 *) srcPtr + 1;
|
---|
4472 | + src_addr_max = ((const uint16 *) (srcPtr + (height - 1) *
|
---|
4473 | + srcPitch)) + (width - 1) - 1;
|
---|
4474 | +
|
---|
4475 | + init_tables(srcPtr, srcPitch, width, height);
|
---|
4476 | + init_flag = 1;
|
---|
4477 | + }
|
---|
4478 | +
|
---|
4479 | + /* Uh oh, the screen size has changed */
|
---|
4480 | + if (cur_screen_width != g_system->getWidth() ||
|
---|
4481 | + cur_screen_height != g_system->getHeight())
|
---|
4482 | + {
|
---|
4483 | + cur_screen_width = g_system->getWidth();
|
---|
4484 | + cur_screen_height = g_system->getHeight();
|
---|
4485 | + src_addr_min = (const uint16 *) srcPtr;
|
---|
4486 | + src_addr_max = ((const uint16 *) (srcPtr + (height - 1) * srcPitch)) +
|
---|
4487 | + (width - 1);
|
---|
4488 | + }
|
---|
4489 | +
|
---|
4490 | + /* Ah ha, we're doing the whole screen, so we can save the bounds of the
|
---|
4491 | + src array for later bounds checking */
|
---|
4492 | + if (width == g_system->getWidth() &&
|
---|
4493 | + height == g_system->getHeight())
|
---|
4494 | + {
|
---|
4495 | + src_addr_min = (const uint16 *) srcPtr;
|
---|
4496 | + src_addr_max = ((const uint16 *) (srcPtr + (height - 1) * srcPitch)) +
|
---|
4497 | + (width - 1);
|
---|
4498 | + }
|
---|
4499 | +
|
---|
4500 | + /* resize and/or blank the old src and dst array */
|
---|
4501 | + resize_old_arrays(srcPtr, dstPtr, width, height, 3);
|
---|
4502 | +
|
---|
4503 | + /* Hmm, the src address isn't within the proper bounds.
|
---|
4504 | + * We're probably drawing an overlay now.
|
---|
4505 | + */
|
---|
4506 | + if ((const uint16 *) srcPtr < src_addr_min ||
|
---|
4507 | + (const uint16 *) srcPtr > src_addr_max)
|
---|
4508 | + {
|
---|
4509 | + anti_alias_pass_3x(srcPtr, dstPtr, width, height,
|
---|
4510 | + 3*width, 3*height, srcPitch, dstPitch, 1);
|
---|
4511 | + }
|
---|
4512 | + else /* Draw the regular screen, this isn't an overlay. */
|
---|
4513 | + {
|
---|
4514 | + anti_alias_pass_3x(srcPtr, dstPtr, width, height,
|
---|
4515 | + 3*width, 3*height, srcPitch, dstPitch, 0);
|
---|
4516 | + }
|
---|
4517 | +
|
---|
4518 | + /* fill old src array */
|
---|
4519 | + fill_old_src(srcPtr, srcPitch, width, height);
|
---|
4520 | + fill_old_dst(srcPtr, dstPtr, srcPitch, dstPitch, width, height, 3);
|
---|
4521 | +}
|
---|
4522 | +
|
---|
4523 | +
|
---|
4524 | +
|
---|
4525 | +/* 2x anti-aliased resize filter, nearest-neighbor anti-aliasing */
|
---|
4526 | +void Edge2x(const uint8 *srcPtr, uint32 srcPitch,
|
---|
4527 | + uint8 *dstPtr, uint32 dstPitch, int width, int height)
|
---|
4528 | +{
|
---|
4529 | + /* Initialize stuff */
|
---|
4530 | + if (!init_flag)
|
---|
4531 | + {
|
---|
4532 | + cur_screen_width = g_system->getWidth();
|
---|
4533 | + cur_screen_height = g_system->getHeight();
|
---|
4534 | +
|
---|
4535 | + /* set initial best guess on min/max screen addresses */
|
---|
4536 | + /* indent by 1 in case only the mouse is ever drawn */
|
---|
4537 | + src_addr_min = (const uint16 *) srcPtr + 1;
|
---|
4538 | + src_addr_max = ((const uint16 *) (srcPtr + (height - 1) *
|
---|
4539 | + srcPitch)) + (width - 1) - 1;
|
---|
4540 | +
|
---|
4541 | + init_tables(srcPtr, srcPitch, width, height);
|
---|
4542 | + init_flag = 1;
|
---|
4543 | + }
|
---|
4544 | +
|
---|
4545 | + /* Uh oh, the screen size has changed */
|
---|
4546 | + if (cur_screen_width != g_system->getWidth() ||
|
---|
4547 | + cur_screen_height != g_system->getHeight())
|
---|
4548 | + {
|
---|
4549 | + cur_screen_width = g_system->getWidth();
|
---|
4550 | + cur_screen_height = g_system->getHeight();
|
---|
4551 | + src_addr_min = (const uint16 *) srcPtr;
|
---|
4552 | + src_addr_max = ((const uint16 *) (srcPtr + (height - 1) * srcPitch)) +
|
---|
4553 | + (width - 1);
|
---|
4554 | + }
|
---|
4555 | +
|
---|
4556 | + /* Ah ha, we're doing the whole screen, so we can save the bounds of the
|
---|
4557 | + src array for later bounds checking */
|
---|
4558 | + if (width == g_system->getWidth() &&
|
---|
4559 | + height == g_system->getHeight())
|
---|
4560 | + {
|
---|
4561 | + src_addr_min = (const uint16 *) srcPtr;
|
---|
4562 | + src_addr_max = ((const uint16 *) (srcPtr + (height - 1) * srcPitch)) +
|
---|
4563 | + (width - 1);
|
---|
4564 | + }
|
---|
4565 | +
|
---|
4566 | + /* resize and/or blank the old src and dst array */
|
---|
4567 | + resize_old_arrays(srcPtr, dstPtr, width, height, 2);
|
---|
4568 | +
|
---|
4569 | + /* Hmm, the src address isn't within the proper bounds.
|
---|
4570 | + * We're probably drawing an overlay now.
|
---|
4571 | + */
|
---|
4572 | + if ((const uint16 *) srcPtr < src_addr_min ||
|
---|
4573 | + (const uint16 *) srcPtr > src_addr_max)
|
---|
4574 | + {
|
---|
4575 | + anti_alias_pass_2x(srcPtr, dstPtr, width, height,
|
---|
4576 | + 2*width, 2*height, srcPitch, dstPitch, 1, 0);
|
---|
4577 | + }
|
---|
4578 | + else /* Draw the regular screen, this isn't an overlay. */
|
---|
4579 | + {
|
---|
4580 | + anti_alias_pass_2x(srcPtr, dstPtr, width, height,
|
---|
4581 | + 2*width, 2*height, srcPitch, dstPitch, 0, 0);
|
---|
4582 | + }
|
---|
4583 | +
|
---|
4584 | + /* fill old src array */
|
---|
4585 | + fill_old_src(srcPtr, srcPitch, width, height);
|
---|
4586 | + fill_old_dst(srcPtr, dstPtr, srcPitch, dstPitch, width, height, 2);
|
---|
4587 | +}
|
---|
4588 | +
|
---|
4589 | +
|
---|
4590 | +
|
---|
4591 | +/*
|
---|
4592 | + * 2x anti-aliased resize filter, interpolation based anti-aliasing.
|
---|
4593 | + * This is useful prior to upsizing with the 1.5x filter for the menu
|
---|
4594 | + * overlay. Nearest-neighbor looks bad with 1.5x resize. Interpolated gives
|
---|
4595 | + * results that look good, like a somewhat blurry Edge3x.
|
---|
4596 | + *
|
---|
4597 | + */
|
---|
4598 | +void Edge2x_Interp(const uint8 *srcPtr, uint32 srcPitch,
|
---|
4599 | + uint8 *dstPtr, uint32 dstPitch, int width, int height)
|
---|
4600 | +{
|
---|
4601 | + /* Initialize stuff */
|
---|
4602 | + if (!init_flag)
|
---|
4603 | + {
|
---|
4604 | + cur_screen_width = g_system->getWidth();
|
---|
4605 | + cur_screen_height = g_system->getHeight();
|
---|
4606 | +
|
---|
4607 | + /* set initial best guess on min/max screen addresses */
|
---|
4608 | + /* indent by 1 in case only the mouse is ever drawn */
|
---|
4609 | + src_addr_min = (const uint16 *) srcPtr + 1;
|
---|
4610 | + src_addr_max = ((const uint16 *) (srcPtr + (height - 1) *
|
---|
4611 | + srcPitch)) + (width - 1) - 1;
|
---|
4612 | +
|
---|
4613 | + init_tables(srcPtr, srcPitch, width, height);
|
---|
4614 | + init_flag = 1;
|
---|
4615 | + }
|
---|
4616 | +
|
---|
4617 | + /* Uh oh, the screen size has changed */
|
---|
4618 | + if (cur_screen_width != g_system->getWidth() ||
|
---|
4619 | + cur_screen_height != g_system->getHeight())
|
---|
4620 | + {
|
---|
4621 | + cur_screen_width = g_system->getWidth();
|
---|
4622 | + cur_screen_height = g_system->getHeight();
|
---|
4623 | + src_addr_min = (const uint16 *) srcPtr;
|
---|
4624 | + src_addr_max = ((const uint16 *) (srcPtr + (height - 1) * srcPitch)) +
|
---|
4625 | + (width - 1);
|
---|
4626 | + }
|
---|
4627 | +
|
---|
4628 | + /* Ah ha, we're doing the whole screen, so we can save the bounds of the
|
---|
4629 | + src array for later bounds checking */
|
---|
4630 | + if (width == g_system->getWidth() &&
|
---|
4631 | + height == g_system->getHeight())
|
---|
4632 | + {
|
---|
4633 | + src_addr_min = (const uint16 *) srcPtr;
|
---|
4634 | + src_addr_max = ((const uint16 *) (srcPtr + (height - 1) * srcPitch)) +
|
---|
4635 | + (width - 1);
|
---|
4636 | + }
|
---|
4637 | +
|
---|
4638 | + /* resize and/or blank the old src and dst array */
|
---|
4639 | + resize_old_arrays(srcPtr, dstPtr, width, height, 2);
|
---|
4640 | +
|
---|
4641 | + /* Hmm, the src address isn't within the proper bounds.
|
---|
4642 | + * We're probably drawing an overlay now.
|
---|
4643 | + */
|
---|
4644 | + if ((const uint16 *) srcPtr < src_addr_min ||
|
---|
4645 | + (const uint16 *) srcPtr > src_addr_max)
|
---|
4646 | + {
|
---|
4647 | + anti_alias_pass_2x(srcPtr, dstPtr, width, height,
|
---|
4648 | + 2*width, 2*height, srcPitch, dstPitch, 1, 0);
|
---|
4649 | + }
|
---|
4650 | + else /* Draw the regular screen, this isn't an overlay. */
|
---|
4651 | + {
|
---|
4652 | + anti_alias_pass_2x(srcPtr, dstPtr, width, height,
|
---|
4653 | + 2*width, 2*height, srcPitch, dstPitch, 0, 1);
|
---|
4654 | + }
|
---|
4655 | +
|
---|
4656 | + /* fill old src array */
|
---|
4657 | + fill_old_src(srcPtr, srcPitch, width, height);
|
---|
4658 | + fill_old_dst(srcPtr, dstPtr, srcPitch, dstPitch, width, height, 2);
|
---|
4659 | +}
|
---|
4660 | diff -ruN -b backup_version/graphics/scaler.h new_version/graphics/scaler.h
|
---|
4661 | --- backup_version/graphics/scaler.h 2006-07-30 00:48:00.000000000 -0500
|
---|
4662 | +++ new_version/graphics/scaler.h 2006-07-31 04:29:20.000000000 -0500
|
---|
4663 | @@ -46,6 +46,9 @@
|
---|
4664 | DECLARE_SCALER(Normal1o5x);
|
---|
4665 | DECLARE_SCALER(TV2x);
|
---|
4666 | DECLARE_SCALER(DotMatrix);
|
---|
4667 | +DECLARE_SCALER(Edge2x);
|
---|
4668 | +DECLARE_SCALER(Edge2x_Interp);
|
---|
4669 | +DECLARE_SCALER(Edge3x);
|
---|
4670 |
|
---|
4671 | #ifndef DISABLE_HQ_SCALERS
|
---|
4672 | DECLARE_SCALER(HQ2x);
|
---|