5ebe8faab2
* test-images.h: Add valid_ras_test and invalid_bmp_1. * test-loaders.c (main): Add random tests for ras and pnm and an invalid bmp which was a crasher until my 2002-03-12 commit. * io-pnm.c (gdk_pixbuf__pnm_image_load_increment): Don't unref the pixbuf on errors. * io-ras.c: Handle some errors.
495 lines
12 KiB
C
495 lines
12 KiB
C
/* GdkPixbuf library - SUNRAS image loader
|
||
*
|
||
* Copyright (C) 1999 The Free Software Foundation
|
||
*
|
||
* Authors: Arjan van de Ven <arjan@fenrus.demon.nl>
|
||
* Federico Mena-Quintero <federico@gimp.org>
|
||
*
|
||
* Based on io-gif.c, io-tiff.c and io-png.c
|
||
*
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public
|
||
* License as published by the Free Software Foundation; either
|
||
* version 2 of the License, or (at your option) any later version.
|
||
*
|
||
* This library 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
|
||
* Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with this library; if not, write to the
|
||
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
||
* Boston, MA 02111-1307, USA.
|
||
*/
|
||
|
||
/*
|
||
|
||
Known bugs:
|
||
* Compressed rasterfiles don't work yet
|
||
|
||
*/
|
||
|
||
#include <config.h>
|
||
#include <stdio.h>
|
||
#ifdef HAVE_UNISTD_H
|
||
#include <unistd.h>
|
||
#endif
|
||
#include <string.h>
|
||
#include "gdk-pixbuf-private.h"
|
||
#include "gdk-pixbuf-io.h"
|
||
|
||
|
||
|
||
/*
|
||
Header structure for sunras files.
|
||
All values are in big-endian order on disk
|
||
|
||
Note: Every scanline is padded to be a multiple of 16 bits
|
||
*/
|
||
|
||
struct rasterfile {
|
||
guint magic;
|
||
guint width;
|
||
guint height;
|
||
guint depth;
|
||
guint length;
|
||
guint type;
|
||
guint maptype;
|
||
guint maplength;
|
||
};
|
||
|
||
/*
|
||
This does a byte-order swap. Does glib have something like
|
||
be32_to_cpu() ??
|
||
*/
|
||
|
||
/* Progressive loading */
|
||
|
||
struct ras_progressive_state {
|
||
ModulePreparedNotifyFunc prepared_func;
|
||
ModuleUpdatedNotifyFunc updated_func;
|
||
gpointer user_data;
|
||
|
||
gint HeaderSize; /* The size of the header-part (incl colormap) */
|
||
guchar *HeaderBuf; /* The buffer for the header (incl colormap) */
|
||
gint HeaderDone; /* The nr of bytes actually in HeaderBuf */
|
||
|
||
gint LineWidth; /* The width of a line in bytes */
|
||
guchar *LineBuf; /* Buffer for 1 line */
|
||
gint LineDone; /* # of bytes in LineBuf */
|
||
gint Lines; /* # of finished lines */
|
||
|
||
gint RasType; /* 32 = BGRA
|
||
24 = BGR
|
||
8 = 8 bit colormapped
|
||
1 = 1 bit bitonal
|
||
*/
|
||
|
||
|
||
struct rasterfile Header; /* Decoded (BE->CPU) header */
|
||
|
||
|
||
GdkPixbuf *pixbuf; /* Our "target" */
|
||
};
|
||
|
||
static gpointer
|
||
gdk_pixbuf__ras_image_begin_load(ModulePreparedNotifyFunc prepared_func,
|
||
ModuleUpdatedNotifyFunc updated_func,
|
||
gpointer user_data,
|
||
GError **error);
|
||
static gboolean gdk_pixbuf__ras_image_stop_load(gpointer data, GError **error);
|
||
static gboolean gdk_pixbuf__ras_image_load_increment(gpointer data,
|
||
const guchar * buf, guint size,
|
||
GError **error);
|
||
|
||
|
||
|
||
/* Shared library entry point */
|
||
static GdkPixbuf *gdk_pixbuf__ras_image_load(FILE * f, GError **error)
|
||
{
|
||
guchar *membuf;
|
||
size_t length;
|
||
struct ras_progressive_state *State;
|
||
|
||
GdkPixbuf *pb;
|
||
|
||
State = gdk_pixbuf__ras_image_begin_load(NULL, NULL, NULL, error);
|
||
|
||
membuf = g_malloc(4096);
|
||
|
||
g_assert(membuf != NULL);
|
||
|
||
while (feof(f) == 0) {
|
||
length = fread(membuf, 1, 4096, f);
|
||
if (!gdk_pixbuf__ras_image_load_increment(State, membuf, length,
|
||
error)) {
|
||
gdk_pixbuf__ras_image_stop_load (State, NULL);
|
||
return NULL;
|
||
}
|
||
}
|
||
g_free(membuf);
|
||
if (State->pixbuf != NULL)
|
||
g_object_ref(State->pixbuf);
|
||
|
||
pb = State->pixbuf;
|
||
|
||
gdk_pixbuf__ras_image_stop_load(State, NULL);
|
||
return pb;
|
||
}
|
||
|
||
static gboolean RAS2State(struct rasterfile *RAS,
|
||
struct ras_progressive_state *State,
|
||
GError **error)
|
||
{
|
||
State->Header.width = GUINT32_FROM_BE(RAS->width);
|
||
State->Header.height = GUINT32_FROM_BE(RAS->height);
|
||
State->Header.depth = GUINT32_FROM_BE(RAS->depth);
|
||
State->Header.type = GUINT32_FROM_BE(RAS->type);
|
||
State->Header.maptype = GUINT32_FROM_BE(RAS->maptype);
|
||
State->Header.maplength = GUINT32_FROM_BE(RAS->maplength);
|
||
|
||
if ((gint)State->Header.width <= 0 ||
|
||
(gint)State->Header.height <= 0 ||
|
||
State->Header.maplength > 768) {
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
|
||
_("RAS image has bogus header data"));
|
||
return FALSE;
|
||
}
|
||
|
||
State->RasType = State->Header.depth; /* This may be less trivial someday */
|
||
State->HeaderSize = 32 + State->Header.maplength;
|
||
|
||
if (State->RasType == 32)
|
||
State->LineWidth = State->Header.width * 4;
|
||
else if (State->RasType == 24)
|
||
State->LineWidth = State->Header.width * 3;
|
||
else if (State->RasType == 8)
|
||
State->LineWidth = State->Header.width * 1;
|
||
else if (State->RasType == 1) {
|
||
State->LineWidth = State->Header.width / 8;
|
||
if ((State->Header.width & 7) != 0)
|
||
State->LineWidth++;
|
||
}
|
||
else {
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
|
||
_("RAS image has unknown type"));
|
||
return FALSE;
|
||
}
|
||
|
||
/* Now pad the line to be a multiple of 16 bits */
|
||
if ((State->LineWidth & 1) != 0)
|
||
State->LineWidth++;
|
||
|
||
if (!State->LineBuf) {
|
||
State->LineBuf = g_try_malloc (State->LineWidth);
|
||
|
||
if (!State->LineBuf) {
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
|
||
_("Not enough memory to load RAS image"));
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
|
||
if (!State->pixbuf) {
|
||
if (State->RasType == 32)
|
||
State->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
|
||
(gint) State->Header.width,
|
||
(gint) State->Header.height);
|
||
else
|
||
State->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8,
|
||
(gint) State->Header.width,
|
||
(gint) State->Header.height);
|
||
|
||
if (!State->pixbuf) {
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
|
||
_("Not enough memory to load RAS image"));
|
||
return FALSE;
|
||
}
|
||
|
||
if (State->prepared_func != NULL)
|
||
/* Notify the client that we are ready to go */
|
||
(*State->prepared_func) (State->pixbuf,
|
||
NULL,
|
||
State->user_data);
|
||
|
||
}
|
||
|
||
if ((State->Header.maplength == 0) && (State->RasType == 1)) {
|
||
State->HeaderBuf[32] = 255;
|
||
State->HeaderBuf[33] = 0;
|
||
State->HeaderBuf[34] = 255;
|
||
State->HeaderBuf[35] = 0;
|
||
State->HeaderBuf[36] = 255;
|
||
State->HeaderBuf[37] = 0;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/*
|
||
* func - called when we have pixmap created (but no image data)
|
||
* user_data - passed as arg 1 to func
|
||
* return context (opaque to user)
|
||
*/
|
||
|
||
static gpointer
|
||
gdk_pixbuf__ras_image_begin_load(ModulePreparedNotifyFunc prepared_func,
|
||
ModuleUpdatedNotifyFunc updated_func,
|
||
gpointer user_data,
|
||
GError **error)
|
||
{
|
||
struct ras_progressive_state *context;
|
||
|
||
context = g_new0(struct ras_progressive_state, 1);
|
||
context->prepared_func = prepared_func;
|
||
context->updated_func = updated_func;
|
||
context->user_data = user_data;
|
||
|
||
context->HeaderSize = 32;
|
||
context->HeaderBuf = g_malloc(32 + 768); /* 32 for rasheader,
|
||
768 for the colormap */
|
||
context->HeaderDone = 0;
|
||
|
||
context->LineWidth = 0;
|
||
context->LineBuf = NULL;
|
||
context->LineDone = 0;
|
||
context->Lines = 0;
|
||
|
||
context->RasType = 0;
|
||
|
||
memset(&context->Header, 0, sizeof(struct rasterfile));
|
||
|
||
|
||
context->pixbuf = NULL;
|
||
|
||
|
||
return (gpointer) context;
|
||
}
|
||
|
||
/*
|
||
* context - returned from image_begin_load
|
||
*
|
||
* free context, unref gdk_pixbuf
|
||
*/
|
||
static gboolean
|
||
gdk_pixbuf__ras_image_stop_load(gpointer data, GError **error)
|
||
{
|
||
struct ras_progressive_state *context =
|
||
(struct ras_progressive_state *) data;
|
||
|
||
/* FIXME this thing needs to report errors if
|
||
* we have unused image data
|
||
*/
|
||
|
||
g_return_val_if_fail(context != NULL, TRUE);
|
||
|
||
if (context->LineBuf != NULL)
|
||
g_free(context->LineBuf);
|
||
if (context->HeaderBuf != NULL)
|
||
g_free(context->HeaderBuf);
|
||
|
||
if (context->pixbuf)
|
||
g_object_unref(context->pixbuf);
|
||
|
||
g_free(context);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/*
|
||
OneLine is called when enough data is received to process 1 line
|
||
of pixels
|
||
*/
|
||
|
||
static void OneLine32(struct ras_progressive_state *context)
|
||
{
|
||
gint X;
|
||
guchar *Pixels;
|
||
|
||
X = 0;
|
||
Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines;
|
||
while (X < context->Header.width) {
|
||
/* The joys of having a BGR byteorder */
|
||
Pixels[X * 4 + 0] = context->LineBuf[X * 4 + 2];
|
||
Pixels[X * 4 + 1] = context->LineBuf[X * 4 + 1];
|
||
Pixels[X * 4 + 2] = context->LineBuf[X * 4 + 0];
|
||
Pixels[X * 4 + 3] = context->LineBuf[X * 4 + 3];
|
||
X++;
|
||
}
|
||
}
|
||
|
||
static void OneLine24(struct ras_progressive_state *context)
|
||
{
|
||
gint X;
|
||
guchar *Pixels;
|
||
|
||
X = 0;
|
||
Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines;
|
||
while (X < context->Header.width) {
|
||
/* The joys of having a BGR byteorder */
|
||
Pixels[X * 3 + 0] = context->LineBuf[X * 3 + 2];
|
||
Pixels[X * 3 + 1] = context->LineBuf[X * 3 + 1];
|
||
Pixels[X * 3 + 2] = context->LineBuf[X * 3 + 0];
|
||
X++;
|
||
}
|
||
|
||
}
|
||
|
||
static void OneLine8(struct ras_progressive_state *context)
|
||
{
|
||
gint X;
|
||
guchar *Pixels;
|
||
|
||
X = 0;
|
||
Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines;
|
||
while (X < context->Header.width) {
|
||
/* The joys of having a BGR byteorder */
|
||
Pixels[X * 3 + 0] =
|
||
context->HeaderBuf[context->LineBuf[X] + 32];
|
||
Pixels[X * 3 + 1] =
|
||
context->HeaderBuf[context->LineBuf[X] + 256 + 32];
|
||
Pixels[X * 3 + 2] =
|
||
context->HeaderBuf[context->LineBuf[X] + 512 + 32];
|
||
X++;
|
||
}
|
||
}
|
||
|
||
static void OneLine1(struct ras_progressive_state *context)
|
||
{
|
||
gint X;
|
||
guchar *Pixels;
|
||
|
||
X = 0;
|
||
Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines;
|
||
while (X < context->Header.width) {
|
||
int Bit;
|
||
|
||
Bit = (context->LineBuf[X/8])>>(7-(X&7));
|
||
Bit = Bit & 1;
|
||
/* The joys of having a BGR byteorder */
|
||
Pixels[X * 3 + 0] =
|
||
context->HeaderBuf[Bit + 32];
|
||
Pixels[X * 3 + 1] =
|
||
context->HeaderBuf[Bit + 2 + 32];
|
||
Pixels[X * 3 + 2] =
|
||
context->HeaderBuf[Bit + 4 + 32];
|
||
X++;
|
||
}
|
||
}
|
||
|
||
|
||
static void OneLine(struct ras_progressive_state *context)
|
||
{
|
||
context->LineDone = 0;
|
||
if (context->Lines >= context->Header.height)
|
||
return;
|
||
if (context->RasType == 32)
|
||
OneLine32(context);
|
||
if (context->RasType == 24)
|
||
OneLine24(context);
|
||
if (context->RasType == 8)
|
||
OneLine8(context);
|
||
if (context->RasType == 1)
|
||
OneLine1(context);
|
||
|
||
context->LineDone = 0;
|
||
context->Lines++;
|
||
|
||
if (context->updated_func != NULL) {
|
||
(*context->updated_func) (context->pixbuf,
|
||
0,
|
||
context->Lines,
|
||
context->Header.width,
|
||
context->Header.height,
|
||
context->user_data);
|
||
|
||
}
|
||
}
|
||
|
||
/*
|
||
* context - from image_begin_load
|
||
* buf - new image data
|
||
* size - length of new image data
|
||
*
|
||
* append image data onto incrementally built output image
|
||
*/
|
||
static gboolean
|
||
gdk_pixbuf__ras_image_load_increment(gpointer data,
|
||
const guchar * buf, guint size,
|
||
GError **error)
|
||
{
|
||
struct ras_progressive_state *context =
|
||
(struct ras_progressive_state *) data;
|
||
|
||
gint BytesToCopy;
|
||
|
||
while (size > 0) {
|
||
if (context->HeaderDone < context->HeaderSize) { /* We still
|
||
have headerbytes to do */
|
||
BytesToCopy =
|
||
context->HeaderSize - context->HeaderDone;
|
||
if (BytesToCopy > size)
|
||
BytesToCopy = size;
|
||
|
||
memmove(context->HeaderBuf + context->HeaderDone,
|
||
buf, BytesToCopy);
|
||
|
||
size -= BytesToCopy;
|
||
buf += BytesToCopy;
|
||
context->HeaderDone += BytesToCopy;
|
||
|
||
} else {
|
||
/* Pixeldata only */
|
||
BytesToCopy =
|
||
context->LineWidth - context->LineDone;
|
||
if (BytesToCopy > size)
|
||
BytesToCopy = size;
|
||
|
||
if (BytesToCopy > 0) {
|
||
memmove(context->LineBuf +
|
||
context->LineDone, buf,
|
||
BytesToCopy);
|
||
|
||
size -= BytesToCopy;
|
||
buf += BytesToCopy;
|
||
context->LineDone += BytesToCopy;
|
||
}
|
||
if ((context->LineDone >= context->LineWidth) &&
|
||
(context->LineWidth > 0))
|
||
OneLine(context);
|
||
|
||
|
||
}
|
||
|
||
if (context->HeaderDone >= 32)
|
||
if (!RAS2State((struct rasterfile *) context->HeaderBuf,
|
||
context, error)) {
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
void
|
||
gdk_pixbuf__ras_fill_vtable (GdkPixbufModule *module)
|
||
{
|
||
module->load = gdk_pixbuf__ras_image_load;
|
||
module->begin_load = gdk_pixbuf__ras_image_begin_load;
|
||
module->stop_load = gdk_pixbuf__ras_image_stop_load;
|
||
module->load_increment = gdk_pixbuf__ras_image_load_increment;
|
||
}
|
||
|