quakeforge/libs/image/png.c

298 lines
6.8 KiB
C
Raw Normal View History

/*
png.c
PNG image handling
Copyright (C) 2003 Harry Roberts
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 2
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, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
static __attribute__ ((used)) const char rcsid[] =
"$Id$";
2003-09-08 14:32:54 +00:00
#ifdef HAVE_PNG
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <png.h>
#include "QF/image.h"
#include "QF/png.h"
#include "QF/qendian.h"
#include "QF/qtypes.h"
#include "QF/quakefs.h"
#include "QF/sys.h"
#include "QF/zone.h"
#include "compat.h"
/* Qread wrapper for libpng */
static void
2003-09-04 21:24:20 +00:00
user_read_data (png_structp png_ptr, png_bytep data, png_size_t length)
{
Qread ((QFile *) png_get_io_ptr (png_ptr), data, length);
}
2003-09-09 16:18:13 +00:00
/* Qwrite wrapper for libpng */
static void
user_write_data (png_structp png_ptr, png_bytep data, png_size_t length)
{
Qwrite ((QFile *) png_get_io_ptr (png_ptr), data, length);
}
/* Qflush wrapper for libpng */
static void
user_flush_data (png_structp png_ptr)
{
Qflush ((QFile *) png_get_io_ptr (png_ptr));
}
/* Basicly taken from the libpng example rpng-x */
static int
2003-09-04 21:24:20 +00:00
readpng_init (QFile *infile, png_structp *png_ptr, png_infop *info_ptr)
{
unsigned char sig[8];
/* Check the signiture */
Qread (infile, sig, 8);
if (!png_check_sig (sig, 8)) {
Sys_Printf ("Bad png file\n");
return (1);
}
*png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL,
NULL);
2003-09-04 21:24:20 +00:00
if (!*png_ptr)
return (2); /* Out of memory! */
2003-09-04 21:24:20 +00:00
*info_ptr = png_create_info_struct (*png_ptr);
if (!*info_ptr) {
png_destroy_read_struct (png_ptr, NULL, NULL);
return (3); /* Out of memory! */
}
/* setjmp() must be called in every function that calls a PNG-reading
* libpng function */
if (setjmp (png_jmpbuf (*png_ptr))) {
2003-09-04 21:24:20 +00:00
png_destroy_read_struct (png_ptr, info_ptr, NULL);
return (4);
}
2003-09-04 21:24:20 +00:00
png_set_read_fn (*png_ptr, infile, user_read_data);
/* Is png_set_sig_bytes needed? */
2003-09-04 21:24:20 +00:00
png_set_sig_bytes (*png_ptr, 8); // We allready read the 8 signiture bytes
2003-09-04 21:24:20 +00:00
png_read_info (*png_ptr, *info_ptr);//read all png info upto the image data
return (0);
}
/* Load the png file and return a texture */
tex_t *
LoadPNG (QFile *infile)
{
double gamma;
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
png_uint_32 height, width, rowbytes, i;
png_bytepp row_pointers = NULL;
int bit_depth, color_type;
tex_t *tex;
if (readpng_init (infile, &png_ptr, &info_ptr) != 0)
return (NULL);
png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
NULL, NULL, NULL);
if (color_type == PNG_COLOR_TYPE_PALETTE)
png_set_expand (png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
png_set_expand (png_ptr);
if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
png_set_expand (png_ptr);
if (bit_depth == 16)
png_set_strip_16 (png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY
|| color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb (png_ptr);
/* NOTE: gamma support? */
/* unlike the example in the libpng documentation, we have *no* idea where
* this file may have come from--so if it doesn't have a file gamma, don't
* do any correction ("do no harm")
*/
2003-12-07 04:21:58 +00:00
if (png_get_gAMA(png_ptr, info_ptr, &gamma))
png_set_gamma (png_ptr, 1.0, gamma);
/* All transformations have been registered, now update the info_ptr
* structure */
png_read_update_info (png_ptr, info_ptr);
/* Allocate tex_t structure */
rowbytes = png_get_rowbytes(png_ptr, info_ptr);
tex = Hunk_TempAlloc (field_offset (tex_t, data[height * rowbytes]));
tex->width = width;
tex->height = height;
if (color_type & PNG_COLOR_MASK_ALPHA)
tex->format = tex_rgba;
else
tex->format = tex_rgb;
tex->palette = NULL;
if ((row_pointers = (png_bytepp) malloc (height * sizeof (png_bytep)))
== NULL) {
png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
return (NULL); /* Out of memory */
}
for (i = 0; i < height; ++i)
row_pointers[i] = tex->data + (i * rowbytes);
/* Now we can go ahead and read the whole image */
png_read_image (png_ptr, row_pointers);
free (row_pointers);
row_pointers = NULL;
png_read_end (png_ptr, NULL);
return (tex);
}
2003-09-08 14:32:54 +00:00
2003-09-09 16:18:13 +00:00
#define WRITEPNG_BIT_DEPTH 8
void
WritePNG (const char *fileName, byte *data, int width, int height)
{
QFile *outfile;
int i;
png_structp png_ptr;
png_infop info_ptr;
png_bytepp row_pointers = NULL;
2003-09-09 16:18:13 +00:00
/* initialize write struct */
png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
Sys_Printf ("png_Create_write_struct failed\n");
return;
}
info_ptr = png_create_info_struct (png_ptr);
if (png_ptr == NULL) {
png_destroy_write_struct (&png_ptr, NULL);
Sys_Printf ("png_create_info_struct failed\n");
return;
}
if (setjmp(png_jmpbuf(png_ptr))) {
png_destroy_write_struct (&png_ptr, &info_ptr);
return;
}
outfile = Qopen (fileName, "wb");
if (!outfile) {
Sys_Printf ("Couldn't open %s\n", fileName);
return; /* Can't open file */
}
png_set_write_fn (png_ptr, outfile, user_write_data, user_flush_data);
2003-09-09 16:18:13 +00:00
/* Write the header */
if (setjmp(png_jmpbuf(png_ptr))) {
Sys_Printf ("Error writing png header\n");
return;
}
png_set_IHDR (png_ptr, info_ptr, width, height, WRITEPNG_BIT_DEPTH,
PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
/* NOTE: Write gamma support? */
/* png_set_gAMA (png_ptr, info_ptr, gamma); */
png_set_bgr(png_ptr);
png_write_info (png_ptr, info_ptr);
/* Setup row pointers */
if ((row_pointers = (png_bytepp)malloc(height * sizeof(png_bytep))) == NULL) {
png_destroy_write_struct (&png_ptr, &info_ptr);
return; /* Out of memory */
}
for (i = 0; i < height; i++) {
row_pointers[height - i - 1] = data + (i * width * 3);
}
if (setjmp(png_jmpbuf(png_ptr))) {
Sys_Printf ("Error writing PNG image data\n");
return;
}
png_write_image (png_ptr, row_pointers);
/* end write */
if (setjmp(png_jmpbuf(png_ptr))) {
Sys_Printf ("Error writing end of PNG image\n");
return;
}
png_write_end (png_ptr, NULL);
Qclose (outfile);
}
2003-09-08 14:32:54 +00:00
#else
#include "QF/image.h"
#include "QF/png.h"
2003-09-08 14:32:54 +00:00
tex_t *
LoadPNG (QFile *infile)
{
return 0;
}
2003-09-09 16:18:13 +00:00
void
WritePNG (const char *fileName, byte *data, int width, int height)
{
return;
}
2003-09-08 14:32:54 +00:00
#endif