index 9b1ff27526382382294c529f1eec2a07d07e1985..2f103d7d126981215f62a65d9f7646c7a488ff73 100644 (file)
* This code is in the Public Domain
*/
+#include <glib/gmem.h>
#include "nr-pixblock.h"
/// Size of buffer that needs no allocation (default 4).
@@ -58,27 +59,39 @@ nr_pixblock_setup_fast (NRPixBlock *pb, NR_PIXBLOCK_MODE mode, int x0, int y0, i
pb->data.px = nr_pixelstore_1M_new (clear, 0x0);
} else {
pb->size = NR_PIXBLOCK_SIZE_BIG;
- pb->data.px = nr_new (unsigned char, size);
+ 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->area.x0 = x0;
- pb->area.y0 = y0;
- pb->area.x1 = x1;
- pb->area.y1 = y1;
+ 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;
}
/**
- * Pixbuf initialisation using nr_new.
+ * Pixbuf initialisation using g_new.
*
* After allocating memory, the buffer is cleared if the clear flag is set.
* \param pb Pointer to the pixbuf struct.
* \param mode Indicates grayscale/RGB/RGBA.
* \param clear True if buffer should be cleared.
* \pre x1>=x0 && y1>=y0 && pb!=NULL
+ FIXME: currently unused except for nr_pixblock_new and pattern tiles, replace with _fast and delete?
*/
void
nr_pixblock_setup (NRPixBlock *pb, NR_PIXBLOCK_MODE mode, int x0, int y0, int x1, int y1, bool clear)
@@ -97,16 +110,16 @@ nr_pixblock_setup (NRPixBlock *pb, NR_PIXBLOCK_MODE mode, int x0, int y0, int x1
if (clear) memset (pb->data.p, 0x0, size);
} else {
pb->size = NR_PIXBLOCK_SIZE_BIG;
- pb->data.px = nr_new (unsigned char, size);
+ pb->data.px = g_new (unsigned char, size);
if (clear) memset (pb->data.px, 0x0, size);
}
pb->mode = mode;
pb->empty = 1;
- pb->area.x0 = x0;
- pb->area.y0 = y0;
- pb->area.x1 = x1;
- pb->area.y1 = y1;
+ 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;
}
@@ -130,10 +143,10 @@ nr_pixblock_setup_extern (NRPixBlock *pb, NR_PIXBLOCK_MODE mode, int x0, int y0,
pb->size = NR_PIXBLOCK_SIZE_STATIC;
pb->mode = mode;
pb->empty = empty;
- pb->area.x0 = x0;
- pb->area.y0 = y0;
- pb->area.x1 = x1;
- pb->area.y1 = y1;
+ 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;
nr_pixelstore_1M_free (pb->data.px);
break;
case NR_PIXBLOCK_SIZE_BIG:
- nr_free (pb->data.px);
+ g_free (pb->data.px);
break;
case NR_PIXBLOCK_SIZE_STATIC:
break;
* Allocates NRPixBlock and sets it up.
*
* \return Pointer to fresh pixblock.
- * Calls nr_new() and nr_pixblock_setup().
+ * Calls g_new() and nr_pixblock_setup().
+FIXME: currently unused, delete?
*/
NRPixBlock *
nr_pixblock_new (NR_PIXBLOCK_MODE mode, int x0, int y0, int x1, int y1, bool clear)
{
NRPixBlock *pb;
- pb = nr_new (NRPixBlock, 1);
+ pb = g_new (NRPixBlock, 1);
nr_pixblock_setup (pb, mode, x0, y0, x1, y1, clear);
{
nr_pixblock_release (pb);
- nr_free (pb);
+ g_free (pb);
return NULL;
}
nr_4K_len -= 1;
px = nr_4K_px[nr_4K_len];
} else {
- px = nr_new (unsigned char, 4096);
+ px = g_new (unsigned char, 4096);
}
if (clear) memset (px, val, 4096);
{
if (nr_4K_len == nr_4K_size) {
nr_4K_size += NR_4K_BLOCK;
- nr_4K_px = nr_renew (nr_4K_px, unsigned char *, nr_4K_size);
+ nr_4K_px = g_renew (unsigned char *, nr_4K_px, nr_4K_size);
}
nr_4K_px[nr_4K_len] = px;
nr_16K_len -= 1;
px = nr_16K_px[nr_16K_len];
} else {
- px = nr_new (unsigned char, 16384);
+ px = g_new (unsigned char, 16384);
}
if (clear) memset (px, val, 16384);
{
if (nr_16K_len == nr_16K_size) {
nr_16K_size += NR_16K_BLOCK;
- nr_16K_px = nr_renew (nr_16K_px, unsigned char *, nr_16K_size);
+ nr_16K_px = g_renew (unsigned char *, nr_16K_px, nr_16K_size);
}
nr_16K_px[nr_16K_len] = px;
nr_64K_len -= 1;
px = nr_64K_px[nr_64K_len];
} else {
- px = nr_new (unsigned char, 65536);
+ px = g_new (unsigned char, 65536);
}
if (clear) memset (px, val, 65536);
{
if (nr_64K_len == nr_64K_size) {
nr_64K_size += NR_64K_BLOCK;
- nr_64K_px = nr_renew (nr_64K_px, unsigned char *, nr_64K_size);
+ nr_64K_px = g_renew (unsigned char *, nr_64K_px, nr_64K_size);
}
nr_64K_px[nr_64K_len] = px;
nr_256K_len -= 1;
px = nr_256K_px[nr_256K_len];
} else {
- px = nr_new (unsigned char, NR_256K);
+ px = g_new (unsigned char, NR_256K);
}
if (clear) memset (px, val, NR_256K);
{
if (nr_256K_len == nr_256K_size) {
nr_256K_size += NR_256K_BLOCK;
- nr_256K_px = nr_renew (nr_256K_px, unsigned char *, nr_256K_size);
+ nr_256K_px = g_renew (unsigned char *, nr_256K_px, nr_256K_size);
}
nr_256K_px[nr_256K_len] = px;
nr_1M_len -= 1;
px = nr_1M_px[nr_1M_len];
} else {
- px = nr_new (unsigned char, NR_1M);
+ px = g_new (unsigned char, NR_1M);
}
if (clear) memset (px, val, NR_1M);
{
if (nr_1M_len == nr_1M_size) {
nr_1M_size += NR_1M_BLOCK;
- nr_1M_px = nr_renew (nr_1M_px, unsigned char *, nr_1M_size);
+ nr_1M_px = g_renew (unsigned char *, nr_1M_px, nr_1M_size);
}
nr_1M_px[nr_1M_len] = px;