forked from AuroraMiddleware/gtk
d23b21018c
1999-11-10 Jonathan Blandford <jrb@redhat.com> * src/io-ras.c (OneLineMapped_file): Now can handle indexing correctly. Patch from Arjan to do so.
463 lines
10 KiB
C
463 lines
10 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 Library 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
|
||
* Library General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Library 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:
|
||
* "Indexed" (incl grayscale) sunras files don't work
|
||
( 1999/11/10 - Fixed for non-progressive loading )
|
||
* 1 bpp sunrasfiles don't work yet
|
||
* Compressed rasterfiles don't work yet
|
||
|
||
*/
|
||
|
||
#include <config.h>
|
||
#include <stdio.h>
|
||
#include <glib.h>
|
||
#include <gdk/gdk.h>
|
||
#include <gtk/gtk.h>
|
||
#include "gdk-pixbuf.h"
|
||
#include "gdk-pixbuf-io.h"
|
||
|
||
|
||
|
||
/*
|
||
Header structure for sunras files.
|
||
All values are in big-endian order on disk
|
||
*/
|
||
|
||
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() ??
|
||
*/
|
||
|
||
static unsigned int be32_to_cpu(guint i)
|
||
{
|
||
unsigned int i2;
|
||
i2 =
|
||
((i & 255) << 24) | (((i >> 8) & 255) << 16) |
|
||
(((i >> 16) & 255) << 8) | ((i >> 24) & 255);
|
||
return i2;
|
||
}
|
||
|
||
/*
|
||
Destroy notification function for the libart pixbuf
|
||
*/
|
||
|
||
static void free_buffer(gpointer user_data, gpointer data)
|
||
{
|
||
free(data);
|
||
}
|
||
|
||
/*
|
||
|
||
OneLineBGR_buf/file does what it says: Reads one line from file or buffer.
|
||
Note: It also changes BGR pixelorder to RGB as libart currently
|
||
doesn't support ART_PIX_BGR.
|
||
|
||
*/
|
||
static void OneLineBGR_buf(guchar * buffer, guint Width, guchar * pixels,
|
||
guint bpp)
|
||
{
|
||
guint X;
|
||
|
||
memcpy(pixels, buffer, (size_t) (Width * bpp));
|
||
X = 0;
|
||
while (X < Width) {
|
||
guchar Blue;
|
||
Blue = pixels[X * bpp];
|
||
pixels[X * bpp] = pixels[X * bpp + 2];
|
||
pixels[X * bpp + 2] = Blue;
|
||
X++;
|
||
}
|
||
}
|
||
|
||
static void OneLineBGR_file(FILE * f, guint Width, guchar * pixels,
|
||
guint bpp)
|
||
{
|
||
size_t result;
|
||
guint X;
|
||
guchar DummyByte;
|
||
|
||
result = fread(pixels, 1, (size_t) (Width * bpp), f);
|
||
|
||
g_assert(result == (size_t) (Width * bpp));
|
||
if (((Width * bpp) & 1) != 0) /* Not 16 bit aligned */
|
||
(void) fread(&DummyByte, 1, 1, f);
|
||
X = 0;
|
||
while (X < Width) {
|
||
guchar Blue;
|
||
Blue = pixels[X * bpp];
|
||
pixels[X * bpp] = pixels[X * bpp + 2];
|
||
pixels[X * bpp + 2] = Blue;
|
||
X++;
|
||
}
|
||
}
|
||
|
||
static void OneLineMapped_file(FILE * f, guint Width, guchar * pixels,
|
||
guint bpp, guchar *Map)
|
||
{
|
||
size_t result;
|
||
guint X;
|
||
guchar DummyByte;
|
||
guchar *buffer;
|
||
|
||
|
||
buffer =g_malloc((size_t) (Width * bpp));
|
||
|
||
g_assert(buffer!=NULL);
|
||
|
||
result = fread(buffer, 1, (size_t) (Width * bpp), f);
|
||
|
||
g_assert(result == (size_t) (Width * bpp));
|
||
|
||
if (((Width * bpp) & 1) != 0) /* Not 16 bit aligned */
|
||
(void) fread(&DummyByte, 1, 1, f);
|
||
X = 0;
|
||
while (X < Width) {
|
||
pixels[X * 3] = Map[buffer[X]];
|
||
pixels[X * 3+1] = Map[buffer[X]+256];
|
||
pixels[X * 3+2] = Map[buffer[X]+512];
|
||
|
||
X++;
|
||
}
|
||
g_free(buffer);
|
||
}
|
||
|
||
static void OneLineMapped_buf(guchar *buffer, guint Width, guchar * pixels,
|
||
guint bpp,guchar *Map)
|
||
{
|
||
size_t result;
|
||
guint X;
|
||
|
||
X = 0;
|
||
while (X < Width) {
|
||
pixels[X * 3] = Map[buffer[X]*3];
|
||
pixels[X * 3+1] = Map[buffer[X]*3+1];
|
||
pixels[X * 3+2] = Map[buffer[X]*3+2];
|
||
|
||
X++;
|
||
}
|
||
}
|
||
|
||
/* Shared library entry point */
|
||
GdkPixbuf *image_load(FILE * f)
|
||
{
|
||
guint bpp;
|
||
guint Y;
|
||
size_t i;
|
||
guchar *pixels;
|
||
guchar ColorMap[768];
|
||
struct rasterfile Header;
|
||
|
||
i = fread(&Header, 1, sizeof(Header), f);
|
||
g_assert(i == 32);
|
||
|
||
/* Fill default colormap */
|
||
for (Y=0;Y<256;Y++) {
|
||
ColorMap[Y*3+0]=Y;
|
||
ColorMap[Y*3+1]=Y;
|
||
ColorMap[Y*3+2]=Y;
|
||
}
|
||
/* Correct the byteorder of the header here */
|
||
Header.width = be32_to_cpu(Header.width);
|
||
Header.height = be32_to_cpu(Header.height);
|
||
Header.depth = be32_to_cpu(Header.depth);
|
||
Header.length = be32_to_cpu(Header.length);
|
||
Header.type = be32_to_cpu(Header.type);
|
||
Header.maptype = be32_to_cpu(Header.maptype);
|
||
Header.maplength = be32_to_cpu(Header.maplength);
|
||
|
||
|
||
bpp = 0;
|
||
if (Header.depth == 32)
|
||
bpp = 4;
|
||
if (Header.depth == 24)
|
||
bpp = 3;
|
||
if (Header.depth == 8)
|
||
bpp = 1;
|
||
|
||
printf("mapl %i \n",Header.maplength);
|
||
if (Header.maplength>0)
|
||
i = fread(ColorMap,1,Header.maplength,f);
|
||
|
||
|
||
g_assert(bpp != 0); /* Only 24 and 32 bpp for now */
|
||
|
||
if (bpp==4)
|
||
pixels = (guchar *) g_malloc(Header.width * Header.height * 4);
|
||
else
|
||
pixels = (guchar *) g_malloc(Header.width * Header.height * 3);
|
||
if (!pixels) {
|
||
return NULL;
|
||
}
|
||
|
||
/*
|
||
|
||
Loop through the file, one line at a time.
|
||
Only BGR-style files are handled right now.
|
||
|
||
*/
|
||
Y = 0;
|
||
while (Y < Header.height) {
|
||
if (bpp>1)
|
||
OneLineBGR_file(f, Header.width,
|
||
&pixels[Y * Header.width * bpp], bpp);
|
||
else
|
||
OneLineMapped_file(f, Header.width,
|
||
&pixels[Y * Header.width * 3], bpp,&ColorMap[0]);
|
||
Y++;
|
||
}
|
||
|
||
|
||
if (bpp == 4)
|
||
return gdk_pixbuf_new_from_data(pixels, ART_PIX_RGB, TRUE,
|
||
(gint) Header.width,
|
||
(gint) Header.height,
|
||
(gint) (Header.width *
|
||
4), free_buffer,
|
||
NULL);
|
||
else
|
||
return gdk_pixbuf_new_from_data(pixels, ART_PIX_RGB, FALSE,
|
||
(gint) Header.width,
|
||
(gint) Header.height,
|
||
(gint) (Header.width *
|
||
3), free_buffer,
|
||
NULL);
|
||
}
|
||
|
||
|
||
/* Progressive loading */
|
||
|
||
struct ras_progressive_state {
|
||
ModulePreparedNotifyFunc prepared_func;
|
||
ModuleUpdatedNotifyFunc updated_func;
|
||
gpointer user_data;
|
||
|
||
GdkPixbuf *pixbuf; /* Our "target" */
|
||
guchar *PixelData; /* pointer to the next line */
|
||
struct rasterfile Header;
|
||
guint bpp;
|
||
guint BytesPerLine;
|
||
guchar *linebuf;
|
||
guchar *ColorMap;
|
||
guint BytesInLB;
|
||
guint LinesDone;
|
||
|
||
|
||
|
||
gboolean have_header;
|
||
};
|
||
|
||
/*
|
||
* func - called when we have pixmap created (but no image data)
|
||
* user_data - passed as arg 1 to func
|
||
* return context (opaque to user)
|
||
*/
|
||
|
||
gpointer
|
||
image_begin_load(ModulePreparedNotifyFunc prepared_func,
|
||
ModuleUpdatedNotifyFunc updated_func, gpointer user_data)
|
||
{
|
||
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->pixbuf = NULL;
|
||
context->linebuf = NULL;
|
||
context->bpp = 0;
|
||
context->have_header = 0;
|
||
context->BytesInLB = 0;
|
||
context->BytesPerLine = 0;
|
||
context->LinesDone = 0;
|
||
context->ColorMap = NULL;
|
||
|
||
return (gpointer) context;
|
||
}
|
||
|
||
/*
|
||
* context - returned from image_begin_load
|
||
*
|
||
* free context, unref gdk_pixbuf
|
||
*/
|
||
void image_stop_load(gpointer data)
|
||
{
|
||
struct ras_progressive_state *context =
|
||
(struct ras_progressive_state *) data;
|
||
|
||
g_return_if_fail(context != NULL);
|
||
|
||
if (context->pixbuf)
|
||
gdk_pixbuf_unref(context->pixbuf);
|
||
|
||
if (context->linebuf)
|
||
g_free(context->linebuf);
|
||
if (context->ColorMap)
|
||
g_free(context->ColorMap);
|
||
g_free(context);
|
||
}
|
||
|
||
|
||
/*
|
||
* context - from image_begin_load
|
||
* buf - new image data
|
||
* size - length of new image data
|
||
*
|
||
* append image data onto inrecrementally built output image
|
||
*/
|
||
gboolean image_load_increment(gpointer data, guchar * buf, guint size)
|
||
{
|
||
struct ras_progressive_state *context =
|
||
(struct ras_progressive_state *) data;
|
||
|
||
if ((context->have_header == 0) && (size < 32))
|
||
return FALSE;
|
||
|
||
if (context->have_header == FALSE) {
|
||
memcpy(&context->Header, buf, 32);
|
||
buf += 32;
|
||
size -= 32;
|
||
|
||
context->Header.width = be32_to_cpu(context->Header.width);
|
||
context->Header.height =
|
||
be32_to_cpu(context->Header.height);
|
||
context->Header.depth = be32_to_cpu(context->Header.depth);
|
||
context->Header.length =
|
||
be32_to_cpu(context->Header.length);
|
||
context->Header.type = be32_to_cpu(context->Header.type);
|
||
context->Header.maptype =
|
||
be32_to_cpu(context->Header.maptype);
|
||
context->Header.maplength =
|
||
be32_to_cpu(context->Header.maplength);
|
||
|
||
context->bpp = 0;
|
||
if (context->Header.depth == 32)
|
||
context->bpp = 4;
|
||
if (context->Header.depth == 24)
|
||
context->bpp = 3;
|
||
if (context->Header.depth == 8)
|
||
context->bpp = 1;
|
||
|
||
|
||
g_assert(context->bpp != 0); /* Only 24 and 32 bpp for now */
|
||
|
||
|
||
if (context->bpp == 4)
|
||
context->pixbuf = gdk_pixbuf_new(ART_PIX_RGB, TRUE,
|
||
8,
|
||
(gint)
|
||
context->Header.
|
||
width,
|
||
(gint)
|
||
context->Header.
|
||
height);
|
||
else
|
||
context->pixbuf =
|
||
gdk_pixbuf_new(ART_PIX_RGB, FALSE, 8,
|
||
(gint) context->Header.width,
|
||
(gint) context->Header.height);
|
||
|
||
/* Use pixbuf buffer to store decompressed data */
|
||
g_assert(context->pixbuf != NULL);
|
||
g_assert(context->pixbuf->art_pixbuf != NULL);
|
||
context->PixelData = context->pixbuf->art_pixbuf->pixels;
|
||
g_assert(context->PixelData != NULL);
|
||
context->BytesPerLine =
|
||
context->Header.width * context->bpp;
|
||
|
||
if (((context->BytesPerLine) & 1) != 0) /* Not 16 bit aligned */
|
||
context->BytesPerLine++;
|
||
|
||
context->linebuf =
|
||
(guchar *) g_malloc(context->BytesPerLine);
|
||
context->have_header = TRUE;
|
||
if (context->linebuf == NULL) {
|
||
/* Failed to allocate memory */
|
||
g_error("Couldn't allocate linebuf");
|
||
}
|
||
|
||
|
||
/* Notify the client that we are ready to go */
|
||
(*context->prepared_func) (context->pixbuf,
|
||
context->user_data);
|
||
}
|
||
|
||
|
||
while (size > 0) {
|
||
guint ToDo;
|
||
ToDo = context->BytesPerLine - context->BytesInLB;
|
||
if (ToDo > size)
|
||
ToDo = size;
|
||
memcpy(context->linebuf + context->BytesInLB,
|
||
buf, (size_t) ToDo);
|
||
size -= ToDo;
|
||
buf += ToDo;
|
||
context->BytesInLB += ToDo;
|
||
if (context->BytesInLB >= context->BytesPerLine) {
|
||
/* linebuf if full */
|
||
if (context->bpp>1)
|
||
OneLineBGR_buf(context->linebuf,
|
||
context->Header.width,
|
||
context->PixelData, context->bpp);
|
||
else
|
||
OneLineMapped_buf(context->linebuf,
|
||
context->Header.width,
|
||
context->PixelData, context->bpp,
|
||
context->ColorMap);
|
||
context->BytesInLB = 0;
|
||
context->PixelData +=
|
||
context->pixbuf->art_pixbuf->rowstride;
|
||
context->LinesDone++;
|
||
|
||
(*context->updated_func) (context->pixbuf,
|
||
context->user_data,
|
||
0,
|
||
context->LinesDone,
|
||
context->Header.width,
|
||
context->Header.height);
|
||
|
||
|
||
}
|
||
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|