uGFX
/
ugfx
2
0
Fork 0
Code Issues 2 Pull Requests Projects Releases Wiki Activity
ugfx/src/gdisp/gdisp_image_png.c

1632 lines
45 KiB
C
Raw Blame History

/*
* This file is subject to the terms of the GFX License. If a copy of
* the license was not distributed with this file, you can obtain one at:
*
* http://ugfx.io/license.html
*/
#include "../../gfx.h"
#if GFX_USE_GDISP && GDISP_NEED_IMAGE && GDISP_NEED_IMAGE_PNG
#include "gdisp_image_support.h"
/*-----------------------------------------------------------------
* Structure definitions
*---------------------------------------------------------------*/
struct PNG_decode;
// PNG info (comes from the PNG header)
typedef struct PNG_info {
gU8 flags; // Flags (global)
#define PNG_FLG_HEADERDONE 0x01 // The header has been processed
#define PNG_FLG_TRANSPARENT 0x02 // Has transparency
#define PNG_FLG_INTERLACE 0x04 // Is Interlaced
#define PNG_FLG_BACKGROUND 0x08 // Has a specified background color
gU8 bitdepth; // 1, 2, 4, 8, 16
gU8 mode; // The PNG color-mode
#define PNG_COLORMODE_GRAY 0x00 // Grayscale
#define PNG_COLORMODE_RGB 0x02 // RGB
#define PNG_COLORMODE_PALETTE 0x03 // Pallete
#define PNG_COLORMODE_GRAYALPHA 0x04 // Grayscale with Alpha
#define PNG_COLORMODE_RGBA 0x06 // RGBA
gU8 bpp; // Bits per pixel
gU8 *cache; // The image cache
unsigned cachesz; // The image cache size
void (*out)(struct PNG_decode *); // The scan line output function
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
gColor bg; // The background color
#endif
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
gU16 trans_r; // Red/grayscale component of the transparent color (PNG_COLORMODE_GRAY and PNG_COLORMODE_RGB only)
gU16 trans_g; // Green component of the transparent color (PNG_COLORMODE_RGB only)
gU16 trans_b; // Blue component of the transparent color (PNG_COLORMODE_RGB only)
#endif
#if GDISP_NEED_IMAGE_PNG_PALETTE_124 || GDISP_NEED_IMAGE_PNG_PALETTE_8
gU16 palsize; // palette size in number of colors
gU8 *palette; // palette in RGBA RGBA... order (4 bytes per entry - PNG_COLORMODE_PALETTE only)
#endif
} PNG_info;
// Handle the PNG file stream
typedef struct PNG_input {
GFILE * f; // The gfile to retrieve data from
unsigned buflen; // The number of bytes left in the buffer
gU8 *pbuf; // The pointer to the next byte
gU32 chunklen; // The number of bytes left in the current PNG chunk
gU32 chunknext; // The file position of the next PNG chunk
gU8 buf[GDISP_IMAGE_PNG_FILE_BUFFER_SIZE]; // Must be a minimum of 8 bytes to hold a chunk header
} PNG_input;
// Handle the display output and windowing
typedef struct PNG_output {
GDisplay *g;
gCoord x, y;
gCoord cx, cy;
gCoord sx, sy;
gCoord ix, iy;
unsigned cnt;
gPixel buf[GDISP_IMAGE_PNG_BLIT_BUFFER_SIZE];
} PNG_output;
// Handle the PNG scan line filter
typedef struct PNG_filter {
unsigned scanbytes;
unsigned bytewidth;
gU8 *line;
gU8 *prev;
} PNG_filter;
// Handle the PNG inflate decompression
typedef struct PNG_zTree {
gU16 table[16]; // Table of code length counts
gU16 trans[288]; // Code to symbol translation table
} PNG_zTree;
typedef struct PNG_zinflate {
gU8 data; // The current input stream data byte
gU8 bits; // The number of bits left in the data byte
gU8 flags; // Decompression flags
#define PNG_ZFLG_EOF 0x01 // No more input data
#define PNG_ZFLG_FINAL 0x02 // This is the final block
#define PNG_ZFLG_RESUME_MASK 0x0C // The mask of bits for the resume state
#define PNG_ZFLG_RESUME_NEW 0x00 // Process a new block
#define PNG_ZFLG_RESUME_COPY 0x04 // Resume a byte copy from the input stream (length in tmp)
#define PNG_ZFLG_RESUME_INFLATE 0x08 // Resume using the specified symbol (symbol in tmp[0])
#define PNG_ZFLG_RESUME_OFFSET 0x0C // Resume a byte offset copy from the buffer (length and offset in tmp)
unsigned bufpos; // The current buffer output position
unsigned bufend; // The current buffer end position (wraps)
PNG_zTree ltree; // The dynamic length tree
PNG_zTree dtree; // The dynamic distance tree
gU8 tmp[288+32]; // Temporary space for decoding dynamic trees and other temporary uses
gU8 buf[GDISP_IMAGE_PNG_Z_BUFFER_SIZE]; // The decoding buffer and sliding window
} PNG_zinflate;
// Put all the decoding structures together.
// Note this is immediately followed by 2 scan lines of uncompressed image data for filtering (dynamic size).
typedef struct PNG_decode {
gImage *img;
PNG_info *pinfo;
PNG_input i;
PNG_output o;
PNG_filter f;
PNG_zinflate z;
} PNG_decode;
/*-----------------------------------------------------------------
* PNG input data stream functions
*---------------------------------------------------------------*/
// Input initialization
static void PNG_iInit(PNG_decode *d) {
if (d->pinfo->cache) {
d->i.pbuf = d->pinfo->cache;
d->i.buflen = d->pinfo->cachesz;
d->i.f = 0;
} else {
d->i.buflen = 0;
d->i.chunklen = 0;
d->i.chunknext = 8;
d->i.f = d->img->f;
}
}
// Load the next byte of image data from the PNG file
static gBool PNG_iLoadData(PNG_decode *d) {
gU32 sz;
// Is there data still left in the buffer?
if (d->i.buflen)
return gTrue;
// If we are cached then we have no more data
if (!d->i.f)
return gFalse;
// Have we finished the current chunk?
if (!d->i.chunklen) {
while(1) {
// Find a new chunk
gfileSetPos(d->i.f, d->i.chunknext);
if (gfileRead(d->i.f, d->i.buf, 8) != 8)
return gFalse;
// Calculate the chunk length and next chunk
d->i.chunklen = gdispImageGetAlignedBE32(d->i.buf, 0);
d->i.chunknext += d->i.chunklen + 12;
// Process only image data chunks
switch (gdispImageGetAlignedBE32(d->i.buf, 4)) {
case 0x49444154: // "IDAT" - Image Data
if (!d->i.chunklen)
break;
goto gotchunk;
case 0x49454E44: // "IEND" - All done
return gFalse;
}
}
}
gotchunk:
// Try to read data some from the chunk
sz = d->i.chunklen;
if (sz > GDISP_IMAGE_PNG_FILE_BUFFER_SIZE)
sz = GDISP_IMAGE_PNG_FILE_BUFFER_SIZE;
if (gfileRead(d->i.f, d->i.buf, sz) != sz)
return gFalse;
d->i.chunklen -= sz;
d->i.buflen = sz;
d->i.pbuf = d->i.buf;
return gTrue;
}
// Get the last loaded byte of image data from the PNG file
static gU8 PNG_iGetByte(PNG_decode *d) {
d->i.buflen--;
return *d->i.pbuf++;
}
/*-----------------------------------------------------------------
* Display output and windowing functions
*---------------------------------------------------------------*/
// Initialize the display output window
static void PNG_oInit(PNG_output *o, GDisplay *g, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy) {
o->g = g;
o->x = x;
o->y = y;
o->cx = cx;
o->cy = cy;
o->sx = sx;
o->sy = sy;
o->ix = o->iy = 0;
o->cnt = 0;
}
// Flush the output buffer to the display
static void PNG_oFlush(PNG_output *o) {
switch(o->cnt) {
case 0: return;
case 1: gdispGDrawPixel(o->g, o->x+o->ix-o->sx, o->y+o->iy-o->sy, o->buf[0]); break;
default: gdispGBlitArea(o->g, o->x+o->ix-o->sx, o->y+o->iy-o->sy, o->cnt, 1, 0, 0, o->cnt, o->buf); break;
}
o->ix += o->cnt;
o->cnt = 0;
}
// Start a new image line
static gBool PNG_oStartY(PNG_output *o, gCoord y) {
if (y < o->sy || y >= o->sy+o->cy)
return gFalse;
o->ix = 0;
o->iy = y;
return gTrue;
}
// Feed a pixel color to the display buffer
static void PNG_oColor(PNG_output *o, gColor c) {
// Is it in the window
if (o->ix+(gCoord)o->cnt < o->sx || o->ix+(gCoord)o->cnt >= o->sx+o->cx) {
// No - just skip the pixel
PNG_oFlush(o);
o->ix++;
return;
}
// Is the buffer full
if (o->cnt >= sizeof(o->buf)/sizeof(o->buf[0]))
PNG_oFlush(o);
// Save the pixel
o->buf[o->cnt++] = c;
}
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY || GDISP_NEED_IMAGE_PNG_ALPHACLIFF > 0
// Feed a transparent pixel to the display buffer
static void PNG_oTransparent(PNG_output *o) {
// Flush any existing pixels
PNG_oFlush(o);
// Just skip the pixel
o->ix++;
}
#endif
/*-----------------------------------------------------------------
* Inflate uncompress functions
*---------------------------------------------------------------*/
// Wrap the zInflate buffer position (after increment)
#if (GDISP_IMAGE_PNG_Z_BUFFER_SIZE & ~(GDISP_IMAGE_PNG_Z_BUFFER_SIZE-1)) == GDISP_IMAGE_PNG_Z_BUFFER_SIZE
#define WRAP_ZBUF(x) { x &= GDISP_IMAGE_PNG_Z_BUFFER_SIZE-1; }
#else
#if GFX_COMPILER_WARNING_TYPE == GFX_COMPILER_WARNING_DIRECT
#warning "PNG: GDISP_IMAGE_PNG_Z_BUFFER_SIZE is more efficient as a power of 2"
#elif GFX_COMPILER_WARNING_TYPE == GFX_COMPILER_WARNING_MACRO
COMPILER_WARNING("PNG: GDISP_IMAGE_PNG_Z_BUFFER_SIZE is more efficient as a power of 2")
#endif
#define WRAP_ZBUF(x) { if (x >= GDISP_IMAGE_PNG_Z_BUFFER_SIZE) x = 0; }
#endif
// Initialize the inflate decompressor
static void PNG_zInit(PNG_zinflate *z) {
z->bits = 0;
z->flags = 0;
z->bufpos = z->bufend = 0;
}
// Get the inflate header (slightly customized for PNG validity testing)
static gBool PNG_zGetHeader(PNG_decode *d) {
if (!PNG_iLoadData(d))
return gFalse;
d->z.tmp[0] = PNG_iGetByte(d);
if (!PNG_iLoadData(d))
return gFalse;
d->z.tmp[1] = PNG_iGetByte(d);
if (gdispImageGetAlignedBE16(d->z.tmp, 0) % 31 != 0 // Must be modulo 31, the FCHECK value is made that way
|| (d->z.tmp[0] & 0x0F) != 8 || (d->z.tmp[0] & 0x80) // only method 8: inflate 32k sliding window
|| (d->z.tmp[1] & 0x20)) // no preset dictionary
return gFalse;
return gTrue;
}
// Get a bit from the input (treated as a LSB first stream)
static unsigned PNG_zGetBit(PNG_decode *d) {
unsigned bit;
// Check for EOF
if ((d->z.flags & PNG_ZFLG_EOF))
return 1;
// Check if data is empty
if (!d->z.bits) {
if (!PNG_iLoadData(d)) {
d->z.flags |= PNG_ZFLG_EOF;
return 1;
}
d->z.data = PNG_iGetByte(d);
d->z.bits = 8;
}
// Get the next bit
d->z.bits--;
bit = d->z.data & 0x01;
d->z.data >>= 1;
return bit;
}
// Get multiple bits from the input (treated as a LSB first stream with bit order retained)
static unsigned PNG_zGetBits(PNG_decode *d, unsigned num) {
unsigned val;
unsigned limit;
unsigned mask;
val = 0;
limit = 1 << num;
for (mask = 1; mask < limit; mask <<= 1)
if (PNG_zGetBit(d))
val += mask;
return val;
}
// Build an inflate dynamic tree using a string of byte lengths
static void PNG_zBuildTree(PNG_zTree *t, const gU8 *lengths, unsigned num) {
unsigned i, sum;
gU16 offs[16];
for (i = 0; i < 16; ++i)
t->table[i] = 0;
for (i = 0; i < num; ++i)
t->table[lengths[i]]++;
t->table[0] = 0;
for (sum = 0, i = 0; i < 16; ++i) {
offs[i] = sum;
sum += t->table[i];
}
for (i = 0; i < num; ++i) {
if (lengths[i])
t->trans[offs[lengths[i]]++] = i;
}
}
// Get an inflate decode symbol
static gU16 PNG_zGetSymbol(PNG_decode *d, PNG_zTree *t) {
int sum, cur;
unsigned len;
sum = cur = 0;
len = 0;
do {
cur <<= 1;
cur += PNG_zGetBit(d);
if ((d->z.flags & PNG_ZFLG_EOF))
return 0;
len++;
sum += t->table[len];
cur -= t->table[len];
} while (cur >= 0);
return t->trans[sum + cur];
}
// Build inflate fixed length and distance trees
static void PNG_zBuildFixedTrees(PNG_decode *d) {
unsigned i;
for (i = 0; i < 16; ++i) d->z.ltree.table[i] = 0;
d->z.ltree.table[7] = 24;
d->z.ltree.table[8] = 152;
d->z.ltree.table[9] = 112;
for (i = 0; i < 24; ++i) d->z.ltree.trans[i] = 256 + i;
for (i = 0; i < 144; ++i) d->z.ltree.trans[24 + i] = i;
for (i = 0; i < 8; ++i) d->z.ltree.trans[24 + 144 + i] = 280 + i;
for (i = 0; i < 112; ++i) d->z.ltree.trans[24 + 144 + 8 + i] = 144 + i;
for (i = 0; i < 16; ++i) d->z.dtree.table[i] = 0;
d->z.dtree.table[5] = 32;
for (i = 0; i < 32; ++i) d->z.dtree.trans[i] = i;
for ( ; i < 288; ++i) d->z.dtree.trans[i] = 0;
}
// Build inflate dynamic length and distance trees
static gBool PNG_zDecodeTrees(PNG_decode *d) {
static const gU8 IndexLookup[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
unsigned hlit, hdist, hclen;
unsigned i, num;
gU16 symbol;
gU8 val;
hlit = PNG_zGetBits(d, 5) + 257; // 257 - 286
hdist = PNG_zGetBits(d, 5) + 1; // 1 - 32
hclen = PNG_zGetBits(d, 4) + 4; // 4 - 19
if ((d->z.flags & PNG_ZFLG_EOF))
return gFalse;
for (i = 0; i < 19; ++i)
d->z.tmp[i] = 0;
// Get code lengths for the code length alphabet
for (i = 0; i < hclen; ++i)
d->z.tmp[IndexLookup[i]] = PNG_zGetBits(d, 3);
if ((d->z.flags & PNG_ZFLG_EOF))
return gFalse;
// Build the code length tree
PNG_zBuildTree(&d->z.ltree, d->z.tmp, 19);
// Decode code lengths
for (num = 0; num < hlit + hdist; ) {
symbol = PNG_zGetSymbol(d, &d->z.ltree);
if ((d->z.flags & PNG_ZFLG_EOF))
return gFalse;
switch(symbol) {
case 16: // Copy the previous code length 3-6 times
val = d->z.tmp[num - 1];
for (i = PNG_zGetBits(d, 2) + 3; i; i--)
d->z.tmp[num++] = val;
break;
case 17: // Repeat code length 0 for 3-10 times
for (i = PNG_zGetBits(d, 3) + 3; i; i--)
d->z.tmp[num++] = 0;
break;
case 18: // Repeat code length 0 for 11-138 times
for (i = PNG_zGetBits(d, 7) + 11; i; i--)
d->z.tmp[num++] = 0;
break;
default: // symbols 0-15 are the actual code lengths
d->z.tmp[num++] = symbol;
break;
}
}
// Build the trees
PNG_zBuildTree(&d->z.ltree, d->z.tmp, hlit);
PNG_zBuildTree(&d->z.dtree, d->z.tmp + hlit, hdist);
return gTrue;
}
// Copy bytes from the input stream. Completing the copy completes the block.
static gBool PNG_zCopyInput(PNG_decode *d, unsigned length) {
// Copy the block
while(length--) {
if (!PNG_iLoadData(d)) { // EOF?
d->z.flags |= PNG_ZFLG_EOF;
return gFalse;
}
d->z.buf[d->z.bufend++] = PNG_iGetByte(d);
WRAP_ZBUF(d->z.bufend);
if (d->z.bufend == d->z.bufpos) { // Buffer full?
d->z.flags = (d->z.flags & ~PNG_ZFLG_RESUME_MASK) | PNG_ZFLG_RESUME_COPY;
((unsigned *)d->z.tmp)[0] = length;
return gTrue;
}
}
// The block is done
d->z.flags = (d->z.flags & ~PNG_ZFLG_RESUME_MASK) | PNG_ZFLG_RESUME_NEW;
return gTrue;
}
// Copy an uncompressed inflate block into the output
static gBool PNG_zUncompressedBlock(PNG_decode *d) {
unsigned length;
// This block works on byte boundaries
d->z.bits = 0;
// Get 4 byte header
for (length = 0; length < 4; length++) {
if (!PNG_iLoadData(d)) { // EOF?
d->z.flags |= PNG_ZFLG_EOF;
return gFalse;
}
d->z.tmp[length] = PNG_iGetByte(d);
}
// Get length
length = gdispImageGetAlignedLE16(d->z.tmp, 0);
// Check length
if ((gU16)length != (gU16)~gdispImageGetAlignedLE16(d->z.tmp, 2)) {
d->z.flags |= PNG_ZFLG_EOF;
return gFalse;
}
// Copy the block
return PNG_zCopyInput(d, length);
}
// Inflate a compressed inflate block into the output
static gBool PNG_zInflateBlock(PNG_decode *d) {
static const gU8 lbits[30] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 6 };
static const gU16 lbase[30] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 323 };
static const gU8 dbits[30] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 };
static const gU16 dbase[30] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 };
unsigned length, dist, offset;
gU16 symbol;
while(1) {
symbol = PNG_zGetSymbol(d, &d->z.ltree); // EOF?
if ((d->z.flags & PNG_ZFLG_EOF))
goto iserror;
// Is the block done?
if (symbol == 256) {
d->z.flags = (d->z.flags & ~PNG_ZFLG_RESUME_MASK) | PNG_ZFLG_RESUME_NEW;
return gTrue;
}
if (symbol < 256) {
// The symbol is the data
d->z.buf[d->z.bufend++] = (gU8)symbol;
WRAP_ZBUF(d->z.bufend);
if (d->z.bufend == d->z.bufpos) { // Buffer full?
d->z.flags = (d->z.flags & ~PNG_ZFLG_RESUME_MASK) | PNG_ZFLG_RESUME_INFLATE;
return gTrue;
}
continue;
}
// Shift the symbol down into an index
symbol -= 257;
if (symbol >= sizeof(lbits)) // Bad index?
goto iserror;
// Get more bits from length code
length = PNG_zGetBits(d, lbits[symbol]) + lbase[symbol];
if ((d->z.flags & PNG_ZFLG_EOF) || length >= GDISP_IMAGE_PNG_Z_BUFFER_SIZE) // Bad length?
goto iserror;
// Get the distance code
dist = PNG_zGetSymbol(d, &d->z.dtree); // Bad distance?
if ((d->z.flags & PNG_ZFLG_EOF) || dist >= sizeof(dbits))
goto iserror;
// Get more bits from distance code
offset = PNG_zGetBits(d, dbits[dist]) + dbase[dist];
if ((d->z.flags & PNG_ZFLG_EOF) || offset >= GDISP_IMAGE_PNG_Z_BUFFER_SIZE) // Bad offset?
goto iserror;
// Work out the source buffer position allowing for wrapping
if (offset > d->z.bufend)
offset -= GDISP_IMAGE_PNG_Z_BUFFER_SIZE;
offset = d->z.bufend - offset;
// Copy the matching string
while (length--) {
d->z.buf[d->z.bufend++] = d->z.buf[offset++];
WRAP_ZBUF(d->z.bufend);
WRAP_ZBUF(offset);
if (d->z.bufend == d->z.bufpos) { // Buffer full?
d->z.flags = (d->z.flags & ~PNG_ZFLG_RESUME_MASK) | PNG_ZFLG_RESUME_OFFSET;
((unsigned *)d->z.tmp)[0] = length;
((unsigned *)d->z.tmp)[1] = offset;
return gTrue;
}
}
}
iserror:
d->z.flags |= PNG_ZFLG_EOF;
return gFalse;
}
// Start a new uncompressed/inflate block
static gBool PNG_zStartBlock(PNG_decode *d) {
// Check for previous error, EOF or no more blocks
if ((d->z.flags & (PNG_ZFLG_EOF|PNG_ZFLG_FINAL)))
return gFalse;
// Is this the final inflate block?
if (PNG_zGetBit(d))
d->z.flags |= PNG_ZFLG_FINAL;
// Get the block type
switch (PNG_zGetBits(d, 2)) {
case 0: // Decompress uncompressed block
if (!PNG_zUncompressedBlock(d))
return gFalse;
break;
case 1: // Decompress block with fixed huffman trees
PNG_zBuildFixedTrees(d);
if (!PNG_zInflateBlock(d))
return gFalse;
break;
case 2: // Decompress block with dynamic huffman trees
if (!PNG_zDecodeTrees(d))
return gFalse;
if (!PNG_zInflateBlock(d))
return gFalse;
break;
default: // Bad block type
// Mark it as an error
d->z.flags |= PNG_ZFLG_EOF;
return gFalse;
}
return gTrue;
}
// Resume an offset copy
static gBool PNG_zResumeOffset(PNG_decode *d, unsigned length, unsigned offset) {
// Copy the matching string
while (length--) {
d->z.buf[d->z.bufend++] = d->z.buf[offset++];
WRAP_ZBUF(d->z.bufend);
WRAP_ZBUF(offset);
if (d->z.bufend == d->z.bufpos) { // Buffer full?
d->z.flags = (d->z.flags & ~PNG_ZFLG_RESUME_MASK) | PNG_ZFLG_RESUME_OFFSET;
((unsigned *)d->z.tmp)[0] = length;
((unsigned *)d->z.tmp)[1] = offset;
return gTrue;
}
}
return PNG_zInflateBlock(d);
}
// Get a fully decompressed byte from the inflate data stream
static gU8 PNG_zGetByte(PNG_decode *d) {
gU8 data;
// Do we have any data in the buffers
while (d->z.bufpos == d->z.bufend) {
// No, get some more data
switch((d->z.flags & PNG_ZFLG_RESUME_MASK)) {
case PNG_ZFLG_RESUME_NEW: // Start a new inflate block
if (!PNG_zStartBlock(d))
return 0xFF;
break;
case PNG_ZFLG_RESUME_COPY: // Resume uncompressed block copy for length bytes
if (!PNG_zCopyInput(d, ((unsigned *)d->z.tmp)[0]))
return 0xFF;
break;
case PNG_ZFLG_RESUME_INFLATE: // Resume compressed block
if (!PNG_zInflateBlock(d))
return 0xFF;
break;
case PNG_ZFLG_RESUME_OFFSET: // Resume compressed block using offset copy for length bytes
if (!PNG_zResumeOffset(d, ((unsigned *)d->z.tmp)[0], ((unsigned *)d->z.tmp)[1]))
return 0xFF;
break;
}
// Check for no data being provided
// A resume code means the buffer is completely full so the test must be skipped
if ((d->z.flags & PNG_ZFLG_RESUME_MASK) != PNG_ZFLG_RESUME_NEW)
break;
}
// Get the next data byte
data = d->z.buf[d->z.bufpos++];
WRAP_ZBUF(d->z.bufpos);
return data;
}
/*-----------------------------------------------------------------
* Scan-line filter functions
*---------------------------------------------------------------*/
// Initialise the scan-line engine
static void PNG_fInit(PNG_filter *f, gU8 *buf, unsigned bytewidth, unsigned scanbytes) {
f->scanbytes = scanbytes;
f->bytewidth = bytewidth;
f->line = buf;
f->prev = 0;
}
// Get ready for the next scan-line
static void PNG_fNext(PNG_filter *f) {
if (f->prev && f->line > f->prev) {
f->line = f->prev;
f->prev += f->scanbytes;
} else {
f->prev = f->line;
f->line += f->scanbytes;
}
}
// Predictor function for filter0 mode 4
static gU8 PNG_fCalcPath(gU16 a, gU16 b, gU16 c) {
gU16 pa = b > c ? (b - c) : (c - b);
gU16 pb = a > c ? (a - c) : (c - a);
gU16 pc = a + b > c + c ? (a + b - c - c) : (c + c - a - b);
if (pc < pa && pc < pb)
return (gU8)c;
if (pb < pa)
return (gU8)b;
return (gU8)a;
}
// Scan-line filter type 0
static gBool PNG_unfilter_type0(PNG_decode *d) { // PNG filter method 0
gU8 ft;
unsigned i;
// Get the filter type and check for validity (eg not EOF)
ft = PNG_zGetByte(d);
if (ft > 0x04)
return gFalse;
// Uncompress the scan line
for(i = 0; i < d->f.scanbytes; i++)
d->f.line[i] = PNG_zGetByte(d);
// Adjust the scan line based on the filter type
// 0 = no adjustment
switch(ft) {
case 1:
for(i = d->f.bytewidth; i < d->f.scanbytes; i++)
d->f.line[i] += d->f.line[i - d->f.bytewidth];
break;
case 2:
if (d->f.prev) {
for(i = 0; i < d->f.scanbytes; i++)
d->f.line[i] += d->f.prev[i];
}
break;
case 3:
if (d->f.prev) {
for(i = 0; i < d->f.bytewidth; i++)
d->f.line[i] += d->f.prev[i] / 2;
for( ; i < d->f.scanbytes; i++)
d->f.line[i] += (d->f.line[i - d->f.bytewidth] + d->f.prev[i]) / 2;
} else {
for(i = d->f.bytewidth; i < d->f.scanbytes; i++)
d->f.line[i] += d->f.line[i - d->f.bytewidth] / 2;
}
break;
case 4:
if (d->f.prev) {
for(i = 0; i < d->f.bytewidth; i++)
d->f.line[i] += d->f.prev[i]; // PNG_fCalcPath(0, val, 0) is always val
for( ; i < d->f.scanbytes; i++)
d->f.line[i] += PNG_fCalcPath(d->f.line[i - d->f.bytewidth], d->f.prev[i], d->f.prev[i - d->f.bytewidth]);
} else {
for(i = d->f.bytewidth; i < d->f.scanbytes; i++)
d->f.line[i] += d->f.line[i - d->f.bytewidth]; // PNG_fCalcPath(val, 0, 0) is always val
}
break;
}
return gTrue;
}
/*-----------------------------------------------------------------
* Scan-line output and color conversion functions
*---------------------------------------------------------------*/
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_124
static void PNG_OutGRAY124(PNG_decode *d) {
unsigned i;
PNG_info *pinfo;
gU8 px;
gU8 bits;
pinfo = d->pinfo;
for(i = 0; i < d->f.scanbytes; i++) {
for(bits = 8; bits; bits -= pinfo->bitdepth) {
px = (d->f.line[i] >> (bits - pinfo->bitdepth)) & ((1U << pinfo->bitdepth)-1);
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
if ((pinfo->flags & PNG_FLG_TRANSPARENT) && (gU16)px == pinfo->trans_r) {
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if ((pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, pinfo->bg);
continue;
}
#endif
PNG_oTransparent(&d->o);
continue;
}
#endif
px = px << (8-pinfo->bitdepth);
if (px >= 0x80) px += ((1U << (8-pinfo->bitdepth))-1);
PNG_oColor(&d->o, LUMA2COLOR(px));
}
}
}
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_8
static void PNG_OutGRAY8(PNG_decode *d) {
unsigned i;
gU8 px;
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
PNG_info *pinfo = d->pinfo;
#endif
for(i = 0; i < d->f.scanbytes; i++) {
px = d->f.line[i];
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
if ((pinfo->flags & PNG_FLG_TRANSPARENT) && (gU16)px == pinfo->trans_r) {
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if ((pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, pinfo->bg);
continue;
}
#endif
PNG_oTransparent(&d->o);
continue;
}
#endif
PNG_oColor(&d->o, LUMA2COLOR(px));
}
}
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_16
static void PNG_OutGRAY16(PNG_decode *d) {
unsigned i;
gU8 px;
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
PNG_info *pinfo = d->pinfo;
#endif
for(i = 0; i < d->f.scanbytes; i+=2) {
px = d->f.line[i];
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
if ((pinfo->flags & PNG_FLG_TRANSPARENT) && gdispImageGetBE16(d->f.line, i) == pinfo->trans_r) {
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if ((pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, pinfo->bg);
continue;
}
#endif
PNG_oTransparent(&d->o);
continue;
}
#endif
PNG_oColor(&d->o, LUMA2COLOR(px));
}
}
#endif
#if GDISP_NEED_IMAGE_PNG_RGB_8
static void PNG_OutRGB8(PNG_decode *d) {
unsigned i;
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
PNG_info *pinfo = d->pinfo;
#endif
for(i = 0; i < d->f.scanbytes; i+=3) {
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
if ((pinfo->flags & PNG_FLG_TRANSPARENT)
&& (gU16)d->f.line[i+0] == pinfo->trans_r
&& (gU16)d->f.line[i+1] == pinfo->trans_g
&& (gU16)d->f.line[i+2] == pinfo->trans_b) {
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if ((pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, pinfo->bg);
continue;
}
#endif
PNG_oTransparent(&d->o);
continue;
}
#endif
PNG_oColor(&d->o, RGB2COLOR(d->f.line[i+0], d->f.line[i+1], d->f.line[i+2]));
}
}
#endif
#if GDISP_NEED_IMAGE_PNG_RGB_16
static void PNG_OutRGB16(PNG_decode *d) {
unsigned i;
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
PNG_info *pinfo = d->pinfo;
#endif
for(i = 0; i < d->f.scanbytes; i+=6) {
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
if ((pinfo->flags & PNG_FLG_TRANSPARENT)
&& gdispImageGetBE16(d->f.line, i+0) == pinfo->trans_r
&& gdispImageGetBE16(d->f.line, i+2) == pinfo->trans_g
&& gdispImageGetBE16(d->f.line, i+4) == pinfo->trans_b) {
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if ((pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, pinfo->bg);
continue;
}
#endif
PNG_oTransparent(&d->o);
continue;
}
#endif
PNG_oColor(&d->o, RGB2COLOR(d->f.line[i+0], d->f.line[i+2], d->f.line[i+4]));
}
}
#endif
#if GDISP_NEED_IMAGE_PNG_PALETTE_124
static void PNG_OutPAL124(PNG_decode *d) {
unsigned i;
PNG_info *pinfo;
unsigned idx;
gU8 bits;
pinfo = d->pinfo;
for(i = 0; i < d->f.scanbytes; i++) {
for(bits = 8; bits; bits -= pinfo->bitdepth) {
idx = (d->f.line[i] >> (bits - pinfo->bitdepth)) & ((1U << pinfo->bitdepth)-1);
if ((gU16)idx >= pinfo->palsize) {
PNG_oColor(&d->o, RGB2COLOR(0, 0, 0));
continue;
}
idx *= 4;
#define pix_color RGB2COLOR(pinfo->palette[idx], pinfo->palette[idx+1], pinfo->palette[idx+2])
#define pix_alpha pinfo->palette[idx+3]
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if (pix_alpha != 255 && (pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, gdispBlendColor(pix_color, pinfo->bg, pix_alpha));
continue;
}
#endif
#if GDISP_NEED_IMAGE_PNG_ALPHACLIFF > 0
if (pix_alpha < GDISP_NEED_IMAGE_PNG_ALPHACLIFF) {
PNG_oTransparent(&d->o);
continue;
}
#endif
#endif
PNG_oColor(&d->o, pix_color);
#undef pix_color
#undef pix_alpha
}
}
}
#endif
#if GDISP_NEED_IMAGE_PNG_PALETTE_8
static void PNG_OutPAL8(PNG_decode *d) {
unsigned i;
PNG_info *pinfo;
unsigned idx;
pinfo = d->pinfo;
for(i = 0; i < d->f.scanbytes; i++) {
idx = (unsigned)d->f.line[i];
if ((gU16)idx >= pinfo->palsize) {
PNG_oColor(&d->o, RGB2COLOR(0, 0, 0));
continue;
}
idx *= 4;
#define pix_color RGB2COLOR(pinfo->palette[idx], pinfo->palette[idx+1], pinfo->palette[idx+2])
#define pix_alpha pinfo->palette[idx+3]
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if (pix_alpha != 255 && (pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, gdispBlendColor(pix_color, pinfo->bg, pix_alpha));
continue;
}
#endif
#if GDISP_NEED_IMAGE_PNG_ALPHACLIFF > 0
if (pix_alpha < GDISP_NEED_IMAGE_PNG_ALPHACLIFF) {
PNG_oTransparent(&d->o);
continue;
}
#endif
#endif
PNG_oColor(&d->o, pix_color);
#undef pix_color
#undef pix_alpha
}
}
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYALPHA_8
static void PNG_OutGRAYA8(PNG_decode *d) {
unsigned i;
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
PNG_info *pinfo = d->pinfo;
#endif
for(i = 0; i < d->f.scanbytes; i+=2) {
#define pix_color LUMA2COLOR(d->f.line[i])
#define pix_alpha d->f.line[i+1]
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if (pix_alpha != 255 && (pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, gdispBlendColor(pix_color, pinfo->bg, pix_alpha));
continue;
}
#endif
#if GDISP_NEED_IMAGE_PNG_ALPHACLIFF > 0
if (pix_alpha < GDISP_NEED_IMAGE_PNG_ALPHACLIFF) {
PNG_oTransparent(&d->o);
continue;
}
#endif
PNG_oColor(&d->o, pix_color);
#undef pix_color
#undef pix_alpha
}
}
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYALPHA_16
static void PNG_OutGRAYA16(PNG_decode *d) {
unsigned i;
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
PNG_info *pinfo = d->pinfo;
#endif
for(i = 0; i < d->f.scanbytes; i+=4) {
#define pix_color LUMA2COLOR(d->f.line[i])
#define pix_alpha d->f.line[i+2]
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if (pix_alpha != 255 && (pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, gdispBlendColor(pix_color, pinfo->bg, pix_alpha));
continue;
}
#endif
#if GDISP_NEED_IMAGE_PNG_ALPHACLIFF > 0
if (pix_alpha < GDISP_NEED_IMAGE_PNG_ALPHACLIFF) {
PNG_oTransparent(&d->o);
continue;
}
#endif
PNG_oColor(&d->o, pix_color);
#undef pix_color
#undef pix_alpha
}
}
#endif
#if GDISP_NEED_IMAGE_PNG_RGBALPHA_8
static void PNG_OutRGBA8(PNG_decode *d) {
unsigned i;
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
PNG_info *pinfo = d->pinfo;
#endif
for(i = 0; i < d->f.scanbytes; i+=4) {
#define pix_color RGB2COLOR(d->f.line[i+0], d->f.line[i+1], d->f.line[i+2])
#define pix_alpha d->f.line[i+3]
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if (pix_alpha != 255 && (pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, gdispBlendColor(pix_color, pinfo->bg, pix_alpha));
continue;
}
#endif
#if GDISP_NEED_IMAGE_PNG_ALPHACLIFF > 0
if (pix_alpha < GDISP_NEED_IMAGE_PNG_ALPHACLIFF) {
PNG_oTransparent(&d->o);
continue;
}
#endif
PNG_oColor(&d->o, pix_color);
#undef pix_color
#undef pix_alpha
}
}
#endif
#if GDISP_NEED_IMAGE_PNG_RGBALPHA_16
static void PNG_OutRGBA16(PNG_decode *d) {
unsigned i;
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
PNG_info *pinfo = d->pinfo;
#endif
for(i = 0; i < d->f.scanbytes; i+=8) {
#define pix_color RGB2COLOR(d->f.line[i+0], d->f.line[i+2], d->f.line[i+4])
#define pix_alpha d->f.line[i+6]
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
if (pix_alpha != 255 && (pinfo->flags & PNG_FLG_BACKGROUND)) {
PNG_oColor(&d->o, gdispBlendColor(pix_color, pinfo->bg, pix_alpha));
continue;
}
#endif
#if GDISP_NEED_IMAGE_PNG_ALPHACLIFF > 0
if (pix_alpha < GDISP_NEED_IMAGE_PNG_ALPHACLIFF) {
PNG_oTransparent(&d->o);
continue;
}
#endif
PNG_oColor(&d->o, pix_color);
#undef pix_color
#undef pix_alpha
}
}
#endif
/*-----------------------------------------------------------------
* Public PNG functions
*---------------------------------------------------------------*/
void gdispImageClose_PNG(gImage *img) {
PNG_info *pinfo;
pinfo = (PNG_info *)img->priv;
if (pinfo) {
if (pinfo->palette)
gdispImageFree(img, (void *)pinfo->palette, pinfo->palsize*4);
if (pinfo->cache)
gdispImageFree(img, (void *)pinfo->cache, pinfo->cachesz);
gdispImageFree(img, (void *)pinfo, sizeof(PNG_info));
img->priv = 0;
}
}
gdispImageError gdispImageOpen_PNG(gImage *img) {
PNG_info *pinfo;
gU32 pos;
gU32 len;
gU8 buf[13];
/* Read the file identifier */
if (gfileRead(img->f, buf, 8) != 8)
return GDISP_IMAGE_ERR_BADFORMAT; // It can't be us
// Check the PNG signature
if(buf[0] != 137 || buf[1] != 80 || buf[2] != 78 || buf[3] != 71 || buf[4] != 13 || buf[5] != 10 || buf[6] != 26 || buf[7] != 10)
return GDISP_IMAGE_ERR_BADFORMAT; // It can't be us
/* We know we are a PNG format image */
img->flags = 0;
img->priv = 0;
img->type = GDISP_IMAGE_TYPE_PNG;
/* Allocate our private area */
if (!(img->priv = gdispImageAlloc(img, sizeof(PNG_info))))
return GDISP_IMAGE_ERR_NOMEMORY;
/* Initialise the essential bits in the private area */
pinfo = (PNG_info *)img->priv;
pinfo->flags = 0;
pinfo->cache = 0;
pinfo->trans_r = 0;
pinfo->trans_g = 0;
pinfo->trans_b = 0;
#if GDISP_NEED_IMAGE_PNG_PALETTE_124 || GDISP_NEED_IMAGE_PNG_PALETTE_8
pinfo->palsize = 0;
pinfo->palette = 0;
#endif
// Cycle the chunks to get other information
for(pos = 8; ; pos += len+12, gfileSetPos(img->f, pos)) {
// Get a chunk header
if (gfileRead(img->f, buf, 8) != 8)
goto exit_baddata;
// Calculate the chunk length
len = gdispImageGetAlignedBE32(buf, 0);
// Process the interesting information chunks
switch (gdispImageGetAlignedBE32(buf, 4)) {
case 0x49484452: // "IHDR" - Header block
// Check if the header is already done
if ((pinfo->flags & PNG_FLG_HEADERDONE))
goto exit_baddata;
// Read the image parameters
if (len < 13 || gfileRead(img->f, buf, 13) != 13)
goto exit_baddata;
img->width = gdispImageGetAlignedBE16(buf, 2);
img->height = gdispImageGetAlignedBE16(buf, 6);
pinfo->bitdepth = gdispImageGetVar(gU8, buf, 8);
pinfo->mode = gdispImageGetVar(gU8, buf, 9);
if (gdispImageGetVar(gU8, buf, 12)) {
pinfo->flags |= PNG_FLG_INTERLACE;
#if !GDISP_NEED_IMAGE_PNG_INTERLACED
goto exit_unsupported;
#endif
}
// Check width and height, filter, compression and interlacing
if (gdispImageGetVar(gU16, buf, 0) != 0 || img->width <= 0 // width
|| gdispImageGetVar(gU16, buf, 4) != 0 || img->height <= 0 // height
|| gdispImageGetVar(gU8, buf, 10) != 0 // compression
|| gdispImageGetVar(gU8, buf, 11) != 0 // filter
|| gdispImageGetVar(gU8, buf, 12) > 1 // interlace
)
goto exit_unsupported;
// Check mode, bitdepth and calculate bits per pixel
switch(pinfo->mode) {
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_124 || GDISP_NEED_IMAGE_PNG_GRAYSCALE_8 || GDISP_NEED_IMAGE_PNG_GRAYSCALE_16
case PNG_COLORMODE_GRAY:
switch(pinfo->bitdepth) {
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_124
case 1:
case 2:
case 4: pinfo->out = PNG_OutGRAY124; break;
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_8
case 8: pinfo->out = PNG_OutGRAY8; break;
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_16
case 16: pinfo->out = PNG_OutGRAY16; break;
#endif
default: goto exit_unsupported;
}
pinfo->bpp = pinfo->bitdepth;
break;
#endif
#if GDISP_NEED_IMAGE_PNG_RGB_8 || GDISP_NEED_IMAGE_PNG_RGB_16
case PNG_COLORMODE_RGB:
switch(pinfo->bitdepth) {
#if GDISP_NEED_IMAGE_PNG_RGB_8
case 8: pinfo->out = PNG_OutRGB8; break;
#endif
#if GDISP_NEED_IMAGE_PNG_RGB_16
case 16: pinfo->out = PNG_OutRGB16; break;
#endif
default: goto exit_unsupported;
}
pinfo->bpp = pinfo->bitdepth * 3;
break;
#endif
#if GDISP_NEED_IMAGE_PNG_PALETTE_124 || GDISP_NEED_IMAGE_PNG_PALETTE_8
case PNG_COLORMODE_PALETTE:
switch(pinfo->bitdepth) {
#if GDISP_NEED_IMAGE_PNG_PALETTE_124
case 1:
case 2:
case 4: pinfo->out = PNG_OutPAL124; break;
#endif
#if GDISP_NEED_IMAGE_PNG_PALETTE_8
case 8: pinfo->out = PNG_OutPAL8; break;
#endif
default: goto exit_unsupported;
}
pinfo->bpp = pinfo->bitdepth;
break;
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYALPHA_8 || GDISP_NEED_IMAGE_PNG_GRAYALPHA_16
case PNG_COLORMODE_GRAYALPHA:
switch(pinfo->bitdepth) {
#if GDISP_NEED_IMAGE_PNG_GRAYALPHA_8
case 8: pinfo->out = PNG_OutGRAYA8; break;
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYALPHA_16
case 16: pinfo->out = PNG_OutGRAYA16; break;
#endif
default: goto exit_unsupported;
}
pinfo->bpp = pinfo->bitdepth * 2;
break;
#endif
#if GDISP_NEED_IMAGE_PNG_RGBALPHA_8 || GDISP_NEED_IMAGE_PNG_RGBALPHA_16
case PNG_COLORMODE_RGBA:
switch(pinfo->bitdepth) {
#if GDISP_NEED_IMAGE_PNG_RGBALPHA_8
case 8: pinfo->out = PNG_OutRGBA8; break;
#endif
#if GDISP_NEED_IMAGE_PNG_RGBALPHA_16
case 16: pinfo->out = PNG_OutRGBA16; break;
#endif
default: goto exit_unsupported;
}
pinfo->bpp = pinfo->bitdepth * 4;
break;
#endif
default:
goto exit_unsupported;
}
pinfo->flags |= PNG_FLG_HEADERDONE;
break;
case 0x49454E44: // "IEND" - All done
goto exit_baddata; // Oops we didn't get any data.
case 0x49444154: // "IDAT" - Image Data
// Check if the header is already done
if (!(pinfo->flags & PNG_FLG_HEADERDONE))
goto exit_baddata;
#if GDISP_NEED_IMAGE_PNG_PALETTE_124 || GDISP_NEED_IMAGE_PNG_PALETTE_8
// Make sure a palette image actually has a palette
if (pinfo->mode == PNG_COLORMODE_PALETTE && !pinfo->palette)
goto exit_baddata;
#endif
// All good
return GDISP_IMAGE_ERR_OK;
#if GDISP_NEED_IMAGE_PNG_PALETTE_124 || GDISP_NEED_IMAGE_PNG_PALETTE_8
case 0x504C5445: // "PLTE" - Palette
// Check if the header is already done
if (!(pinfo->flags & PNG_FLG_HEADERDONE))
goto exit_baddata;
// Skip a palette if we don't need it.
if (pinfo->mode != PNG_COLORMODE_PALETTE)
break;
// Check the size and that we don't have one already
if (len > 3 * 256 || pinfo->palette)
goto exit_baddata;
// Allocate the palette
pinfo->palsize = len / 3;
if (!(pinfo->palette = gfxAlloc(pinfo->palsize * 4)))
goto exit_nonmem;
// Read the palette
{
gU16 idx;
gU8 *p;
for(idx=pinfo->palsize, p=pinfo->palette; idx; p += 4, idx--) {
if (gfileRead(img->f, p, 3) != 3)
goto exit_baddata;
p[3] = 255;
}
}
break;
#endif
#if GDISP_NEED_IMAGE_PNG_TRANSPARENCY
case 0x74524E53: // "tRNS" - Transparency
// Check if the header is already done
if (!(pinfo->flags & PNG_FLG_HEADERDONE))
goto exit_baddata;
// Transparency is handled differently depending on the mode
switch(pinfo->mode) {
#if GDISP_NEED_IMAGE_PNG_PALETTE_124 || GDISP_NEED_IMAGE_PNG_PALETTE_8
case PNG_COLORMODE_PALETTE:
if (len > pinfo->palsize)
goto exit_baddata;
// Adjust the palette
{
gU16 idx;
gU8 *p;
for(idx=len, p=pinfo->palette+3; idx; p += 4, idx--) {
if (gfileRead(img->f, p, 1) != 1)
goto exit_baddata;
}
}
break;
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_124 || GDISP_NEED_IMAGE_PNG_GRAYSCALE_8 || GDISP_NEED_IMAGE_PNG_GRAYSCALE_16
case PNG_COLORMODE_GRAY:
// Read the transparency color
if (len != 2 || gfileRead(img->f, buf, 2) != 2)
goto exit_baddata;
pinfo->flags |= PNG_FLG_TRANSPARENT;
pinfo->trans_r = gdispImageGetAlignedBE16(buf, 0);
break;
#endif
#if GDISP_NEED_IMAGE_PNG_RGB_8 || GDISP_NEED_IMAGE_PNG_RGB_16
case PNG_COLORMODE_RGB:
// Read the transparency color
if (len != 6 || gfileRead(img->f, buf, 6) != 6)
goto exit_baddata;
pinfo->flags |= PNG_FLG_TRANSPARENT;
pinfo->trans_r = gdispImageGetAlignedBE16(buf, 0);
pinfo->trans_g = gdispImageGetAlignedBE16(buf, 2);
pinfo->trans_b = gdispImageGetAlignedBE16(buf, 4);
break;
#endif
default:
goto exit_unsupported;
}
break;
#endif
#if GDISP_NEED_IMAGE_PNG_BACKGROUND
case 0x624B4744: // "bKGD" - Background
// Check if the header is already done
if (!(pinfo->flags & PNG_FLG_HEADERDONE))
goto exit_baddata;
pinfo->flags |= PNG_FLG_BACKGROUND;
// Background data is handled differently depending on the mode
switch(pinfo->mode) {
#if GDISP_NEED_IMAGE_PNG_PALETTE_124 || GDISP_NEED_IMAGE_PNG_PALETTE_8
case PNG_COLORMODE_PALETTE:
if (!pinfo->palette || len < 1 || gfileRead(img->f, buf, 1) != 1 || (gU16)buf[0] >= pinfo->palsize)
goto exit_baddata;
pinfo->bg = RGB2COLOR(pinfo->palette[((unsigned)buf[0])*4+0],
pinfo->palette[((unsigned)buf[0])*4+1],
pinfo->palette[((unsigned)buf[0])*4+2]);
break;
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_124 || GDISP_NEED_IMAGE_PNG_GRAYSCALE_8 || GDISP_NEED_IMAGE_PNG_GRAYSCALE_16 || GDISP_NEED_IMAGE_PNG_GRAYALPHA_8 || GDISP_NEED_IMAGE_PNG_GRAYALPHA_16
case PNG_COLORMODE_GRAY:
case PNG_COLORMODE_GRAYALPHA:
if (len < 2 || gfileRead(img->f, buf, 2) != 2)
goto exit_baddata;
switch(pinfo->bitdepth) {
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_124
case 1:
case 2:
case 4:
buf[1] <<= 8-pinfo->bitdepth;
if (buf[1] >= 0x80)
buf[1] += ((1U << (8-pinfo->bitdepth))-1);
pinfo->bg = LUMA2COLOR(buf[1]);
break;
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_8 || GDISP_NEED_IMAGE_PNG_GRAYALPHA_8
case 8:
pinfo->bg = LUMA2COLOR(buf[1]);
break;
#endif
#if GDISP_NEED_IMAGE_PNG_GRAYSCALE_16 || GDISP_NEED_IMAGE_PNG_GRAYALPHA_16
case 16:
pinfo->bg = LUMA2COLOR(buf[0]);
break;
#endif
}
break;
#endif
#if GDISP_NEED_IMAGE_PNG_RGB_8 || GDISP_NEED_IMAGE_PNG_RGB_16 || GDISP_NEED_IMAGE_PNG_RGBALPHA_8 || GDISP_NEED_IMAGE_PNG_RGBALPHA_16
case PNG_COLORMODE_RGB:
case PNG_COLORMODE_RGBA:
if (len < 6 || gfileRead(img->f, buf, 6) != 6)
goto exit_baddata;
#if GDISP_NEED_IMAGE_PNG_RGB_16 || GDISP_NEED_IMAGE_PNG_RGBALPHA_16
if (pinfo->bitdepth == 16) {
pinfo->bg = RGB2COLOR(buf[0], buf[2], buf[4]);
} else
#endif
pinfo->bg = RGB2COLOR(buf[1], buf[3], buf[5]);
break;
#endif
default:
goto exit_unsupported;
}
break;
#endif
}
}
exit_baddata:
gdispImageClose_PNG(img);
return GDISP_IMAGE_ERR_BADDATA;
exit_unsupported:
gdispImageClose_PNG(img);
return GDISP_IMAGE_ERR_UNSUPPORTED;
exit_nonmem:
gdispImageClose_PNG(img);
return GDISP_IMAGE_ERR_NOMEMORY;
}
gdispImageError gdispGImageDraw_PNG(GDisplay *g, gImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy) {
PNG_info *pinfo;
PNG_decode *d;
// Allocate the space to decode with including space for 2 full scan lines for filtering.
pinfo = (PNG_info *)img->priv;
if (!(d = gdispImageAlloc(img, sizeof(PNG_decode) + (img->width * pinfo->bpp + 7) / 4)))
return GDISP_IMAGE_ERR_NOMEMORY;
// Initialise the decoder
d->img = img;
d->pinfo = pinfo;
PNG_iInit(d);
PNG_oInit(&d->o, g, x, y, cx, cy, sx, sy);
PNG_zInit(&d->z);
// Process the zlib inflate header
if (!PNG_zGetHeader(d))
goto exit_baddata;
#if GDISP_NEED_IMAGE_PNG_INTERLACED
if ((pinfo->flags & PNG_FLG_INTERLACE)) {
// Interlaced decoding
#error "PNG Decoder: Interlaced PNG's are not supported yet!"
} else
#endif
{
// Non-interlaced decoding
PNG_fInit(&d->f, (gU8 *)(d+1), (pinfo->bpp + 7) / 8, (img->width * pinfo->bpp + 7) / 8);
for(y = 0; y < sy+cy; PNG_fNext(&d->f), y++) {
if (!PNG_unfilter_type0(d))
goto exit_baddata;
if (PNG_oStartY(&d->o, y)) {
pinfo->out(d);
PNG_oFlush(&d->o);
}
}
}
// Clean up
gdispImageFree(img, d, sizeof(PNG_decode) + (img->width * pinfo->bpp + 7) / 4);
return GDISP_IMAGE_ERR_OK;
exit_baddata:
gdispImageFree(img, d, sizeof(PNG_decode) + (img->width * pinfo->bpp + 7) / 4);
return GDISP_IMAGE_ERR_BADDATA;
}
gdispImageError gdispImageCache_PNG(gImage *img) {
PNG_info *pinfo;
unsigned chunknext;
unsigned chunklen;
gU8 *pcache;
gU8 buf[8];
// If we are already cached - just return OK
pinfo = (PNG_info *)img->priv;
if (pinfo->cache)
return GDISP_IMAGE_ERR_OK;
// Calculate the size of all the image data blocks in the image
pinfo->cachesz = 0;
chunknext = 8;
while(1) {
// Find a new chunk
gfileSetPos(img->f, chunknext);
if (gfileRead(img->f, buf, 8) != 8)
return GDISP_IMAGE_ERR_BADDATA;
// Calculate the chunk length and next chunk
chunklen = gdispImageGetAlignedBE32(buf, 0);
chunknext += chunklen + 12;
// Process only image data chunks
switch (gdispImageGetAlignedBE32(buf, 4)) {
case 0x49444154: // "IDAT" - Image Data
pinfo->cachesz += chunklen;
break;
case 0x49454E44: // "IEND" - All done
if (!pinfo->cachesz)
return GDISP_IMAGE_ERR_BADDATA;
goto gotsize;
}
}
gotsize:
// Allocate the cache
if (!(pcache = gdispImageAlloc(img, pinfo->cachesz)))
return GDISP_IMAGE_ERR_NOMEMORY;
pinfo->cache = pcache;
// Read the image data into the cache
chunknext = 8;
while(1) {
// Find a new chunk
gfileSetPos(img->f, chunknext);
if (gfileRead(img->f, buf, 8) != 8)
goto baddata;
// Calculate the chunk length and next chunk
chunklen = gdispImageGetAlignedBE32(buf, 0);
chunknext += chunklen + 12;
// Process only image data chunks
switch (gdispImageGetAlignedBE32(buf, 4)) {
case 0x49444154: // "IDAT" - Image Data
if (gfileRead(img->f, pcache, chunklen) != chunklen)
goto baddata;
pcache += chunklen;
break;
case 0x49454E44: // "IEND" - All done
return GDISP_IMAGE_ERR_OK;
}
}
baddata:
// Oops - can't read the data. Throw away the cache.
gdispImageFree(img, pinfo->cache, pinfo->cachesz);
pinfo->cache = 0;
return GDISP_IMAGE_ERR_BADDATA;
}
gDelay gdispImageNext_PNG(gImage *img) {
(void) img;
/* No more frames/pages */
return gDelayForever;
}
#endif /* GFX_USE_GDISP && GDISP_NEED_IMAGE && GDISP_NEED_IMAGE_PNG */
Reference in New Issue View Git Blame Copy Permalink