From 55ed757c5fc4a2ef465374adcd65069d2235955b Mon Sep 17 00:00:00 2001 From: Dana Jansens Date: Thu, 4 Sep 2003 06:23:27 +0000 Subject: [PATCH] new scaling, based on the Bresenham algorithm --- render/image.c | 206 ++++++++++++++++++++++++++++++++++++------------- 1 file changed, 151 insertions(+), 55 deletions(-) diff --git a/render/image.c b/render/image.c index 2ec71043..7e29aa6e 100644 --- a/render/image.c +++ b/render/image.c @@ -4,70 +4,166 @@ #include -void RrImageDraw(RrPixel32 *target, RrTextureRGBA *rgba, RrRect *area) +#define AVERAGE(a, b) ( ((((a) ^ (b)) & 0xfefefefeL) >> 1) + ((a) & (b)) ) + +static void scale_line(RrPixel32 *dest, RrPixel32 *source, gint w, gint dw) { - RrPixel32 *draw = rgba->data; - gint c, i, e, t, sfw, sfh; - sfw = area->width; - sfh = area->height; - - g_assert(rgba->data != NULL); - - if ((rgba->width != sfw || rgba->height != sfh) && - (rgba->width != rgba->cwidth || rgba->height != rgba->cheight)) { - double dx = rgba->width / (double)sfw; - double dy = rgba->height / (double)sfh; - double px = 0.0; - double py = 0.0; - int iy = 0; - - /* scale it and cache it */ - if (rgba->cache != NULL) - g_free(rgba->cache); - rgba->cache = g_new(RrPixel32, sfw * sfh); - rgba->cwidth = sfw; - rgba->cheight = sfh; - for (i = 0, c = 0, e = sfw*sfh; i < e; ++i) { - rgba->cache[i] = rgba->data[(int)px + iy]; - if (++c >= sfw) { - c = 0; - px = 0; - py += dy; - iy = (int)py * rgba->width; - } else - px += dx; + gint num_pixels = dw; + gint int_part = w / dw; + gint fract_part = w % dw; + gint err = 0; + + while (num_pixels-- > 0) { + *dest++ = *source; + source += int_part; + err += fract_part; + if (err >= dw) { + err -= dw; + source++; } + } +} + +static RrPixel32* scale_half(RrPixel32 *source, gint w, gint h) +{ + RrPixel32 *out, *dest, *sourceline, *sourceline2; + gint dw, dh, x, y; + + sourceline = source; + sourceline2 = source + w; + + dw = w >> 1; + dh = h >> 1; + + out = dest = g_new(RrPixel32, dw * dh); - /* do we use the cache we may have just created, or the original? */ - if (rgba->width != sfw || rgba->height != sfh) - draw = rgba->cache; + for (y = 0; y < dh; ++y) { + RrPixel32 *s, *s2; + + s = sourceline; + s2 = sourceline2; + + for (x = 0; x < dw; ++x) { + *dest++ = AVERAGE(AVERAGE(*s, *(s+1)), + AVERAGE(*s2, *(s2+1))); + s += 2; + s2 += 2; + } + sourceline += w << 1; + sourceline2 += w << 1; + } + return out; +} + +static RrPixel32* scale_rect(RrPixel32 *fullsource, + gint w, gint h, gint dw, gint dh) +{ + RrPixel32 *out, *dest; + RrPixel32 *source = fullsource; + RrPixel32 *oldsource = NULL; + RrPixel32 *prev_source = NULL; + gint num_pixels; + gint int_part; + gint fract_part; + gint err = 0; + + while (dw <= (w >> 1) && dh <= (h >> 1)) { + source = scale_half(source, w, h); + w >>= 1; h >>= 1; + g_free(oldsource); + oldsource = source; + } + + num_pixels = dh; + int_part = (h / dh) * w; + fract_part = h % dh; + + out = dest = g_new(RrPixel32, dw * dh); + + while (num_pixels-- > 0) { + if (source == prev_source) { + memcpy(dest, dest - dw, dw * sizeof(RrPixel32)); + } else { + scale_line(dest, source, w, dw); + prev_source = source; + } + dest += dw; + source += int_part; + err += fract_part; + if (err >= dh) { + err -= dh; + source += w; + } + } + + g_free(oldsource); + + return out; +} + +void RrImageDraw(RrPixel32 *target, RrTextureRGBA *rgba, + gint target_w, gint target_h, + RrRect *area) +{ + RrPixel32 *dest; + RrPixel32 *source; + gint sw, sh, dw, dh; + gint col, num_pixels; + + sw = rgba->width; + sh = rgba->height; + + /* keep the ratio */ + dw = area->width; + dh = (int)(dw * ((double)sh / sw)); + if (dh > area->height) { + dh = area->height; + dw = (int)(dh * ((double)sw / sh)); + } + + if (sw != dw || sh != dh) { + /*if (!(rgba->cache && dw == rgba->cwidth && dh == rgba->cheight))*/ { + g_free(rgba->cache); + rgba->cache = scale_rect(rgba->data, sw, sh, dw, dh); + rgba->cwidth = dw; + rgba->cheight = dh; + } + source = rgba->cache; + } else { + source = rgba->data; + } - /* apply the alpha channel */ - for (i = 0, c = 0, t = area->x, e = sfw*sfh; i < e; ++i, ++t) { - guchar alpha, r, g, b, bgr, bgg, bgb; + /* copy source -> dest, and apply the alpha channel */ + col = 0; + num_pixels = dw * dh; + dest = target + area->x + target_w * area->y; + while (num_pixels-- > 0) { + guchar alpha, r, g, b, bgr, bgg, bgb; - alpha = draw[i] >> RrDefaultAlphaOffset; - r = draw[i] >> RrDefaultRedOffset; - g = draw[i] >> RrDefaultGreenOffset; - b = draw[i] >> RrDefaultBlueOffset; + alpha = *source >> RrDefaultAlphaOffset; + r = *source >> RrDefaultRedOffset; + g = *source >> RrDefaultGreenOffset; + b = *source >> RrDefaultBlueOffset; + + /* background color */ + bgr = *dest >> RrDefaultRedOffset; + bgg = *dest >> RrDefaultGreenOffset; + bgb = *dest >> RrDefaultBlueOffset; - if (c >= sfw) { - c = 0; - t += area->width - sfw; - } + r = bgr + (((r - bgr) * alpha) >> 8); + g = bgg + (((g - bgg) * alpha) >> 8); + b = bgb + (((b - bgb) * alpha) >> 8); - /* background color */ - bgr = target[t] >> RrDefaultRedOffset; - bgg = target[t] >> RrDefaultGreenOffset; - bgb = target[t] >> RrDefaultBlueOffset; + *dest = ((r << RrDefaultRedOffset) | + (g << RrDefaultGreenOffset) | + (b << RrDefaultBlueOffset)); - r = bgr + (((r - bgr) * alpha) >> 8); - g = bgg + (((g - bgg) * alpha) >> 8); - b = bgb + (((b - bgb) * alpha) >> 8); + dest++; + source++; - target[t] = (r << RrDefaultRedOffset) - | (g << RrDefaultGreenOffset) - | (b << RrDefaultBlueOffset); + if (col++ >= dw) { + col = 0; + dest += target_w - dw; } } } -- 2.39.2