aboutsummaryrefslogtreecommitdiff
path: root/contrib
diff options
context:
space:
mode:
authorToomas Soome <tsoome@FreeBSD.org>2021-01-02 19:29:24 +0000
committerToomas Soome <tsoome@FreeBSD.org>2021-01-02 19:29:24 +0000
commit80aa931900c863a5d088c49b560488ab32f2d1d9 (patch)
tree852d085b41355822531809fc29808e5ef9e1275e /contrib
parent72c59f1728c12fbdcd316c172708d8f3a60299be (diff)
downloadsrc-80aa931900c863a5d088c49b560488ab32f2d1d9.tar.gz
src-80aa931900c863a5d088c49b560488ab32f2d1d9.zip
contrib: setup pnglite
Diffstat (limited to 'contrib')
-rw-r--r--contrib/pnglite/README.md2
-rw-r--r--contrib/pnglite/pnglite.c892
-rw-r--r--contrib/pnglite/pnglite.h289
3 files changed, 443 insertions, 740 deletions
diff --git a/contrib/pnglite/README.md b/contrib/pnglite/README.md
index 4d2929600228..bbb5209b38b3 100644
--- a/contrib/pnglite/README.md
+++ b/contrib/pnglite/README.md
@@ -2,4 +2,4 @@ pnglite
====
#### A pretty small png library
-Currently all documentation resides in pnglite.h.
+Currently all documentation resides in pnglite.h.
diff --git a/contrib/pnglite/pnglite.c b/contrib/pnglite/pnglite.c
index 4899f24b6a85..e3cc2f866c6f 100644
--- a/contrib/pnglite/pnglite.c
+++ b/contrib/pnglite/pnglite.c
@@ -1,131 +1,86 @@
-/* pnglite.c - pnglite library
- For conditions of distribution and use, see copyright notice in pnglite.h
-*/
-#define DO_CRC_CHECKS 1
-#define USE_ZLIB 1
-
-#if USE_ZLIB
-#include <zlib.h>
+/*
+ * pnglite.c - pnglite library
+ * For conditions of distribution and use, see copyright notice in pnglite.h
+ */
+
+/*
+ * Note: this source is updated to enable build for FreeBSD boot loader.
+ */
+
+#ifdef _STANDALONE
+#include <sys/cdefs.h>
+#include <stand.h>
#else
-#include "zlite.h"
-#endif
-
#include <stdio.h>
#include <stdlib.h>
-#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#endif
+#include <zlib.h>
#include "pnglite.h"
-static png_alloc_t png_alloc;
-static png_free_t png_free;
+#ifndef abs
+#define abs(x) ((x) < 0? -(x):(x))
+#endif
-static size_t file_read(png_t* png, void* out, size_t size, size_t numel)
-{
- size_t result;
- if(png->read_fun)
- {
- result = png->read_fun(out, size, numel, png->user_pointer);
- }
- else
- {
- if(!out)
- {
- result = fseek(png->user_pointer, (long)(size*numel), SEEK_CUR);
- }
- else
- {
- result = fread(out, size, numel, png->user_pointer);
- }
- }
+#define PNG_32b(b, s) ((uint32_t)(b) << (s))
+#define PNG_U32(b1, b2, b3, b4) \
+ (PNG_32b(b1, 24) | PNG_32b(b2, 16) | PNG_32b(b3, 8) | PNG_32b(b4, 0))
- return result;
-}
+#define png_IDAT PNG_U32(73, 68, 65, 84)
+#define png_IEND PNG_U32(73, 69, 78, 68)
-static size_t file_write(png_t* png, void* p, size_t size, size_t numel)
+static ssize_t
+file_read(png_t *png, void *out, size_t size, size_t numel)
{
- size_t result;
+ ssize_t result;
+ off_t offset = (off_t)(size * numel);
- if(png->write_fun)
- {
- result = png->write_fun(p, size, numel, png->user_pointer);
- }
- else
- {
- result = fwrite(p, size, numel, png->user_pointer);
+ if (offset < 0)
+ return (PNG_FILE_ERROR);
+
+ if (!out) {
+ result = lseek(png->fd, offset, SEEK_CUR);
+ } else {
+ result = read(png->fd, out, size * numel);
}
- return result;
+ return (result);
}
-static int file_read_ul(png_t* png, unsigned *out)
+static int
+file_read_ul(png_t *png, unsigned *out)
{
- unsigned char buf[4];
+ uint8_t buf[4];
- if(file_read(png, buf, 1, 4) != 4)
- return PNG_FILE_ERROR;
+ if (file_read(png, buf, 1, 4) != 4)
+ return (PNG_FILE_ERROR);
*out = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
- return PNG_NO_ERROR;
+ return (PNG_NO_ERROR);
}
-static int file_write_ul(png_t* png, unsigned in)
-{
- unsigned char buf[4];
-
- buf[0] = (in>>24) & 0xff;
- buf[1] = (in>>16) & 0xff;
- buf[2] = (in>>8) & 0xff;
- buf[3] = (in) & 0xff;
-
- if(file_write(png, buf, 1, 4) != 4)
- return PNG_FILE_ERROR;
-
- return PNG_NO_ERROR;
-}
-
-static unsigned get_ul(unsigned char* buf)
+static unsigned
+get_ul(uint8_t *buf)
{
unsigned result;
- unsigned char foo[4];
+ uint8_t foo[4];
memcpy(foo, buf, 4);
result = (foo[0]<<24) | (foo[1]<<16) | (foo[2]<<8) | foo[3];
- return result;
-}
-
-static unsigned set_ul(unsigned char* buf, unsigned in)
-{
- buf[0] = (in>>24) & 0xff;
- buf[1] = (in>>16) & 0xff;
- buf[2] = (in>>8) & 0xff;
- buf[3] = (in) & 0xff;
-
- return PNG_NO_ERROR;
+ return (result);
}
-int png_init(png_alloc_t pngalloc, png_free_t pngfree)
-{
- if(pngalloc)
- png_alloc = pngalloc;
- else
- png_alloc = &malloc;
-
- if(pngfree)
- png_free = pngfree;
- else
- png_free = &free;
-
- return PNG_NO_ERROR;
-}
-
-static int png_get_bpp(png_t* png)
+static int
+png_get_bpp(png_t *png)
{
int bpp;
- switch(png->color_type)
- {
+ switch (png->color_type) {
case PNG_GREYSCALE:
bpp = 1; break;
case PNG_TRUECOLOR:
@@ -137,44 +92,40 @@ static int png_get_bpp(png_t* png)
case PNG_TRUECOLOR_ALPHA:
bpp = 4; break;
default:
- return PNG_FILE_ERROR;
+ return (PNG_FILE_ERROR);
}
- bpp *= png->depth/8;
+ bpp *= png->depth / 8;
- return bpp;
+ return (bpp);
}
-static int png_read_ihdr(png_t* png)
+static int
+png_read_ihdr(png_t *png)
{
- unsigned length;
-#if DO_CRC_CHECKS
+ unsigned length = 0;
unsigned orig_crc;
unsigned calc_crc;
-#endif
- unsigned char ihdr[13+4]; /* length should be 13, make room for type (IHDR) */
+ uint8_t ihdr[13+4]; /* length should be 13, make room for type (IHDR) */
- file_read_ul(png, &length);
+ if (file_read_ul(png, &length) != PNG_NO_ERROR)
+ return (PNG_FILE_ERROR);
- if(length != 13)
- {
- printf("%d\n", length);
- return PNG_CRC_ERROR;
- }
+ if (length != 13)
+ return (PNG_CRC_ERROR);
+
+ if (file_read(png, ihdr, 1, 13+4) != 13+4)
+ return (PNG_EOF_ERROR);
- if(file_read(png, ihdr, 1, 13+4) != 13+4)
- return PNG_EOF_ERROR;
-#if DO_CRC_CHECKS
- file_read_ul(png, &orig_crc);
+ if (file_read_ul(png, &orig_crc) != PNG_NO_ERROR)
+ return (PNG_FILE_ERROR);
- calc_crc = crc32(0L, 0, 0);
+ calc_crc = crc32(0L, Z_NULL, 0);
calc_crc = crc32(calc_crc, ihdr, 13+4);
- if(orig_crc != calc_crc)
- return PNG_CRC_ERROR;
-#else
- file_read_ul(png);
-#endif
+ if (orig_crc != calc_crc) {
+ return (PNG_CRC_ERROR);
+ }
png->width = get_ul(ihdr+4);
png->height = get_ul(ihdr+8);
@@ -184,51 +135,20 @@ static int png_read_ihdr(png_t* png)
png->filter_method = ihdr[15];
png->interlace_method = ihdr[16];
- if(png->color_type == PNG_INDEXED)
- return PNG_NOT_SUPPORTED;
-
- if(png->depth != 8 && png->depth != 16)
- return PNG_NOT_SUPPORTED;
+ if (png->color_type == PNG_INDEXED)
+ return (PNG_NOT_SUPPORTED);
- if(png->interlace_method)
- return PNG_NOT_SUPPORTED;
+ if (png->depth != 8 && png->depth != 16)
+ return (PNG_NOT_SUPPORTED);
- return PNG_NO_ERROR;
-}
-
-static int png_write_ihdr(png_t* png)
-{
- unsigned char ihdr[13+4];
- unsigned char *p = ihdr;
- unsigned crc;
-
- file_write(png, "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A", 1, 8);
-
- file_write_ul(png, 13);
-
- *p = 'I'; p++;
- *p = 'H'; p++;
- *p = 'D'; p++;
- *p = 'R'; p++;
- set_ul(p, png->width); p+=4;
- set_ul(p, png->height); p+=4;
- *p = png->depth; p++;
- *p = png->color_type; p++;
- *p = 0; p++;
- *p = 0; p++;
- *p = 0; p++;
+ if (png->interlace_method)
+ return (PNG_NOT_SUPPORTED);
- file_write(png, ihdr, 1, 13+4);
-
- crc = crc32(0L, 0, 0);
- crc = crc32(crc, ihdr, 13+4);
-
- file_write_ul(png, crc);
-
- return PNG_NO_ERROR;
+ return (PNG_NO_ERROR);
}
-void png_print_info(png_t* png)
+void
+png_print_info(png_t *png)
{
printf("PNG INFO:\n");
printf("\twidth:\t\t%d\n", png->width);
@@ -236,416 +156,287 @@ void png_print_info(png_t* png)
printf("\tdepth:\t\t%d\n", png->depth);
printf("\tcolor:\t\t");
- switch(png->color_type)
- {
- case PNG_GREYSCALE: printf("greyscale\n"); break;
- case PNG_TRUECOLOR: printf("truecolor\n"); break;
- case PNG_INDEXED: printf("palette\n"); break;
- case PNG_GREYSCALE_ALPHA: printf("greyscale with alpha\n"); break;
- case PNG_TRUECOLOR_ALPHA: printf("truecolor with alpha\n"); break;
- default: printf("unknown, this is not good\n"); break;
+ switch (png->color_type) {
+ case PNG_GREYSCALE:
+ printf("greyscale\n"); break;
+ case PNG_TRUECOLOR:
+ printf("truecolor\n"); break;
+ case PNG_INDEXED:
+ printf("palette\n"); break;
+ case PNG_GREYSCALE_ALPHA:
+ printf("greyscale with alpha\n"); break;
+ case PNG_TRUECOLOR_ALPHA:
+ printf("truecolor with alpha\n"); break;
+ default:
+ printf("unknown, this is not good\n"); break;
}
- printf("\tcompression:\t%s\n", png->compression_method?"unknown, this is not good":"inflate/deflate");
- printf("\tfilter:\t\t%s\n", png->filter_method?"unknown, this is not good":"adaptive");
- printf("\tinterlace:\t%s\n", png->interlace_method?"interlace":"no interlace");
+ printf("\tcompression:\t%s\n",
+ png->compression_method?
+ "unknown, this is not good":"inflate/deflate");
+ printf("\tfilter:\t\t%s\n",
+ png->filter_method? "unknown, this is not good":"adaptive");
+ printf("\tinterlace:\t%s\n",
+ png->interlace_method? "interlace":"no interlace");
}
-int png_open_read(png_t* png, png_read_callback_t read_fun, void* user_pointer)
+int
+png_open(png_t *png, const char *filename)
{
char header[8];
int result;
- png->read_fun = read_fun;
- png->write_fun = 0;
- png->user_pointer = user_pointer;
-
- if(!read_fun && !user_pointer)
- return PNG_WRONG_ARGUMENTS;
+ png->image = NULL;
+ png->fd = open(filename, O_RDONLY);
+ if (png->fd == -1)
+ return (PNG_FILE_ERROR);
- if(file_read(png, header, 1, 8) != 8)
- return PNG_EOF_ERROR;
+ if (file_read(png, header, 1, 8) != 8) {
+ result = PNG_EOF_ERROR;
+ goto done;
+ }
- if(memcmp(header, "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A", 8) != 0)
- return PNG_HEADER_ERROR;
+ if (memcmp(header, "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A", 8) != 0) {
+ result = PNG_HEADER_ERROR;
+ goto done;
+ }
result = png_read_ihdr(png);
+ if (result == PNG_NO_ERROR) {
+ result = png_get_bpp(png);
+ if (result > 0) {
+ png->bpp = (uint8_t)result;
+ result = PNG_NO_ERROR;
+ }
+ }
- png->bpp = (unsigned char)png_get_bpp(png);
-
- return result;
-}
-
-int png_open_write(png_t* png, png_write_callback_t write_fun, void* user_pointer)
-{
- png->write_fun = write_fun;
- png->read_fun = 0;
- png->user_pointer = user_pointer;
-
- if(!write_fun && !user_pointer)
- return PNG_WRONG_ARGUMENTS;
-
- return PNG_NO_ERROR;
-}
-
-int png_open(png_t* png, png_read_callback_t read_fun, void* user_pointer)
-{
- return png_open_read(png, read_fun, user_pointer);
-}
-
-int png_open_file_read(png_t *png, const char* filename)
-{
- FILE* fp = fopen(filename, "rb");
-
- if(!fp)
- return PNG_FILE_ERROR;
-
- return png_open_read(png, 0, fp);
-}
-
-int png_open_file_write(png_t *png, const char* filename)
-{
- FILE* fp = fopen(filename, "wb");
-
- if(!fp)
- return PNG_FILE_ERROR;
+done:
+ if (result == PNG_NO_ERROR) {
+ uint64_t size = png->width * png->height * png->bpp;
- return png_open_write(png, 0, fp);
-}
+ if (size < UINT_MAX)
+ png->image = malloc(size);
+ if (png->image == NULL)
+ result = PNG_MEMORY_ERROR;
+ }
-int png_open_file(png_t *png, const char* filename)
-{
- return png_open_file_read(png, filename);
-}
+ if (result == PNG_NO_ERROR)
+ result = png_get_data(png, png->image);
-int png_close_file(png_t* png)
-{
- fclose(png->user_pointer);
+ if (result != PNG_NO_ERROR) {
+ free(png->image);
+ (void) close(png->fd);
+ png->fd = -1;
+ return (result);
+ }
- return PNG_NO_ERROR;
+ return (result);
}
-static int png_init_deflate(png_t* png, unsigned char* data, int datalen)
+int
+png_close(png_t *png)
{
- z_stream *stream;
- png->zs = png_alloc(sizeof(z_stream));
-
- stream = png->zs;
-
- if(!stream)
- return PNG_MEMORY_ERROR;
-
- memset(stream, 0, sizeof(z_stream));
+ (void) close(png->fd);
+ png->fd = -1;
+ free(png->image);
+ png->image = NULL;
- if(deflateInit(stream, Z_DEFAULT_COMPRESSION) != Z_OK)
- return PNG_ZLIB_ERROR;
-
- stream->next_in = data;
- stream->avail_in = datalen;
-
- return PNG_NO_ERROR;
+ return (PNG_NO_ERROR);
}
-static int png_init_inflate(png_t* png)
+static int
+png_init_inflate(png_t *png)
{
-#if USE_ZLIB
z_stream *stream;
- png->zs = png_alloc(sizeof(z_stream));
-#else
- zl_stream *stream;
- png->zs = png_alloc(sizeof(zl_stream));
-#endif
+ png->zs = calloc(1, sizeof (z_stream));
stream = png->zs;
- if(!stream)
- return PNG_MEMORY_ERROR;
+ if (!stream)
+ return (PNG_MEMORY_ERROR);
-#if USE_ZLIB
- memset(stream, 0, sizeof(z_stream));
- if(inflateInit(stream) != Z_OK)
- return PNG_ZLIB_ERROR;
-#else
- memset(stream, 0, sizeof(zl_stream));
- if(z_inflateInit(stream) != Z_OK)
- return PNG_ZLIB_ERROR;
-#endif
+ if (inflateInit(stream) != Z_OK) {
+ free(png->zs);
+ png->zs = NULL;
+ return (PNG_ZLIB_ERROR);
+ }
stream->next_out = png->png_data;
stream->avail_out = png->png_datalen;
- return PNG_NO_ERROR;
+ return (PNG_NO_ERROR);
}
-static int png_end_deflate(png_t* png)
+static int
+png_end_inflate(png_t *png)
{
z_stream *stream = png->zs;
+ int rc = PNG_NO_ERROR;
- if(!stream)
- return PNG_MEMORY_ERROR;
+ if (!stream)
+ return (PNG_MEMORY_ERROR);
- deflateEnd(stream);
-
- png_free(png->zs);
-
- return PNG_NO_ERROR;
-}
-
-static int png_end_inflate(png_t* png)
-{
-#if USE_ZLIB
- z_stream *stream = png->zs;
-#else
- zl_stream *stream = png->zs;
-#endif
-
- if(!stream)
- return PNG_MEMORY_ERROR;
-
-#if USE_ZLIB
- if(inflateEnd(stream) != Z_OK)
-#else
- if(z_inflateEnd(stream) != Z_OK)
-#endif
- {
+ if (inflateEnd(stream) != Z_OK) {
printf("ZLIB says: %s\n", stream->msg);
- return PNG_ZLIB_ERROR;
+ rc = PNG_ZLIB_ERROR;
}
- png_free(png->zs);
+ free(png->zs);
+ png->zs = NULL;
- return PNG_NO_ERROR;
+ return (rc);
}
-static int png_inflate(png_t* png, unsigned char* data, int len)
+static int
+png_inflate(png_t *png, uint8_t *data, int len)
{
int result;
-#if USE_ZLIB
z_stream *stream = png->zs;
-#else
- zl_stream *stream = png->zs;
-#endif
- if(!stream)
- return PNG_MEMORY_ERROR;
+ if (!stream)
+ return (PNG_MEMORY_ERROR);
stream->next_in = data;
stream->avail_in = len;
-#if USE_ZLIB
result = inflate(stream, Z_SYNC_FLUSH);
-#else
- result = z_inflate(stream);
-#endif
-
- if(result != Z_STREAM_END && result != Z_OK)
- {
- printf("%s\n", stream->msg);
- return PNG_ZLIB_ERROR;
- }
-
- if(stream->avail_in != 0)
- return PNG_ZLIB_ERROR;
-
- return PNG_NO_ERROR;
-}
-
-static int png_deflate(png_t* png, char* outdata, int outlen, int *outwritten)
-{
- int result;
-
- z_stream *stream = png->zs;
-
- if(!stream)
- return PNG_MEMORY_ERROR;
- stream->next_out = (unsigned char*)outdata;
- stream->avail_out = outlen;
-
- result = deflate(stream, Z_SYNC_FLUSH);
-
- *outwritten = outlen - stream->avail_out;
-
- if(result != Z_STREAM_END && result != Z_OK)
- {
+ if (result != Z_STREAM_END && result != Z_OK) {
printf("%s\n", stream->msg);
- return PNG_ZLIB_ERROR;
+ return (PNG_ZLIB_ERROR);
}
- return result;
-}
+ if (stream->avail_in != 0)
+ return (PNG_ZLIB_ERROR);
-static int png_write_idats(png_t* png, unsigned char* data)
-{
- unsigned char *chunk;
- unsigned long written;
- unsigned long crc;
- unsigned size = png->width * png->height * png->bpp + png->height;
- unsigned chunk_size = compressBound(size);
-
- (void)png_init_deflate;
- (void)png_end_deflate;
- (void)png_deflate;
-
- chunk = png_alloc(chunk_size + 4);
- memcpy(chunk, "IDAT", 4);
-
- written = chunk_size;
- compress(chunk+4, &written, data, size);
-
- crc = crc32(0L, Z_NULL, 0);
- crc = crc32(crc, chunk, written+4);
- set_ul(chunk+written+4, crc);
- file_write_ul(png, written);
- file_write(png, chunk, 1, written+8);
- png_free(chunk);
-
- file_write_ul(png, 0);
- file_write(png, "IEND", 1, 4);
- crc = crc32(0L, (const unsigned char *)"IEND", 4);
- file_write_ul(png, crc);
-
- return PNG_NO_ERROR;
+ return (PNG_NO_ERROR);
}
-static int png_read_idat(png_t* png, unsigned length)
+static int
+png_read_idat(png_t *png, unsigned length)
{
-#if DO_CRC_CHECKS
unsigned orig_crc;
unsigned calc_crc;
-#endif
+ ssize_t len = length;
- if(!png->readbuf || png->readbuflen < length)
- {
- if (png->readbuf)
- {
- png_free(png->readbuf);
- }
- png->readbuf = png_alloc(length);
+ if (!png->readbuf || png->readbuflen < length) {
+ png->readbuf = realloc(png->readbuf, length);
png->readbuflen = length;
}
- if(!png->readbuf)
- {
- return PNG_MEMORY_ERROR;
- }
+ if (!png->readbuf)
+ return (PNG_MEMORY_ERROR);
- if(file_read(png, png->readbuf, 1, length) != length)
- {
- return PNG_FILE_ERROR;
- }
+ if (file_read(png, png->readbuf, 1, length) != len)
+ return (PNG_FILE_ERROR);
-#if DO_CRC_CHECKS
calc_crc = crc32(0L, Z_NULL, 0);
- calc_crc = crc32(calc_crc, (unsigned char*)"IDAT", 4);
- calc_crc = crc32(calc_crc, (unsigned char*)png->readbuf, length);
+ calc_crc = crc32(calc_crc, (uint8_t *)"IDAT", 4);
+ calc_crc = crc32(calc_crc, (uint8_t *)png->readbuf, length);
- file_read_ul(png, &orig_crc);
+ if (file_read_ul(png, &orig_crc) != PNG_NO_ERROR)
+ return (PNG_FILE_ERROR);
- if(orig_crc != calc_crc)
- {
- return PNG_CRC_ERROR;
- }
-#else
- file_read_ul(png);
-#endif
+ if (orig_crc != calc_crc)
+ return (PNG_CRC_ERROR);
- return png_inflate(png, png->readbuf, length);
+ return (png_inflate(png, png->readbuf, length));
}
-static int png_process_chunk(png_t* png)
+static int
+png_process_chunk(png_t *png)
{
int result = PNG_NO_ERROR;
unsigned type;
unsigned length;
- file_read_ul(png, &length);
-
- if(file_read(png, &type, 1, 4) != 4)
- return PNG_FILE_ERROR;
-
- if(type == *(unsigned int*)"IDAT") /* if we found an idat, all other idats should be followed with no other chunks in between */
- {
- if(!png->png_data) /* first IDAT */
- {
- png->png_datalen = png->width * png->height * png->bpp + png->height;
- png->png_data = png_alloc(png->png_datalen);
+ if (file_read_ul(png, &length) != PNG_NO_ERROR)
+ return (PNG_FILE_ERROR);
+
+ if (file_read_ul(png, &type) != PNG_NO_ERROR)
+ return (PNG_FILE_ERROR);
+
+ /*
+ * if we found an idat, all other idats should be followed with no
+ * other chunks in between
+ */
+ if (type == png_IDAT) {
+ if (!png->png_data) { /* first IDAT */
+ png->png_datalen = png->width * png->height *
+ png->bpp + png->height;
+ png->png_data = malloc(png->png_datalen);
}
- if(!png->png_data)
- return PNG_MEMORY_ERROR;
+ if (!png->png_data)
+ return (PNG_MEMORY_ERROR);
- if(!png->zs)
- {
+ if (!png->zs) {
result = png_init_inflate(png);
- if(result != PNG_NO_ERROR)
- return result;
+ if (result != PNG_NO_ERROR)
+ return (result);
}
- return png_read_idat(png, length);
- }
- else if(type == *(unsigned int*)"IEND")
- {
- return PNG_DONE;
- }
+ return (png_read_idat(png, length));
+ } else if (type == png_IEND)
+ return (PNG_DONE);
else
- {
- file_read(png, 0, 1, length + 4); /* unknown chunk */
- }
+ (void) file_read(png, 0, 1, length + 4); /* unknown chunk */
- return result;
+ return (result);
}
-static void png_filter_sub(int stride, unsigned char* in, unsigned char* out, int len)
+static void
+png_filter_sub(unsigned stride, uint8_t *in, uint8_t *out, unsigned len)
{
- int i;
- unsigned char a = 0;
+ unsigned i;
+ uint8_t a = 0;
- for(i = 0; i < len; i++)
- {
- if(i >= stride)
+ for (i = 0; i < len; i++) {
+ if (i >= stride)
a = out[i - stride];
out[i] = in[i] + a;
}
}
-static void png_filter_up(int stride, unsigned char* in, unsigned char* out, unsigned char* prev_line, int len)
+static void
+png_filter_up(unsigned stride __unused, uint8_t *in, uint8_t *out,
+ uint8_t *prev_line, unsigned len)
{
- int i;
+ unsigned i;
- if(prev_line)
- {
- for(i = 0; i < len; i++)
- out[i] = in[i] + prev_line[i];
- }
- else
+ if (prev_line) {
+ for (i = 0; i < len; i++)
+ out[i] = in[i] + prev_line[i];
+ } else
memcpy(out, in, len);
}
-static void png_filter_average(int stride, unsigned char* in, unsigned char* out, unsigned char* prev_line, int len)
+static void
+png_filter_average(unsigned stride, uint8_t *in, uint8_t *out,
+ uint8_t *prev_line, unsigned len)
{
- int i;
- unsigned char a = 0;
- unsigned char b = 0;
+ unsigned int i;
+ uint8_t a = 0;
+ uint8_t b = 0;
unsigned int sum = 0;
- for(i = 0; i < len; i++)
- {
- if(prev_line)
+ for (i = 0; i < len; i++) {
+ if (prev_line)
b = prev_line[i];
- if(i >= stride)
+ if (i >= stride)
a = out[i - stride];
sum = a;
sum += b;
- out[i] = (char)(in[i] + sum/2);
+ out[i] = in[i] + sum/2;
}
}
-static unsigned char png_paeth(unsigned char a, unsigned char b, unsigned char c)
+static uint8_t
+png_paeth(uint8_t a, uint8_t b, uint8_t c)
{
int p = (int)a + b - c;
int pa = abs(p - a);
@@ -654,39 +445,37 @@ static unsigned char png_paeth(unsigned char a, unsigned char b, unsigned char c
int pr;
- if(pa <= pb && pa <= pc)
+ if (pa <= pb && pa <= pc)
pr = a;
- else if(pb <= pc)
+ else if (pb <= pc)
pr = b;
else
pr = c;
- return (char)pr;
+ return (pr);
}
-static void png_filter_paeth(int stride, unsigned char* in, unsigned char* out, unsigned char* prev_line, int len)
+static void
+png_filter_paeth(unsigned stride, uint8_t *in, uint8_t *out, uint8_t *prev_line,
+ unsigned len)
{
- int i;
- unsigned char a;
- unsigned char b;
- unsigned char c;
-
- for(i = 0; i < len; i++)
- {
- if(prev_line && i >= stride)
- {
+ unsigned i;
+ uint8_t a;
+ uint8_t b;
+ uint8_t c;
+
+ for (i = 0; i < len; i++) {
+ if (prev_line && i >= stride) {
a = out[i - stride];
b = prev_line[i];
c = prev_line[i - stride];
- }
- else
- {
- if(prev_line)
+ } else {
+ if (prev_line)
b = prev_line[i];
else
b = 0;
- if(i >= stride)
+ if (i >= stride)
a = out[i - stride];
else
a = 0;
@@ -698,72 +487,80 @@ static void png_filter_paeth(int stride, unsigned char* in, unsigned char* out,
}
}
-static int png_filter(png_t* png, unsigned char* data)
-{
- return PNG_NO_ERROR;
-}
-
-static int png_unfilter(png_t* png, unsigned char* data)
+static int
+png_unfilter(png_t *png, uint8_t *data)
{
unsigned i;
unsigned pos = 0;
unsigned outpos = 0;
- unsigned char *filtered = png->png_data;
-
- int stride = png->bpp;
+ uint8_t *filtered = png->png_data;
+ unsigned stride = png->bpp;
- while(pos < png->png_datalen)
- {
- unsigned char filter = filtered[pos];
+ while (pos < png->png_datalen) {
+ uint8_t filter = filtered[pos];
pos++;
- if(png->depth == 16)
- {
- for(i = 0; i < png->width * stride; i+=2)
- {
- *(short*)(filtered+pos+i) = (filtered[pos+i] << 8) | filtered[pos+i+1];
+ if (png->depth == 16) {
+ for (i = 0; i < png->width * stride; i += 2) {
+ *(short *)(filtered+pos+i) =
+ (filtered[pos+i] << 8) | filtered[pos+i+1];
}
}
- switch(filter)
- {
+ switch (filter) {
case 0: /* none */
memcpy(data+outpos, filtered+pos, png->width * stride);
break;
case 1: /* sub */
- png_filter_sub(stride, filtered+pos, data+outpos, png->width * stride);
+ png_filter_sub(stride, filtered+pos, data+outpos,
+ png->width * stride);
break;
case 2: /* up */
- if(outpos)
- png_filter_up(stride, filtered+pos, data+outpos, data + outpos - (png->width*stride), png->width*stride);
- else
- png_filter_up(stride, filtered+pos, data+outpos, 0, png->width*stride);
+ if (outpos) {
+ png_filter_up(stride, filtered+pos, data+outpos,
+ data + outpos - (png->width*stride),
+ png->width*stride);
+ } else {
+ png_filter_up(stride, filtered+pos, data+outpos,
+ 0, png->width*stride);
+ }
break;
case 3: /* average */
- if(outpos)
- png_filter_average(stride, filtered+pos, data+outpos, data + outpos - (png->width*stride), png->width*stride);
- else
- png_filter_average(stride, filtered+pos, data+outpos, 0, png->width*stride);
+ if (outpos) {
+ png_filter_average(stride, filtered+pos,
+ data+outpos,
+ data + outpos - (png->width*stride),
+ png->width*stride);
+ } else {
+ png_filter_average(stride, filtered+pos,
+ data+outpos, 0, png->width*stride);
+ }
break;
case 4: /* paeth */
- if(outpos)
- png_filter_paeth(stride, filtered+pos, data+outpos, data + outpos - (png->width*stride), png->width*stride);
- else
- png_filter_paeth(stride, filtered+pos, data+outpos, 0, png->width*stride);
+ if (outpos) {
+ png_filter_paeth(stride, filtered+pos,
+ data+outpos,
+ data + outpos - (png->width*stride),
+ png->width*stride);
+ } else {
+ png_filter_paeth(stride, filtered+pos,
+ data+outpos, 0, png->width*stride);
+ }
break;
default:
- return PNG_UNKNOWN_FILTER;
+ return (PNG_UNKNOWN_FILTER);
}
outpos += png->width * stride;
pos += png->width * stride;
}
- return PNG_NO_ERROR;
+ return (PNG_NO_ERROR);
}
-int png_get_data(png_t* png, unsigned char* data)
+int
+png_get_data(png_t *png, uint8_t *data)
{
int result = PNG_NO_ERROR;
@@ -773,90 +570,59 @@ int png_get_data(png_t* png, unsigned char* data)
png->readbuf = NULL;
png->readbuflen = 0;
- while(result == PNG_NO_ERROR)
- {
+ while (result == PNG_NO_ERROR)
result = png_process_chunk(png);
- }
- if (png->readbuf)
- {
- png_free(png->readbuf);
+ if (png->readbuf) {
+ free(png->readbuf);
png->readbuflen = 0;
}
if (png->zs)
- {
- png_end_inflate(png);
- }
+ (void) png_end_inflate(png);
- if(result != PNG_DONE)
- {
- png_free(png->png_data);
- return result;
+ if (result != PNG_DONE) {
+ free(png->png_data);
+ return (result);
}
result = png_unfilter(png, data);
- png_free(png->png_data);
-
- return result;
-}
-
-int png_set_data(png_t* png, unsigned width, unsigned height, char depth, int color, unsigned char* data)
-{
- int i;
- unsigned char *filtered;
- png->width = width;
- png->height = height;
- png->depth = depth;
- png->color_type = color;
- png->bpp = png_get_bpp(png);
-
- filtered = png_alloc(width * height * png->bpp + height);
-
- for(i = 0; i < png->height; i++)
- {
- filtered[i*png->width*png->bpp+i] = 0;
- memcpy(&filtered[i*png->width*png->bpp+i+1], data + i * png->width*png->bpp, png->width*png->bpp);
- }
-
- png_filter(png, filtered);
- png_write_ihdr(png);
- png_write_idats(png, filtered);
-
- png_free(filtered);
+ free(png->png_data);
- return PNG_NO_ERROR;
+ return (result);
}
-char* png_error_string(int error)
+char *
+png_error_string(int error)
{
- switch(error)
- {
+ switch (error) {
case PNG_NO_ERROR:
- return "No error";
+ return ("No error");
case PNG_FILE_ERROR:
- return "Unknown file error.";
+ return ("Unknown file error.");
case PNG_HEADER_ERROR:
- return "No PNG header found. Are you sure this is a PNG?";
+ return ("No PNG header found. Are you sure this is a PNG?");
case PNG_IO_ERROR:
- return "Failure while reading file.";
+ return ("Failure while reading file.");
case PNG_EOF_ERROR:
- return "Reached end of file.";
+ return ("Reached end of file.");
case PNG_CRC_ERROR:
- return "CRC or chunk length error.";
+ return ("CRC or chunk length error.");
case PNG_MEMORY_ERROR:
- return "Could not allocate memory.";
+ return ("Could not allocate memory.");
case PNG_ZLIB_ERROR:
- return "zlib reported an error.";
+ return ("zlib reported an error.");
case PNG_UNKNOWN_FILTER:
- return "Unknown filter method used in scanline.";
+ return ("Unknown filter method used in scanline.");
case PNG_DONE:
- return "PNG done";
+ return ("PNG done");
case PNG_NOT_SUPPORTED:
- return "The PNG is unsupported by pnglite, too bad for you!";
+ return ("The PNG is unsupported by pnglite, too bad for you!");
case PNG_WRONG_ARGUMENTS:
- return "Wrong combination of arguments passed to png_open. You must use either a read_function or supply a file pointer to use.";
+ return ("Wrong combination of arguments passed to png_open. "
+ "You must use either a read_function or supply a file "
+ "pointer to use.");
default:
- return "Unknown error.";
+ return ("Unknown error.");
};
}
diff --git a/contrib/pnglite/pnglite.h b/contrib/pnglite/pnglite.h
index bbb207502409..3c3a3320c28b 100644
--- a/contrib/pnglite/pnglite.h
+++ b/contrib/pnglite/pnglite.h
@@ -1,46 +1,46 @@
-/* pnglite.h - Interface for pnglite library
- Copyright (c) 2007 Daniel Karling
-
- This software is provided 'as-is', without any express or implied
- warranty. In no event will the authors be held liable for any damages
- arising from the use of this software.
-
- Permission is granted to anyone to use this software for any purpose,
- including commercial applications, and to alter it and redistribute it
- freely, subject to the following restrictions:
-
- 1. The origin of this software must not be misrepresented; you must not
- claim that you wrote the original software. If you use this software
- in a product, an acknowledgment in the product documentation would be
- appreciated but is not required.
-
- 2. Altered source versions must be plainly marked as such, and must not be
- misrepresented as being the original software.
-
- 3. This notice may not be removed or altered from any source
- distribution.
-
- Daniel Karling
- daniel.karling@gmail.com
+/*
+ * pnglite.h - Interface for pnglite library
+ * Copyright (c) 2007 Daniel Karling
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not
+ * be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * Daniel Karling
+ * daniel.karling@gmail.com
*/
#ifndef _PNGLITE_H_
-#define _PNGLITE_H_
+#define _PNGLITE_H_
#include <string.h>
#ifdef __cplusplus
-extern "C"{
+extern "C" {
#endif
/*
- Enumerations for pnglite.
- Negative numbers are error codes and 0 and up are okay responses.
-*/
+ * Enumerations for pnglite.
+ * Negative numbers are error codes and 0 and up are okay responses.
+ */
-enum
-{
+enum {
PNG_DONE = 1,
PNG_NO_ERROR = 0,
PNG_FILE_ERROR = -1,
@@ -56,11 +56,10 @@ enum
};
/*
- The five different kinds of color storage in PNG files.
-*/
+ * The five different kinds of color storage in PNG files.
+ */
-enum
-{
+enum {
PNG_GREYSCALE = 0,
PNG_TRUECOLOR = 2,
PNG_INDEXED = 3,
@@ -68,165 +67,103 @@ enum
PNG_TRUECOLOR_ALPHA = 6
};
-/*
- Typedefs for callbacks.
-*/
-
-typedef unsigned (*png_write_callback_t)(void* input, size_t size, size_t numel, void* user_pointer);
-typedef unsigned (*png_read_callback_t)(void* output, size_t size, size_t numel, void* user_pointer);
-typedef void (*png_free_t)(void* p);
-typedef void * (*png_alloc_t)(size_t s);
-
-typedef struct
-{
- void* zs; /* pointer to z_stream */
- png_read_callback_t read_fun;
- png_write_callback_t write_fun;
- void* user_pointer;
-
- unsigned char* png_data;
- unsigned png_datalen;
-
- unsigned width;
- unsigned height;
- unsigned char depth;
- unsigned char color_type;
- unsigned char compression_method;
- unsigned char filter_method;
- unsigned char interlace_method;
- unsigned char bpp;
-
- unsigned char* readbuf;
- unsigned readbuflen;
+typedef struct {
+ void *zs; /* pointer to z_stream */
+ int fd;
+ unsigned char *image;
+
+ unsigned char *png_data;
+ unsigned png_datalen;
+
+ unsigned width;
+ unsigned height;
+ unsigned char depth;
+ unsigned char color_type;
+ unsigned char compression_method;
+ unsigned char filter_method;
+ unsigned char interlace_method;
+ unsigned char bpp;
+
+ unsigned char *readbuf;
+ unsigned readbuflen;
} png_t;
-/*
- Function: png_init
-
- This function initializes pnglite. The parameters can be used to set your own memory allocation routines following these formats:
-
- > void* (*custom_alloc)(size_t s)
- > void (*custom_free)(void* p)
- Parameters:
- pngalloc - Pointer to custom allocation routine. If 0 is passed, malloc from libc will be used.
- pngfree - Pointer to custom free routine. If 0 is passed, free from libc will be used.
-
- Returns:
- Always returns PNG_NO_ERROR.
-*/
-
-int png_init(png_alloc_t pngalloc, png_free_t pngfree);
-
-/*
- Function: png_open_file
-
- This function is used to open a png file with the internal file IO system. This function should be used instead of
- png_open if no custom read function is used.
-
- Parameters:
- png - Empty png_t struct.
- filename - Filename of the file to be opened.
-
- Returns:
- PNG_NO_ERROR on success, otherwise an error code.
-*/
-
-int png_open_file(png_t *png, const char* filename);
-
-int png_open_file_read(png_t *png, const char* filename);
-int png_open_file_write(png_t *png, const char* filename);
/*
- Function: png_open
-
- This function reads or writes a png from/to the specified callback. The callbacks should be of the format:
-
- > size_t (*png_write_callback_t)(void* input, size_t size, size_t numel, void* user_pointer);
- > size_t (*png_read_callback_t)(void* output, size_t size, size_t numel, void* user_pointer).
-
- Only one callback has to be specified. The read callback in case of PNG reading, otherwise the write callback.
-
- Writing:
- The callback will be called like fwrite.
-
- Reading:
- The callback will be called each time pnglite needs more data. The callback should read as much data as requested,
- or return 0. This should always be possible if the PNG is sane. If the output-buffer is a null-pointer the callback
- should only skip ahead the specified number of elements. If the callback is a null-pointer the user_pointer will be
- treated as a file pointer (use png_open_file instead).
-
- Parameters:
- png - png_t struct
- read_fun - Callback function for reading.
- user_pointer - User pointer to be passed to read_fun.
-
- Returns:
- PNG_NO_ERROR on success, otherwise an error code.
-*/
-
-int png_open(png_t* png, png_read_callback_t read_fun, void* user_pointer);
+ * Function: png_open
+ *
+ * This function is used to open a png file with the internal file
+ * IO system.
+ *
+ * Parameters:
+ * png - Empty png_t struct.
+ * filename - Filename of the file to be opened.
+ *
+ * Returns:
+ * PNG_NO_ERROR on success, otherwise an error code.
+ */
-int png_open_read(png_t* png, png_read_callback_t read_fun, void* user_pointer);
-int png_open_write(png_t* png, png_write_callback_t write_fun, void* user_pointer);
+int png_open(png_t *png, const char *filename);
/*
- Function: png_print_info
-
- This function prints some info about the opened png file to stdout.
-
- Parameters:
- png - png struct to get info from.
-*/
+ * Function: png_print_info
+ *
+ * This function prints some info about the opened png file to stdout.
+ *
+ * Parameters:
+ * png - png struct to get info from.
+ */
-void png_print_info(png_t* png);
+void png_print_info(png_t *png);
/*
- Function: png_error_string
-
- This function translates an error code to a human readable string.
-
- Parameters:
- error - Error code.
-
- Returns:
- Pointer to string.
-*/
+ * Function: png_error_string
+ *
+ * This function translates an error code to a human readable string.
+ *
+ * Parameters:
+ * error - Error code.
+ *
+ * Returns:
+ * Pointer to string.
+ */
-char* png_error_string(int error);
+char *png_error_string(int error);
/*
- Function: png_get_data
-
- This function decodes the opened png file and stores the result in data. data should be big enough to hold the decoded png. Required size will be:
-
- > width*height*(bytes per pixel)
-
- Parameters:
- data - Where to store result.
-
- Returns:
- PNG_NO_ERROR on success, otherwise an error code.
-*/
-
-int png_get_data(png_t* png, unsigned char* data);
+ * Function: png_get_data
+ *
+ * This function decodes the opened png file and stores the result in data.
+ * data should be big enough to hold the decoded png.
+ * Required size will be:
+ *
+ * > width*height*(bytes per pixel)
+ *
+ * Parameters:
+ * data - Where to store result.
+ *
+ * Returns:
+ * PNG_NO_ERROR on success, otherwise an error code.
+ */
-int png_set_data(png_t* png, unsigned width, unsigned height, char depth, int color, unsigned char* data);
+int png_get_data(png_t *png, uint8_t *data);
/*
- Function: png_close_file
-
- Closes an open png file pointer. Should only be used when the png has been opened with png_open_file.
-
- Parameters:
- png - png to close.
-
- Returns:
- PNG_NO_ERROR
-*/
+ * Function: png_close
+ *
+ * Closes an open png file pointer.
+ *
+ * Parameters:
+ * png - png to close.
+ *
+ * Returns:
+ * PNG_NO_ERROR
+ */
-int png_close_file(png_t* png);
+int png_close(png_t *png);
#ifdef __cplusplus
}
#endif
-#endif
+
+#endif /* _PNGLITE_H_ */