Allocation/Setup of NRPixBlock objects. More...

Defines
#define	__NR_PIXBLOCK_C__
#define	NR_TINY_MAX sizeof (unsigned char *)
	Size of buffer that needs no allocation (default 4).
#define	NR_4K_BLOCK 32
#define	NR_16K_BLOCK 32
#define	NR_64K_BLOCK 32
#define	NR_256K_BLOCK 32
#define	NR_256K 262144
#define	NR_1M_BLOCK 32
#define	NR_1M 1048576
Functions
void	nr_pixblock_setup_fast (NRPixBlock *pb, NR_PIXBLOCK_MODE mode, int x0, int y0, int x1, int y1, bool clear)
	Pixbuf initialisation using homegrown memory handling ("pixelstore").
void	nr_pixblock_setup (NRPixBlock *pb, NR_PIXBLOCK_MODE mode, int x0, int y0, int x1, int y1, bool clear)
	Pixbuf initialisation using g_new.
void	nr_pixblock_setup_extern (NRPixBlock pb, NR_PIXBLOCK_MODE mode, int x0, int y0, int x1, int y1, unsigned char px, int rs, bool empty, bool clear)
	Pixbuf initialisation with preset values.
void	nr_pixblock_release (NRPixBlock *pb)
	Frees memory taken by pixel data in NRPixBlock.
NRPixBlock *	nr_pixblock_new (NR_PIXBLOCK_MODE mode, int x0, int y0, int x1, int y1, bool clear)
	Allocates NRPixBlock and sets it up.
NRPixBlock *	nr_pixblock_new_fast (NR_PIXBLOCK_MODE mode, int x0, int y0, int x1, int y1, bool clear)
	Allocates NRPixBlock and sets it up.
NRPixBlock *	nr_pixblock_free (NRPixBlock *pb)
	Frees all memory taken by pixblock.
unsigned char *	nr_pixelstore_4K_new (bool clear, unsigned char val)
void	nr_pixelstore_4K_free (unsigned char *px)
unsigned char *	nr_pixelstore_16K_new (bool clear, unsigned char val)
void	nr_pixelstore_16K_free (unsigned char *px)
unsigned char *	nr_pixelstore_64K_new (bool clear, unsigned char val)
void	nr_pixelstore_64K_free (unsigned char *px)
unsigned char *	nr_pixelstore_256K_new (bool clear, unsigned char val)
void	nr_pixelstore_256K_free (unsigned char *px)
unsigned char *	nr_pixelstore_1M_new (bool clear, unsigned char val)
void	nr_pixelstore_1M_free (unsigned char *px)
Variables
static unsigned char **	nr_4K_px = NULL
static unsigned int	nr_4K_len = 0
static unsigned int	nr_4K_size = 0
static unsigned char **	nr_16K_px = NULL
static unsigned int	nr_16K_len = 0
static unsigned int	nr_16K_size = 0
static unsigned char **	nr_64K_px = NULL
static unsigned int	nr_64K_len = 0
static unsigned int	nr_64K_size = 0
static unsigned char **	nr_256K_px = NULL
static unsigned int	nr_256K_len = 0
static unsigned int	nr_256K_size = 0
static unsigned char **	nr_1M_px = NULL
static unsigned int	nr_1M_len = 0
static unsigned int	nr_1M_size = 0

Detailed Description

Allocation/Setup of NRPixBlock objects.

Pixel store functions.

This code is in the Public Domain

Definition in file nr-pixblock.cpp.

Define Documentation

#define __NR_PIXBLOCK_C__

Definition at line 1 of file nr-pixblock.cpp.

#define NR_16K_BLOCK 32

Definition at line 310 of file nr-pixblock.cpp.

#define NR_1M 1048576

Definition at line 414 of file nr-pixblock.cpp.

Referenced by nr_pixelstore_1M_new().

#define NR_1M_BLOCK 32

Definition at line 413 of file nr-pixblock.cpp.

#define NR_256K 262144

Definition at line 379 of file nr-pixblock.cpp.

Referenced by nr_pixelstore_256K_new().

#define NR_256K_BLOCK 32

Definition at line 378 of file nr-pixblock.cpp.

#define NR_4K_BLOCK 32

Definition at line 276 of file nr-pixblock.cpp.

#define NR_64K_BLOCK 32

Definition at line 344 of file nr-pixblock.cpp.

#define NR_TINY_MAX sizeof (unsigned char *)

Size of buffer that needs no allocation (default 4).

Definition at line 20 of file nr-pixblock.cpp.

Referenced by nr_pixblock_setup(), and nr_pixblock_setup_fast().

Function Documentation

NRPixBlock* nr_pixblock_free ( NRPixBlock * pb )

Frees all memory taken by pixblock.

Returns:: NULL

Definition at line 265 of file nr-pixblock.cpp.

References nr_pixblock_release().

Referenced by Inkscape::Filters::FilterGaussian::render(), and Inkscape::Filters::FilterComposite::render().

{
    nr_pixblock_release (pb);

    g_free (pb);

    return NULL;
}

NRPixBlock* nr_pixblock_new	(	NR_PIXBLOCK_MODE	mode,
		int	x0,
		int	y0,
		int	x1,
		int	y1,
		bool	clear
	)

Allocates NRPixBlock and sets it up.

Returns:: Pointer to fresh pixblock. Calls g_new() and nr_pixblock_setup(). FIXME: currently unused, delete? JG: Should be used more often! (To simplify memory management.)

Definition at line 220 of file nr-pixblock.cpp.

References NRPixBlock::data, nr_pixblock_setup(), NR_PIXBLOCK_SIZE_TINY, NRPixBlock::px, and NRPixBlock::size.

{
    NRPixBlock *pb;

    pb = g_new (NRPixBlock, 1);
    if (!pb) return 0;

    nr_pixblock_setup (pb, mode, x0, y0, x1, y1, clear);
    if (pb->size!=NR_PIXBLOCK_SIZE_TINY && !pb->data.px) {
        g_free(pb);
        return 0;
    }

    return pb;
}

NRPixBlock* nr_pixblock_new_fast	(	NR_PIXBLOCK_MODE	mode,
		int	x0,
		int	y0,
		int	x1,
		int	y1,
		bool	clear
	)

Allocates NRPixBlock and sets it up.

Returns:: Pointer to fresh pixblock. Calls g_new() and nr_pixblock_setup().

Definition at line 243 of file nr-pixblock.cpp.

References NRPixBlock::data, nr_pixblock_setup_fast(), NR_PIXBLOCK_SIZE_TINY, NRPixBlock::px, and NRPixBlock::size.

Referenced by Inkscape::Filters::FilterGaussian::render(), and Inkscape::Filters::FilterComposite::render().

{
    NRPixBlock *pb;

    pb = g_new (NRPixBlock, 1);
    if (!pb) return 0;

    nr_pixblock_setup_fast (pb, mode, x0, y0, x1, y1, clear);
    if (pb->size!=NR_PIXBLOCK_SIZE_TINY && !pb->data.px) {
        g_free(pb);
        return 0;
    }

    return pb;
}

void nr_pixblock_release ( NRPixBlock * pb )

Frees memory taken by pixel data in NRPixBlock.

Parameters:

pb

Pointer to pixblock.

Precondition:: pb and pb->data.px point to valid addresses.

According to pb->size, one of the functions for freeing the pixelstore is called. May be called regardless of how pixbuf was set up.

Definition at line 182 of file nr-pixblock.cpp.

References NRPixBlock::data, NR_PIXBLOCK_SIZE_16K, NR_PIXBLOCK_SIZE_1M, NR_PIXBLOCK_SIZE_256K, NR_PIXBLOCK_SIZE_4K, NR_PIXBLOCK_SIZE_64K, NR_PIXBLOCK_SIZE_BIG, NR_PIXBLOCK_SIZE_STATIC, NR_PIXBLOCK_SIZE_TINY, nr_pixelstore_16K_free(), nr_pixelstore_1M_free(), nr_pixelstore_256K_free(), nr_pixelstore_4K_free(), nr_pixelstore_64K_free(), NRPixBlock::px, and NRPixBlock::size.

{
    switch (pb->size) {
    case NR_PIXBLOCK_SIZE_TINY:
        break;
    case NR_PIXBLOCK_SIZE_4K:
        nr_pixelstore_4K_free (pb->data.px);
        break;
    case NR_PIXBLOCK_SIZE_16K:
        nr_pixelstore_16K_free (pb->data.px);
        break;
    case NR_PIXBLOCK_SIZE_64K:
        nr_pixelstore_64K_free (pb->data.px);
        break;
    case NR_PIXBLOCK_SIZE_256K:
        nr_pixelstore_256K_free (pb->data.px);
        break;
    case NR_PIXBLOCK_SIZE_1M:
        nr_pixelstore_1M_free (pb->data.px);
        break;
    case NR_PIXBLOCK_SIZE_BIG:
        g_free (pb->data.px);
        break;
    case NR_PIXBLOCK_SIZE_STATIC:
        break;
    default:
        break;
    }
}

void nr_pixblock_setup	(	NRPixBlock *	pb,
		NR_PIXBLOCK_MODE	mode,
		int	x0,
		int	y0,
		int	x1,
		int	y1,
		bool	clear
	)

Pixbuf initialisation using g_new.

After allocating memory, the buffer is cleared if the clear flag is set.

Parameters:

	pb	Pointer to the pixbuf struct.
	mode	Indicates grayscale/RGB/RGBA.
	clear	True if buffer should be cleared.

Precondition:: x1>=x0 && y1>=y0 && pb!=NULL FIXME: currently unused except for nr_pixblock_new and pattern tiles, replace with _fast and delete?

Definition at line 101 of file nr-pixblock.cpp.

References NRPixBlock::area, NRPixBlock::data, NRPixBlock::empty, h, NRPixBlock::mode, NR_PIXBLOCK_MODE_R8G8B8, NR_TINY_MAX, NRPixBlock::p, NRPixBlock::px, NRPixBlock::rs, NRPixBlock::size, NRPixBlock::visible_area, dxf_input::w, NRRectL::x0, NRRectL::x1, NRRectL::y0, and NRRectL::y1.

Referenced by nr_pixblock_new(), and sp_pattern_painter_new().

{
    int w, h, bpp;
    size_t size;

    w = x1 - x0;
    h = y1 - y0;
    bpp = (mode == NR_PIXBLOCK_MODE_A8) ? 1 : (mode == NR_PIXBLOCK_MODE_R8G8B8) ? 3 : 4;

    size = bpp * w * h;

    if (size <= NR_TINY_MAX) {
        pb->size = NR_PIXBLOCK_SIZE_TINY;
        if (clear) memset (pb->data.p, 0x0, size);
    } else {
        pb->size = NR_PIXBLOCK_SIZE_BIG;
        pb->data.px = g_new (unsigned char, size);
        if (clear) memset (pb->data.px, 0x0, size);
    }

    pb->mode = mode;
    pb->empty = 1;
    pb->visible_area.x0 = pb->area.x0 = x0;
    pb->visible_area.y0 = pb->area.y0 = y0;
    pb->visible_area.x1 = pb->area.x1 = x1;
    pb->visible_area.y1 = pb->area.y1 = y1;
    pb->rs = bpp * w;
}

void nr_pixblock_setup_extern	(	NRPixBlock *	pb,
		NR_PIXBLOCK_MODE	mode,
		int	x0,
		int	y0,
		int	x1,
		int	y1,
		unsigned char *	px,
		int	rs,
		bool	empty,
		bool	clear
	)

Pixbuf initialisation with preset values.

After copying all parameters into the NRPixBlock struct, the pixel buffer is cleared if the clear flag is set.

Parameters:

	pb	Pointer to the pixbuf struct.
	mode	Indicates grayscale/RGB/RGBA.
	clear	True if buffer should be cleared.

Precondition:: x1>=x0 && y1>=y0 && pb!=NULL

Todo:: How do you recognise if

px was an uncleared tiny buffer?

Definition at line 140 of file nr-pixblock.cpp.

References NRPixBlock::area, NRPixBlock::data, NRPixBlock::empty, NRPixBlock::mode, NR_PIXBLOCK_MODE_R8G8B8, NULL, NRPixBlock::px, NRPixBlock::rs, NRPixBlock::size, NRPixBlock::visible_area, dxf_input::w, NRRectL::x0, NRRectL::x1, voronoi::y, NRRectL::y0, and NRRectL::y1.

Referenced by clonetiler_trace_pick(), nr_arena_item_invoke_render(), Inkscape::Filters::FilterImage::render(), render_pixbuf(), sp_canvas_arena_render(), sp_canvas_paint_single_buffer(), sp_export_get_rows(), sp_flood_do_flood_fill(), sp_font_preview_expose(), sp_generate_internal_bitmap(), sp_gradient_image_update(), sp_icon_doc_icon(), and sp_pat_fill().

{
    int w, bpp;

    w = x1 - x0;
    bpp = (mode == NR_PIXBLOCK_MODE_A8) ? 1 : (mode == NR_PIXBLOCK_MODE_R8G8B8) ? 3 : 4;

    pb->size = NR_PIXBLOCK_SIZE_STATIC; 
    pb->mode = mode;
    pb->empty = empty;
    pb->visible_area.x0 = pb->area.x0 = x0;
    pb->visible_area.y0 = pb->area.y0 = y0;
    pb->visible_area.x1 = pb->area.x1 = x1;
    pb->visible_area.y1 = pb->area.y1 = y1;
    pb->data.px = px;
    pb->rs = rs;

        g_assert (pb->data.px != NULL);
    if (clear) {
        if (rs == bpp * w) {
            if (pb->data.px) 
                memset (pb->data.px, 0x0, bpp * (y1 - y0) * w);
        } else {
            int y;
            for (y = y0; y < y1; y++) {
                memset (pb->data.px + (y - y0) * rs, 0x0, bpp * w);
            }
        }
    }
}

void nr_pixblock_setup_fast	(	NRPixBlock *	pb,
		NR_PIXBLOCK_MODE	mode,
		int	x0,
		int	y0,
		int	x1,
		int	y1,
		bool	clear
	)

Pixbuf initialisation using homegrown memory handling ("pixelstore").

Pixbuf sizes are differentiated into tiny, <4K, <16K, <64K, and more, with each type having its own method of memory handling. After allocating memory, the buffer is cleared if the clear flag is set. Intended to reduce memory fragmentation.

Parameters:

	pb	Pointer to the pixbuf struct.
	mode	Indicates grayscale/RGB/RGBA.
	clear	True if buffer should be cleared.

Precondition:: x1>=x0 && y1>=y0 && pb!=NULL

Definition at line 35 of file nr-pixblock.cpp.

References NRPixBlock::area, NRPixBlock::data, NRPixBlock::empty, h, NRPixBlock::mode, NR_PIXBLOCK_MODE_R8G8B8, nr_pixelstore_16K_new(), nr_pixelstore_1M_new(), nr_pixelstore_256K_new(), nr_pixelstore_4K_new(), nr_pixelstore_64K_new(), NR_TINY_MAX, NULL, NRPixBlock::p, NRPixBlock::px, NRPixBlock::rs, NRPixBlock::size, NRPixBlock::visible_area, dxf_input::w, NRRectL::x0, NRRectL::x1, NRRectL::y0, and NRRectL::y1.

{
    int w, h, bpp;
    size_t size;

    w = x1 - x0;
    h = y1 - y0;
    bpp = (mode == NR_PIXBLOCK_MODE_A8) ? 1 : (mode == NR_PIXBLOCK_MODE_R8G8B8) ? 3 : 4;

    size = bpp * w * h;

    if (size <= NR_TINY_MAX) {
        pb->size = NR_PIXBLOCK_SIZE_TINY;
        if (clear) memset (pb->data.p, 0x0, size);
    } else if (size <= 4096) {
        pb->size = NR_PIXBLOCK_SIZE_4K;
        pb->data.px = nr_pixelstore_4K_new (clear, 0x0);
    } else if (size <= 16384) {
        pb->size = NR_PIXBLOCK_SIZE_16K;
        pb->data.px = nr_pixelstore_16K_new (clear, 0x0);
    } else if (size <= 65536) {
        pb->size = NR_PIXBLOCK_SIZE_64K;
        pb->data.px = nr_pixelstore_64K_new (clear, 0x0);
    } else if (size <= 262144) {
        pb->size = NR_PIXBLOCK_SIZE_256K;
        pb->data.px = nr_pixelstore_256K_new (clear, 0x0);
    } else if (size <= 1048576) {
        pb->size = NR_PIXBLOCK_SIZE_1M;
        pb->data.px = nr_pixelstore_1M_new (clear, 0x0);
    } else {
        pb->size = NR_PIXBLOCK_SIZE_BIG;
             pb->data.px = NULL;
        if (size > 100000000) { // Don't even try to allocate more than 100Mb (5000x5000 RGBA
                            // pixels). It'll just bog the system down even if successful. FIXME:
                            // Can anyone suggest something better than the magic number?
                g_warning ("%lu bytes requested for pixel buffer, I won't try to allocate that.", (long unsigned) size);
                return;
             }
        pb->data.px = g_try_new (unsigned char, size);
        if (pb->data.px == NULL) { // memory allocation failed
                g_warning ("Could not allocate %lu bytes for pixel buffer!", (long unsigned) size);
                return;
             }
        if (clear) memset (pb->data.px, 0x0, size);
    }

    pb->mode = mode;
    pb->empty = 1;
    pb->visible_area.x0 = pb->area.x0 = x0;
    pb->visible_area.y0 = pb->area.y0 = y0;
    pb->visible_area.x1 = pb->area.x1 = x1;
    pb->visible_area.y1 = pb->area.y1 = y1;
    pb->rs = bpp * w;
}

void nr_pixelstore_16K_free ( unsigned char * px )

Definition at line 333 of file nr-pixblock.cpp.

References nr_16K_len, nr_16K_px, and nr_16K_size.

Referenced by nr_pixblock_release(), and sp_font_preview_expose().

{
    if (nr_16K_len == nr_16K_size) {
        nr_16K_size += NR_16K_BLOCK;
        nr_16K_px = g_renew (unsigned char *, nr_16K_px, nr_16K_size);
    }

    nr_16K_px[nr_16K_len] = px;
    nr_16K_len += 1;
}

unsigned char* nr_pixelstore_16K_new	(	bool	clear,
		unsigned char	val
	)

Definition at line 316 of file nr-pixblock.cpp.

References nr_16K_len, and nr_16K_px.

Referenced by nr_pixblock_setup_fast(), and sp_font_preview_expose().

{
    unsigned char *px;

    if (nr_16K_len != 0) {
        nr_16K_len -= 1;
        px = nr_16K_px[nr_16K_len];
    } else {
        px = g_new (unsigned char, 16384);
    }
    
    if (clear) memset (px, val, 16384);

    return px;
}

void nr_pixelstore_1M_free ( unsigned char * px )

Definition at line 437 of file nr-pixblock.cpp.

References nr_1M_len, nr_1M_px, and nr_1M_size.

Referenced by nr_pixblock_release(), and sp_canvas_paint_single_buffer().

{
    if (nr_1M_len == nr_1M_size) {
        nr_1M_size += NR_1M_BLOCK;
        nr_1M_px = g_renew (unsigned char *, nr_1M_px, nr_1M_size);
    }

    nr_1M_px[nr_1M_len] = px;
    nr_1M_len += 1;
}

unsigned char* nr_pixelstore_1M_new	(	bool	clear,
		unsigned char	val
	)

Definition at line 420 of file nr-pixblock.cpp.

References NR_1M, nr_1M_len, and nr_1M_px.

Referenced by nr_pixblock_setup_fast(), and sp_canvas_paint_single_buffer().

{
    unsigned char *px;

    if (nr_1M_len != 0) {
        nr_1M_len -= 1;
        px = nr_1M_px[nr_1M_len];
    } else {
           px = g_new (unsigned char, NR_1M);
    }

    if (clear) memset (px, val, NR_1M);

    return px;
}

void nr_pixelstore_256K_free ( unsigned char * px )

Definition at line 402 of file nr-pixblock.cpp.

References nr_256K_len, nr_256K_px, and nr_256K_size.

Referenced by nr_pixblock_release(), and sp_canvas_paint_single_buffer().

{
    if (nr_256K_len == nr_256K_size) {
        nr_256K_size += NR_256K_BLOCK;
        nr_256K_px = g_renew (unsigned char *, nr_256K_px, nr_256K_size);
    }

    nr_256K_px[nr_256K_len] = px;
    nr_256K_len += 1;
}

unsigned char* nr_pixelstore_256K_new	(	bool	clear,
		unsigned char	val
	)

Definition at line 385 of file nr-pixblock.cpp.

References NR_256K, nr_256K_len, and nr_256K_px.

Referenced by nr_pixblock_setup_fast(), and sp_canvas_paint_single_buffer().

{
    unsigned char *px;

    if (nr_256K_len != 0) {
        nr_256K_len -= 1;
        px = nr_256K_px[nr_256K_len];
    } else {
           px = g_new (unsigned char, NR_256K);
    }

    if (clear) memset (px, val, NR_256K);

    return px;
}

void nr_pixelstore_4K_free ( unsigned char * px )

Definition at line 299 of file nr-pixblock.cpp.

References nr_4K_len, nr_4K_px, and nr_4K_size.

Referenced by nr_pixblock_release().

{
    if (nr_4K_len == nr_4K_size) {
        nr_4K_size += NR_4K_BLOCK;
        nr_4K_px = g_renew (unsigned char *, nr_4K_px, nr_4K_size);
    }

    nr_4K_px[nr_4K_len] = px;
    nr_4K_len += 1;
}

unsigned char* nr_pixelstore_4K_new	(	bool	clear,
		unsigned char	val
	)

Definition at line 282 of file nr-pixblock.cpp.

References nr_4K_len, and nr_4K_px.

Referenced by nr_pixblock_setup_fast().

{
    unsigned char *px;

    if (nr_4K_len != 0) {
        nr_4K_len -= 1;
        px = nr_4K_px[nr_4K_len];
    } else {
        px = g_new (unsigned char, 4096);
    }
    
    if (clear) memset (px, val, 4096);

    return px;
}

void nr_pixelstore_64K_free ( unsigned char * px )

Definition at line 367 of file nr-pixblock.cpp.

References nr_64K_len, nr_64K_px, and nr_64K_size.

Referenced by nr_pixblock_release(), and sp_export_png_file().

{
    if (nr_64K_len == nr_64K_size) {
        nr_64K_size += NR_64K_BLOCK;
        nr_64K_px = g_renew (unsigned char *, nr_64K_px, nr_64K_size);
    }

    nr_64K_px[nr_64K_len] = px;
    nr_64K_len += 1;
}

unsigned char* nr_pixelstore_64K_new	(	bool	clear,
		unsigned char	val
	)

Definition at line 350 of file nr-pixblock.cpp.

References nr_64K_len, and nr_64K_px.

Referenced by nr_pixblock_setup_fast(), and sp_export_png_file().

{
    unsigned char *px;

    if (nr_64K_len != 0) {
        nr_64K_len -= 1;
        px = nr_64K_px[nr_64K_len];
    } else {
        px = g_new (unsigned char, 65536);
    }

    if (clear) memset (px, val, 65536);

    return px;
}