mirror of https://github.com/GNOME/gimp.git
app: remove PixelSurround, no clue when it became unused
This commit is contained in:
parent
6a9a37d3d9
commit
1f09580aba
|
@ -29,8 +29,6 @@ libappbase_a_SOURCES = \
|
||||||
pixel-processor.h \
|
pixel-processor.h \
|
||||||
pixel-region.c \
|
pixel-region.c \
|
||||||
pixel-region.h \
|
pixel-region.h \
|
||||||
pixel-surround.c \
|
|
||||||
pixel-surround.h \
|
|
||||||
siox.c \
|
siox.c \
|
||||||
siox.h \
|
siox.h \
|
||||||
temp-buf.c \
|
temp-buf.c \
|
||||||
|
|
|
@ -51,8 +51,6 @@ typedef struct _PixelRegionIterator PixelRegionIterator;
|
||||||
typedef struct _PixelRegion PixelRegion;
|
typedef struct _PixelRegion PixelRegion;
|
||||||
typedef struct _PixelRegionHolder PixelRegionHolder;
|
typedef struct _PixelRegionHolder PixelRegionHolder;
|
||||||
|
|
||||||
typedef struct _PixelSurround PixelSurround;
|
|
||||||
|
|
||||||
typedef struct _SioxState SioxState;
|
typedef struct _SioxState SioxState;
|
||||||
|
|
||||||
typedef struct _TempBuf TempBuf;
|
typedef struct _TempBuf TempBuf;
|
||||||
|
|
|
@ -1,419 +0,0 @@
|
||||||
/* GIMP - The GNU Image Manipulation Program
|
|
||||||
* Copyright (C) 1995-2001 Spencer Kimball, Peter Mattis, and others
|
|
||||||
*
|
|
||||||
* This program is free software: you can redistribute it and/or modify
|
|
||||||
* it under the terms of the GNU General Public License as published by
|
|
||||||
* the Free Software Foundation; either version 3 of the License, or
|
|
||||||
* (at your option) any later version.
|
|
||||||
*
|
|
||||||
* This program is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*
|
|
||||||
* You should have received a copy of the GNU General Public License
|
|
||||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "config.h"
|
|
||||||
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include <glib-object.h>
|
|
||||||
|
|
||||||
#include "base-types.h"
|
|
||||||
|
|
||||||
#include "pixel-region.h"
|
|
||||||
#include "pixel-surround.h"
|
|
||||||
#include "tile-manager.h"
|
|
||||||
#include "tile.h"
|
|
||||||
|
|
||||||
|
|
||||||
struct _PixelSurround
|
|
||||||
{
|
|
||||||
TileManager *mgr; /* tile manager to access tiles from */
|
|
||||||
gint xmax; /* largest x coordinate in tile manager */
|
|
||||||
gint ymax; /* largest y coordinate in tile manager */
|
|
||||||
gint bpp; /* bytes per pixel in tile manager */
|
|
||||||
gint w; /* width of pixel surround area */
|
|
||||||
gint h; /* height of pixel surround area */
|
|
||||||
Tile *tile; /* locked tile (may be NULL) */
|
|
||||||
gint tile_x; /* origin of locked tile */
|
|
||||||
gint tile_y; /* origin of locked tile */
|
|
||||||
gint tile_w; /* width of locked tile */
|
|
||||||
gint tile_h; /* height of locked tile */
|
|
||||||
gint rowstride; /* rowstride of buffers */
|
|
||||||
guchar *bg; /* buffer filled with background color */
|
|
||||||
guchar *buf; /* buffer used for combining tile data */
|
|
||||||
PixelSurroundMode mode;
|
|
||||||
};
|
|
||||||
|
|
||||||
static const guchar * pixel_surround_get_data (PixelSurround *surround,
|
|
||||||
gint x,
|
|
||||||
gint y,
|
|
||||||
gint *w,
|
|
||||||
gint *h,
|
|
||||||
gint *rowstride);
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* pixel_surround_new:
|
|
||||||
* @tiles: tile manager
|
|
||||||
* @width: width of surround region
|
|
||||||
* @height: height of surround region
|
|
||||||
* @mode: how to deal with pixels that are not covered by the tile manager
|
|
||||||
*
|
|
||||||
* PixelSurround provides you a contiguous read-only view of the area
|
|
||||||
* surrounding a pixel. It is an efficient pixel access strategy for
|
|
||||||
* interpolation algorithms.
|
|
||||||
*
|
|
||||||
* Return value: a new #PixelSurround.
|
|
||||||
*/
|
|
||||||
PixelSurround *
|
|
||||||
pixel_surround_new (TileManager *tiles,
|
|
||||||
gint width,
|
|
||||||
gint height,
|
|
||||||
PixelSurroundMode mode)
|
|
||||||
{
|
|
||||||
PixelSurround *surround;
|
|
||||||
|
|
||||||
g_return_val_if_fail (tiles != NULL, NULL);
|
|
||||||
g_return_val_if_fail (width < TILE_WIDTH, NULL);
|
|
||||||
g_return_val_if_fail (height < TILE_WIDTH, NULL);
|
|
||||||
|
|
||||||
surround = g_slice_new0 (PixelSurround);
|
|
||||||
|
|
||||||
surround->mgr = tiles;
|
|
||||||
surround->xmax = tile_manager_width (surround->mgr) - 1;
|
|
||||||
surround->ymax = tile_manager_height (surround->mgr) - 1;
|
|
||||||
surround->bpp = tile_manager_bpp (tiles);
|
|
||||||
surround->w = width;
|
|
||||||
surround->h = height;
|
|
||||||
surround->rowstride = width * surround->bpp;
|
|
||||||
surround->bg = g_new0 (guchar, surround->rowstride * height);
|
|
||||||
surround->buf = g_new (guchar, surround->rowstride * height);
|
|
||||||
surround->mode = mode;
|
|
||||||
|
|
||||||
return surround;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* pixel_surround_set_bg:
|
|
||||||
* @surround: a #PixelSurround
|
|
||||||
* @bg: background color
|
|
||||||
*
|
|
||||||
* This sets the color that the #PixelSurround uses when in
|
|
||||||
* %PIXEL_SURROUND_BACKGROUND mode for pixels that are not covered by
|
|
||||||
* the tile manager.
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
pixel_surround_set_bg (PixelSurround *surround,
|
|
||||||
const guchar *bg)
|
|
||||||
{
|
|
||||||
guchar *dest = surround->bg;
|
|
||||||
gint pixels = surround->w * surround->h;
|
|
||||||
|
|
||||||
while (pixels--)
|
|
||||||
{
|
|
||||||
gint i;
|
|
||||||
|
|
||||||
for (i = 0; i < surround->bpp; i++)
|
|
||||||
*dest++ = bg[i];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* pixel_surround_lock:
|
|
||||||
* @surround: a #PixelSurround
|
|
||||||
* @x: X coordinate of upper left corner
|
|
||||||
* @y: Y coordinate of upper left corner
|
|
||||||
* @rowstride: return location for rowstride
|
|
||||||
*
|
|
||||||
* Gives access to a region of pixels. The upper left corner is
|
|
||||||
* specified by the @x and @y parameters. The size of the region
|
|
||||||
* is determined by the dimensions given when creating the @surround.
|
|
||||||
*
|
|
||||||
* When you don't need to read from the pixels any longer, you should
|
|
||||||
* unlock the @surround using pixel_surround_unlock(). If you need a
|
|
||||||
* different region, just call pixel_surround_lock() again.
|
|
||||||
*
|
|
||||||
* Return value: pointer to pixel data (read-only)
|
|
||||||
*/
|
|
||||||
const guchar *
|
|
||||||
pixel_surround_lock (PixelSurround *surround,
|
|
||||||
gint x,
|
|
||||||
gint y,
|
|
||||||
gint *rowstride)
|
|
||||||
{
|
|
||||||
const guchar *src;
|
|
||||||
gint w, h;
|
|
||||||
|
|
||||||
src = pixel_surround_get_data (surround, x, y, &w, &h, rowstride);
|
|
||||||
|
|
||||||
if (w >= surround->w && h >= surround->h)
|
|
||||||
{
|
|
||||||
/* return a pointer to the data if it covers the whole region */
|
|
||||||
return src;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* otherwise, copy region to our internal buffer */
|
|
||||||
guchar *dest = surround->buf;
|
|
||||||
gint inc = surround->w;
|
|
||||||
gint i = 0;
|
|
||||||
gint j = 0;
|
|
||||||
|
|
||||||
/* These loops are somewhat twisted. The idea is to make as few
|
|
||||||
* calls to pixel_surround_get_data() as possible. Thus whenever we
|
|
||||||
* have source data, we copy all of it to the destination buffer.
|
|
||||||
* The inner loops that copy data are nested into outer loops that
|
|
||||||
* make sure that the destination area is completley filled.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* jump right into the loops since we already have source data */
|
|
||||||
goto start;
|
|
||||||
|
|
||||||
while (i < surround->w)
|
|
||||||
{
|
|
||||||
dest = surround->buf + i * surround->bpp;
|
|
||||||
|
|
||||||
for (j = 0; j < surround->h;)
|
|
||||||
{
|
|
||||||
gint rows;
|
|
||||||
|
|
||||||
src = pixel_surround_get_data (surround,
|
|
||||||
x + i, y + j, &w, &h, rowstride);
|
|
||||||
|
|
||||||
start:
|
|
||||||
|
|
||||||
w = MIN (w, surround->w - i);
|
|
||||||
h = MIN (h, surround->h - j);
|
|
||||||
|
|
||||||
rows = h;
|
|
||||||
|
|
||||||
while (rows--)
|
|
||||||
{
|
|
||||||
memcpy (dest, src, w * surround->bpp);
|
|
||||||
|
|
||||||
src += *rowstride;
|
|
||||||
dest += surround->rowstride;
|
|
||||||
}
|
|
||||||
|
|
||||||
j += h;
|
|
||||||
inc = MIN (inc, w);
|
|
||||||
}
|
|
||||||
|
|
||||||
i += inc;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
*rowstride = surround->rowstride;
|
|
||||||
|
|
||||||
return surround->buf;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* pixel_surround_release:
|
|
||||||
* @surround: #PixelSurround
|
|
||||||
*
|
|
||||||
* Unlocks pixels locked by @surround. See pixel_surround_lock().
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
pixel_surround_release (PixelSurround *surround)
|
|
||||||
{
|
|
||||||
if (surround->tile)
|
|
||||||
{
|
|
||||||
tile_release (surround->tile, FALSE);
|
|
||||||
surround->tile = NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* pixel_surround_destroy:
|
|
||||||
* @surround: #PixelSurround
|
|
||||||
*
|
|
||||||
* Unlocks pixels and frees any resources allocated for @surround. You
|
|
||||||
* must not use @surround any longer after calling this function.
|
|
||||||
*/
|
|
||||||
void
|
|
||||||
pixel_surround_destroy (PixelSurround *surround)
|
|
||||||
{
|
|
||||||
g_return_if_fail (surround != NULL);
|
|
||||||
|
|
||||||
pixel_surround_release (surround);
|
|
||||||
|
|
||||||
g_free (surround->buf);
|
|
||||||
g_free (surround->bg);
|
|
||||||
|
|
||||||
g_slice_free (PixelSurround, surround);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
enum
|
|
||||||
{
|
|
||||||
LEFT = 1 << 0,
|
|
||||||
RIGHT = 1 << 1,
|
|
||||||
TOP = 1 << 2,
|
|
||||||
BOTTOM = 1 << 3
|
|
||||||
};
|
|
||||||
|
|
||||||
static void
|
|
||||||
pixel_surround_fill_row (PixelSurround *surround,
|
|
||||||
const guchar *src,
|
|
||||||
gint w)
|
|
||||||
{
|
|
||||||
guchar *dest = surround->bg;
|
|
||||||
gint bytes = MIN (w, surround->w) * surround->bpp;
|
|
||||||
gint rows = surround->h;
|
|
||||||
|
|
||||||
while (rows--)
|
|
||||||
{
|
|
||||||
memcpy (dest, src, bytes);
|
|
||||||
dest += surround->rowstride;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
pixel_surround_fill_col (PixelSurround *surround,
|
|
||||||
const guchar *src,
|
|
||||||
gint rowstride,
|
|
||||||
gint h)
|
|
||||||
{
|
|
||||||
guchar *dest = surround->bg;
|
|
||||||
gint cols = surround->w;
|
|
||||||
gint rows = MIN (h, surround->h);
|
|
||||||
|
|
||||||
while (cols--)
|
|
||||||
{
|
|
||||||
const guchar *s = src;
|
|
||||||
guchar *d = dest;
|
|
||||||
gint r = rows;
|
|
||||||
|
|
||||||
while (r--)
|
|
||||||
{
|
|
||||||
memcpy (d, s, surround->bpp);
|
|
||||||
|
|
||||||
s += rowstride;
|
|
||||||
d += surround->rowstride;
|
|
||||||
}
|
|
||||||
|
|
||||||
dest += surround->bpp;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static const guchar *
|
|
||||||
pixel_surround_get_data (PixelSurround *surround,
|
|
||||||
gint x,
|
|
||||||
gint y,
|
|
||||||
gint *w,
|
|
||||||
gint *h,
|
|
||||||
gint *rowstride)
|
|
||||||
{
|
|
||||||
/* do we still have a tile lock that we can use? */
|
|
||||||
if (surround->tile)
|
|
||||||
{
|
|
||||||
if (x < surround->tile_x || x >= surround->tile_x + surround->tile_w ||
|
|
||||||
y < surround->tile_y || y >= surround->tile_y + surround->tile_h)
|
|
||||||
{
|
|
||||||
tile_release (surround->tile, FALSE);
|
|
||||||
surround->tile = NULL;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* if not, try to get one for the target pixel */
|
|
||||||
if (! surround->tile)
|
|
||||||
{
|
|
||||||
surround->tile = tile_manager_get_tile (surround->mgr, x, y, TRUE, FALSE);
|
|
||||||
|
|
||||||
if (surround->tile)
|
|
||||||
{
|
|
||||||
/* store offset and size of the locked tile */
|
|
||||||
surround->tile_x = x & ~(TILE_WIDTH - 1);
|
|
||||||
surround->tile_y = y & ~(TILE_HEIGHT - 1);
|
|
||||||
surround->tile_w = tile_ewidth (surround->tile);
|
|
||||||
surround->tile_h = tile_eheight (surround->tile);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (surround->tile)
|
|
||||||
{
|
|
||||||
*w = surround->tile_x + surround->tile_w - x;
|
|
||||||
*h = surround->tile_y + surround->tile_h - y;
|
|
||||||
|
|
||||||
*rowstride = surround->tile_w * surround->bpp;
|
|
||||||
|
|
||||||
return tile_data_pointer (surround->tile, x, y);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (surround->mode == PIXEL_SURROUND_SMEAR)
|
|
||||||
{
|
|
||||||
const guchar *edata;
|
|
||||||
gint ex = x;
|
|
||||||
gint ey = y;
|
|
||||||
gint ew, eh;
|
|
||||||
gint estride;
|
|
||||||
gint ecode = 0;
|
|
||||||
|
|
||||||
if (ex < 0)
|
|
||||||
{
|
|
||||||
ex = 0;
|
|
||||||
ecode |= LEFT;
|
|
||||||
}
|
|
||||||
else if (ex > surround->xmax)
|
|
||||||
{
|
|
||||||
ex = surround->xmax;
|
|
||||||
ecode |= RIGHT;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (ey < 0)
|
|
||||||
{
|
|
||||||
ey = 0;
|
|
||||||
ecode |= TOP;
|
|
||||||
}
|
|
||||||
else if (ey > surround->ymax)
|
|
||||||
{
|
|
||||||
ey = surround->ymax;
|
|
||||||
ecode |= BOTTOM;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* call ourselves with corrected coordinates */
|
|
||||||
edata = pixel_surround_get_data (surround, ex, ey, &ew, &eh, &estride);
|
|
||||||
|
|
||||||
/* fill the virtual background tile */
|
|
||||||
switch (ecode)
|
|
||||||
{
|
|
||||||
case (TOP | LEFT):
|
|
||||||
case (TOP | RIGHT):
|
|
||||||
case (BOTTOM | LEFT):
|
|
||||||
case (BOTTOM | RIGHT):
|
|
||||||
pixel_surround_set_bg (surround, edata);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case (TOP):
|
|
||||||
case (BOTTOM):
|
|
||||||
pixel_surround_fill_row (surround, edata, ew);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case (LEFT):
|
|
||||||
case (RIGHT):
|
|
||||||
pixel_surround_fill_col (surround, edata, estride, eh);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* return a pointer to the virtual background tile */
|
|
||||||
|
|
||||||
if (x < 0)
|
|
||||||
*w = MIN (- x, surround->w);
|
|
||||||
else
|
|
||||||
*w = surround->w;
|
|
||||||
|
|
||||||
if (y < 0)
|
|
||||||
*h = MIN (- y, surround->h);
|
|
||||||
else
|
|
||||||
*h = surround->h;
|
|
||||||
|
|
||||||
*rowstride = surround->rowstride;
|
|
||||||
|
|
||||||
return surround->bg;
|
|
||||||
}
|
|
|
@ -1,53 +0,0 @@
|
||||||
/* GIMP - The GNU Image Manipulation Program
|
|
||||||
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
||||||
*
|
|
||||||
* This program is free software: you can redistribute it and/or modify
|
|
||||||
* it under the terms of the GNU General Public License as published by
|
|
||||||
* the Free Software Foundation; either version 3 of the License, or
|
|
||||||
* (at your option) any later version.
|
|
||||||
*
|
|
||||||
* This program is distributed in the hope that it will be useful,
|
|
||||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
||||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
||||||
* GNU General Public License for more details.
|
|
||||||
*
|
|
||||||
* You should have received a copy of the GNU General Public License
|
|
||||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef __PIXEL_SURROUND_H__
|
|
||||||
#define __PIXEL_SURROUND_H__
|
|
||||||
|
|
||||||
|
|
||||||
/* PixelSurround describes a (read-only)
|
|
||||||
* region around a pixel in a tile manager
|
|
||||||
*/
|
|
||||||
|
|
||||||
typedef enum
|
|
||||||
{
|
|
||||||
PIXEL_SURROUND_SMEAR,
|
|
||||||
PIXEL_SURROUND_BACKGROUND
|
|
||||||
} PixelSurroundMode;
|
|
||||||
|
|
||||||
|
|
||||||
PixelSurround * pixel_surround_new (TileManager *tiles,
|
|
||||||
gint width,
|
|
||||||
gint height,
|
|
||||||
PixelSurroundMode mode);
|
|
||||||
void pixel_surround_set_bg (PixelSurround *surround,
|
|
||||||
const guchar *bg);
|
|
||||||
|
|
||||||
/* return a pointer to a buffer which contains all the surrounding pixels
|
|
||||||
* strategy: if we are in the middle of a tile, use the tile storage
|
|
||||||
* otherwise just copy into our own malloced buffer and return that
|
|
||||||
*/
|
|
||||||
const guchar * pixel_surround_lock (PixelSurround *surround,
|
|
||||||
gint x,
|
|
||||||
gint y,
|
|
||||||
gint *rowstride);
|
|
||||||
|
|
||||||
void pixel_surround_release (PixelSurround *surround);
|
|
||||||
void pixel_surround_destroy (PixelSurround *surround);
|
|
||||||
|
|
||||||
|
|
||||||
#endif /* __PIXEL_SURROUND_H__ */
|
|
Loading…
Reference in New Issue