/shark/trunk/ports/png/pngerror.c |
---|
0,0 → 1,291 |
/* pngerror.c - stub functions for i/o and memory allocation |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file provides a location for all error handling. Users who |
* need special error handling are expected to write replacement functions |
* and use png_set_error_fn() to use those functions. See the instructions |
* at each function. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
static void /* PRIVATE */ |
png_default_error PNGARG((png_structp png_ptr, |
png_const_charp error_message)); |
static void /* PRIVATE */ |
png_default_warning PNGARG((png_structp png_ptr, |
png_const_charp warning_message)); |
/* This function is called whenever there is a fatal error. This function |
* should not be changed. If there is a need to handle errors differently, |
* you should supply a replacement error function and use png_set_error_fn() |
* to replace the error function at run-time. |
*/ |
void PNGAPI |
png_error(png_structp png_ptr, png_const_charp error_message) |
{ |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
char msg[16]; |
if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) |
{ |
int offset = 0; |
if (*error_message == '#') |
{ |
for (offset=1; offset<15; offset++) |
if (*(error_message+offset) == ' ') |
break; |
if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) |
{ |
int i; |
for (i=0; i<offset-1; i++) |
msg[i]=error_message[i+1]; |
msg[i]='\0'; |
error_message=msg; |
} |
else |
error_message+=offset; |
} |
else |
{ |
if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) |
{ |
msg[0]='0'; |
msg[1]='\0'; |
error_message=msg; |
} |
} |
} |
#endif |
if (png_ptr->error_fn != NULL) |
(*(png_ptr->error_fn))(png_ptr, error_message); |
/* if the following returns or doesn't exist, use the default function, |
which will not return */ |
png_default_error(png_ptr, error_message); |
} |
/* This function is called whenever there is a non-fatal error. This function |
* should not be changed. If there is a need to handle warnings differently, |
* you should supply a replacement warning function and use |
* png_set_error_fn() to replace the warning function at run-time. |
*/ |
void PNGAPI |
png_warning(png_structp png_ptr, png_const_charp warning_message) |
{ |
int offset = 0; |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
if (png_ptr->flags&(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) |
#endif |
{ |
if (*warning_message == '#') |
{ |
for (offset=1; offset<15; offset++) |
if (*(warning_message+offset) == ' ') |
break; |
} |
} |
if (png_ptr->warning_fn != NULL) |
(*(png_ptr->warning_fn))(png_ptr, |
(png_const_charp)(warning_message+offset)); |
else |
png_default_warning(png_ptr, (png_const_charp)(warning_message+offset)); |
} |
/* These utilities are used internally to build an error message that relates |
* to the current chunk. The chunk name comes from png_ptr->chunk_name, |
* this is used to prefix the message. The message is limited in length |
* to 63 bytes, the name characters are output as hex digits wrapped in [] |
* if the character is invalid. |
*/ |
#define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97)) |
static PNG_CONST char png_digit[16] = { |
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', |
'F' }; |
static void /* PRIVATE */ |
png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp |
error_message) |
{ |
int iout = 0, iin = 0; |
while (iin < 4) |
{ |
int c = png_ptr->chunk_name[iin++]; |
if (isnonalpha(c)) |
{ |
buffer[iout++] = '['; |
buffer[iout++] = png_digit[(c & 0xf0) >> 4]; |
buffer[iout++] = png_digit[c & 0x0f]; |
buffer[iout++] = ']'; |
} |
else |
{ |
buffer[iout++] = (png_byte)c; |
} |
} |
if (error_message == NULL) |
buffer[iout] = 0; |
else |
{ |
buffer[iout++] = ':'; |
buffer[iout++] = ' '; |
png_memcpy(buffer+iout, error_message, 64); |
buffer[iout+63] = 0; |
} |
} |
void PNGAPI |
png_chunk_error(png_structp png_ptr, png_const_charp error_message) |
{ |
char msg[18+64]; |
png_format_buffer(png_ptr, msg, error_message); |
png_error(png_ptr, msg); |
} |
void PNGAPI |
png_chunk_warning(png_structp png_ptr, png_const_charp warning_message) |
{ |
char msg[18+64]; |
png_format_buffer(png_ptr, msg, warning_message); |
png_warning(png_ptr, msg); |
} |
/* This is the default error handling function. Note that replacements for |
* this function MUST NOT RETURN, or the program will likely crash. This |
* function is used by default, or if the program supplies NULL for the |
* error function pointer in png_set_error_fn(). |
*/ |
static void /* PRIVATE */ |
png_default_error(png_structp png_ptr, png_const_charp error_message) |
{ |
#ifndef PNG_NO_CONSOLE_IO |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
if (*error_message == '#') |
{ |
int offset; |
char error_number[16]; |
for (offset=0; offset<15; offset++) |
{ |
error_number[offset] = *(error_message+offset+1); |
if (*(error_message+offset) == ' ') |
break; |
} |
if((offset > 1) && (offset < 15)) |
{ |
error_number[offset-1]='\0'; |
cprintf("libpng error no. %s: %s\n", error_number, |
error_message+offset); |
} |
else |
cprintf("libpng error: %s, offset=%d\n", error_message,offset); |
} |
else |
#endif |
cprintf("libpng error: %s\n", error_message); |
#else |
if (error_message) |
/* make compiler happy */ ; |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
# ifdef USE_FAR_KEYWORD |
{ |
jmp_buf jmpbuf; |
png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf)); |
longjmp(jmpbuf, 1); |
} |
# else |
longjmp(png_ptr->jmpbuf, 1); |
# endif |
#else |
if (png_ptr) |
/* make compiler happy */ ; |
PNG_ABORT(); |
#endif |
} |
/* This function is called when there is a warning, but the library thinks |
* it can continue anyway. Replacement functions don't have to do anything |
* here if you don't want them to. In the default configuration, png_ptr is |
* not used, but it is passed in case it may be useful. |
*/ |
static void /* PRIVATE */ |
png_default_warning(png_structp png_ptr, png_const_charp warning_message) |
{ |
#ifndef PNG_NO_CONSOLE_IO |
# ifdef PNG_ERROR_NUMBERS_SUPPORTED |
if (*warning_message == '#') |
{ |
int offset; |
char warning_number[16]; |
for (offset=0; offset<15; offset++) |
{ |
warning_number[offset]=*(warning_message+offset+1); |
if (*(warning_message+offset) == ' ') |
break; |
} |
if((offset > 1) && (offset < 15)) |
{ |
warning_number[offset-1]='\0'; |
cprintf("libpng warning no. %s: %s\n", warning_number, |
warning_message+offset); |
} |
else |
cprintf("libpng warning: %s\n", warning_message); |
} |
else |
# endif |
cprintf("libpng warning: %s\n", warning_message); |
#else |
if (warning_message) |
/* appease compiler */ ; |
#endif |
if (png_ptr) |
return; |
} |
/* This function is called when the application wants to use another method |
* of handling errors and warnings. Note that the error function MUST NOT |
* return to the calling routine or serious problems will occur. The return |
* method used in the default routine calls longjmp(png_ptr->jmpbuf, 1) |
*/ |
void PNGAPI |
png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warning_fn) |
{ |
png_ptr->error_ptr = error_ptr; |
png_ptr->error_fn = error_fn; |
png_ptr->warning_fn = warning_fn; |
} |
/* This function returns a pointer to the error_ptr associated with the user |
* functions. The application should free any memory associated with this |
* pointer before png_write_destroy and png_read_destroy are called. |
*/ |
png_voidp PNGAPI |
png_get_error_ptr(png_structp png_ptr) |
{ |
return ((png_voidp)png_ptr->error_ptr); |
} |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
void PNGAPI |
png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode) |
{ |
if(png_ptr != NULL) |
{ |
png_ptr->flags &= |
((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode); |
} |
} |
#endif |
/shark/trunk/ports/png/infcodes.h |
---|
0,0 → 1,27 |
/* infcodes.h -- header to use infcodes.c |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* WARNING: this file should *not* be used by applications. It is |
part of the implementation of the compression library and is |
subject to change. Applications should only use zlib.h. |
*/ |
struct inflate_codes_state; |
typedef struct inflate_codes_state FAR inflate_codes_statef; |
extern inflate_codes_statef *inflate_codes_new OF(( |
uInt, uInt, |
inflate_huft *, inflate_huft *, |
z_streamp )); |
extern int inflate_codes OF(( |
inflate_blocks_statef *, |
z_streamp , |
int)); |
extern void inflate_codes_free OF(( |
inflate_codes_statef *, |
z_streamp )); |
/shark/trunk/ports/png/pngwtran.c |
---|
0,0 → 1,563 |
/* pngwtran.c - transforms the data in a row for PNG writers |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#ifdef PNG_WRITE_SUPPORTED |
/* Transform the data according to the user's wishes. The order of |
* transformations is significant. |
*/ |
void /* PRIVATE */ |
png_do_write_transformations(png_structp png_ptr) |
{ |
png_debug(1, "in png_do_write_transformations\n"); |
if (png_ptr == NULL) |
return; |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
if (png_ptr->transformations & PNG_USER_TRANSFORM) |
if(png_ptr->write_user_transform_fn != NULL) |
(*(png_ptr->write_user_transform_fn)) /* user write transform function */ |
(png_ptr, /* png_ptr */ |
&(png_ptr->row_info), /* row_info: */ |
/* png_uint_32 width; width of row */ |
/* png_uint_32 rowbytes; number of bytes in row */ |
/* png_byte color_type; color type of pixels */ |
/* png_byte bit_depth; bit depth of samples */ |
/* png_byte channels; number of channels (1-4) */ |
/* png_byte pixel_depth; bits per pixel (depth*channels) */ |
png_ptr->row_buf + 1); /* start of pixel data for row */ |
#endif |
#if defined(PNG_WRITE_FILLER_SUPPORTED) |
if (png_ptr->transformations & PNG_FILLER) |
png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->flags); |
#endif |
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_WRITE_PACK_SUPPORTED) |
if (png_ptr->transformations & PNG_PACK) |
png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1, |
(png_uint_32)png_ptr->bit_depth); |
#endif |
#if defined(PNG_WRITE_SWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_WRITE_SHIFT_SUPPORTED) |
if (png_ptr->transformations & PNG_SHIFT) |
png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1, |
&(png_ptr->shift)); |
#endif |
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_ALPHA) |
png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_WRITE_BGR_SUPPORTED) |
if (png_ptr->transformations & PNG_BGR) |
png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_WRITE_INVERT_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
} |
#if defined(PNG_WRITE_PACK_SUPPORTED) |
/* Pack pixels into bytes. Pass the true bit depth in bit_depth. The |
* row_info bit depth should be 8 (one pixel per byte). The channels |
* should be 1 (this only happens on grayscale and paletted images). |
*/ |
void /* PRIVATE */ |
png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) |
{ |
png_debug(1, "in png_do_pack\n"); |
if (row_info->bit_depth == 8 && |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
row_info->channels == 1) |
{ |
switch ((int)bit_depth) |
{ |
case 1: |
{ |
png_bytep sp, dp; |
int mask, v; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
sp = row; |
dp = row; |
mask = 0x80; |
v = 0; |
for (i = 0; i < row_width; i++) |
{ |
if (*sp != 0) |
v |= mask; |
sp++; |
if (mask > 1) |
mask >>= 1; |
else |
{ |
mask = 0x80; |
*dp = (png_byte)v; |
dp++; |
v = 0; |
} |
} |
if (mask != 0x80) |
*dp = (png_byte)v; |
break; |
} |
case 2: |
{ |
png_bytep sp, dp; |
int shift, v; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
sp = row; |
dp = row; |
shift = 6; |
v = 0; |
for (i = 0; i < row_width; i++) |
{ |
png_byte value; |
value = (png_byte)(*sp & 0x03); |
v |= (value << shift); |
if (shift == 0) |
{ |
shift = 6; |
*dp = (png_byte)v; |
dp++; |
v = 0; |
} |
else |
shift -= 2; |
sp++; |
} |
if (shift != 6) |
*dp = (png_byte)v; |
break; |
} |
case 4: |
{ |
png_bytep sp, dp; |
int shift, v; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
sp = row; |
dp = row; |
shift = 4; |
v = 0; |
for (i = 0; i < row_width; i++) |
{ |
png_byte value; |
value = (png_byte)(*sp & 0x0f); |
v |= (value << shift); |
if (shift == 0) |
{ |
shift = 4; |
*dp = (png_byte)v; |
dp++; |
v = 0; |
} |
else |
shift -= 4; |
sp++; |
} |
if (shift != 4) |
*dp = (png_byte)v; |
break; |
} |
} |
row_info->bit_depth = (png_byte)bit_depth; |
row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels); |
row_info->rowbytes = |
((row_info->width * row_info->pixel_depth + 7) >> 3); |
} |
} |
#endif |
#if defined(PNG_WRITE_SHIFT_SUPPORTED) |
/* Shift pixel values to take advantage of whole range. Pass the |
* true number of bits in bit_depth. The row should be packed |
* according to row_info->bit_depth. Thus, if you had a row of |
* bit depth 4, but the pixels only had values from 0 to 7, you |
* would pass 3 as bit_depth, and this routine would translate the |
* data to 0 to 15. |
*/ |
void /* PRIVATE */ |
png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth) |
{ |
png_debug(1, "in png_do_shift\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL && |
#else |
if ( |
#endif |
row_info->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
int shift_start[4], shift_dec[4]; |
int channels = 0; |
if (row_info->color_type & PNG_COLOR_MASK_COLOR) |
{ |
shift_start[channels] = row_info->bit_depth - bit_depth->red; |
shift_dec[channels] = bit_depth->red; |
channels++; |
shift_start[channels] = row_info->bit_depth - bit_depth->green; |
shift_dec[channels] = bit_depth->green; |
channels++; |
shift_start[channels] = row_info->bit_depth - bit_depth->blue; |
shift_dec[channels] = bit_depth->blue; |
channels++; |
} |
else |
{ |
shift_start[channels] = row_info->bit_depth - bit_depth->gray; |
shift_dec[channels] = bit_depth->gray; |
channels++; |
} |
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) |
{ |
shift_start[channels] = row_info->bit_depth - bit_depth->alpha; |
shift_dec[channels] = bit_depth->alpha; |
channels++; |
} |
/* with low row depths, could only be grayscale, so one channel */ |
if (row_info->bit_depth < 8) |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_byte mask; |
png_uint_32 row_bytes = row_info->rowbytes; |
if (bit_depth->gray == 1 && row_info->bit_depth == 2) |
mask = 0x55; |
else if (row_info->bit_depth == 4 && bit_depth->gray == 3) |
mask = 0x11; |
else |
mask = 0xff; |
for (i = 0; i < row_bytes; i++, bp++) |
{ |
png_uint_16 v; |
int j; |
v = *bp; |
*bp = 0; |
for (j = shift_start[0]; j > -shift_dec[0]; j -= shift_dec[0]) |
{ |
if (j > 0) |
*bp |= (png_byte)((v << j) & 0xff); |
else |
*bp |= (png_byte)((v >> (-j)) & mask); |
} |
} |
} |
else if (row_info->bit_depth == 8) |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_uint_32 istop = channels * row_info->width; |
for (i = 0; i < istop; i++, bp++) |
{ |
png_uint_16 v; |
int j; |
int c = (int)(i%channels); |
v = *bp; |
*bp = 0; |
for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) |
{ |
if (j > 0) |
*bp |= (png_byte)((v << j) & 0xff); |
else |
*bp |= (png_byte)((v >> (-j)) & 0xff); |
} |
} |
} |
else |
{ |
png_bytep bp; |
png_uint_32 i; |
png_uint_32 istop = channels * row_info->width; |
for (bp = row, i = 0; i < istop; i++) |
{ |
int c = (int)(i%channels); |
png_uint_16 value, v; |
int j; |
v = (png_uint_16)(((png_uint_16)(*bp) << 8) + *(bp + 1)); |
value = 0; |
for (j = shift_start[c]; j > -shift_dec[c]; j -= shift_dec[c]) |
{ |
if (j > 0) |
value |= (png_uint_16)((v << j) & (png_uint_16)0xffff); |
else |
value |= (png_uint_16)((v >> (-j)) & (png_uint_16)0xffff); |
} |
*bp++ = (png_byte)(value >> 8); |
*bp++ = (png_byte)(value & 0xff); |
} |
} |
} |
} |
#endif |
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
void /* PRIVATE */ |
png_do_write_swap_alpha(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_write_swap_alpha\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
/* This converts from ARGB to RGBA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
png_byte save = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = save; |
} |
} |
/* This converts from AARRGGBB to RRGGBBAA */ |
else |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
png_byte save[2]; |
save[0] = *(sp++); |
save[1] = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = save[0]; |
*(dp++) = save[1]; |
} |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
/* This converts from AG to GA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
png_byte save = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = save; |
} |
} |
/* This converts from AAGG to GGAA */ |
else |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
png_byte save[2]; |
save[0] = *(sp++); |
save[1] = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = save[0]; |
*(dp++) = save[1]; |
} |
} |
} |
} |
} |
#endif |
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
void /* PRIVATE */ |
png_do_write_invert_alpha(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_write_invert_alpha\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
/* This inverts the alpha channel in RGBA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
/* This inverts the alpha channel in RRGGBBAA */ |
else |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = (png_byte)(255 - *(sp++)); |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
/* This inverts the alpha channel in GA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
*(dp++) = *(sp++); |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
/* This inverts the alpha channel in GGAA */ |
else |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
for (i = 0, sp = dp = row; i < row_width; i++) |
{ |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = (png_byte)(255 - *(sp++)); |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
} |
} |
} |
#endif |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
/* undoes intrapixel differencing */ |
void /* PRIVATE */ |
png_do_write_intrapixel(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_write_intrapixel\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
int bytes_per_pixel; |
png_uint_32 row_width = row_info->width; |
if (row_info->bit_depth == 8) |
{ |
png_bytep rp; |
png_uint_32 i; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
bytes_per_pixel = 3; |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
bytes_per_pixel = 4; |
else |
return; |
for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) |
{ |
*(rp) = (png_byte)((*rp - *(rp+1))&0xff); |
*(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff); |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
png_bytep rp; |
png_uint_32 i; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
bytes_per_pixel = 6; |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
bytes_per_pixel = 8; |
else |
return; |
for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) |
{ |
png_uint_32 s0=*(rp )<<8 | *(rp+1); |
png_uint_32 s1=*(rp+2)<<8 | *(rp+3); |
png_uint_32 s2=*(rp+4)<<8 | *(rp+5); |
png_uint_32 red=(s0-s1)&0xffff; |
png_uint_32 blue=(s2-s1)&0xffff; |
*(rp ) = (png_byte)((red>>8)&0xff); |
*(rp+1) = (png_byte)(red&0xff); |
*(rp+4) = (png_byte)((blue>>8)&0xff); |
*(rp+5) = (png_byte)(blue&0xff); |
} |
} |
} |
} |
#endif /* PNG_MNG_FEATURES_SUPPORTED */ |
#endif /* PNG_WRITE_SUPPORTED */ |
/shark/trunk/ports/png/inffixed.h |
---|
0,0 → 1,151 |
/* inffixed.h -- table for decoding fixed codes |
* Generated automatically by the maketree.c program |
*/ |
/* WARNING: this file should *not* be used by applications. It is |
part of the implementation of the compression library and is |
subject to change. Applications should only use zlib.h. |
*/ |
local uInt fixed_bl = 9; |
local uInt fixed_bd = 5; |
local inflate_huft fixed_tl[] = { |
{{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115}, |
{{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},192}, |
{{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},160}, |
{{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},224}, |
{{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},144}, |
{{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},208}, |
{{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},176}, |
{{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},240}, |
{{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227}, |
{{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},200}, |
{{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},168}, |
{{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},232}, |
{{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},152}, |
{{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},216}, |
{{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},184}, |
{{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},248}, |
{{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163}, |
{{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},196}, |
{{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},164}, |
{{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},228}, |
{{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},148}, |
{{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},212}, |
{{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},180}, |
{{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},244}, |
{{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0}, |
{{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},204}, |
{{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},172}, |
{{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},236}, |
{{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},156}, |
{{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},220}, |
{{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},188}, |
{{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},252}, |
{{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131}, |
{{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},194}, |
{{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},162}, |
{{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},226}, |
{{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},146}, |
{{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},210}, |
{{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},178}, |
{{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},242}, |
{{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258}, |
{{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},202}, |
{{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},170}, |
{{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},234}, |
{{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},154}, |
{{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},218}, |
{{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},186}, |
{{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},250}, |
{{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195}, |
{{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},198}, |
{{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},166}, |
{{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},230}, |
{{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},150}, |
{{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},214}, |
{{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},182}, |
{{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},246}, |
{{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0}, |
{{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},206}, |
{{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},174}, |
{{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},238}, |
{{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},158}, |
{{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},222}, |
{{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},190}, |
{{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},254}, |
{{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115}, |
{{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},193}, |
{{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},161}, |
{{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},225}, |
{{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},145}, |
{{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},209}, |
{{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},177}, |
{{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},241}, |
{{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227}, |
{{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},201}, |
{{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},169}, |
{{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},233}, |
{{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},153}, |
{{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},217}, |
{{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},185}, |
{{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},249}, |
{{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163}, |
{{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},197}, |
{{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},165}, |
{{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},229}, |
{{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},149}, |
{{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},213}, |
{{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},181}, |
{{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},245}, |
{{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0}, |
{{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},205}, |
{{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},173}, |
{{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},237}, |
{{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},157}, |
{{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},221}, |
{{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},189}, |
{{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},253}, |
{{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131}, |
{{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},195}, |
{{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},163}, |
{{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},227}, |
{{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},147}, |
{{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},211}, |
{{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},179}, |
{{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},243}, |
{{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258}, |
{{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},203}, |
{{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},171}, |
{{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},235}, |
{{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},155}, |
{{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},219}, |
{{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},187}, |
{{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},251}, |
{{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195}, |
{{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},199}, |
{{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},167}, |
{{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},231}, |
{{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},151}, |
{{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},215}, |
{{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},183}, |
{{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},247}, |
{{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0}, |
{{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},207}, |
{{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},175}, |
{{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},239}, |
{{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},159}, |
{{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},223}, |
{{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},191}, |
{{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},255} |
}; |
local inflate_huft fixed_td[] = { |
{{{80,5}},1}, {{{87,5}},257}, {{{83,5}},17}, {{{91,5}},4097}, |
{{{81,5}},5}, {{{89,5}},1025}, {{{85,5}},65}, {{{93,5}},16385}, |
{{{80,5}},3}, {{{88,5}},513}, {{{84,5}},33}, {{{92,5}},8193}, |
{{{82,5}},9}, {{{90,5}},2049}, {{{86,5}},129}, {{{192,5}},24577}, |
{{{80,5}},2}, {{{87,5}},385}, {{{83,5}},25}, {{{91,5}},6145}, |
{{{81,5}},7}, {{{89,5}},1537}, {{{85,5}},97}, {{{93,5}},24577}, |
{{{80,5}},4}, {{{88,5}},769}, {{{84,5}},49}, {{{92,5}},12289}, |
{{{82,5}},13}, {{{90,5}},3073}, {{{86,5}},193}, {{{192,5}},24577} |
}; |
/shark/trunk/ports/png/pngvcrd.c |
---|
0,0 → 1,3845 |
/* pngvcrd.c - mixed C/assembler version of utilities to read a PNG file |
* |
* For Intel x86 CPU and Microsoft Visual C++ compiler |
* |
* libpng version 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* Copyright (c) 1998, Intel Corporation |
* |
* Contributed by Nirav Chhatrapati, Intel Corporation, 1998 |
* Interface to libpng contributed by Gilles Vollant, 1999 |
* |
* |
* In png_do_read_interlace() in libpng versions 1.0.3a through 1.0.4d, |
* a sign error in the post-MMX cleanup code for each pixel_depth resulted |
* in bad pixels at the beginning of some rows of some images, and also |
* (due to out-of-range memory reads and writes) caused heap corruption |
* when compiled with MSVC 6.0. The error was fixed in version 1.0.4e. |
* |
* [png_read_filter_row_mmx_avg() bpp == 2 bugfix, GRR 20000916] |
* |
* [runtime MMX configuration, GRR 20010102] |
* |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD) |
static int mmx_supported=2; |
int PNGAPI |
png_mmx_support(void) |
{ |
int mmx_supported_local = 0; |
_asm { |
push ebx //CPUID will trash these |
push ecx |
push edx |
pushfd //Save Eflag to stack |
pop eax //Get Eflag from stack into eax |
mov ecx, eax //Make another copy of Eflag in ecx |
xor eax, 0x200000 //Toggle ID bit in Eflag [i.e. bit(21)] |
push eax //Save modified Eflag back to stack |
popfd //Restored modified value back to Eflag reg |
pushfd //Save Eflag to stack |
pop eax //Get Eflag from stack |
push ecx // save original Eflag to stack |
popfd // restore original Eflag |
xor eax, ecx //Compare the new Eflag with the original Eflag |
jz NOT_SUPPORTED //If the same, CPUID instruction is not supported, |
//skip following instructions and jump to |
//NOT_SUPPORTED label |
xor eax, eax //Set eax to zero |
_asm _emit 0x0f //CPUID instruction (two bytes opcode) |
_asm _emit 0xa2 |
cmp eax, 1 //make sure eax return non-zero value |
jl NOT_SUPPORTED //If eax is zero, mmx not supported |
xor eax, eax //set eax to zero |
inc eax //Now increment eax to 1. This instruction is |
//faster than the instruction "mov eax, 1" |
_asm _emit 0x0f //CPUID instruction |
_asm _emit 0xa2 |
and edx, 0x00800000 //mask out all bits but mmx bit(24) |
cmp edx, 0 // 0 = mmx not supported |
jz NOT_SUPPORTED // non-zero = Yes, mmx IS supported |
mov mmx_supported_local, 1 //set return value to 1 |
NOT_SUPPORTED: |
mov eax, mmx_supported_local //move return value to eax |
pop edx //CPUID trashed these |
pop ecx |
pop ebx |
} |
//mmx_supported_local=0; // test code for force don't support MMX |
//printf("MMX : %u (1=MMX supported)\n",mmx_supported_local); |
mmx_supported = mmx_supported_local; |
return mmx_supported_local; |
} |
/* Combines the row recently read in with the previous row. |
This routine takes care of alpha and transparency if requested. |
This routine also handles the two methods of progressive display |
of interlaced images, depending on the mask value. |
The mask value describes which pixels are to be combined with |
the row. The pattern always repeats every 8 pixels, so just 8 |
bits are needed. A one indicates the pixel is to be combined; a |
zero indicates the pixel is to be skipped. This is in addition |
to any alpha or transparency value associated with the pixel. If |
you want all pixels to be combined, pass 0xff (255) in mask. */ |
/* Use this routine for x86 platform - uses faster MMX routine if machine |
supports MMX */ |
void /* PRIVATE */ |
png_combine_row(png_structp png_ptr, png_bytep row, int mask) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
#endif |
png_debug(1,"in png_combine_row_asm\n"); |
if (mmx_supported == 2) { |
/* this should have happened in png_init_mmx_flags() already */ |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
png_mmx_support(); |
} |
if (mask == 0xff) |
{ |
png_memcpy(row, png_ptr->row_buf + 1, |
(png_size_t)((png_ptr->width * png_ptr->row_info.pixel_depth + 7) >> 3)); |
} |
/* GRR: add "else if (mask == 0)" case? |
* or does png_combine_row() not even get called in that case? */ |
else |
{ |
switch (png_ptr->row_info.pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp; |
png_bytep dp; |
int s_inc, s_start, s_end; |
int m; |
int shift; |
png_uint_32 i; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
else |
#endif |
{ |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
int value; |
value = (*sp >> shift) & 0x1; |
*dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp; |
png_bytep dp; |
int s_start, s_end, s_inc; |
int m; |
int shift; |
png_uint_32 i; |
int value; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
else |
#endif |
{ |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0x3; |
*dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp; |
png_bytep dp; |
int s_start, s_end, s_inc; |
int m; |
int shift; |
png_uint_32 i; |
int value; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
else |
#endif |
{ |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0xf; |
*dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 8: |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
png_uint_32 len; |
int m; |
int diff, unmask; |
__int64 mask0=0x0102040810204080; |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && mmx_supported */ ) |
{ |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
m = 0x80; |
unmask = ~mask; |
len = png_ptr->width &~7; //reduce to multiple of 8 |
diff = png_ptr->width & 7; //amount lost |
_asm |
{ |
movd mm7, unmask //load bit pattern |
psubb mm6,mm6 //zero mm6 |
punpcklbw mm7,mm7 |
punpcklwd mm7,mm7 |
punpckldq mm7,mm7 //fill register with 8 masks |
movq mm0,mask0 |
pand mm0,mm7 //nonzero if keep byte |
pcmpeqb mm0,mm6 //zeros->1s, v versa |
mov ecx,len //load length of line (pixels) |
mov esi,srcptr //load source |
mov ebx,dstptr //load dest |
cmp ecx,0 //lcr |
je mainloop8end |
mainloop8: |
movq mm4,[esi] |
pand mm4,mm0 |
movq mm6,mm0 |
pandn mm6,[ebx] |
por mm4,mm6 |
movq [ebx],mm4 |
add esi,8 //inc by 8 bytes processed |
add ebx,8 |
sub ecx,8 //dec by 8 pixels processed |
ja mainloop8 |
mainloop8end: |
mov ecx,diff |
cmp ecx,0 |
jz end8 |
mov edx,mask |
sal edx,24 //make low byte the high byte |
secondloop8: |
sal edx,1 //move high bit to CF |
jnc skip8 //if CF = 0 |
mov al,[esi] |
mov [ebx],al |
skip8: |
inc esi |
inc ebx |
dec ecx |
jnz secondloop8 |
end8: |
emms |
} |
} |
else /* mmx not supported - use modified C routine */ |
{ |
register unsigned int incr1, initial_val, final_val; |
png_size_t pixel_bytes; |
png_uint_32 i; |
register int disp = png_pass_inc[png_ptr->pass]; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dstptr, srcptr, pixel_bytes); |
srcptr += incr1; |
dstptr += incr1; |
} |
} /* end of else */ |
break; |
} // end 8 bpp |
case 16: |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
png_uint_32 len; |
int unmask, diff; |
__int64 mask1=0x0101020204040808, |
mask0=0x1010202040408080; |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && mmx_supported */ ) |
{ |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
unmask = ~mask; |
len = (png_ptr->width)&~7; |
diff = (png_ptr->width)&7; |
_asm |
{ |
movd mm7, unmask //load bit pattern |
psubb mm6,mm6 //zero mm6 |
punpcklbw mm7,mm7 |
punpcklwd mm7,mm7 |
punpckldq mm7,mm7 //fill register with 8 masks |
movq mm0,mask0 |
movq mm1,mask1 |
pand mm0,mm7 |
pand mm1,mm7 |
pcmpeqb mm0,mm6 |
pcmpeqb mm1,mm6 |
mov ecx,len //load length of line |
mov esi,srcptr //load source |
mov ebx,dstptr //load dest |
cmp ecx,0 //lcr |
jz mainloop16end |
mainloop16: |
movq mm4,[esi] |
pand mm4,mm0 |
movq mm6,mm0 |
movq mm7,[ebx] |
pandn mm6,mm7 |
por mm4,mm6 |
movq [ebx],mm4 |
movq mm5,[esi+8] |
pand mm5,mm1 |
movq mm7,mm1 |
movq mm6,[ebx+8] |
pandn mm7,mm6 |
por mm5,mm7 |
movq [ebx+8],mm5 |
add esi,16 //inc by 16 bytes processed |
add ebx,16 |
sub ecx,8 //dec by 8 pixels processed |
ja mainloop16 |
mainloop16end: |
mov ecx,diff |
cmp ecx,0 |
jz end16 |
mov edx,mask |
sal edx,24 //make low byte the high byte |
secondloop16: |
sal edx,1 //move high bit to CF |
jnc skip16 //if CF = 0 |
mov ax,[esi] |
mov [ebx],ax |
skip16: |
add esi,2 |
add ebx,2 |
dec ecx |
jnz secondloop16 |
end16: |
emms |
} |
} |
else /* mmx not supported - use modified C routine */ |
{ |
register unsigned int incr1, initial_val, final_val; |
png_size_t pixel_bytes; |
png_uint_32 i; |
register int disp = png_pass_inc[png_ptr->pass]; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dstptr, srcptr, pixel_bytes); |
srcptr += incr1; |
dstptr += incr1; |
} |
} /* end of else */ |
break; |
} // end 16 bpp |
case 24: |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
png_uint_32 len; |
int unmask, diff; |
__int64 mask2=0x0101010202020404, //24bpp |
mask1=0x0408080810101020, |
mask0=0x2020404040808080; |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
unmask = ~mask; |
len = (png_ptr->width)&~7; |
diff = (png_ptr->width)&7; |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && mmx_supported */ ) |
{ |
_asm |
{ |
movd mm7, unmask //load bit pattern |
psubb mm6,mm6 //zero mm6 |
punpcklbw mm7,mm7 |
punpcklwd mm7,mm7 |
punpckldq mm7,mm7 //fill register with 8 masks |
movq mm0,mask0 |
movq mm1,mask1 |
movq mm2,mask2 |
pand mm0,mm7 |
pand mm1,mm7 |
pand mm2,mm7 |
pcmpeqb mm0,mm6 |
pcmpeqb mm1,mm6 |
pcmpeqb mm2,mm6 |
mov ecx,len //load length of line |
mov esi,srcptr //load source |
mov ebx,dstptr //load dest |
cmp ecx,0 |
jz mainloop24end |
mainloop24: |
movq mm4,[esi] |
pand mm4,mm0 |
movq mm6,mm0 |
movq mm7,[ebx] |
pandn mm6,mm7 |
por mm4,mm6 |
movq [ebx],mm4 |
movq mm5,[esi+8] |
pand mm5,mm1 |
movq mm7,mm1 |
movq mm6,[ebx+8] |
pandn mm7,mm6 |
por mm5,mm7 |
movq [ebx+8],mm5 |
movq mm6,[esi+16] |
pand mm6,mm2 |
movq mm4,mm2 |
movq mm7,[ebx+16] |
pandn mm4,mm7 |
por mm6,mm4 |
movq [ebx+16],mm6 |
add esi,24 //inc by 24 bytes processed |
add ebx,24 |
sub ecx,8 //dec by 8 pixels processed |
ja mainloop24 |
mainloop24end: |
mov ecx,diff |
cmp ecx,0 |
jz end24 |
mov edx,mask |
sal edx,24 //make low byte the high byte |
secondloop24: |
sal edx,1 //move high bit to CF |
jnc skip24 //if CF = 0 |
mov ax,[esi] |
mov [ebx],ax |
xor eax,eax |
mov al,[esi+2] |
mov [ebx+2],al |
skip24: |
add esi,3 |
add ebx,3 |
dec ecx |
jnz secondloop24 |
end24: |
emms |
} |
} |
else /* mmx not supported - use modified C routine */ |
{ |
register unsigned int incr1, initial_val, final_val; |
png_size_t pixel_bytes; |
png_uint_32 i; |
register int disp = png_pass_inc[png_ptr->pass]; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dstptr, srcptr, pixel_bytes); |
srcptr += incr1; |
dstptr += incr1; |
} |
} /* end of else */ |
break; |
} // end 24 bpp |
case 32: |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
png_uint_32 len; |
int unmask, diff; |
__int64 mask3=0x0101010102020202, //32bpp |
mask2=0x0404040408080808, |
mask1=0x1010101020202020, |
mask0=0x4040404080808080; |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
unmask = ~mask; |
len = (png_ptr->width)&~7; |
diff = (png_ptr->width)&7; |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && mmx_supported */ ) |
{ |
_asm |
{ |
movd mm7, unmask //load bit pattern |
psubb mm6,mm6 //zero mm6 |
punpcklbw mm7,mm7 |
punpcklwd mm7,mm7 |
punpckldq mm7,mm7 //fill register with 8 masks |
movq mm0,mask0 |
movq mm1,mask1 |
movq mm2,mask2 |
movq mm3,mask3 |
pand mm0,mm7 |
pand mm1,mm7 |
pand mm2,mm7 |
pand mm3,mm7 |
pcmpeqb mm0,mm6 |
pcmpeqb mm1,mm6 |
pcmpeqb mm2,mm6 |
pcmpeqb mm3,mm6 |
mov ecx,len //load length of line |
mov esi,srcptr //load source |
mov ebx,dstptr //load dest |
cmp ecx,0 //lcr |
jz mainloop32end |
mainloop32: |
movq mm4,[esi] |
pand mm4,mm0 |
movq mm6,mm0 |
movq mm7,[ebx] |
pandn mm6,mm7 |
por mm4,mm6 |
movq [ebx],mm4 |
movq mm5,[esi+8] |
pand mm5,mm1 |
movq mm7,mm1 |
movq mm6,[ebx+8] |
pandn mm7,mm6 |
por mm5,mm7 |
movq [ebx+8],mm5 |
movq mm6,[esi+16] |
pand mm6,mm2 |
movq mm4,mm2 |
movq mm7,[ebx+16] |
pandn mm4,mm7 |
por mm6,mm4 |
movq [ebx+16],mm6 |
movq mm7,[esi+24] |
pand mm7,mm3 |
movq mm5,mm3 |
movq mm4,[ebx+24] |
pandn mm5,mm4 |
por mm7,mm5 |
movq [ebx+24],mm7 |
add esi,32 //inc by 32 bytes processed |
add ebx,32 |
sub ecx,8 //dec by 8 pixels processed |
ja mainloop32 |
mainloop32end: |
mov ecx,diff |
cmp ecx,0 |
jz end32 |
mov edx,mask |
sal edx,24 //make low byte the high byte |
secondloop32: |
sal edx,1 //move high bit to CF |
jnc skip32 //if CF = 0 |
mov eax,[esi] |
mov [ebx],eax |
skip32: |
add esi,4 |
add ebx,4 |
dec ecx |
jnz secondloop32 |
end32: |
emms |
} |
} |
else /* mmx _not supported - Use modified C routine */ |
{ |
register unsigned int incr1, initial_val, final_val; |
png_size_t pixel_bytes; |
png_uint_32 i; |
register int disp = png_pass_inc[png_ptr->pass]; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dstptr, srcptr, pixel_bytes); |
srcptr += incr1; |
dstptr += incr1; |
} |
} /* end of else */ |
break; |
} // end 32 bpp |
case 48: |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
png_uint_32 len; |
int unmask, diff; |
__int64 mask5=0x0101010101010202, |
mask4=0x0202020204040404, |
mask3=0x0404080808080808, |
mask2=0x1010101010102020, |
mask1=0x2020202040404040, |
mask0=0x4040808080808080; |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && mmx_supported */ ) |
{ |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
unmask = ~mask; |
len = (png_ptr->width)&~7; |
diff = (png_ptr->width)&7; |
_asm |
{ |
movd mm7, unmask //load bit pattern |
psubb mm6,mm6 //zero mm6 |
punpcklbw mm7,mm7 |
punpcklwd mm7,mm7 |
punpckldq mm7,mm7 //fill register with 8 masks |
movq mm0,mask0 |
movq mm1,mask1 |
movq mm2,mask2 |
movq mm3,mask3 |
movq mm4,mask4 |
movq mm5,mask5 |
pand mm0,mm7 |
pand mm1,mm7 |
pand mm2,mm7 |
pand mm3,mm7 |
pand mm4,mm7 |
pand mm5,mm7 |
pcmpeqb mm0,mm6 |
pcmpeqb mm1,mm6 |
pcmpeqb mm2,mm6 |
pcmpeqb mm3,mm6 |
pcmpeqb mm4,mm6 |
pcmpeqb mm5,mm6 |
mov ecx,len //load length of line |
mov esi,srcptr //load source |
mov ebx,dstptr //load dest |
cmp ecx,0 |
jz mainloop48end |
mainloop48: |
movq mm7,[esi] |
pand mm7,mm0 |
movq mm6,mm0 |
pandn mm6,[ebx] |
por mm7,mm6 |
movq [ebx],mm7 |
movq mm6,[esi+8] |
pand mm6,mm1 |
movq mm7,mm1 |
pandn mm7,[ebx+8] |
por mm6,mm7 |
movq [ebx+8],mm6 |
movq mm6,[esi+16] |
pand mm6,mm2 |
movq mm7,mm2 |
pandn mm7,[ebx+16] |
por mm6,mm7 |
movq [ebx+16],mm6 |
movq mm7,[esi+24] |
pand mm7,mm3 |
movq mm6,mm3 |
pandn mm6,[ebx+24] |
por mm7,mm6 |
movq [ebx+24],mm7 |
movq mm6,[esi+32] |
pand mm6,mm4 |
movq mm7,mm4 |
pandn mm7,[ebx+32] |
por mm6,mm7 |
movq [ebx+32],mm6 |
movq mm7,[esi+40] |
pand mm7,mm5 |
movq mm6,mm5 |
pandn mm6,[ebx+40] |
por mm7,mm6 |
movq [ebx+40],mm7 |
add esi,48 //inc by 32 bytes processed |
add ebx,48 |
sub ecx,8 //dec by 8 pixels processed |
ja mainloop48 |
mainloop48end: |
mov ecx,diff |
cmp ecx,0 |
jz end48 |
mov edx,mask |
sal edx,24 //make low byte the high byte |
secondloop48: |
sal edx,1 //move high bit to CF |
jnc skip48 //if CF = 0 |
mov eax,[esi] |
mov [ebx],eax |
skip48: |
add esi,4 |
add ebx,4 |
dec ecx |
jnz secondloop48 |
end48: |
emms |
} |
} |
else /* mmx _not supported - Use modified C routine */ |
{ |
register unsigned int incr1, initial_val, final_val; |
png_size_t pixel_bytes; |
png_uint_32 i; |
register int disp = png_pass_inc[png_ptr->pass]; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
srcptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dstptr = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dstptr, srcptr, pixel_bytes); |
srcptr += incr1; |
dstptr += incr1; |
} |
} /* end of else */ |
break; |
} // end 48 bpp |
default: |
{ |
png_bytep sptr; |
png_bytep dp; |
png_size_t pixel_bytes; |
int offset_table[7] = {0, 4, 0, 2, 0, 1, 0}; |
unsigned int i; |
register int disp = png_pass_inc[png_ptr->pass]; // get the offset |
register unsigned int incr1, initial_val, final_val; |
pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
sptr = png_ptr->row_buf + 1 + offset_table[png_ptr->pass]* |
pixel_bytes; |
dp = row + offset_table[png_ptr->pass]*pixel_bytes; |
initial_val = offset_table[png_ptr->pass]*pixel_bytes; |
final_val = png_ptr->width*pixel_bytes; |
incr1 = (disp)*pixel_bytes; |
for (i = initial_val; i < final_val; i += incr1) |
{ |
png_memcpy(dp, sptr, pixel_bytes); |
sptr += incr1; |
dp += incr1; |
} |
break; |
} |
} /* end switch (png_ptr->row_info.pixel_depth) */ |
} /* end if (non-trivial mask) */ |
} /* end png_combine_row() */ |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
void /* PRIVATE */ |
png_do_read_interlace(png_structp png_ptr) |
{ |
png_row_infop row_info = &(png_ptr->row_info); |
png_bytep row = png_ptr->row_buf + 1; |
int pass = png_ptr->pass; |
png_uint_32 transformations = png_ptr->transformations; |
#ifdef PNG_USE_LOCAL_ARRAYS |
const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
#endif |
png_debug(1,"in png_do_read_interlace\n"); |
if (mmx_supported == 2) { |
/* this should have happened in png_init_mmx_flags() already */ |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
png_mmx_support(); |
} |
if (row != NULL && row_info != NULL) |
{ |
png_uint_32 final_width; |
final_width = row_info->width * png_pass_inc[pass]; |
switch (row_info->pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_byte v; |
png_uint_32 i; |
int j; |
sp = row + (png_size_t)((row_info->width - 1) >> 3); |
dp = row + (png_size_t)((final_width - 1) >> 3); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (int)((row_info->width + 7) & 7); |
dshift = (int)((final_width + 7) & 7); |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
else |
#endif |
{ |
sshift = 7 - (int)((row_info->width + 7) & 7); |
dshift = 7 - (int)((final_width + 7) & 7); |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
for (i = row_info->width; i; i--) |
{ |
v = (png_byte)((*sp >> sshift) & 0x1); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_uint_32 i; |
sp = row + (png_size_t)((row_info->width - 1) >> 2); |
dp = row + (png_size_t)((final_width - 1) >> 2); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (png_size_t)(((row_info->width + 3) & 3) << 1); |
dshift = (png_size_t)(((final_width + 3) & 3) << 1); |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
else |
#endif |
{ |
sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1); |
dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1); |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
for (i = row_info->width; i; i--) |
{ |
png_byte v; |
int j; |
v = (png_byte)((*sp >> sshift) & 0x3); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_uint_32 i; |
sp = row + (png_size_t)((row_info->width - 1) >> 1); |
dp = row + (png_size_t)((final_width - 1) >> 1); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (png_size_t)(((row_info->width + 1) & 1) << 2); |
dshift = (png_size_t)(((final_width + 1) & 1) << 2); |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
else |
#endif |
{ |
sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2); |
dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2); |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
for (i = row_info->width; i; i--) |
{ |
png_byte v; |
int j; |
v = (png_byte)((*sp >> sshift) & 0xf); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
default: // This is the place where the routine is modified |
{ |
__int64 const4 = 0x0000000000FFFFFF; |
// __int64 const5 = 0x000000FFFFFF0000; // unused... |
__int64 const6 = 0x00000000000000FF; |
png_bytep sptr, dp; |
png_uint_32 i; |
png_size_t pixel_bytes; |
int width = row_info->width; |
pixel_bytes = (row_info->pixel_depth >> 3); |
sptr = row + (width - 1) * pixel_bytes; |
dp = row + (final_width - 1) * pixel_bytes; |
// New code by Nirav Chhatrapati - Intel Corporation |
// sign fix by GRR |
// NOTE: there is NO MMX code for 48-bit and 64-bit images |
// use MMX routine if machine supports it |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE) |
/* && mmx_supported */ ) |
{ |
if (pixel_bytes == 3) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width |
sub edi, 21 // (png_pass_inc[pass] - 1)*pixel_bytes |
loop_pass0: |
movd mm0, [esi] ; X X X X X v2 v1 v0 |
pand mm0, const4 ; 0 0 0 0 0 v2 v1 v0 |
movq mm1, mm0 ; 0 0 0 0 0 v2 v1 v0 |
psllq mm0, 16 ; 0 0 0 v2 v1 v0 0 0 |
movq mm2, mm0 ; 0 0 0 v2 v1 v0 0 0 |
psllq mm0, 24 ; v2 v1 v0 0 0 0 0 0 |
psrlq mm1, 8 ; 0 0 0 0 0 0 v2 v1 |
por mm0, mm2 ; v2 v1 v0 v2 v1 v0 0 0 |
por mm0, mm1 ; v2 v1 v0 v2 v1 v0 v2 v1 |
movq mm3, mm0 ; v2 v1 v0 v2 v1 v0 v2 v1 |
psllq mm0, 16 ; v0 v2 v1 v0 v2 v1 0 0 |
movq mm4, mm3 ; v2 v1 v0 v2 v1 v0 v2 v1 |
punpckhdq mm3, mm0 ; v0 v2 v1 v0 v2 v1 v0 v2 |
movq [edi+16] , mm4 |
psrlq mm0, 32 ; 0 0 0 0 v0 v2 v1 v0 |
movq [edi+8] , mm3 |
punpckldq mm0, mm4 ; v1 v0 v2 v1 v0 v2 v1 v0 |
sub esi, 3 |
movq [edi], mm0 |
sub edi, 24 |
//sub esi, 3 |
dec ecx |
jnz loop_pass0 |
EMMS |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width |
sub edi, 9 // (png_pass_inc[pass] - 1)*pixel_bytes |
loop_pass2: |
movd mm0, [esi] ; X X X X X v2 v1 v0 |
pand mm0, const4 ; 0 0 0 0 0 v2 v1 v0 |
movq mm1, mm0 ; 0 0 0 0 0 v2 v1 v0 |
psllq mm0, 16 ; 0 0 0 v2 v1 v0 0 0 |
movq mm2, mm0 ; 0 0 0 v2 v1 v0 0 0 |
psllq mm0, 24 ; v2 v1 v0 0 0 0 0 0 |
psrlq mm1, 8 ; 0 0 0 0 0 0 v2 v1 |
por mm0, mm2 ; v2 v1 v0 v2 v1 v0 0 0 |
por mm0, mm1 ; v2 v1 v0 v2 v1 v0 v2 v1 |
movq [edi+4], mm0 ; move to memory |
psrlq mm0, 16 ; 0 0 v2 v1 v0 v2 v1 v0 |
movd [edi], mm0 ; move to memory |
sub esi, 3 |
sub edi, 12 |
dec ecx |
jnz loop_pass2 |
EMMS |
} |
} |
else if (width) /* && ((pass == 4) || (pass == 5)) */ |
{ |
int width_mmx = ((width >> 1) << 1) - 8; |
if (width_mmx < 0) |
width_mmx = 0; |
width -= width_mmx; // 8 or 9 pix, 24 or 27 bytes |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 3 |
sub edi, 9 |
loop_pass4: |
movq mm0, [esi] ; X X v2 v1 v0 v5 v4 v3 |
movq mm7, mm0 ; X X v2 v1 v0 v5 v4 v3 |
movq mm6, mm0 ; X X v2 v1 v0 v5 v4 v3 |
psllq mm0, 24 ; v1 v0 v5 v4 v3 0 0 0 |
pand mm7, const4 ; 0 0 0 0 0 v5 v4 v3 |
psrlq mm6, 24 ; 0 0 0 X X v2 v1 v0 |
por mm0, mm7 ; v1 v0 v5 v4 v3 v5 v4 v3 |
movq mm5, mm6 ; 0 0 0 X X v2 v1 v0 |
psllq mm6, 8 ; 0 0 X X v2 v1 v0 0 |
movq [edi], mm0 ; move quad to memory |
psrlq mm5, 16 ; 0 0 0 0 0 X X v2 |
pand mm5, const6 ; 0 0 0 0 0 0 0 v2 |
por mm6, mm5 ; 0 0 X X v2 v1 v0 v2 |
movd [edi+8], mm6 ; move double to memory |
sub esi, 6 |
sub edi, 12 |
sub ecx, 2 |
jnz loop_pass4 |
EMMS |
} |
} |
sptr -= width_mmx*3; |
dp -= width_mmx*6; |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 3); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 3); |
dp -= 3; |
} |
sptr -= 3; |
} |
} |
} /* end of pixel_bytes == 3 */ |
else if (pixel_bytes == 1) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 2) << 2); |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub edi, 31 |
sub esi, 3 |
loop1_pass0: |
movd mm0, [esi] ; X X X X v0 v1 v2 v3 |
movq mm1, mm0 ; X X X X v0 v1 v2 v3 |
punpcklbw mm0, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 |
movq mm2, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 |
punpcklwd mm0, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 |
movq mm3, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 |
punpckldq mm0, mm0 ; v3 v3 v3 v3 v3 v3 v3 v3 |
punpckhdq mm3, mm3 ; v2 v2 v2 v2 v2 v2 v2 v2 |
movq [edi], mm0 ; move to memory v3 |
punpckhwd mm2, mm2 ; v0 v0 v0 v0 v1 v1 v1 v1 |
movq [edi+8], mm3 ; move to memory v2 |
movq mm4, mm2 ; v0 v0 v0 v0 v1 v1 v1 v1 |
punpckldq mm2, mm2 ; v1 v1 v1 v1 v1 v1 v1 v1 |
punpckhdq mm4, mm4 ; v0 v0 v0 v0 v0 v0 v0 v0 |
movq [edi+16], mm2 ; move to memory v1 |
movq [edi+24], mm4 ; move to memory v0 |
sub esi, 4 |
sub edi, 32 |
sub ecx, 4 |
jnz loop1_pass0 |
EMMS |
} |
} |
sptr -= width_mmx; |
dp -= width_mmx*8; |
for (i = width; i; i--) |
{ |
int j; |
/* I simplified this part in version 1.0.4e |
* here and in several other instances where |
* pixel_bytes == 1 -- GR-P |
* |
* Original code: |
* |
* png_byte v[8]; |
* png_memcpy(v, sptr, pixel_bytes); |
* for (j = 0; j < png_pass_inc[pass]; j++) |
* { |
* png_memcpy(dp, v, pixel_bytes); |
* dp -= pixel_bytes; |
* } |
* sptr -= pixel_bytes; |
* |
* Replacement code is in the next three lines: |
*/ |
for (j = 0; j < png_pass_inc[pass]; j++) |
*dp-- = *sptr; |
sptr--; |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 2) << 2); |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub edi, 15 |
sub esi, 3 |
loop1_pass2: |
movd mm0, [esi] ; X X X X v0 v1 v2 v3 |
punpcklbw mm0, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 |
movq mm1, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 |
punpcklwd mm0, mm0 ; v2 v2 v2 v2 v3 v3 v3 v3 |
punpckhwd mm1, mm1 ; v0 v0 v0 v0 v1 v1 v1 v1 |
movq [edi], mm0 ; move to memory v2 and v3 |
sub esi, 4 |
movq [edi+8], mm1 ; move to memory v1 and v0 |
sub edi, 16 |
sub ecx, 4 |
jnz loop1_pass2 |
EMMS |
} |
} |
sptr -= width_mmx; |
dp -= width_mmx*4; |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
sptr --; |
} |
} |
else if (width) /* && ((pass == 4) || (pass == 5))) */ |
{ |
int width_mmx = ((width >> 3) << 3); |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub edi, 15 |
sub esi, 7 |
loop1_pass4: |
movq mm0, [esi] ; v0 v1 v2 v3 v4 v5 v6 v7 |
movq mm1, mm0 ; v0 v1 v2 v3 v4 v5 v6 v7 |
punpcklbw mm0, mm0 ; v4 v4 v5 v5 v6 v6 v7 v7 |
//movq mm1, mm0 ; v0 v0 v1 v1 v2 v2 v3 v3 |
punpckhbw mm1, mm1 ;v0 v0 v1 v1 v2 v2 v3 v3 |
movq [edi+8], mm1 ; move to memory v0 v1 v2 and v3 |
sub esi, 8 |
movq [edi], mm0 ; move to memory v4 v5 v6 and v7 |
//sub esi, 4 |
sub edi, 16 |
sub ecx, 8 |
jnz loop1_pass4 |
EMMS |
} |
} |
sptr -= width_mmx; |
dp -= width_mmx*2; |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
sptr --; |
} |
} |
} /* end of pixel_bytes == 1 */ |
else if (pixel_bytes == 2) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 1) << 1); |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 2 |
sub edi, 30 |
loop2_pass0: |
movd mm0, [esi] ; X X X X v1 v0 v3 v2 |
punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 |
movq mm1, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 |
punpckldq mm0, mm0 ; v3 v2 v3 v2 v3 v2 v3 v2 |
punpckhdq mm1, mm1 ; v1 v0 v1 v0 v1 v0 v1 v0 |
movq [edi], mm0 |
movq [edi + 8], mm0 |
movq [edi + 16], mm1 |
movq [edi + 24], mm1 |
sub esi, 4 |
sub edi, 32 |
sub ecx, 2 |
jnz loop2_pass0 |
EMMS |
} |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*16 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 2 |
sub edi, 14 |
loop2_pass2: |
movd mm0, [esi] ; X X X X v1 v0 v3 v2 |
punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 |
movq mm1, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 |
punpckldq mm0, mm0 ; v3 v2 v3 v2 v3 v2 v3 v2 |
punpckhdq mm1, mm1 ; v1 v0 v1 v0 v1 v0 v1 v0 |
movq [edi], mm0 |
sub esi, 4 |
movq [edi + 8], mm1 |
//sub esi, 4 |
sub edi, 16 |
sub ecx, 2 |
jnz loop2_pass2 |
EMMS |
} |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*8 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
else if (width) // pass == 4 or 5 |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 2 |
sub edi, 6 |
loop2_pass4: |
movd mm0, [esi] ; X X X X v1 v0 v3 v2 |
punpcklwd mm0, mm0 ; v1 v0 v1 v0 v3 v2 v3 v2 |
sub esi, 4 |
movq [edi], mm0 |
sub edi, 8 |
sub ecx, 2 |
jnz loop2_pass4 |
EMMS |
} |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*4 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
} /* end of pixel_bytes == 2 */ |
else if (pixel_bytes == 4) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 4 |
sub edi, 60 |
loop4_pass0: |
movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 |
movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 |
punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 |
punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 |
movq [edi], mm0 |
movq [edi + 8], mm0 |
movq [edi + 16], mm0 |
movq [edi + 24], mm0 |
movq [edi+32], mm1 |
movq [edi + 40], mm1 |
movq [edi+ 48], mm1 |
sub esi, 8 |
movq [edi + 56], mm1 |
sub edi, 64 |
sub ecx, 2 |
jnz loop4_pass0 |
EMMS |
} |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*32 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 4 |
sub edi, 28 |
loop4_pass2: |
movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 |
movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 |
punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 |
punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 |
movq [edi], mm0 |
movq [edi + 8], mm0 |
movq [edi+16], mm1 |
movq [edi + 24], mm1 |
sub esi, 8 |
sub edi, 32 |
sub ecx, 2 |
jnz loop4_pass2 |
EMMS |
} |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*16 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
else if (width) // pass == 4 or 5 |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; |
if (width_mmx) |
{ |
_asm |
{ |
mov esi, sptr |
mov edi, dp |
mov ecx, width_mmx |
sub esi, 4 |
sub edi, 12 |
loop4_pass4: |
movq mm0, [esi] ; v3 v2 v1 v0 v7 v6 v5 v4 |
movq mm1, mm0 ; v3 v2 v1 v0 v7 v6 v5 v4 |
punpckldq mm0, mm0 ; v7 v6 v5 v4 v7 v6 v5 v4 |
punpckhdq mm1, mm1 ; v3 v2 v1 v0 v3 v2 v1 v0 |
movq [edi], mm0 |
sub esi, 8 |
movq [edi + 8], mm1 |
sub edi, 16 |
sub ecx, 2 |
jnz loop4_pass4 |
EMMS |
} |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*8 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
} /* end of pixel_bytes == 4 */ |
else if (pixel_bytes == 6) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 6); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 6); |
dp -= 6; |
} |
sptr -= 6; |
} |
} /* end of pixel_bytes == 6 */ |
else |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr-= pixel_bytes; |
} |
} |
} /* end of mmx_supported */ |
else /* MMX not supported: use modified C code - takes advantage |
* of inlining of memcpy for a constant */ |
{ |
if (pixel_bytes == 1) |
{ |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
*dp-- = *sptr; |
sptr--; |
} |
} |
else if (pixel_bytes == 3) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
else if (pixel_bytes == 2) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
else if (pixel_bytes == 4) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
else if (pixel_bytes == 6) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
else |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
} /* end of MMX not supported */ |
break; |
} |
} /* end switch (row_info->pixel_depth) */ |
row_info->width = final_width; |
row_info->rowbytes = ((final_width * |
(png_uint_32)row_info->pixel_depth + 7) >> 3); |
} |
} |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
// These variables are utilized in the functions below. They are declared |
// globally here to ensure alignment on 8-byte boundaries. |
union uAll { |
__int64 use; |
double align; |
} LBCarryMask = {0x0101010101010101}, |
HBClearMask = {0x7f7f7f7f7f7f7f7f}, |
ActiveMask, ActiveMask2, ActiveMaskEnd, ShiftBpp, ShiftRem; |
// Optimized code for PNG Average filter decoder |
void /* PRIVATE */ |
png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row |
, png_bytep prev_row) |
{ |
int bpp; |
png_uint_32 FullLength; |
png_uint_32 MMXLength; |
//png_uint_32 len; |
int diff; |
bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel |
FullLength = row_info->rowbytes; // # of bytes to filter |
_asm { |
// Init address pointers and offset |
mov edi, row // edi ==> Avg(x) |
xor ebx, ebx // ebx ==> x |
mov edx, edi |
mov esi, prev_row // esi ==> Prior(x) |
sub edx, bpp // edx ==> Raw(x-bpp) |
xor eax, eax |
// Compute the Raw value for the first bpp bytes |
// Raw(x) = Avg(x) + (Prior(x)/2) |
davgrlp: |
mov al, [esi + ebx] // Load al with Prior(x) |
inc ebx |
shr al, 1 // divide by 2 |
add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx |
cmp ebx, bpp |
mov [edi+ebx-1], al // Write back Raw(x); |
// mov does not affect flags; -1 to offset inc ebx |
jb davgrlp |
// get # of bytes to alignment |
mov diff, edi // take start of row |
add diff, ebx // add bpp |
add diff, 0xf // add 7 + 8 to incr past alignment boundary |
and diff, 0xfffffff8 // mask to alignment boundary |
sub diff, edi // subtract from start ==> value ebx at alignment |
jz davggo |
// fix alignment |
// Compute the Raw value for the bytes upto the alignment boundary |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
xor ecx, ecx |
davglp1: |
xor eax, eax |
mov cl, [esi + ebx] // load cl with Prior(x) |
mov al, [edx + ebx] // load al with Raw(x-bpp) |
add ax, cx |
inc ebx |
shr ax, 1 // divide by 2 |
add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx |
cmp ebx, diff // Check if at alignment boundary |
mov [edi+ebx-1], al // Write back Raw(x); |
// mov does not affect flags; -1 to offset inc ebx |
jb davglp1 // Repeat until at alignment boundary |
davggo: |
mov eax, FullLength |
mov ecx, eax |
sub eax, ebx // subtract alignment fix |
and eax, 0x00000007 // calc bytes over mult of 8 |
sub ecx, eax // drop over bytes from original length |
mov MMXLength, ecx |
} // end _asm block |
// Now do the math for the rest of the row |
switch ( bpp ) |
{ |
case 3: |
{ |
ActiveMask.use = 0x0000000000ffffff; |
ShiftBpp.use = 24; // == 3 * 8 |
ShiftRem.use = 40; // == 64 - 24 |
_asm { |
// Re-init address pointers and offset |
movq mm7, ActiveMask |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
movq mm5, LBCarryMask |
mov edi, row // edi ==> Avg(x) |
movq mm4, HBClearMask |
mov esi, prev_row // esi ==> Prior(x) |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes |
// (we correct position in loop below) |
davg3lp: |
movq mm0, [edi + ebx] // Load mm0 with Avg(x) |
// Add (Prev_row/2) to Average |
movq mm3, mm5 |
psrlq mm2, ShiftRem // Correct position Raw(x-bpp) data |
movq mm1, [esi + ebx] // Load mm1 with Prior(x) |
movq mm6, mm7 |
pand mm3, mm1 // get lsb for each prev_row byte |
psrlq mm1, 1 // divide prev_row bytes by 2 |
pand mm1, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte |
// Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 1 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active |
// byte |
// Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry |
psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 3-5 |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active |
// byte |
// Add 3rd active group (Raw(x-bpp)/2) to Average with LBCarry |
psllq mm6, ShiftBpp // shift the mm6 mask to cover the last two |
// bytes |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
// Data only needs to be shifted once here to |
// get the correct x-bpp offset. |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
add ebx, 8 |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active |
// byte |
// Now ready to write back to memory |
movq [edi + ebx - 8], mm0 |
// Move updated Raw(x) to use as Raw(x-bpp) for next loop |
cmp ebx, MMXLength |
movq mm2, mm0 // mov updated Raw(x) to mm2 |
jb davg3lp |
} // end _asm block |
} |
break; |
case 6: |
case 4: |
case 7: |
case 5: |
{ |
ActiveMask.use = 0xffffffffffffffff; // use shift below to clear |
// appropriate inactive bytes |
ShiftBpp.use = bpp << 3; |
ShiftRem.use = 64 - ShiftBpp.use; |
_asm { |
movq mm4, HBClearMask |
// Re-init address pointers and offset |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
// Load ActiveMask and clear all bytes except for 1st active group |
movq mm7, ActiveMask |
mov edi, row // edi ==> Avg(x) |
psrlq mm7, ShiftRem |
mov esi, prev_row // esi ==> Prior(x) |
movq mm6, mm7 |
movq mm5, LBCarryMask |
psllq mm6, ShiftBpp // Create mask for 2nd active group |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes |
// (we correct position in loop below) |
davg4lp: |
movq mm0, [edi + ebx] |
psrlq mm2, ShiftRem // shift data to position correctly |
movq mm1, [esi + ebx] |
// Add (Prev_row/2) to Average |
movq mm3, mm5 |
pand mm3, mm1 // get lsb for each prev_row byte |
psrlq mm1, 1 // divide prev_row bytes by 2 |
pand mm1, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte |
// Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm7 // Leave only Active Group 1 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active |
// byte |
// Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
add ebx, 8 |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active |
// byte |
cmp ebx, MMXLength |
// Now ready to write back to memory |
movq [edi + ebx - 8], mm0 |
// Prep Raw(x-bpp) for next loop |
movq mm2, mm0 // mov updated Raws to mm2 |
jb davg4lp |
} // end _asm block |
} |
break; |
case 2: |
{ |
ActiveMask.use = 0x000000000000ffff; |
ShiftBpp.use = 16; // == 2 * 8 [BUGFIX] |
ShiftRem.use = 48; // == 64 - 16 [BUGFIX] |
_asm { |
// Load ActiveMask |
movq mm7, ActiveMask |
// Re-init address pointers and offset |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
movq mm5, LBCarryMask |
mov edi, row // edi ==> Avg(x) |
movq mm4, HBClearMask |
mov esi, prev_row // esi ==> Prior(x) |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes |
// (we correct position in loop below) |
davg2lp: |
movq mm0, [edi + ebx] |
psrlq mm2, ShiftRem // shift data to position correctly [BUGFIX] |
movq mm1, [esi + ebx] |
// Add (Prev_row/2) to Average |
movq mm3, mm5 |
pand mm3, mm1 // get lsb for each prev_row byte |
psrlq mm1, 1 // divide prev_row bytes by 2 |
pand mm1, mm4 // clear invalid bit 7 of each byte |
movq mm6, mm7 |
paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte |
// Add 1st active group (Raw(x-bpp)/2) to Average with LBCarry |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 1 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte |
// Add 2nd active group (Raw(x-bpp)/2) to Average with LBCarry |
psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 2 & 3 |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte |
// Add rdd active group (Raw(x-bpp)/2) to Average with LBCarry |
psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 4 & 5 |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
// Data only needs to be shifted once here to |
// get the correct x-bpp offset. |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte |
// Add 4th active group (Raw(x-bpp)/2) to Average with LBCarry |
psllq mm6, ShiftBpp // shift the mm6 mask to cover bytes 6 & 7 |
movq mm2, mm0 // mov updated Raws to mm2 |
psllq mm2, ShiftBpp // shift data to position correctly |
// Data only needs to be shifted once here to |
// get the correct x-bpp offset. |
add ebx, 8 |
movq mm1, mm3 // now use mm1 for getting LBCarrys |
pand mm1, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 (Only valid for active group) |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm2, mm1 // add LBCarrys to (Raw(x-bpp)/2) for each byte |
pand mm2, mm6 // Leave only Active Group 2 bytes to add to Avg |
paddb mm0, mm2 // add (Raw/2) + LBCarrys to Avg for each Active byte |
cmp ebx, MMXLength |
// Now ready to write back to memory |
movq [edi + ebx - 8], mm0 |
// Prep Raw(x-bpp) for next loop |
movq mm2, mm0 // mov updated Raws to mm2 |
jb davg2lp |
} // end _asm block |
} |
break; |
case 1: // bpp == 1 |
{ |
_asm { |
// Re-init address pointers and offset |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
mov edi, row // edi ==> Avg(x) |
cmp ebx, FullLength // Test if offset at end of array |
jnb davg1end |
// Do Paeth decode for remaining bytes |
mov esi, prev_row // esi ==> Prior(x) |
mov edx, edi |
xor ecx, ecx // zero ecx before using cl & cx in loop below |
sub edx, bpp // edx ==> Raw(x-bpp) |
davg1lp: |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
xor eax, eax |
mov cl, [esi + ebx] // load cl with Prior(x) |
mov al, [edx + ebx] // load al with Raw(x-bpp) |
add ax, cx |
inc ebx |
shr ax, 1 // divide by 2 |
add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx |
cmp ebx, FullLength // Check if at end of array |
mov [edi+ebx-1], al // Write back Raw(x); |
// mov does not affect flags; -1 to offset inc ebx |
jb davg1lp |
davg1end: |
} // end _asm block |
} |
return; |
case 8: // bpp == 8 |
{ |
_asm { |
// Re-init address pointers and offset |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
movq mm5, LBCarryMask |
mov edi, row // edi ==> Avg(x) |
movq mm4, HBClearMask |
mov esi, prev_row // esi ==> Prior(x) |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm2, [edi + ebx - 8] // Load previous aligned 8 bytes |
// (NO NEED to correct position in loop below) |
davg8lp: |
movq mm0, [edi + ebx] |
movq mm3, mm5 |
movq mm1, [esi + ebx] |
add ebx, 8 |
pand mm3, mm1 // get lsb for each prev_row byte |
psrlq mm1, 1 // divide prev_row bytes by 2 |
pand mm3, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm1, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm3 // add LBCarrys to Avg for each byte |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte |
paddb mm0, mm2 // add (Raw/2) to Avg for each byte |
cmp ebx, MMXLength |
movq [edi + ebx - 8], mm0 |
movq mm2, mm0 // reuse as Raw(x-bpp) |
jb davg8lp |
} // end _asm block |
} |
break; |
default: // bpp greater than 8 |
{ |
_asm { |
movq mm5, LBCarryMask |
// Re-init address pointers and offset |
mov ebx, diff // ebx ==> x = offset to alignment boundary |
mov edi, row // edi ==> Avg(x) |
movq mm4, HBClearMask |
mov edx, edi |
mov esi, prev_row // esi ==> Prior(x) |
sub edx, bpp // edx ==> Raw(x-bpp) |
davgAlp: |
movq mm0, [edi + ebx] |
movq mm3, mm5 |
movq mm1, [esi + ebx] |
pand mm3, mm1 // get lsb for each prev_row byte |
movq mm2, [edx + ebx] |
psrlq mm1, 1 // divide prev_row bytes by 2 |
pand mm3, mm2 // get LBCarrys for each byte where both |
// lsb's were == 1 |
psrlq mm2, 1 // divide raw bytes by 2 |
pand mm1, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm3 // add LBCarrys to Avg for each byte |
pand mm2, mm4 // clear invalid bit 7 of each byte |
paddb mm0, mm1 // add (Prev_row/2) to Avg for each byte |
add ebx, 8 |
paddb mm0, mm2 // add (Raw/2) to Avg for each byte |
cmp ebx, MMXLength |
movq [edi + ebx - 8], mm0 |
jb davgAlp |
} // end _asm block |
} |
break; |
} // end switch ( bpp ) |
_asm { |
// MMX acceleration complete now do clean-up |
// Check if any remaining bytes left to decode |
mov ebx, MMXLength // ebx ==> x = offset bytes remaining after MMX |
mov edi, row // edi ==> Avg(x) |
cmp ebx, FullLength // Test if offset at end of array |
jnb davgend |
// Do Paeth decode for remaining bytes |
mov esi, prev_row // esi ==> Prior(x) |
mov edx, edi |
xor ecx, ecx // zero ecx before using cl & cx in loop below |
sub edx, bpp // edx ==> Raw(x-bpp) |
davglp2: |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
xor eax, eax |
mov cl, [esi + ebx] // load cl with Prior(x) |
mov al, [edx + ebx] // load al with Raw(x-bpp) |
add ax, cx |
inc ebx |
shr ax, 1 // divide by 2 |
add al, [edi+ebx-1] // Add Avg(x); -1 to offset inc ebx |
cmp ebx, FullLength // Check if at end of array |
mov [edi+ebx-1], al // Write back Raw(x); |
// mov does not affect flags; -1 to offset inc ebx |
jb davglp2 |
davgend: |
emms // End MMX instructions; prep for possible FP instrs. |
} // end _asm block |
} |
// Optimized code for PNG Paeth filter decoder |
void /* PRIVATE */ |
png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row, |
png_bytep prev_row) |
{ |
png_uint_32 FullLength; |
png_uint_32 MMXLength; |
//png_uint_32 len; |
int bpp; |
int diff; |
//int ptemp; |
int patemp, pbtemp, pctemp; |
bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel |
FullLength = row_info->rowbytes; // # of bytes to filter |
_asm |
{ |
xor ebx, ebx // ebx ==> x offset |
mov edi, row |
xor edx, edx // edx ==> x-bpp offset |
mov esi, prev_row |
xor eax, eax |
// Compute the Raw value for the first bpp bytes |
// Note: the formula works out to be always |
// Paeth(x) = Raw(x) + Prior(x) where x < bpp |
dpthrlp: |
mov al, [edi + ebx] |
add al, [esi + ebx] |
inc ebx |
cmp ebx, bpp |
mov [edi + ebx - 1], al |
jb dpthrlp |
// get # of bytes to alignment |
mov diff, edi // take start of row |
add diff, ebx // add bpp |
xor ecx, ecx |
add diff, 0xf // add 7 + 8 to incr past alignment boundary |
and diff, 0xfffffff8 // mask to alignment boundary |
sub diff, edi // subtract from start ==> value ebx at alignment |
jz dpthgo |
// fix alignment |
dpthlp1: |
xor eax, eax |
// pav = p - a = (a + b - c) - a = b - c |
mov al, [esi + ebx] // load Prior(x) into al |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
sub eax, ecx // subtract Prior(x-bpp) |
mov patemp, eax // Save pav for later use |
xor eax, eax |
// pbv = p - b = (a + b - c) - b = a - c |
mov al, [edi + edx] // load Raw(x-bpp) into al |
sub eax, ecx // subtract Prior(x-bpp) |
mov ecx, eax |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
add eax, patemp // pcv = pav + pbv |
// pc = abs(pcv) |
test eax, 0x80000000 |
jz dpthpca |
neg eax // reverse sign of neg values |
dpthpca: |
mov pctemp, eax // save pc for later use |
// pb = abs(pbv) |
test ecx, 0x80000000 |
jz dpthpba |
neg ecx // reverse sign of neg values |
dpthpba: |
mov pbtemp, ecx // save pb for later use |
// pa = abs(pav) |
mov eax, patemp |
test eax, 0x80000000 |
jz dpthpaa |
neg eax // reverse sign of neg values |
dpthpaa: |
mov patemp, eax // save pa for later use |
// test if pa <= pb |
cmp eax, ecx |
jna dpthabb |
// pa > pb; now test if pb <= pc |
cmp ecx, pctemp |
jna dpthbbc |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthpaeth |
dpthbbc: |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
mov cl, [esi + ebx] // load Prior(x) into cl |
jmp dpthpaeth |
dpthabb: |
// pa <= pb; now test if pa <= pc |
cmp eax, pctemp |
jna dpthabc |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthpaeth |
dpthabc: |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
mov cl, [edi + edx] // load Raw(x-bpp) into cl |
dpthpaeth: |
inc ebx |
inc edx |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
add [edi + ebx - 1], cl |
cmp ebx, diff |
jb dpthlp1 |
dpthgo: |
mov ecx, FullLength |
mov eax, ecx |
sub eax, ebx // subtract alignment fix |
and eax, 0x00000007 // calc bytes over mult of 8 |
sub ecx, eax // drop over bytes from original length |
mov MMXLength, ecx |
} // end _asm block |
// Now do the math for the rest of the row |
switch ( bpp ) |
{ |
case 3: |
{ |
ActiveMask.use = 0x0000000000ffffff; |
ActiveMaskEnd.use = 0xffff000000000000; |
ShiftBpp.use = 24; // == bpp(3) * 8 |
ShiftRem.use = 40; // == 64 - 24 |
_asm |
{ |
mov ebx, diff |
mov edi, row |
mov esi, prev_row |
pxor mm0, mm0 |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] |
dpth3lp: |
psrlq mm1, ShiftRem // shift last 3 bytes to 1st 3 bytes |
movq mm2, [esi + ebx] // load b=Prior(x) |
punpcklbw mm1, mm0 // Unpack High bytes of a |
movq mm3, [esi+ebx-8] // Prep c=Prior(x-bpp) bytes |
punpcklbw mm2, mm0 // Unpack High bytes of b |
psrlq mm3, ShiftRem // shift last 3 bytes to 1st 3 bytes |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
punpcklbw mm3, mm0 // Unpack High bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
paddw mm7, mm3 |
pxor mm0, mm0 |
packuswb mm7, mm1 |
movq mm3, [esi + ebx] // load c=Prior(x-bpp) |
pand mm7, ActiveMask |
movq mm2, mm3 // load b=Prior(x) step 1 |
paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) |
punpcklbw mm3, mm0 // Unpack High bytes of c |
movq [edi + ebx], mm7 // write back updated value |
movq mm1, mm7 // Now mm1 will be used as Raw(x-bpp) |
// Now do Paeth for 2nd set of bytes (3-5) |
psrlq mm2, ShiftBpp // load b=Prior(x) step 2 |
punpcklbw mm1, mm0 // Unpack High bytes of a |
pxor mm7, mm7 |
punpcklbw mm2, mm0 // Unpack High bytes of b |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
psubw mm5, mm3 |
psubw mm4, mm3 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = |
// pav + pbv = pbv + pav |
movq mm6, mm5 |
paddw mm6, mm4 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm5 // Create mask pbv bytes < 0 |
pcmpgtw mm7, mm4 // Create mask pav bytes < 0 |
pand mm0, mm5 // Only pbv bytes < 0 in mm0 |
pand mm7, mm4 // Only pav bytes < 0 in mm7 |
psubw mm5, mm0 |
psubw mm4, mm7 |
psubw mm5, mm0 |
psubw mm4, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
movq mm2, [esi + ebx] // load b=Prior(x) |
pand mm3, mm7 |
pandn mm7, mm0 |
pxor mm1, mm1 |
paddw mm7, mm3 |
pxor mm0, mm0 |
packuswb mm7, mm1 |
movq mm3, mm2 // load c=Prior(x-bpp) step 1 |
pand mm7, ActiveMask |
punpckhbw mm2, mm0 // Unpack High bytes of b |
psllq mm7, ShiftBpp // Shift bytes to 2nd group of 3 bytes |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) |
psllq mm3, ShiftBpp // load c=Prior(x-bpp) step 2 |
movq [edi + ebx], mm7 // write back updated value |
movq mm1, mm7 |
punpckhbw mm3, mm0 // Unpack High bytes of c |
psllq mm1, ShiftBpp // Shift bytes |
// Now mm1 will be used as Raw(x-bpp) |
// Now do Paeth for 3rd, and final, set of bytes (6-7) |
pxor mm7, mm7 |
punpckhbw mm1, mm0 // Unpack High bytes of a |
psubw mm4, mm3 |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
pxor mm0, mm0 |
paddw mm6, mm5 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
pandn mm0, mm1 |
pandn mm7, mm4 |
paddw mm0, mm2 |
paddw mm7, mm5 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pand mm3, mm7 |
pandn mm7, mm0 |
paddw mm7, mm3 |
pxor mm1, mm1 |
packuswb mm1, mm7 |
// Step ebx to next set of 8 bytes and repeat loop til done |
add ebx, 8 |
pand mm1, ActiveMaskEnd |
paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) |
cmp ebx, MMXLength |
pxor mm0, mm0 // pxor does not affect flags |
movq [edi + ebx - 8], mm1 // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
// mm3 ready to be used as Prior(x-bpp) next loop |
jb dpth3lp |
} // end _asm block |
} |
break; |
case 6: |
case 7: |
case 5: |
{ |
ActiveMask.use = 0x00000000ffffffff; |
ActiveMask2.use = 0xffffffff00000000; |
ShiftBpp.use = bpp << 3; // == bpp * 8 |
ShiftRem.use = 64 - ShiftBpp.use; |
_asm |
{ |
mov ebx, diff |
mov edi, row |
mov esi, prev_row |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] |
pxor mm0, mm0 |
dpth6lp: |
// Must shift to position Raw(x-bpp) data |
psrlq mm1, ShiftRem |
// Do first set of 4 bytes |
movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes |
punpcklbw mm1, mm0 // Unpack Low bytes of a |
movq mm2, [esi + ebx] // load b=Prior(x) |
punpcklbw mm2, mm0 // Unpack Low bytes of b |
// Must shift to position Prior(x-bpp) data |
psrlq mm3, ShiftRem |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
punpcklbw mm3, mm0 // Unpack Low bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
paddw mm7, mm3 |
pxor mm0, mm0 |
packuswb mm7, mm1 |
movq mm3, [esi + ebx - 8] // load c=Prior(x-bpp) |
pand mm7, ActiveMask |
psrlq mm3, ShiftRem |
movq mm2, [esi + ebx] // load b=Prior(x) step 1 |
paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) |
movq mm6, mm2 |
movq [edi + ebx], mm7 // write back updated value |
movq mm1, [edi+ebx-8] |
psllq mm6, ShiftBpp |
movq mm5, mm7 |
psrlq mm1, ShiftRem |
por mm3, mm6 |
psllq mm5, ShiftBpp |
punpckhbw mm3, mm0 // Unpack High bytes of c |
por mm1, mm5 |
// Do second set of 4 bytes |
punpckhbw mm2, mm0 // Unpack High bytes of b |
punpckhbw mm1, mm0 // Unpack High bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
pxor mm1, mm1 |
paddw mm7, mm3 |
pxor mm0, mm0 |
// Step ex to next set of 8 bytes and repeat loop til done |
add ebx, 8 |
packuswb mm1, mm7 |
paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) |
cmp ebx, MMXLength |
movq [edi + ebx - 8], mm1 // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
jb dpth6lp |
} // end _asm block |
} |
break; |
case 4: |
{ |
ActiveMask.use = 0x00000000ffffffff; |
_asm { |
mov ebx, diff |
mov edi, row |
mov esi, prev_row |
pxor mm0, mm0 |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] // Only time should need to read |
// a=Raw(x-bpp) bytes |
dpth4lp: |
// Do first set of 4 bytes |
movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes |
punpckhbw mm1, mm0 // Unpack Low bytes of a |
movq mm2, [esi + ebx] // load b=Prior(x) |
punpcklbw mm2, mm0 // Unpack High bytes of b |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
punpckhbw mm3, mm0 // Unpack High bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
paddw mm7, mm3 |
pxor mm0, mm0 |
packuswb mm7, mm1 |
movq mm3, [esi + ebx] // load c=Prior(x-bpp) |
pand mm7, ActiveMask |
movq mm2, mm3 // load b=Prior(x) step 1 |
paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) |
punpcklbw mm3, mm0 // Unpack High bytes of c |
movq [edi + ebx], mm7 // write back updated value |
movq mm1, mm7 // Now mm1 will be used as Raw(x-bpp) |
// Do second set of 4 bytes |
punpckhbw mm2, mm0 // Unpack Low bytes of b |
punpcklbw mm1, mm0 // Unpack Low bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
pxor mm1, mm1 |
paddw mm7, mm3 |
pxor mm0, mm0 |
// Step ex to next set of 8 bytes and repeat loop til done |
add ebx, 8 |
packuswb mm1, mm7 |
paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) |
cmp ebx, MMXLength |
movq [edi + ebx - 8], mm1 // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
jb dpth4lp |
} // end _asm block |
} |
break; |
case 8: // bpp == 8 |
{ |
ActiveMask.use = 0x00000000ffffffff; |
_asm { |
mov ebx, diff |
mov edi, row |
mov esi, prev_row |
pxor mm0, mm0 |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] // Only time should need to read |
// a=Raw(x-bpp) bytes |
dpth8lp: |
// Do first set of 4 bytes |
movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes |
punpcklbw mm1, mm0 // Unpack Low bytes of a |
movq mm2, [esi + ebx] // load b=Prior(x) |
punpcklbw mm2, mm0 // Unpack Low bytes of b |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
punpcklbw mm3, mm0 // Unpack Low bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
paddw mm7, mm3 |
pxor mm0, mm0 |
packuswb mm7, mm1 |
movq mm3, [esi+ebx-8] // read c=Prior(x-bpp) bytes |
pand mm7, ActiveMask |
movq mm2, [esi + ebx] // load b=Prior(x) |
paddb mm7, [edi + ebx] // add Paeth predictor with Raw(x) |
punpckhbw mm3, mm0 // Unpack High bytes of c |
movq [edi + ebx], mm7 // write back updated value |
movq mm1, [edi+ebx-8] // read a=Raw(x-bpp) bytes |
// Do second set of 4 bytes |
punpckhbw mm2, mm0 // Unpack High bytes of b |
punpckhbw mm1, mm0 // Unpack High bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
movq mm4, mm2 |
// pbv = p - b = (a + b - c) - b = a - c |
movq mm5, mm1 |
psubw mm4, mm3 |
pxor mm7, mm7 |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
movq mm6, mm4 |
psubw mm5, mm3 |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
pcmpgtw mm0, mm4 // Create mask pav bytes < 0 |
paddw mm6, mm5 |
pand mm0, mm4 // Only pav bytes < 0 in mm7 |
pcmpgtw mm7, mm5 // Create mask pbv bytes < 0 |
psubw mm4, mm0 |
pand mm7, mm5 // Only pbv bytes < 0 in mm0 |
psubw mm4, mm0 |
psubw mm5, mm7 |
pxor mm0, mm0 |
pcmpgtw mm0, mm6 // Create mask pcv bytes < 0 |
pand mm0, mm6 // Only pav bytes < 0 in mm7 |
psubw mm5, mm7 |
psubw mm6, mm0 |
// test pa <= pb |
movq mm7, mm4 |
psubw mm6, mm0 |
pcmpgtw mm7, mm5 // pa > pb? |
movq mm0, mm7 |
// use mm7 mask to merge pa & pb |
pand mm5, mm7 |
// use mm0 mask copy to merge a & b |
pand mm2, mm0 |
pandn mm7, mm4 |
pandn mm0, mm1 |
paddw mm7, mm5 |
paddw mm0, mm2 |
// test ((pa <= pb)? pa:pb) <= pc |
pcmpgtw mm7, mm6 // pab > pc? |
pxor mm1, mm1 |
pand mm3, mm7 |
pandn mm7, mm0 |
pxor mm1, mm1 |
paddw mm7, mm3 |
pxor mm0, mm0 |
// Step ex to next set of 8 bytes and repeat loop til done |
add ebx, 8 |
packuswb mm1, mm7 |
paddb mm1, [edi + ebx - 8] // add Paeth predictor with Raw(x) |
cmp ebx, MMXLength |
movq [edi + ebx - 8], mm1 // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
jb dpth8lp |
} // end _asm block |
} |
break; |
case 1: // bpp = 1 |
case 2: // bpp = 2 |
default: // bpp > 8 |
{ |
_asm { |
mov ebx, diff |
cmp ebx, FullLength |
jnb dpthdend |
mov edi, row |
mov esi, prev_row |
// Do Paeth decode for remaining bytes |
mov edx, ebx |
xor ecx, ecx // zero ecx before using cl & cx in loop below |
sub edx, bpp // Set edx = ebx - bpp |
dpthdlp: |
xor eax, eax |
// pav = p - a = (a + b - c) - a = b - c |
mov al, [esi + ebx] // load Prior(x) into al |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
sub eax, ecx // subtract Prior(x-bpp) |
mov patemp, eax // Save pav for later use |
xor eax, eax |
// pbv = p - b = (a + b - c) - b = a - c |
mov al, [edi + edx] // load Raw(x-bpp) into al |
sub eax, ecx // subtract Prior(x-bpp) |
mov ecx, eax |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
add eax, patemp // pcv = pav + pbv |
// pc = abs(pcv) |
test eax, 0x80000000 |
jz dpthdpca |
neg eax // reverse sign of neg values |
dpthdpca: |
mov pctemp, eax // save pc for later use |
// pb = abs(pbv) |
test ecx, 0x80000000 |
jz dpthdpba |
neg ecx // reverse sign of neg values |
dpthdpba: |
mov pbtemp, ecx // save pb for later use |
// pa = abs(pav) |
mov eax, patemp |
test eax, 0x80000000 |
jz dpthdpaa |
neg eax // reverse sign of neg values |
dpthdpaa: |
mov patemp, eax // save pa for later use |
// test if pa <= pb |
cmp eax, ecx |
jna dpthdabb |
// pa > pb; now test if pb <= pc |
cmp ecx, pctemp |
jna dpthdbbc |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthdpaeth |
dpthdbbc: |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
mov cl, [esi + ebx] // load Prior(x) into cl |
jmp dpthdpaeth |
dpthdabb: |
// pa <= pb; now test if pa <= pc |
cmp eax, pctemp |
jna dpthdabc |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthdpaeth |
dpthdabc: |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
mov cl, [edi + edx] // load Raw(x-bpp) into cl |
dpthdpaeth: |
inc ebx |
inc edx |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
add [edi + ebx - 1], cl |
cmp ebx, FullLength |
jb dpthdlp |
dpthdend: |
} // end _asm block |
} |
return; // No need to go further with this one |
} // end switch ( bpp ) |
_asm |
{ |
// MMX acceleration complete now do clean-up |
// Check if any remaining bytes left to decode |
mov ebx, MMXLength |
cmp ebx, FullLength |
jnb dpthend |
mov edi, row |
mov esi, prev_row |
// Do Paeth decode for remaining bytes |
mov edx, ebx |
xor ecx, ecx // zero ecx before using cl & cx in loop below |
sub edx, bpp // Set edx = ebx - bpp |
dpthlp2: |
xor eax, eax |
// pav = p - a = (a + b - c) - a = b - c |
mov al, [esi + ebx] // load Prior(x) into al |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
sub eax, ecx // subtract Prior(x-bpp) |
mov patemp, eax // Save pav for later use |
xor eax, eax |
// pbv = p - b = (a + b - c) - b = a - c |
mov al, [edi + edx] // load Raw(x-bpp) into al |
sub eax, ecx // subtract Prior(x-bpp) |
mov ecx, eax |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
add eax, patemp // pcv = pav + pbv |
// pc = abs(pcv) |
test eax, 0x80000000 |
jz dpthpca2 |
neg eax // reverse sign of neg values |
dpthpca2: |
mov pctemp, eax // save pc for later use |
// pb = abs(pbv) |
test ecx, 0x80000000 |
jz dpthpba2 |
neg ecx // reverse sign of neg values |
dpthpba2: |
mov pbtemp, ecx // save pb for later use |
// pa = abs(pav) |
mov eax, patemp |
test eax, 0x80000000 |
jz dpthpaa2 |
neg eax // reverse sign of neg values |
dpthpaa2: |
mov patemp, eax // save pa for later use |
// test if pa <= pb |
cmp eax, ecx |
jna dpthabb2 |
// pa > pb; now test if pb <= pc |
cmp ecx, pctemp |
jna dpthbbc2 |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthpaeth2 |
dpthbbc2: |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
mov cl, [esi + ebx] // load Prior(x) into cl |
jmp dpthpaeth2 |
dpthabb2: |
// pa <= pb; now test if pa <= pc |
cmp eax, pctemp |
jna dpthabc2 |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
mov cl, [esi + edx] // load Prior(x-bpp) into cl |
jmp dpthpaeth2 |
dpthabc2: |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
mov cl, [edi + edx] // load Raw(x-bpp) into cl |
dpthpaeth2: |
inc ebx |
inc edx |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
add [edi + ebx - 1], cl |
cmp ebx, FullLength |
jb dpthlp2 |
dpthend: |
emms // End MMX instructions; prep for possible FP instrs. |
} // end _asm block |
} |
// Optimized code for PNG Sub filter decoder |
void /* PRIVATE */ |
png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row) |
{ |
//int test; |
int bpp; |
png_uint_32 FullLength; |
png_uint_32 MMXLength; |
int diff; |
bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel |
FullLength = row_info->rowbytes - bpp; // # of bytes to filter |
_asm { |
mov edi, row |
mov esi, edi // lp = row |
add edi, bpp // rp = row + bpp |
xor eax, eax |
// get # of bytes to alignment |
mov diff, edi // take start of row |
add diff, 0xf // add 7 + 8 to incr past |
// alignment boundary |
xor ebx, ebx |
and diff, 0xfffffff8 // mask to alignment boundary |
sub diff, edi // subtract from start ==> value |
// ebx at alignment |
jz dsubgo |
// fix alignment |
dsublp1: |
mov al, [esi+ebx] |
add [edi+ebx], al |
inc ebx |
cmp ebx, diff |
jb dsublp1 |
dsubgo: |
mov ecx, FullLength |
mov edx, ecx |
sub edx, ebx // subtract alignment fix |
and edx, 0x00000007 // calc bytes over mult of 8 |
sub ecx, edx // drop over bytes from length |
mov MMXLength, ecx |
} // end _asm block |
// Now do the math for the rest of the row |
switch ( bpp ) |
{ |
case 3: |
{ |
ActiveMask.use = 0x0000ffffff000000; |
ShiftBpp.use = 24; // == 3 * 8 |
ShiftRem.use = 40; // == 64 - 24 |
_asm { |
mov edi, row |
movq mm7, ActiveMask // Load ActiveMask for 2nd active byte group |
mov esi, edi // lp = row |
add edi, bpp // rp = row + bpp |
movq mm6, mm7 |
mov ebx, diff |
psllq mm6, ShiftBpp // Move mask in mm6 to cover 3rd active |
// byte group |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] |
dsub3lp: |
psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes |
// no need for mask; shift clears inactive bytes |
// Add 1st active group |
movq mm0, [edi+ebx] |
paddb mm0, mm1 |
// Add 2nd active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
pand mm1, mm7 // mask to use only 2nd active group |
paddb mm0, mm1 |
// Add 3rd active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
pand mm1, mm6 // mask to use only 3rd active group |
add ebx, 8 |
paddb mm0, mm1 |
cmp ebx, MMXLength |
movq [edi+ebx-8], mm0 // Write updated Raws back to array |
// Prep for doing 1st add at top of loop |
movq mm1, mm0 |
jb dsub3lp |
} // end _asm block |
} |
break; |
case 1: |
{ |
// Placed here just in case this is a duplicate of the |
// non-MMX code for the SUB filter in png_read_filter_row below |
// |
// png_bytep rp; |
// png_bytep lp; |
// png_uint_32 i; |
// bpp = (row_info->pixel_depth + 7) >> 3; |
// for (i = (png_uint_32)bpp, rp = row + bpp, lp = row; |
// i < row_info->rowbytes; i++, rp++, lp++) |
// { |
// *rp = (png_byte)(((int)(*rp) + (int)(*lp)) & 0xff); |
// } |
_asm { |
mov ebx, diff |
mov edi, row |
cmp ebx, FullLength |
jnb dsub1end |
mov esi, edi // lp = row |
xor eax, eax |
add edi, bpp // rp = row + bpp |
dsub1lp: |
mov al, [esi+ebx] |
add [edi+ebx], al |
inc ebx |
cmp ebx, FullLength |
jb dsub1lp |
dsub1end: |
} // end _asm block |
} |
return; |
case 6: |
case 7: |
case 4: |
case 5: |
{ |
ShiftBpp.use = bpp << 3; |
ShiftRem.use = 64 - ShiftBpp.use; |
_asm { |
mov edi, row |
mov ebx, diff |
mov esi, edi // lp = row |
add edi, bpp // rp = row + bpp |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] |
dsub4lp: |
psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes |
// no need for mask; shift clears inactive bytes |
movq mm0, [edi+ebx] |
paddb mm0, mm1 |
// Add 2nd active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
// there is no need for any mask |
// since shift clears inactive bits/bytes |
add ebx, 8 |
paddb mm0, mm1 |
cmp ebx, MMXLength |
movq [edi+ebx-8], mm0 |
movq mm1, mm0 // Prep for doing 1st add at top of loop |
jb dsub4lp |
} // end _asm block |
} |
break; |
case 2: |
{ |
ActiveMask.use = 0x00000000ffff0000; |
ShiftBpp.use = 16; // == 2 * 8 |
ShiftRem.use = 48; // == 64 - 16 |
_asm { |
movq mm7, ActiveMask // Load ActiveMask for 2nd active byte group |
mov ebx, diff |
movq mm6, mm7 |
mov edi, row |
psllq mm6, ShiftBpp // Move mask in mm6 to cover 3rd active |
// byte group |
mov esi, edi // lp = row |
movq mm5, mm6 |
add edi, bpp // rp = row + bpp |
psllq mm5, ShiftBpp // Move mask in mm5 to cover 4th active |
// byte group |
// PRIME the pump (load the first Raw(x-bpp) data set |
movq mm1, [edi+ebx-8] |
dsub2lp: |
// Add 1st active group |
psrlq mm1, ShiftRem // Shift data for adding 1st bpp bytes |
// no need for mask; shift clears inactive |
// bytes |
movq mm0, [edi+ebx] |
paddb mm0, mm1 |
// Add 2nd active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
pand mm1, mm7 // mask to use only 2nd active group |
paddb mm0, mm1 |
// Add 3rd active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
pand mm1, mm6 // mask to use only 3rd active group |
paddb mm0, mm1 |
// Add 4th active group |
movq mm1, mm0 // mov updated Raws to mm1 |
psllq mm1, ShiftBpp // shift data to position correctly |
pand mm1, mm5 // mask to use only 4th active group |
add ebx, 8 |
paddb mm0, mm1 |
cmp ebx, MMXLength |
movq [edi+ebx-8], mm0 // Write updated Raws back to array |
movq mm1, mm0 // Prep for doing 1st add at top of loop |
jb dsub2lp |
} // end _asm block |
} |
break; |
case 8: |
{ |
_asm { |
mov edi, row |
mov ebx, diff |
mov esi, edi // lp = row |
add edi, bpp // rp = row + bpp |
mov ecx, MMXLength |
movq mm7, [edi+ebx-8] // PRIME the pump (load the first |
// Raw(x-bpp) data set |
and ecx, 0x0000003f // calc bytes over mult of 64 |
dsub8lp: |
movq mm0, [edi+ebx] // Load Sub(x) for 1st 8 bytes |
paddb mm0, mm7 |
movq mm1, [edi+ebx+8] // Load Sub(x) for 2nd 8 bytes |
movq [edi+ebx], mm0 // Write Raw(x) for 1st 8 bytes |
// Now mm0 will be used as Raw(x-bpp) for |
// the 2nd group of 8 bytes. This will be |
// repeated for each group of 8 bytes with |
// the 8th group being used as the Raw(x-bpp) |
// for the 1st group of the next loop. |
paddb mm1, mm0 |
movq mm2, [edi+ebx+16] // Load Sub(x) for 3rd 8 bytes |
movq [edi+ebx+8], mm1 // Write Raw(x) for 2nd 8 bytes |
paddb mm2, mm1 |
movq mm3, [edi+ebx+24] // Load Sub(x) for 4th 8 bytes |
movq [edi+ebx+16], mm2 // Write Raw(x) for 3rd 8 bytes |
paddb mm3, mm2 |
movq mm4, [edi+ebx+32] // Load Sub(x) for 5th 8 bytes |
movq [edi+ebx+24], mm3 // Write Raw(x) for 4th 8 bytes |
paddb mm4, mm3 |
movq mm5, [edi+ebx+40] // Load Sub(x) for 6th 8 bytes |
movq [edi+ebx+32], mm4 // Write Raw(x) for 5th 8 bytes |
paddb mm5, mm4 |
movq mm6, [edi+ebx+48] // Load Sub(x) for 7th 8 bytes |
movq [edi+ebx+40], mm5 // Write Raw(x) for 6th 8 bytes |
paddb mm6, mm5 |
movq mm7, [edi+ebx+56] // Load Sub(x) for 8th 8 bytes |
movq [edi+ebx+48], mm6 // Write Raw(x) for 7th 8 bytes |
add ebx, 64 |
paddb mm7, mm6 |
cmp ebx, ecx |
movq [edi+ebx-8], mm7 // Write Raw(x) for 8th 8 bytes |
jb dsub8lp |
cmp ebx, MMXLength |
jnb dsub8lt8 |
dsub8lpA: |
movq mm0, [edi+ebx] |
add ebx, 8 |
paddb mm0, mm7 |
cmp ebx, MMXLength |
movq [edi+ebx-8], mm0 // use -8 to offset early add to ebx |
movq mm7, mm0 // Move calculated Raw(x) data to mm1 to |
// be the new Raw(x-bpp) for the next loop |
jb dsub8lpA |
dsub8lt8: |
} // end _asm block |
} |
break; |
default: // bpp greater than 8 bytes |
{ |
_asm { |
mov ebx, diff |
mov edi, row |
mov esi, edi // lp = row |
add edi, bpp // rp = row + bpp |
dsubAlp: |
movq mm0, [edi+ebx] |
movq mm1, [esi+ebx] |
add ebx, 8 |
paddb mm0, mm1 |
cmp ebx, MMXLength |
movq [edi+ebx-8], mm0 // mov does not affect flags; -8 to offset |
// add ebx |
jb dsubAlp |
} // end _asm block |
} |
break; |
} // end switch ( bpp ) |
_asm { |
mov ebx, MMXLength |
mov edi, row |
cmp ebx, FullLength |
jnb dsubend |
mov esi, edi // lp = row |
xor eax, eax |
add edi, bpp // rp = row + bpp |
dsublp2: |
mov al, [esi+ebx] |
add [edi+ebx], al |
inc ebx |
cmp ebx, FullLength |
jb dsublp2 |
dsubend: |
emms // End MMX instructions; prep for possible FP instrs. |
} // end _asm block |
} |
// Optimized code for PNG Up filter decoder |
void /* PRIVATE */ |
png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row, |
png_bytep prev_row) |
{ |
png_uint_32 len; |
len = row_info->rowbytes; // # of bytes to filter |
_asm { |
mov edi, row |
// get # of bytes to alignment |
mov ecx, edi |
xor ebx, ebx |
add ecx, 0x7 |
xor eax, eax |
and ecx, 0xfffffff8 |
mov esi, prev_row |
sub ecx, edi |
jz dupgo |
// fix alignment |
duplp1: |
mov al, [edi+ebx] |
add al, [esi+ebx] |
inc ebx |
cmp ebx, ecx |
mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx |
jb duplp1 |
dupgo: |
mov ecx, len |
mov edx, ecx |
sub edx, ebx // subtract alignment fix |
and edx, 0x0000003f // calc bytes over mult of 64 |
sub ecx, edx // drop over bytes from length |
// Unrolled loop - use all MMX registers and interleave to reduce |
// number of branch instructions (loops) and reduce partial stalls |
duploop: |
movq mm1, [esi+ebx] |
movq mm0, [edi+ebx] |
movq mm3, [esi+ebx+8] |
paddb mm0, mm1 |
movq mm2, [edi+ebx+8] |
movq [edi+ebx], mm0 |
paddb mm2, mm3 |
movq mm5, [esi+ebx+16] |
movq [edi+ebx+8], mm2 |
movq mm4, [edi+ebx+16] |
movq mm7, [esi+ebx+24] |
paddb mm4, mm5 |
movq mm6, [edi+ebx+24] |
movq [edi+ebx+16], mm4 |
paddb mm6, mm7 |
movq mm1, [esi+ebx+32] |
movq [edi+ebx+24], mm6 |
movq mm0, [edi+ebx+32] |
movq mm3, [esi+ebx+40] |
paddb mm0, mm1 |
movq mm2, [edi+ebx+40] |
movq [edi+ebx+32], mm0 |
paddb mm2, mm3 |
movq mm5, [esi+ebx+48] |
movq [edi+ebx+40], mm2 |
movq mm4, [edi+ebx+48] |
movq mm7, [esi+ebx+56] |
paddb mm4, mm5 |
movq mm6, [edi+ebx+56] |
movq [edi+ebx+48], mm4 |
add ebx, 64 |
paddb mm6, mm7 |
cmp ebx, ecx |
movq [edi+ebx-8], mm6 // (+56)movq does not affect flags; |
// -8 to offset add ebx |
jb duploop |
cmp edx, 0 // Test for bytes over mult of 64 |
jz dupend |
// 2 lines added by lcreeve@netins.net |
// (mail 11 Jul 98 in png-implement list) |
cmp edx, 8 //test for less than 8 bytes |
jb duplt8 |
add ecx, edx |
and edx, 0x00000007 // calc bytes over mult of 8 |
sub ecx, edx // drop over bytes from length |
jz duplt8 |
// Loop using MMX registers mm0 & mm1 to update 8 bytes simultaneously |
duplpA: |
movq mm1, [esi+ebx] |
movq mm0, [edi+ebx] |
add ebx, 8 |
paddb mm0, mm1 |
cmp ebx, ecx |
movq [edi+ebx-8], mm0 // movq does not affect flags; -8 to offset add ebx |
jb duplpA |
cmp edx, 0 // Test for bytes over mult of 8 |
jz dupend |
duplt8: |
xor eax, eax |
add ecx, edx // move over byte count into counter |
// Loop using x86 registers to update remaining bytes |
duplp2: |
mov al, [edi + ebx] |
add al, [esi + ebx] |
inc ebx |
cmp ebx, ecx |
mov [edi + ebx-1], al // mov does not affect flags; -1 to offset inc ebx |
jb duplp2 |
dupend: |
// Conversion of filtered row completed |
emms // End MMX instructions; prep for possible FP instrs. |
} // end _asm block |
} |
// Optimized png_read_filter_row routines |
void /* PRIVATE */ |
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep |
row, png_bytep prev_row, int filter) |
{ |
#ifdef PNG_DEBUG |
char filnm[10]; |
#endif |
if (mmx_supported == 2) { |
/* this should have happened in png_init_mmx_flags() already */ |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
png_mmx_support(); |
} |
#ifdef PNG_DEBUG |
png_debug(1, "in png_read_filter_row\n"); |
switch (filter) |
{ |
case 0: sprintf(filnm, "none"); |
break; |
case 1: sprintf(filnm, "sub-%s", |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : "x86"); |
break; |
case 2: sprintf(filnm, "up-%s", |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : "x86"); |
break; |
case 3: sprintf(filnm, "avg-%s", |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : "x86"); |
break; |
case 4: sprintf(filnm, "Paeth-%s", |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX":"x86"); |
break; |
default: sprintf(filnm, "unknw"); |
break; |
} |
png_debug2(0,"row=%5d, %s, ", png_ptr->row_number, filnm); |
png_debug2(0, "pd=%2d, b=%d, ", (int)row_info->pixel_depth, |
(int)((row_info->pixel_depth + 7) >> 3)); |
png_debug1(0,"len=%8d, ", row_info->rowbytes); |
#endif /* PNG_DEBUG */ |
switch (filter) |
{ |
case PNG_FILTER_VALUE_NONE: |
break; |
case PNG_FILTER_VALUE_SUB: |
{ |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
{ |
png_read_filter_row_mmx_sub(row_info, row); |
} |
else |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_bytep rp = row + bpp; |
png_bytep lp = row; |
for (i = bpp; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); |
rp++; |
} |
} |
break; |
} |
case PNG_FILTER_VALUE_UP: |
{ |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
{ |
png_read_filter_row_mmx_up(row_info, row, prev_row); |
} |
else |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
for (i = 0; i < istop; ++i) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
} |
break; |
} |
case PNG_FILTER_VALUE_AVG: |
{ |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
{ |
png_read_filter_row_mmx_avg(row_info, row, prev_row); |
} |
else |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop = row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
((int)(*pp++) >> 1)) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
((int)(*pp++ + *lp++) >> 1)) & 0xff); |
rp++; |
} |
} |
break; |
} |
case PNG_FILTER_VALUE_PAETH: |
{ |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
{ |
png_read_filter_row_mmx_paeth(row_info, row, prev_row); |
} |
else |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_bytep cp = prev_row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop=row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) // use leftover rp,pp |
{ |
int a, b, c, pa, pb, pc, p; |
a = *lp++; |
b = *pp++; |
c = *cp++; |
p = b - c; |
pc = a - c; |
#ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
#else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
/* |
if (pa <= pb && pa <= pc) |
p = a; |
else if (pb <= pc) |
p = b; |
else |
p = c; |
*/ |
p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; |
*rp = (png_byte)(((int)(*rp) + p) & 0xff); |
rp++; |
} |
} |
break; |
} |
default: |
png_warning(png_ptr, "Ignoring bad row filter type"); |
*row=0; |
break; |
} |
} |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED && PNG_USE_PNGVCRD */ |
/shark/trunk/ports/png/deflate.c |
---|
0,0 → 1,1350 |
/* deflate.c -- compress data using the deflation algorithm |
* Copyright (C) 1995-2002 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* |
* ALGORITHM |
* |
* The "deflation" process depends on being able to identify portions |
* of the input text which are identical to earlier input (within a |
* sliding window trailing behind the input currently being processed). |
* |
* The most straightforward technique turns out to be the fastest for |
* most input files: try all possible matches and select the longest. |
* The key feature of this algorithm is that insertions into the string |
* dictionary are very simple and thus fast, and deletions are avoided |
* completely. Insertions are performed at each input character, whereas |
* string matches are performed only when the previous match ends. So it |
* is preferable to spend more time in matches to allow very fast string |
* insertions and avoid deletions. The matching algorithm for small |
* strings is inspired from that of Rabin & Karp. A brute force approach |
* is used to find longer strings when a small match has been found. |
* A similar algorithm is used in comic (by Jan-Mark Wams) and freeze |
* (by Leonid Broukhis). |
* A previous version of this file used a more sophisticated algorithm |
* (by Fiala and Greene) which is guaranteed to run in linear amortized |
* time, but has a larger average cost, uses more memory and is patented. |
* However the F&G algorithm may be faster for some highly redundant |
* files if the parameter max_chain_length (described below) is too large. |
* |
* ACKNOWLEDGEMENTS |
* |
* The idea of lazy evaluation of matches is due to Jan-Mark Wams, and |
* I found it in 'freeze' written by Leonid Broukhis. |
* Thanks to many people for bug reports and testing. |
* |
* REFERENCES |
* |
* Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". |
* Available in ftp://ds.internic.net/rfc/rfc1951.txt |
* |
* A description of the Rabin and Karp algorithm is given in the book |
* "Algorithms" by R. Sedgewick, Addison-Wesley, p252. |
* |
* Fiala,E.R., and Greene,D.H. |
* Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 |
* |
*/ |
/* @(#) $Id: deflate.c,v 1.1 2003-03-20 13:08:10 giacomo Exp $ */ |
#include "deflate.h" |
const char deflate_copyright[] = |
" deflate 1.1.4 Copyright 1995-2002 Jean-loup Gailly "; |
/* |
If you use the zlib library in a product, an acknowledgment is welcome |
in the documentation of your product. If for some reason you cannot |
include such an acknowledgment, I would appreciate that you keep this |
copyright string in the executable of your product. |
*/ |
/* =========================================================================== |
* Function prototypes. |
*/ |
typedef enum { |
need_more, /* block not completed, need more input or more output */ |
block_done, /* block flush performed */ |
finish_started, /* finish started, need only more output at next deflate */ |
finish_done /* finish done, accept no more input or output */ |
} block_state; |
typedef block_state (*compress_func) OF((deflate_state *s, int flush)); |
/* Compression function. Returns the block state after the call. */ |
local void fill_window OF((deflate_state *s)); |
local block_state deflate_stored OF((deflate_state *s, int flush)); |
local block_state deflate_fast OF((deflate_state *s, int flush)); |
local block_state deflate_slow OF((deflate_state *s, int flush)); |
local void lm_init OF((deflate_state *s)); |
local void putShortMSB OF((deflate_state *s, uInt b)); |
local void flush_pending OF((z_streamp strm)); |
local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); |
#ifdef ASMV |
void match_init OF((void)); /* asm code initialization */ |
uInt longest_match OF((deflate_state *s, IPos cur_match)); |
#else |
local uInt longest_match OF((deflate_state *s, IPos cur_match)); |
#endif |
#ifdef DEBUG |
local void check_match OF((deflate_state *s, IPos start, IPos match, |
int length)); |
#endif |
/* =========================================================================== |
* Local data |
*/ |
#define NIL 0 |
/* Tail of hash chains */ |
#ifndef TOO_FAR |
# define TOO_FAR 4096 |
#endif |
/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ |
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) |
/* Minimum amount of lookahead, except at the end of the input file. |
* See deflate.c for comments about the MIN_MATCH+1. |
*/ |
/* Values for max_lazy_match, good_match and max_chain_length, depending on |
* the desired pack level (0..9). The values given below have been tuned to |
* exclude worst case performance for pathological files. Better values may be |
* found for specific files. |
*/ |
typedef struct config_s { |
ush good_length; /* reduce lazy search above this match length */ |
ush max_lazy; /* do not perform lazy search above this match length */ |
ush nice_length; /* quit search above this match length */ |
ush max_chain; |
compress_func func; |
} config; |
local const config configuration_table[10] = { |
/* good lazy nice chain */ |
/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ |
/* 1 */ {4, 4, 8, 4, deflate_fast}, /* maximum speed, no lazy matches */ |
/* 2 */ {4, 5, 16, 8, deflate_fast}, |
/* 3 */ {4, 6, 32, 32, deflate_fast}, |
/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ |
/* 5 */ {8, 16, 32, 32, deflate_slow}, |
/* 6 */ {8, 16, 128, 128, deflate_slow}, |
/* 7 */ {8, 32, 128, 256, deflate_slow}, |
/* 8 */ {32, 128, 258, 1024, deflate_slow}, |
/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* maximum compression */ |
/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 |
* For deflate_fast() (levels <= 3) good is ignored and lazy has a different |
* meaning. |
*/ |
#define EQUAL 0 |
/* result of memcmp for equal strings */ |
struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ |
/* =========================================================================== |
* Update a hash value with the given input byte |
* IN assertion: all calls to to UPDATE_HASH are made with consecutive |
* input characters, so that a running hash key can be computed from the |
* previous key instead of complete recalculation each time. |
*/ |
#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask) |
/* =========================================================================== |
* Insert string str in the dictionary and set match_head to the previous head |
* of the hash chain (the most recent string with same hash key). Return |
* the previous length of the hash chain. |
* If this file is compiled with -DFASTEST, the compression level is forced |
* to 1, and no hash chains are maintained. |
* IN assertion: all calls to to INSERT_STRING are made with consecutive |
* input characters and the first MIN_MATCH bytes of str are valid |
* (except for the last MIN_MATCH-1 bytes of the input file). |
*/ |
#ifdef FASTEST |
#define INSERT_STRING(s, str, match_head) \ |
(UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ |
match_head = s->head[s->ins_h], \ |
s->head[s->ins_h] = (Pos)(str)) |
#else |
#define INSERT_STRING(s, str, match_head) \ |
(UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ |
s->prev[(str) & s->w_mask] = match_head = s->head[s->ins_h], \ |
s->head[s->ins_h] = (Pos)(str)) |
#endif |
/* =========================================================================== |
* Initialize the hash table (avoiding 64K overflow for 16 bit systems). |
* prev[] will be initialized on the fly. |
*/ |
#define CLEAR_HASH(s) \ |
s->head[s->hash_size-1] = NIL; \ |
zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); |
/* ========================================================================= */ |
int ZEXPORT deflateInit_(strm, level, version, stream_size) |
z_streamp strm; |
int level; |
const char *version; |
int stream_size; |
{ |
return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, |
Z_DEFAULT_STRATEGY, version, stream_size); |
/* To do: ignore strm->next_in if we use it as window */ |
} |
/* ========================================================================= */ |
int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, |
version, stream_size) |
z_streamp strm; |
int level; |
int method; |
int windowBits; |
int memLevel; |
int strategy; |
const char *version; |
int stream_size; |
{ |
deflate_state *s; |
int noheader = 0; |
static const char* my_version = ZLIB_VERSION; |
ushf *overlay; |
/* We overlay pending_buf and d_buf+l_buf. This works since the average |
* output size for (length,distance) codes is <= 24 bits. |
*/ |
if (version == Z_NULL || version[0] != my_version[0] || |
stream_size != sizeof(z_stream)) { |
return Z_VERSION_ERROR; |
} |
if (strm == Z_NULL) return Z_STREAM_ERROR; |
strm->msg = Z_NULL; |
if (strm->zalloc == Z_NULL) { |
strm->zalloc = zcalloc; |
strm->opaque = (voidpf)0; |
} |
if (strm->zfree == Z_NULL) strm->zfree = zcfree; |
if (level == Z_DEFAULT_COMPRESSION) level = 6; |
#ifdef FASTEST |
level = 1; |
#endif |
if (windowBits < 0) { /* undocumented feature: suppress zlib header */ |
noheader = 1; |
windowBits = -windowBits; |
} |
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || |
windowBits < 9 || windowBits > 15 || level < 0 || level > 9 || |
strategy < 0 || strategy > Z_HUFFMAN_ONLY) { |
return Z_STREAM_ERROR; |
} |
s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); |
if (s == Z_NULL) return Z_MEM_ERROR; |
strm->state = (struct internal_state FAR *)s; |
s->strm = strm; |
s->noheader = noheader; |
s->w_bits = windowBits; |
s->w_size = 1 << s->w_bits; |
s->w_mask = s->w_size - 1; |
s->hash_bits = memLevel + 7; |
s->hash_size = 1 << s->hash_bits; |
s->hash_mask = s->hash_size - 1; |
s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); |
s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); |
s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); |
s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); |
s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ |
overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); |
s->pending_buf = (uchf *) overlay; |
s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); |
if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || |
s->pending_buf == Z_NULL) { |
strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); |
deflateEnd (strm); |
return Z_MEM_ERROR; |
} |
s->d_buf = overlay + s->lit_bufsize/sizeof(ush); |
s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; |
s->level = level; |
s->strategy = strategy; |
s->method = (Byte)method; |
return deflateReset(strm); |
} |
/* ========================================================================= */ |
int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) |
z_streamp strm; |
const Bytef *dictionary; |
uInt dictLength; |
{ |
deflate_state *s; |
uInt length = dictLength; |
uInt n; |
IPos hash_head = 0; |
if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || |
strm->state->status != INIT_STATE) return Z_STREAM_ERROR; |
s = strm->state; |
strm->adler = adler32(strm->adler, dictionary, dictLength); |
if (length < MIN_MATCH) return Z_OK; |
if (length > MAX_DIST(s)) { |
length = MAX_DIST(s); |
#ifndef USE_DICT_HEAD |
dictionary += dictLength - length; /* use the tail of the dictionary */ |
#endif |
} |
zmemcpy(s->window, dictionary, length); |
s->strstart = length; |
s->block_start = (long)length; |
/* Insert all strings in the hash table (except for the last two bytes). |
* s->lookahead stays null, so s->ins_h will be recomputed at the next |
* call of fill_window. |
*/ |
s->ins_h = s->window[0]; |
UPDATE_HASH(s, s->ins_h, s->window[1]); |
for (n = 0; n <= length - MIN_MATCH; n++) { |
INSERT_STRING(s, n, hash_head); |
} |
if (hash_head) hash_head = 0; /* to make compiler happy */ |
return Z_OK; |
} |
/* ========================================================================= */ |
int ZEXPORT deflateReset (strm) |
z_streamp strm; |
{ |
deflate_state *s; |
if (strm == Z_NULL || strm->state == Z_NULL || |
strm->zalloc == Z_NULL || strm->zfree == Z_NULL) return Z_STREAM_ERROR; |
strm->total_in = strm->total_out = 0; |
strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ |
strm->data_type = Z_UNKNOWN; |
s = (deflate_state *)strm->state; |
s->pending = 0; |
s->pending_out = s->pending_buf; |
if (s->noheader < 0) { |
s->noheader = 0; /* was set to -1 by deflate(..., Z_FINISH); */ |
} |
s->status = s->noheader ? BUSY_STATE : INIT_STATE; |
strm->adler = 1; |
s->last_flush = Z_NO_FLUSH; |
_tr_init(s); |
lm_init(s); |
return Z_OK; |
} |
/* ========================================================================= */ |
int ZEXPORT deflateParams(strm, level, strategy) |
z_streamp strm; |
int level; |
int strategy; |
{ |
deflate_state *s; |
compress_func func; |
int err = Z_OK; |
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
s = strm->state; |
if (level == Z_DEFAULT_COMPRESSION) { |
level = 6; |
} |
if (level < 0 || level > 9 || strategy < 0 || strategy > Z_HUFFMAN_ONLY) { |
return Z_STREAM_ERROR; |
} |
func = configuration_table[s->level].func; |
if (func != configuration_table[level].func && strm->total_in != 0) { |
/* Flush the last buffer: */ |
err = deflate(strm, Z_PARTIAL_FLUSH); |
} |
if (s->level != level) { |
s->level = level; |
s->max_lazy_match = configuration_table[level].max_lazy; |
s->good_match = configuration_table[level].good_length; |
s->nice_match = configuration_table[level].nice_length; |
s->max_chain_length = configuration_table[level].max_chain; |
} |
s->strategy = strategy; |
return err; |
} |
/* ========================================================================= |
* Put a short in the pending buffer. The 16-bit value is put in MSB order. |
* IN assertion: the stream state is correct and there is enough room in |
* pending_buf. |
*/ |
local void putShortMSB (s, b) |
deflate_state *s; |
uInt b; |
{ |
put_byte(s, (Byte)(b >> 8)); |
put_byte(s, (Byte)(b & 0xff)); |
} |
/* ========================================================================= |
* Flush as much pending output as possible. All deflate() output goes |
* through this function so some applications may wish to modify it |
* to avoid allocating a large strm->next_out buffer and copying into it. |
* (See also read_buf()). |
*/ |
local void flush_pending(strm) |
z_streamp strm; |
{ |
unsigned len = strm->state->pending; |
if (len > strm->avail_out) len = strm->avail_out; |
if (len == 0) return; |
zmemcpy(strm->next_out, strm->state->pending_out, len); |
strm->next_out += len; |
strm->state->pending_out += len; |
strm->total_out += len; |
strm->avail_out -= len; |
strm->state->pending -= len; |
if (strm->state->pending == 0) { |
strm->state->pending_out = strm->state->pending_buf; |
} |
} |
/* ========================================================================= */ |
int ZEXPORT deflate (strm, flush) |
z_streamp strm; |
int flush; |
{ |
int old_flush; /* value of flush param for previous deflate call */ |
deflate_state *s; |
if (strm == Z_NULL || strm->state == Z_NULL || |
flush > Z_FINISH || flush < 0) { |
return Z_STREAM_ERROR; |
} |
s = strm->state; |
if (strm->next_out == Z_NULL || |
(strm->next_in == Z_NULL && strm->avail_in != 0) || |
(s->status == FINISH_STATE && flush != Z_FINISH)) { |
ERR_RETURN(strm, Z_STREAM_ERROR); |
} |
if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); |
s->strm = strm; /* just in case */ |
old_flush = s->last_flush; |
s->last_flush = flush; |
/* Write the zlib header */ |
if (s->status == INIT_STATE) { |
uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; |
uInt level_flags = (s->level-1) >> 1; |
if (level_flags > 3) level_flags = 3; |
header |= (level_flags << 6); |
if (s->strstart != 0) header |= PRESET_DICT; |
header += 31 - (header % 31); |
s->status = BUSY_STATE; |
putShortMSB(s, header); |
/* Save the adler32 of the preset dictionary: */ |
if (s->strstart != 0) { |
putShortMSB(s, (uInt)(strm->adler >> 16)); |
putShortMSB(s, (uInt)(strm->adler & 0xffff)); |
} |
strm->adler = 1L; |
} |
/* Flush as much pending output as possible */ |
if (s->pending != 0) { |
flush_pending(strm); |
if (strm->avail_out == 0) { |
/* Since avail_out is 0, deflate will be called again with |
* more output space, but possibly with both pending and |
* avail_in equal to zero. There won't be anything to do, |
* but this is not an error situation so make sure we |
* return OK instead of BUF_ERROR at next call of deflate: |
*/ |
s->last_flush = -1; |
return Z_OK; |
} |
/* Make sure there is something to do and avoid duplicate consecutive |
* flushes. For repeated and useless calls with Z_FINISH, we keep |
* returning Z_STREAM_END instead of Z_BUFF_ERROR. |
*/ |
} else if (strm->avail_in == 0 && flush <= old_flush && |
flush != Z_FINISH) { |
ERR_RETURN(strm, Z_BUF_ERROR); |
} |
/* User must not provide more input after the first FINISH: */ |
if (s->status == FINISH_STATE && strm->avail_in != 0) { |
ERR_RETURN(strm, Z_BUF_ERROR); |
} |
/* Start a new block or continue the current one. |
*/ |
if (strm->avail_in != 0 || s->lookahead != 0 || |
(flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { |
block_state bstate; |
bstate = (*(configuration_table[s->level].func))(s, flush); |
if (bstate == finish_started || bstate == finish_done) { |
s->status = FINISH_STATE; |
} |
if (bstate == need_more || bstate == finish_started) { |
if (strm->avail_out == 0) { |
s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ |
} |
return Z_OK; |
/* If flush != Z_NO_FLUSH && avail_out == 0, the next call |
* of deflate should use the same flush parameter to make sure |
* that the flush is complete. So we don't have to output an |
* empty block here, this will be done at next call. This also |
* ensures that for a very small output buffer, we emit at most |
* one empty block. |
*/ |
} |
if (bstate == block_done) { |
if (flush == Z_PARTIAL_FLUSH) { |
_tr_align(s); |
} else { /* FULL_FLUSH or SYNC_FLUSH */ |
_tr_stored_block(s, (char*)0, 0L, 0); |
/* For a full flush, this empty block will be recognized |
* as a special marker by inflate_sync(). |
*/ |
if (flush == Z_FULL_FLUSH) { |
CLEAR_HASH(s); /* forget history */ |
} |
} |
flush_pending(strm); |
if (strm->avail_out == 0) { |
s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ |
return Z_OK; |
} |
} |
} |
Assert(strm->avail_out > 0, "bug2"); |
if (flush != Z_FINISH) return Z_OK; |
if (s->noheader) return Z_STREAM_END; |
/* Write the zlib trailer (adler32) */ |
putShortMSB(s, (uInt)(strm->adler >> 16)); |
putShortMSB(s, (uInt)(strm->adler & 0xffff)); |
flush_pending(strm); |
/* If avail_out is zero, the application will call deflate again |
* to flush the rest. |
*/ |
s->noheader = -1; /* write the trailer only once! */ |
return s->pending != 0 ? Z_OK : Z_STREAM_END; |
} |
/* ========================================================================= */ |
int ZEXPORT deflateEnd (strm) |
z_streamp strm; |
{ |
int status; |
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
status = strm->state->status; |
if (status != INIT_STATE && status != BUSY_STATE && |
status != FINISH_STATE) { |
return Z_STREAM_ERROR; |
} |
/* Deallocate in reverse order of allocations: */ |
TRY_FREE(strm, strm->state->pending_buf); |
TRY_FREE(strm, strm->state->head); |
TRY_FREE(strm, strm->state->prev); |
TRY_FREE(strm, strm->state->window); |
ZFREE(strm, strm->state); |
strm->state = Z_NULL; |
return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; |
} |
/* ========================================================================= |
* Copy the source state to the destination state. |
* To simplify the source, this is not supported for 16-bit MSDOS (which |
* doesn't have enough memory anyway to duplicate compression states). |
*/ |
int ZEXPORT deflateCopy (dest, source) |
z_streamp dest; |
z_streamp source; |
{ |
#ifdef MAXSEG_64K |
return Z_STREAM_ERROR; |
#else |
deflate_state *ds; |
deflate_state *ss; |
ushf *overlay; |
if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { |
return Z_STREAM_ERROR; |
} |
ss = source->state; |
*dest = *source; |
ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); |
if (ds == Z_NULL) return Z_MEM_ERROR; |
dest->state = (struct internal_state FAR *) ds; |
*ds = *ss; |
ds->strm = dest; |
ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); |
ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); |
ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); |
overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); |
ds->pending_buf = (uchf *) overlay; |
if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || |
ds->pending_buf == Z_NULL) { |
deflateEnd (dest); |
return Z_MEM_ERROR; |
} |
/* following zmemcpy do not work for 16-bit MSDOS */ |
zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); |
zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); |
zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); |
zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); |
ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); |
ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); |
ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; |
ds->l_desc.dyn_tree = ds->dyn_ltree; |
ds->d_desc.dyn_tree = ds->dyn_dtree; |
ds->bl_desc.dyn_tree = ds->bl_tree; |
return Z_OK; |
#endif |
} |
/* =========================================================================== |
* Read a new buffer from the current input stream, update the adler32 |
* and total number of bytes read. All deflate() input goes through |
* this function so some applications may wish to modify it to avoid |
* allocating a large strm->next_in buffer and copying from it. |
* (See also flush_pending()). |
*/ |
local int read_buf(strm, buf, size) |
z_streamp strm; |
Bytef *buf; |
unsigned size; |
{ |
unsigned len = strm->avail_in; |
if (len > size) len = size; |
if (len == 0) return 0; |
strm->avail_in -= len; |
if (!strm->state->noheader) { |
strm->adler = adler32(strm->adler, strm->next_in, len); |
} |
zmemcpy(buf, strm->next_in, len); |
strm->next_in += len; |
strm->total_in += len; |
return (int)len; |
} |
/* =========================================================================== |
* Initialize the "longest match" routines for a new zlib stream |
*/ |
local void lm_init (s) |
deflate_state *s; |
{ |
s->window_size = (ulg)2L*s->w_size; |
CLEAR_HASH(s); |
/* Set the default configuration parameters: |
*/ |
s->max_lazy_match = configuration_table[s->level].max_lazy; |
s->good_match = configuration_table[s->level].good_length; |
s->nice_match = configuration_table[s->level].nice_length; |
s->max_chain_length = configuration_table[s->level].max_chain; |
s->strstart = 0; |
s->block_start = 0L; |
s->lookahead = 0; |
s->match_length = s->prev_length = MIN_MATCH-1; |
s->match_available = 0; |
s->ins_h = 0; |
#ifdef ASMV |
match_init(); /* initialize the asm code */ |
#endif |
} |
/* =========================================================================== |
* Set match_start to the longest match starting at the given string and |
* return its length. Matches shorter or equal to prev_length are discarded, |
* in which case the result is equal to prev_length and match_start is |
* garbage. |
* IN assertions: cur_match is the head of the hash chain for the current |
* string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 |
* OUT assertion: the match length is not greater than s->lookahead. |
*/ |
#ifndef ASMV |
/* For 80x86 and 680x0, an optimized version will be provided in match.asm or |
* match.S. The code will be functionally equivalent. |
*/ |
#ifndef FASTEST |
local uInt longest_match(s, cur_match) |
deflate_state *s; |
IPos cur_match; /* current match */ |
{ |
unsigned chain_length = s->max_chain_length;/* max hash chain length */ |
register Bytef *scan = s->window + s->strstart; /* current string */ |
register Bytef *match; /* matched string */ |
register int len; /* length of current match */ |
int best_len = s->prev_length; /* best match length so far */ |
int nice_match = s->nice_match; /* stop if match long enough */ |
IPos limit = s->strstart > (IPos)MAX_DIST(s) ? |
s->strstart - (IPos)MAX_DIST(s) : NIL; |
/* Stop when cur_match becomes <= limit. To simplify the code, |
* we prevent matches with the string of window index 0. |
*/ |
Posf *prev = s->prev; |
uInt wmask = s->w_mask; |
#ifdef UNALIGNED_OK |
/* Compare two bytes at a time. Note: this is not always beneficial. |
* Try with and without -DUNALIGNED_OK to check. |
*/ |
register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; |
register ush scan_start = *(ushf*)scan; |
register ush scan_end = *(ushf*)(scan+best_len-1); |
#else |
register Bytef *strend = s->window + s->strstart + MAX_MATCH; |
register Byte scan_end1 = scan[best_len-1]; |
register Byte scan_end = scan[best_len]; |
#endif |
/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. |
* It is easy to get rid of this optimization if necessary. |
*/ |
Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); |
/* Do not waste too much time if we already have a good match: */ |
if (s->prev_length >= s->good_match) { |
chain_length >>= 2; |
} |
/* Do not look for matches beyond the end of the input. This is necessary |
* to make deflate deterministic. |
*/ |
if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; |
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); |
do { |
Assert(cur_match < s->strstart, "no future"); |
match = s->window + cur_match; |
/* Skip to next match if the match length cannot increase |
* or if the match length is less than 2: |
*/ |
#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) |
/* This code assumes sizeof(unsigned short) == 2. Do not use |
* UNALIGNED_OK if your compiler uses a different size. |
*/ |
if (*(ushf*)(match+best_len-1) != scan_end || |
*(ushf*)match != scan_start) continue; |
/* It is not necessary to compare scan[2] and match[2] since they are |
* always equal when the other bytes match, given that the hash keys |
* are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at |
* strstart+3, +5, ... up to strstart+257. We check for insufficient |
* lookahead only every 4th comparison; the 128th check will be made |
* at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is |
* necessary to put more guard bytes at the end of the window, or |
* to check more often for insufficient lookahead. |
*/ |
Assert(scan[2] == match[2], "scan[2]?"); |
scan++, match++; |
do { |
} while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && |
*(ushf*)(scan+=2) == *(ushf*)(match+=2) && |
*(ushf*)(scan+=2) == *(ushf*)(match+=2) && |
*(ushf*)(scan+=2) == *(ushf*)(match+=2) && |
scan < strend); |
/* The funny "do {}" generates better code on most compilers */ |
/* Here, scan <= window+strstart+257 */ |
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); |
if (*scan == *match) scan++; |
len = (MAX_MATCH - 1) - (int)(strend-scan); |
scan = strend - (MAX_MATCH-1); |
#else /* UNALIGNED_OK */ |
if (match[best_len] != scan_end || |
match[best_len-1] != scan_end1 || |
*match != *scan || |
*++match != scan[1]) continue; |
/* The check at best_len-1 can be removed because it will be made |
* again later. (This heuristic is not always a win.) |
* It is not necessary to compare scan[2] and match[2] since they |
* are always equal when the other bytes match, given that |
* the hash keys are equal and that HASH_BITS >= 8. |
*/ |
scan += 2, match++; |
Assert(*scan == *match, "match[2]?"); |
/* We check for insufficient lookahead only every 8th comparison; |
* the 256th check will be made at strstart+258. |
*/ |
do { |
} while (*++scan == *++match && *++scan == *++match && |
*++scan == *++match && *++scan == *++match && |
*++scan == *++match && *++scan == *++match && |
*++scan == *++match && *++scan == *++match && |
scan < strend); |
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); |
len = MAX_MATCH - (int)(strend - scan); |
scan = strend - MAX_MATCH; |
#endif /* UNALIGNED_OK */ |
if (len > best_len) { |
s->match_start = cur_match; |
best_len = len; |
if (len >= nice_match) break; |
#ifdef UNALIGNED_OK |
scan_end = *(ushf*)(scan+best_len-1); |
#else |
scan_end1 = scan[best_len-1]; |
scan_end = scan[best_len]; |
#endif |
} |
} while ((cur_match = prev[cur_match & wmask]) > limit |
&& --chain_length != 0); |
if ((uInt)best_len <= s->lookahead) return (uInt)best_len; |
return s->lookahead; |
} |
#else /* FASTEST */ |
/* --------------------------------------------------------------------------- |
* Optimized version for level == 1 only |
*/ |
local uInt longest_match(s, cur_match) |
deflate_state *s; |
IPos cur_match; /* current match */ |
{ |
register Bytef *scan = s->window + s->strstart; /* current string */ |
register Bytef *match; /* matched string */ |
register int len; /* length of current match */ |
register Bytef *strend = s->window + s->strstart + MAX_MATCH; |
/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. |
* It is easy to get rid of this optimization if necessary. |
*/ |
Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); |
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); |
Assert(cur_match < s->strstart, "no future"); |
match = s->window + cur_match; |
/* Return failure if the match length is less than 2: |
*/ |
if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; |
/* The check at best_len-1 can be removed because it will be made |
* again later. (This heuristic is not always a win.) |
* It is not necessary to compare scan[2] and match[2] since they |
* are always equal when the other bytes match, given that |
* the hash keys are equal and that HASH_BITS >= 8. |
*/ |
scan += 2, match += 2; |
Assert(*scan == *match, "match[2]?"); |
/* We check for insufficient lookahead only every 8th comparison; |
* the 256th check will be made at strstart+258. |
*/ |
do { |
} while (*++scan == *++match && *++scan == *++match && |
*++scan == *++match && *++scan == *++match && |
*++scan == *++match && *++scan == *++match && |
*++scan == *++match && *++scan == *++match && |
scan < strend); |
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); |
len = MAX_MATCH - (int)(strend - scan); |
if (len < MIN_MATCH) return MIN_MATCH - 1; |
s->match_start = cur_match; |
return len <= s->lookahead ? len : s->lookahead; |
} |
#endif /* FASTEST */ |
#endif /* ASMV */ |
#ifdef DEBUG |
/* =========================================================================== |
* Check that the match at match_start is indeed a match. |
*/ |
local void check_match(s, start, match, length) |
deflate_state *s; |
IPos start, match; |
int length; |
{ |
/* check that the match is indeed a match */ |
if (zmemcmp(s->window + match, |
s->window + start, length) != EQUAL) { |
cprintf(" start %u, match %u, length %d\n", |
start, match, length); |
do { |
cprintf("%c%c", s->window[match++], s->window[start++]); |
} while (--length != 0); |
z_error("invalid match"); |
} |
if (z_verbose > 1) { |
cprintf("\\[%d,%d]", start-match, length); |
do { putc(s->window[start++], stderr); } while (--length != 0); |
} |
} |
#else |
# define check_match(s, start, match, length) |
#endif |
/* =========================================================================== |
* Fill the window when the lookahead becomes insufficient. |
* Updates strstart and lookahead. |
* |
* IN assertion: lookahead < MIN_LOOKAHEAD |
* OUT assertions: strstart <= window_size-MIN_LOOKAHEAD |
* At least one byte has been read, or avail_in == 0; reads are |
* performed for at least two bytes (required for the zip translate_eol |
* option -- not supported here). |
*/ |
local void fill_window(s) |
deflate_state *s; |
{ |
register unsigned n, m; |
register Posf *p; |
unsigned more; /* Amount of free space at the end of the window. */ |
uInt wsize = s->w_size; |
do { |
more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); |
/* Deal with !@#$% 64K limit: */ |
if (more == 0 && s->strstart == 0 && s->lookahead == 0) { |
more = wsize; |
} else if (more == (unsigned)(-1)) { |
/* Very unlikely, but possible on 16 bit machine if strstart == 0 |
* and lookahead == 1 (input done one byte at time) |
*/ |
more--; |
/* If the window is almost full and there is insufficient lookahead, |
* move the upper half to the lower one to make room in the upper half. |
*/ |
} else if (s->strstart >= wsize+MAX_DIST(s)) { |
zmemcpy(s->window, s->window+wsize, (unsigned)wsize); |
s->match_start -= wsize; |
s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ |
s->block_start -= (long) wsize; |
/* Slide the hash table (could be avoided with 32 bit values |
at the expense of memory usage). We slide even when level == 0 |
to keep the hash table consistent if we switch back to level > 0 |
later. (Using level 0 permanently is not an optimal usage of |
zlib, so we don't care about this pathological case.) |
*/ |
n = s->hash_size; |
p = &s->head[n]; |
do { |
m = *--p; |
*p = (Pos)(m >= wsize ? m-wsize : NIL); |
} while (--n); |
n = wsize; |
#ifndef FASTEST |
p = &s->prev[n]; |
do { |
m = *--p; |
*p = (Pos)(m >= wsize ? m-wsize : NIL); |
/* If n is not on any hash chain, prev[n] is garbage but |
* its value will never be used. |
*/ |
} while (--n); |
#endif |
more += wsize; |
} |
if (s->strm->avail_in == 0) return; |
/* If there was no sliding: |
* strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && |
* more == window_size - lookahead - strstart |
* => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) |
* => more >= window_size - 2*WSIZE + 2 |
* In the BIG_MEM or MMAP case (not yet supported), |
* window_size == input_size + MIN_LOOKAHEAD && |
* strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. |
* Otherwise, window_size == 2*WSIZE so more >= 2. |
* If there was sliding, more >= WSIZE. So in all cases, more >= 2. |
*/ |
Assert(more >= 2, "more < 2"); |
n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); |
s->lookahead += n; |
/* Initialize the hash value now that we have some input: */ |
if (s->lookahead >= MIN_MATCH) { |
s->ins_h = s->window[s->strstart]; |
UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); |
#if MIN_MATCH != 3 |
Call UPDATE_HASH() MIN_MATCH-3 more times |
#endif |
} |
/* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, |
* but this is not important since only literal bytes will be emitted. |
*/ |
} while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); |
} |
/* =========================================================================== |
* Flush the current block, with given end-of-file flag. |
* IN assertion: strstart is set to the end of the current match. |
*/ |
#define FLUSH_BLOCK_ONLY(s, eof) { \ |
_tr_flush_block(s, (s->block_start >= 0L ? \ |
(charf *)&s->window[(unsigned)s->block_start] : \ |
(charf *)Z_NULL), \ |
(ulg)((long)s->strstart - s->block_start), \ |
(eof)); \ |
s->block_start = s->strstart; \ |
flush_pending(s->strm); \ |
Tracev((stderr,"[FLUSH]")); \ |
} |
/* Same but force premature exit if necessary. */ |
#define FLUSH_BLOCK(s, eof) { \ |
FLUSH_BLOCK_ONLY(s, eof); \ |
if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \ |
} |
/* =========================================================================== |
* Copy without compression as much as possible from the input stream, return |
* the current block state. |
* This function does not insert new strings in the dictionary since |
* uncompressible data is probably not useful. This function is used |
* only for the level=0 compression option. |
* NOTE: this function should be optimized to avoid extra copying from |
* window to pending_buf. |
*/ |
local block_state deflate_stored(s, flush) |
deflate_state *s; |
int flush; |
{ |
/* Stored blocks are limited to 0xffff bytes, pending_buf is limited |
* to pending_buf_size, and each stored block has a 5 byte header: |
*/ |
ulg max_block_size = 0xffff; |
ulg max_start; |
if (max_block_size > s->pending_buf_size - 5) { |
max_block_size = s->pending_buf_size - 5; |
} |
/* Copy as much as possible from input to output: */ |
for (;;) { |
/* Fill the window as much as possible: */ |
if (s->lookahead <= 1) { |
Assert(s->strstart < s->w_size+MAX_DIST(s) || |
s->block_start >= (long)s->w_size, "slide too late"); |
fill_window(s); |
if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; |
if (s->lookahead == 0) break; /* flush the current block */ |
} |
Assert(s->block_start >= 0L, "block gone"); |
s->strstart += s->lookahead; |
s->lookahead = 0; |
/* Emit a stored block if pending_buf will be full: */ |
max_start = s->block_start + max_block_size; |
if (s->strstart == 0 || (ulg)s->strstart >= max_start) { |
/* strstart == 0 is possible when wraparound on 16-bit machine */ |
s->lookahead = (uInt)(s->strstart - max_start); |
s->strstart = (uInt)max_start; |
FLUSH_BLOCK(s, 0); |
} |
/* Flush if we may have to slide, otherwise block_start may become |
* negative and the data will be gone: |
*/ |
if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { |
FLUSH_BLOCK(s, 0); |
} |
} |
FLUSH_BLOCK(s, flush == Z_FINISH); |
return flush == Z_FINISH ? finish_done : block_done; |
} |
/* =========================================================================== |
* Compress as much as possible from the input stream, return the current |
* block state. |
* This function does not perform lazy evaluation of matches and inserts |
* new strings in the dictionary only for unmatched strings or for short |
* matches. It is used only for the fast compression options. |
*/ |
local block_state deflate_fast(s, flush) |
deflate_state *s; |
int flush; |
{ |
IPos hash_head = NIL; /* head of the hash chain */ |
int bflush; /* set if current block must be flushed */ |
for (;;) { |
/* Make sure that we always have enough lookahead, except |
* at the end of the input file. We need MAX_MATCH bytes |
* for the next match, plus MIN_MATCH bytes to insert the |
* string following the next match. |
*/ |
if (s->lookahead < MIN_LOOKAHEAD) { |
fill_window(s); |
if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { |
return need_more; |
} |
if (s->lookahead == 0) break; /* flush the current block */ |
} |
/* Insert the string window[strstart .. strstart+2] in the |
* dictionary, and set hash_head to the head of the hash chain: |
*/ |
if (s->lookahead >= MIN_MATCH) { |
INSERT_STRING(s, s->strstart, hash_head); |
} |
/* Find the longest match, discarding those <= prev_length. |
* At this point we have always match_length < MIN_MATCH |
*/ |
if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { |
/* To simplify the code, we prevent matches with the string |
* of window index 0 (in particular we have to avoid a match |
* of the string with itself at the start of the input file). |
*/ |
if (s->strategy != Z_HUFFMAN_ONLY) { |
s->match_length = longest_match (s, hash_head); |
} |
/* longest_match() sets match_start */ |
} |
if (s->match_length >= MIN_MATCH) { |
check_match(s, s->strstart, s->match_start, s->match_length); |
_tr_tally_dist(s, s->strstart - s->match_start, |
s->match_length - MIN_MATCH, bflush); |
s->lookahead -= s->match_length; |
/* Insert new strings in the hash table only if the match length |
* is not too large. This saves time but degrades compression. |
*/ |
#ifndef FASTEST |
if (s->match_length <= s->max_insert_length && |
s->lookahead >= MIN_MATCH) { |
s->match_length--; /* string at strstart already in hash table */ |
do { |
s->strstart++; |
INSERT_STRING(s, s->strstart, hash_head); |
/* strstart never exceeds WSIZE-MAX_MATCH, so there are |
* always MIN_MATCH bytes ahead. |
*/ |
} while (--s->match_length != 0); |
s->strstart++; |
} else |
#endif |
{ |
s->strstart += s->match_length; |
s->match_length = 0; |
s->ins_h = s->window[s->strstart]; |
UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); |
#if MIN_MATCH != 3 |
Call UPDATE_HASH() MIN_MATCH-3 more times |
#endif |
/* If lookahead < MIN_MATCH, ins_h is garbage, but it does not |
* matter since it will be recomputed at next deflate call. |
*/ |
} |
} else { |
/* No match, output a literal byte */ |
Tracevv((stderr,"%c", s->window[s->strstart])); |
_tr_tally_lit (s, s->window[s->strstart], bflush); |
s->lookahead--; |
s->strstart++; |
} |
if (bflush) FLUSH_BLOCK(s, 0); |
} |
FLUSH_BLOCK(s, flush == Z_FINISH); |
return flush == Z_FINISH ? finish_done : block_done; |
} |
/* =========================================================================== |
* Same as above, but achieves better compression. We use a lazy |
* evaluation for matches: a match is finally adopted only if there is |
* no better match at the next window position. |
*/ |
local block_state deflate_slow(s, flush) |
deflate_state *s; |
int flush; |
{ |
IPos hash_head = NIL; /* head of hash chain */ |
int bflush; /* set if current block must be flushed */ |
/* Process the input block. */ |
for (;;) { |
/* Make sure that we always have enough lookahead, except |
* at the end of the input file. We need MAX_MATCH bytes |
* for the next match, plus MIN_MATCH bytes to insert the |
* string following the next match. |
*/ |
if (s->lookahead < MIN_LOOKAHEAD) { |
fill_window(s); |
if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { |
return need_more; |
} |
if (s->lookahead == 0) break; /* flush the current block */ |
} |
/* Insert the string window[strstart .. strstart+2] in the |
* dictionary, and set hash_head to the head of the hash chain: |
*/ |
if (s->lookahead >= MIN_MATCH) { |
INSERT_STRING(s, s->strstart, hash_head); |
} |
/* Find the longest match, discarding those <= prev_length. |
*/ |
s->prev_length = s->match_length, s->prev_match = s->match_start; |
s->match_length = MIN_MATCH-1; |
if (hash_head != NIL && s->prev_length < s->max_lazy_match && |
s->strstart - hash_head <= MAX_DIST(s)) { |
/* To simplify the code, we prevent matches with the string |
* of window index 0 (in particular we have to avoid a match |
* of the string with itself at the start of the input file). |
*/ |
if (s->strategy != Z_HUFFMAN_ONLY) { |
s->match_length = longest_match (s, hash_head); |
} |
/* longest_match() sets match_start */ |
if (s->match_length <= 5 && (s->strategy == Z_FILTERED || |
(s->match_length == MIN_MATCH && |
s->strstart - s->match_start > TOO_FAR))) { |
/* If prev_match is also MIN_MATCH, match_start is garbage |
* but we will ignore the current match anyway. |
*/ |
s->match_length = MIN_MATCH-1; |
} |
} |
/* If there was a match at the previous step and the current |
* match is not better, output the previous match: |
*/ |
if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { |
uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; |
/* Do not insert strings in hash table beyond this. */ |
check_match(s, s->strstart-1, s->prev_match, s->prev_length); |
_tr_tally_dist(s, s->strstart -1 - s->prev_match, |
s->prev_length - MIN_MATCH, bflush); |
/* Insert in hash table all strings up to the end of the match. |
* strstart-1 and strstart are already inserted. If there is not |
* enough lookahead, the last two strings are not inserted in |
* the hash table. |
*/ |
s->lookahead -= s->prev_length-1; |
s->prev_length -= 2; |
do { |
if (++s->strstart <= max_insert) { |
INSERT_STRING(s, s->strstart, hash_head); |
} |
} while (--s->prev_length != 0); |
s->match_available = 0; |
s->match_length = MIN_MATCH-1; |
s->strstart++; |
if (bflush) FLUSH_BLOCK(s, 0); |
} else if (s->match_available) { |
/* If there was no match at the previous position, output a |
* single literal. If there was a match but the current match |
* is longer, truncate the previous match to a single literal. |
*/ |
Tracevv((stderr,"%c", s->window[s->strstart-1])); |
_tr_tally_lit(s, s->window[s->strstart-1], bflush); |
if (bflush) { |
FLUSH_BLOCK_ONLY(s, 0); |
} |
s->strstart++; |
s->lookahead--; |
if (s->strm->avail_out == 0) return need_more; |
} else { |
/* There is no previous match to compare with, wait for |
* the next step to decide. |
*/ |
s->match_available = 1; |
s->strstart++; |
s->lookahead--; |
} |
} |
Assert (flush != Z_NO_FLUSH, "no flush?"); |
if (s->match_available) { |
Tracevv((stderr,"%c", s->window[s->strstart-1])); |
_tr_tally_lit(s, s->window[s->strstart-1], bflush); |
s->match_available = 0; |
} |
FLUSH_BLOCK(s, flush == Z_FINISH); |
return flush == Z_FINISH ? finish_done : block_done; |
} |
/shark/trunk/ports/png/zutil.c |
---|
0,0 → 1,225 |
/* zutil.c -- target dependent utility functions for the compression library |
* Copyright (C) 1995-2002 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* @(#) $Id: zutil.c,v 1.1 2003-03-20 13:08:13 giacomo Exp $ */ |
#include "zutil.h" |
struct internal_state {int dummy;}; /* for buggy compilers */ |
#ifndef STDC |
extern void exit OF((int)); |
#endif |
const char *z_errmsg[10] = { |
"need dictionary", /* Z_NEED_DICT 2 */ |
"stream end", /* Z_STREAM_END 1 */ |
"", /* Z_OK 0 */ |
"file error", /* Z_ERRNO (-1) */ |
"stream error", /* Z_STREAM_ERROR (-2) */ |
"data error", /* Z_DATA_ERROR (-3) */ |
"insufficient memory", /* Z_MEM_ERROR (-4) */ |
"buffer error", /* Z_BUF_ERROR (-5) */ |
"incompatible version",/* Z_VERSION_ERROR (-6) */ |
""}; |
const char * ZEXPORT zlibVersion() |
{ |
return ZLIB_VERSION; |
} |
#ifdef DEBUG |
# ifndef verbose |
# define verbose 0 |
# endif |
int z_verbose = verbose; |
void z_error (m) |
char *m; |
{ |
cprintf("%s\n", m); |
exit(1); |
} |
#endif |
/* exported to allow conversion of error code to string for compress() and |
* uncompress() |
*/ |
const char * ZEXPORT zError(err) |
int err; |
{ |
return ERR_MSG(err); |
} |
#ifndef HAVE_MEMCPY |
void zmemcpy(dest, source, len) |
Bytef* dest; |
const Bytef* source; |
uInt len; |
{ |
if (len == 0) return; |
do { |
*dest++ = *source++; /* ??? to be unrolled */ |
} while (--len != 0); |
} |
int zmemcmp(s1, s2, len) |
const Bytef* s1; |
const Bytef* s2; |
uInt len; |
{ |
uInt j; |
for (j = 0; j < len; j++) { |
if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; |
} |
return 0; |
} |
void zmemzero(dest, len) |
Bytef* dest; |
uInt len; |
{ |
if (len == 0) return; |
do { |
*dest++ = 0; /* ??? to be unrolled */ |
} while (--len != 0); |
} |
#endif |
#ifdef __TURBOC__ |
#if (defined( __BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__) |
/* Small and medium model in Turbo C are for now limited to near allocation |
* with reduced MAX_WBITS and MAX_MEM_LEVEL |
*/ |
# define MY_ZCALLOC |
/* Turbo C malloc() does not allow dynamic allocation of 64K bytes |
* and farmalloc(64K) returns a pointer with an offset of 8, so we |
* must fix the pointer. Warning: the pointer must be put back to its |
* original form in order to free it, use zcfree(). |
*/ |
#define MAX_PTR 10 |
/* 10*64K = 640K */ |
local int next_ptr = 0; |
typedef struct ptr_table_s { |
voidpf org_ptr; |
voidpf new_ptr; |
} ptr_table; |
local ptr_table table[MAX_PTR]; |
/* This table is used to remember the original form of pointers |
* to large buffers (64K). Such pointers are normalized with a zero offset. |
* Since MSDOS is not a preemptive multitasking OS, this table is not |
* protected from concurrent access. This hack doesn't work anyway on |
* a protected system like OS/2. Use Microsoft C instead. |
*/ |
voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) |
{ |
voidpf buf = opaque; /* just to make some compilers happy */ |
ulg bsize = (ulg)items*size; |
/* If we allocate less than 65520 bytes, we assume that farmalloc |
* will return a usable pointer which doesn't have to be normalized. |
*/ |
if (bsize < 65520L) { |
buf = farmalloc(bsize); |
if (*(ush*)&buf != 0) return buf; |
} else { |
buf = farmalloc(bsize + 16L); |
} |
if (buf == NULL || next_ptr >= MAX_PTR) return NULL; |
table[next_ptr].org_ptr = buf; |
/* Normalize the pointer to seg:0 */ |
*((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; |
*(ush*)&buf = 0; |
table[next_ptr++].new_ptr = buf; |
return buf; |
} |
void zcfree (voidpf opaque, voidpf ptr) |
{ |
int n; |
if (*(ush*)&ptr != 0) { /* object < 64K */ |
farfree(ptr); |
return; |
} |
/* Find the original pointer */ |
for (n = 0; n < next_ptr; n++) { |
if (ptr != table[n].new_ptr) continue; |
farfree(table[n].org_ptr); |
while (++n < next_ptr) { |
table[n-1] = table[n]; |
} |
next_ptr--; |
return; |
} |
ptr = opaque; /* just to make some compilers happy */ |
Assert(0, "zcfree: ptr not found"); |
} |
#endif |
#endif /* __TURBOC__ */ |
#if defined(M_I86) && !defined(__32BIT__) |
/* Microsoft C in 16-bit mode */ |
# define MY_ZCALLOC |
#if (!defined(_MSC_VER) || (_MSC_VER <= 600)) |
# define _halloc halloc |
# define _hfree hfree |
#endif |
voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) |
{ |
if (opaque) opaque = 0; /* to make compiler happy */ |
return _halloc((long)items, size); |
} |
void zcfree (voidpf opaque, voidpf ptr) |
{ |
if (opaque) opaque = 0; /* to make compiler happy */ |
_hfree(ptr); |
} |
#endif /* MSC */ |
#ifndef MY_ZCALLOC /* Any system without a special alloc function */ |
#ifndef STDC |
extern voidp calloc OF((uInt items, uInt size)); |
extern void free OF((voidpf ptr)); |
#endif |
voidpf zcalloc (opaque, items, size) |
voidpf opaque; |
unsigned items; |
unsigned size; |
{ |
if (opaque) items += size - size; /* make compiler happy */ |
return (voidpf)calloc(items, size); |
} |
void zcfree (opaque, ptr) |
voidpf opaque; |
voidpf ptr; |
{ |
free(ptr); |
if (opaque) return; /* make compiler happy */ |
} |
#endif /* MY_ZCALLOC */ |
/shark/trunk/ports/png/gzio.c |
---|
0,0 → 1,875 |
/* gzio.c -- IO on .gz files |
* Copyright (C) 1995-2002 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
* |
* Compile this file with -DNO_DEFLATE to avoid the compression code. |
*/ |
/* @(#) $Id: gzio.c,v 1.1 2003-03-20 13:08:10 giacomo Exp $ */ |
#include <stdio.h> |
#include "zutil.h" |
struct internal_state {int dummy;}; /* for buggy compilers */ |
#ifndef Z_BUFSIZE |
# ifdef MAXSEG_64K |
# define Z_BUFSIZE 4096 /* minimize memory usage for 16-bit DOS */ |
# else |
# define Z_BUFSIZE 16384 |
# endif |
#endif |
#ifndef Z_PRINTF_BUFSIZE |
# define Z_PRINTF_BUFSIZE 4096 |
#endif |
#define ALLOC(size) malloc(size) |
#define TRYFREE(p) {if (p) free(p);} |
static int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */ |
/* gzip flag byte */ |
#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ |
#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */ |
#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ |
#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ |
#define COMMENT 0x10 /* bit 4 set: file comment present */ |
#define RESERVED 0xE0 /* bits 5..7: reserved */ |
typedef struct gz_stream { |
z_stream stream; |
int z_err; /* error code for last stream operation */ |
int z_eof; /* set if end of input file */ |
FILE *file; /* .gz file */ |
Byte *inbuf; /* input buffer */ |
Byte *outbuf; /* output buffer */ |
uLong crc; /* crc32 of uncompressed data */ |
char *msg; /* error message */ |
char *path; /* path name for debugging only */ |
int transparent; /* 1 if input file is not a .gz file */ |
char mode; /* 'w' or 'r' */ |
long startpos; /* start of compressed data in file (header skipped) */ |
} gz_stream; |
local gzFile gz_open OF((const char *path, const char *mode, int fd)); |
local int do_flush OF((gzFile file, int flush)); |
local int get_byte OF((gz_stream *s)); |
local void check_header OF((gz_stream *s)); |
local int destroy OF((gz_stream *s)); |
local void putLong OF((FILE *file, uLong x)); |
local uLong getLong OF((gz_stream *s)); |
/* =========================================================================== |
Opens a gzip (.gz) file for reading or writing. The mode parameter |
is as in fopen ("rb" or "wb"). The file is given either by file descriptor |
or path name (if fd == -1). |
gz_open return NULL if the file could not be opened or if there was |
insufficient memory to allocate the (de)compression state; errno |
can be checked to distinguish the two cases (if errno is zero, the |
zlib error is Z_MEM_ERROR). |
*/ |
local gzFile gz_open (path, mode, fd) |
const char *path; |
const char *mode; |
int fd; |
{ |
int err; |
int level = Z_DEFAULT_COMPRESSION; /* compression level */ |
int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */ |
char *p = (char*)mode; |
gz_stream *s; |
char fmode[80]; /* copy of mode, without the compression level */ |
char *m = fmode; |
if (!path || !mode) return Z_NULL; |
s = (gz_stream *)ALLOC(sizeof(gz_stream)); |
if (!s) return Z_NULL; |
s->stream.zalloc = (alloc_func)0; |
s->stream.zfree = (free_func)0; |
s->stream.opaque = (voidpf)0; |
s->stream.next_in = s->inbuf = Z_NULL; |
s->stream.next_out = s->outbuf = Z_NULL; |
s->stream.avail_in = s->stream.avail_out = 0; |
s->file = NULL; |
s->z_err = Z_OK; |
s->z_eof = 0; |
s->crc = crc32(0L, Z_NULL, 0); |
s->msg = NULL; |
s->transparent = 0; |
s->path = (char*)ALLOC(strlen(path)+1); |
if (s->path == NULL) { |
return destroy(s), (gzFile)Z_NULL; |
} |
strcpy(s->path, path); /* do this early for debugging */ |
s->mode = '\0'; |
do { |
if (*p == 'r') s->mode = 'r'; |
if (*p == 'w' || *p == 'a') s->mode = 'w'; |
if (*p >= '0' && *p <= '9') { |
level = *p - '0'; |
} else if (*p == 'f') { |
strategy = Z_FILTERED; |
} else if (*p == 'h') { |
strategy = Z_HUFFMAN_ONLY; |
} else { |
*m++ = *p; /* copy the mode */ |
} |
} while (*p++ && m != fmode + sizeof(fmode)); |
if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL; |
if (s->mode == 'w') { |
#ifdef NO_DEFLATE |
err = Z_STREAM_ERROR; |
#else |
err = deflateInit2(&(s->stream), level, |
Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, strategy); |
/* windowBits is passed < 0 to suppress zlib header */ |
s->stream.next_out = s->outbuf = (Byte*)ALLOC(Z_BUFSIZE); |
#endif |
if (err != Z_OK || s->outbuf == Z_NULL) { |
return destroy(s), (gzFile)Z_NULL; |
} |
} else { |
s->stream.next_in = s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); |
err = inflateInit2(&(s->stream), -MAX_WBITS); |
/* windowBits is passed < 0 to tell that there is no zlib header. |
* Note that in this case inflate *requires* an extra "dummy" byte |
* after the compressed stream in order to complete decompression and |
* return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are |
* present after the compressed stream. |
*/ |
if (err != Z_OK || s->inbuf == Z_NULL) { |
return destroy(s), (gzFile)Z_NULL; |
} |
} |
s->stream.avail_out = Z_BUFSIZE; |
errno = 0; |
s->file = fd < 0 ? F_OPEN(path, fmode) : (FILE*)fdopen(fd, fmode); |
if (s->file == NULL) { |
return destroy(s), (gzFile)Z_NULL; |
} |
if (s->mode == 'w') { |
/* Write a very simple .gz header: |
*/ |
fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1], |
Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE); |
s->startpos = 10L; |
/* We use 10L instead of ftell(s->file) to because ftell causes an |
* fflush on some systems. This version of the library doesn't use |
* startpos anyway in write mode, so this initialization is not |
* necessary. |
*/ |
} else { |
check_header(s); /* skip the .gz header */ |
s->startpos = (ftell(s->file) - s->stream.avail_in); |
} |
return (gzFile)s; |
} |
/* =========================================================================== |
Opens a gzip (.gz) file for reading or writing. |
*/ |
gzFile ZEXPORT gzopen (path, mode) |
const char *path; |
const char *mode; |
{ |
return gz_open (path, mode, -1); |
} |
/* =========================================================================== |
Associate a gzFile with the file descriptor fd. fd is not dup'ed here |
to mimic the behavio(u)r of fdopen. |
*/ |
gzFile ZEXPORT gzdopen (fd, mode) |
int fd; |
const char *mode; |
{ |
char name[20]; |
if (fd < 0) return (gzFile)Z_NULL; |
sprintf(name, "<fd:%d>", fd); /* for debugging */ |
return gz_open (name, mode, fd); |
} |
/* =========================================================================== |
* Update the compression level and strategy |
*/ |
int ZEXPORT gzsetparams (file, level, strategy) |
gzFile file; |
int level; |
int strategy; |
{ |
gz_stream *s = (gz_stream*)file; |
if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR; |
/* Make room to allow flushing */ |
if (s->stream.avail_out == 0) { |
s->stream.next_out = s->outbuf; |
if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) { |
s->z_err = Z_ERRNO; |
} |
s->stream.avail_out = Z_BUFSIZE; |
} |
return deflateParams (&(s->stream), level, strategy); |
} |
/* =========================================================================== |
Read a byte from a gz_stream; update next_in and avail_in. Return EOF |
for end of file. |
IN assertion: the stream s has been sucessfully opened for reading. |
*/ |
local int get_byte(s) |
gz_stream *s; |
{ |
if (s->z_eof) return EOF; |
if (s->stream.avail_in == 0) { |
errno = 0; |
s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file); |
if (s->stream.avail_in == 0) { |
s->z_eof = 1; |
if (ferror(s->file)) s->z_err = Z_ERRNO; |
return EOF; |
} |
s->stream.next_in = s->inbuf; |
} |
s->stream.avail_in--; |
return *(s->stream.next_in)++; |
} |
/* =========================================================================== |
Check the gzip header of a gz_stream opened for reading. Set the stream |
mode to transparent if the gzip magic header is not present; set s->err |
to Z_DATA_ERROR if the magic header is present but the rest of the header |
is incorrect. |
IN assertion: the stream s has already been created sucessfully; |
s->stream.avail_in is zero for the first time, but may be non-zero |
for concatenated .gz files. |
*/ |
local void check_header(s) |
gz_stream *s; |
{ |
int method; /* method byte */ |
int flags; /* flags byte */ |
uInt len; |
int c; |
/* Check the gzip magic header */ |
for (len = 0; len < 2; len++) { |
c = get_byte(s); |
if (c != gz_magic[len]) { |
if (len != 0) s->stream.avail_in++, s->stream.next_in--; |
if (c != EOF) { |
s->stream.avail_in++, s->stream.next_in--; |
s->transparent = 1; |
} |
s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END; |
return; |
} |
} |
method = get_byte(s); |
flags = get_byte(s); |
if (method != Z_DEFLATED || (flags & RESERVED) != 0) { |
s->z_err = Z_DATA_ERROR; |
return; |
} |
/* Discard time, xflags and OS code: */ |
for (len = 0; len < 6; len++) (void)get_byte(s); |
if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */ |
len = (uInt)get_byte(s); |
len += ((uInt)get_byte(s))<<8; |
/* len is garbage if EOF but the loop below will quit anyway */ |
while (len-- != 0 && get_byte(s) != EOF) ; |
} |
if ((flags & ORIG_NAME) != 0) { /* skip the original file name */ |
while ((c = get_byte(s)) != 0 && c != EOF) ; |
} |
if ((flags & COMMENT) != 0) { /* skip the .gz file comment */ |
while ((c = get_byte(s)) != 0 && c != EOF) ; |
} |
if ((flags & HEAD_CRC) != 0) { /* skip the header crc */ |
for (len = 0; len < 2; len++) (void)get_byte(s); |
} |
s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK; |
} |
/* =========================================================================== |
* Cleanup then free the given gz_stream. Return a zlib error code. |
Try freeing in the reverse order of allocations. |
*/ |
local int destroy (s) |
gz_stream *s; |
{ |
int err = Z_OK; |
if (!s) return Z_STREAM_ERROR; |
TRYFREE(s->msg); |
if (s->stream.state != NULL) { |
if (s->mode == 'w') { |
#ifdef NO_DEFLATE |
err = Z_STREAM_ERROR; |
#else |
err = deflateEnd(&(s->stream)); |
#endif |
} else if (s->mode == 'r') { |
err = inflateEnd(&(s->stream)); |
} |
} |
if (s->file != NULL && fclose(s->file)) { |
#ifdef ESPIPE |
if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */ |
#endif |
err = Z_ERRNO; |
} |
if (s->z_err < 0) err = s->z_err; |
TRYFREE(s->inbuf); |
TRYFREE(s->outbuf); |
TRYFREE(s->path); |
TRYFREE(s); |
return err; |
} |
/* =========================================================================== |
Reads the given number of uncompressed bytes from the compressed file. |
gzread returns the number of bytes actually read (0 for end of file). |
*/ |
int ZEXPORT gzread (file, buf, len) |
gzFile file; |
voidp buf; |
unsigned len; |
{ |
gz_stream *s = (gz_stream*)file; |
Bytef *start = (Bytef*)buf; /* starting point for crc computation */ |
Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */ |
if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR; |
if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1; |
if (s->z_err == Z_STREAM_END) return 0; /* EOF */ |
next_out = (Byte*)buf; |
s->stream.next_out = (Bytef*)buf; |
s->stream.avail_out = len; |
while (s->stream.avail_out != 0) { |
if (s->transparent) { |
/* Copy first the lookahead bytes: */ |
uInt n = s->stream.avail_in; |
if (n > s->stream.avail_out) n = s->stream.avail_out; |
if (n > 0) { |
zmemcpy(s->stream.next_out, s->stream.next_in, n); |
next_out += n; |
s->stream.next_out = next_out; |
s->stream.next_in += n; |
s->stream.avail_out -= n; |
s->stream.avail_in -= n; |
} |
if (s->stream.avail_out > 0) { |
s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out, |
s->file); |
} |
len -= s->stream.avail_out; |
s->stream.total_in += (uLong)len; |
s->stream.total_out += (uLong)len; |
if (len == 0) s->z_eof = 1; |
return (int)len; |
} |
if (s->stream.avail_in == 0 && !s->z_eof) { |
errno = 0; |
s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file); |
if (s->stream.avail_in == 0) { |
s->z_eof = 1; |
if (ferror(s->file)) { |
s->z_err = Z_ERRNO; |
break; |
} |
} |
s->stream.next_in = s->inbuf; |
} |
s->z_err = inflate(&(s->stream), Z_NO_FLUSH); |
if (s->z_err == Z_STREAM_END) { |
/* Check CRC and original size */ |
s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start)); |
start = s->stream.next_out; |
if (getLong(s) != s->crc) { |
s->z_err = Z_DATA_ERROR; |
} else { |
(void)getLong(s); |
/* The uncompressed length returned by above getlong() may |
* be different from s->stream.total_out) in case of |
* concatenated .gz files. Check for such files: |
*/ |
check_header(s); |
if (s->z_err == Z_OK) { |
uLong total_in = s->stream.total_in; |
uLong total_out = s->stream.total_out; |
inflateReset(&(s->stream)); |
s->stream.total_in = total_in; |
s->stream.total_out = total_out; |
s->crc = crc32(0L, Z_NULL, 0); |
} |
} |
} |
if (s->z_err != Z_OK || s->z_eof) break; |
} |
s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start)); |
return (int)(len - s->stream.avail_out); |
} |
/* =========================================================================== |
Reads one byte from the compressed file. gzgetc returns this byte |
or -1 in case of end of file or error. |
*/ |
int ZEXPORT gzgetc(file) |
gzFile file; |
{ |
unsigned char c; |
return gzread(file, &c, 1) == 1 ? c : -1; |
} |
/* =========================================================================== |
Reads bytes from the compressed file until len-1 characters are |
read, or a newline character is read and transferred to buf, or an |
end-of-file condition is encountered. The string is then terminated |
with a null character. |
gzgets returns buf, or Z_NULL in case of error. |
The current implementation is not optimized at all. |
*/ |
char * ZEXPORT gzgets(file, buf, len) |
gzFile file; |
char *buf; |
int len; |
{ |
char *b = buf; |
if (buf == Z_NULL || len <= 0) return Z_NULL; |
while (--len > 0 && gzread(file, buf, 1) == 1 && *buf++ != '\n') ; |
*buf = '\0'; |
return b == buf && len > 0 ? Z_NULL : b; |
} |
#ifndef NO_DEFLATE |
/* =========================================================================== |
Writes the given number of uncompressed bytes into the compressed file. |
gzwrite returns the number of bytes actually written (0 in case of error). |
*/ |
int ZEXPORT gzwrite (file, buf, len) |
gzFile file; |
const voidp buf; |
unsigned len; |
{ |
gz_stream *s = (gz_stream*)file; |
if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR; |
s->stream.next_in = (Bytef*)buf; |
s->stream.avail_in = len; |
while (s->stream.avail_in != 0) { |
if (s->stream.avail_out == 0) { |
s->stream.next_out = s->outbuf; |
if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) { |
s->z_err = Z_ERRNO; |
break; |
} |
s->stream.avail_out = Z_BUFSIZE; |
} |
s->z_err = deflate(&(s->stream), Z_NO_FLUSH); |
if (s->z_err != Z_OK) break; |
} |
s->crc = crc32(s->crc, (const Bytef *)buf, len); |
return (int)(len - s->stream.avail_in); |
} |
/* =========================================================================== |
Converts, formats, and writes the args to the compressed file under |
control of the format string, as in fprintf. gzprintf returns the number of |
uncompressed bytes actually written (0 in case of error). |
*/ |
#ifdef STDC |
#include <stdarg.h> |
int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...) |
{ |
char buf[Z_PRINTF_BUFSIZE]; |
va_list va; |
int len; |
va_start(va, format); |
#ifdef HAS_vsnprintf |
(void)vsnprintf(buf, sizeof(buf), format, va); |
#else |
(void)vsprintf(buf, format, va); |
#endif |
va_end(va); |
len = strlen(buf); /* some *sprintf don't return the nb of bytes written */ |
if (len <= 0) return 0; |
return gzwrite(file, buf, (unsigned)len); |
} |
#else /* not ANSI C */ |
int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, |
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) |
gzFile file; |
const char *format; |
int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, |
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20; |
{ |
char buf[Z_PRINTF_BUFSIZE]; |
int len; |
#ifdef HAS_snprintf |
snprintf(buf, sizeof(buf), format, a1, a2, a3, a4, a5, a6, a7, a8, |
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); |
#else |
sprintf(buf, format, a1, a2, a3, a4, a5, a6, a7, a8, |
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); |
#endif |
len = strlen(buf); /* old sprintf doesn't return the nb of bytes written */ |
if (len <= 0) return 0; |
return gzwrite(file, buf, len); |
} |
#endif |
/* =========================================================================== |
Writes c, converted to an unsigned char, into the compressed file. |
gzputc returns the value that was written, or -1 in case of error. |
*/ |
int ZEXPORT gzputc(file, c) |
gzFile file; |
int c; |
{ |
unsigned char cc = (unsigned char) c; /* required for big endian systems */ |
return gzwrite(file, &cc, 1) == 1 ? (int)cc : -1; |
} |
/* =========================================================================== |
Writes the given null-terminated string to the compressed file, excluding |
the terminating null character. |
gzputs returns the number of characters written, or -1 in case of error. |
*/ |
int ZEXPORT gzputs(file, s) |
gzFile file; |
const char *s; |
{ |
return gzwrite(file, (char*)s, (unsigned)strlen(s)); |
} |
/* =========================================================================== |
Flushes all pending output into the compressed file. The parameter |
flush is as in the deflate() function. |
*/ |
local int do_flush (file, flush) |
gzFile file; |
int flush; |
{ |
uInt len; |
int done = 0; |
gz_stream *s = (gz_stream*)file; |
if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR; |
s->stream.avail_in = 0; /* should be zero already anyway */ |
for (;;) { |
len = Z_BUFSIZE - s->stream.avail_out; |
if (len != 0) { |
if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) { |
s->z_err = Z_ERRNO; |
return Z_ERRNO; |
} |
s->stream.next_out = s->outbuf; |
s->stream.avail_out = Z_BUFSIZE; |
} |
if (done) break; |
s->z_err = deflate(&(s->stream), flush); |
/* Ignore the second of two consecutive flushes: */ |
if (len == 0 && s->z_err == Z_BUF_ERROR) s->z_err = Z_OK; |
/* deflate has finished flushing only when it hasn't used up |
* all the available space in the output buffer: |
*/ |
done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END); |
if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break; |
} |
return s->z_err == Z_STREAM_END ? Z_OK : s->z_err; |
} |
int ZEXPORT gzflush (file, flush) |
gzFile file; |
int flush; |
{ |
gz_stream *s = (gz_stream*)file; |
int err = do_flush (file, flush); |
if (err) return err; |
fflush(s->file); |
return s->z_err == Z_STREAM_END ? Z_OK : s->z_err; |
} |
#endif /* NO_DEFLATE */ |
/* =========================================================================== |
Sets the starting position for the next gzread or gzwrite on the given |
compressed file. The offset represents a number of bytes in the |
gzseek returns the resulting offset location as measured in bytes from |
the beginning of the uncompressed stream, or -1 in case of error. |
SEEK_END is not implemented, returns error. |
In this version of the library, gzseek can be extremely slow. |
*/ |
z_off_t ZEXPORT gzseek (file, offset, whence) |
gzFile file; |
z_off_t offset; |
int whence; |
{ |
gz_stream *s = (gz_stream*)file; |
if (s == NULL || whence == SEEK_END || |
s->z_err == Z_ERRNO || s->z_err == Z_DATA_ERROR) { |
return -1L; |
} |
if (s->mode == 'w') { |
#ifdef NO_DEFLATE |
return -1L; |
#else |
if (whence == SEEK_SET) { |
offset -= s->stream.total_in; |
} |
if (offset < 0) return -1L; |
/* At this point, offset is the number of zero bytes to write. */ |
if (s->inbuf == Z_NULL) { |
s->inbuf = (Byte*)ALLOC(Z_BUFSIZE); /* for seeking */ |
zmemzero(s->inbuf, Z_BUFSIZE); |
} |
while (offset > 0) { |
uInt size = Z_BUFSIZE; |
if (offset < Z_BUFSIZE) size = (uInt)offset; |
size = gzwrite(file, s->inbuf, size); |
if (size == 0) return -1L; |
offset -= size; |
} |
return (z_off_t)s->stream.total_in; |
#endif |
} |
/* Rest of function is for reading only */ |
/* compute absolute position */ |
if (whence == SEEK_CUR) { |
offset += s->stream.total_out; |
} |
if (offset < 0) return -1L; |
if (s->transparent) { |
/* map to fseek */ |
s->stream.avail_in = 0; |
s->stream.next_in = s->inbuf; |
if (fseek(s->file, offset, SEEK_SET) < 0) return -1L; |
s->stream.total_in = s->stream.total_out = (uLong)offset; |
return offset; |
} |
/* For a negative seek, rewind and use positive seek */ |
if ((uLong)offset >= s->stream.total_out) { |
offset -= s->stream.total_out; |
} else if (gzrewind(file) < 0) { |
return -1L; |
} |
/* offset is now the number of bytes to skip. */ |
if (offset != 0 && s->outbuf == Z_NULL) { |
s->outbuf = (Byte*)ALLOC(Z_BUFSIZE); |
} |
while (offset > 0) { |
int size = Z_BUFSIZE; |
if (offset < Z_BUFSIZE) size = (int)offset; |
size = gzread(file, s->outbuf, (uInt)size); |
if (size <= 0) return -1L; |
offset -= size; |
} |
return (z_off_t)s->stream.total_out; |
} |
/* =========================================================================== |
Rewinds input file. |
*/ |
int ZEXPORT gzrewind (file) |
gzFile file; |
{ |
gz_stream *s = (gz_stream*)file; |
if (s == NULL || s->mode != 'r') return -1; |
s->z_err = Z_OK; |
s->z_eof = 0; |
s->stream.avail_in = 0; |
s->stream.next_in = s->inbuf; |
s->crc = crc32(0L, Z_NULL, 0); |
if (s->startpos == 0) { /* not a compressed file */ |
rewind(s->file); |
return 0; |
} |
(void) inflateReset(&s->stream); |
return fseek(s->file, s->startpos, SEEK_SET); |
} |
/* =========================================================================== |
Returns the starting position for the next gzread or gzwrite on the |
given compressed file. This position represents a number of bytes in the |
uncompressed data stream. |
*/ |
z_off_t ZEXPORT gztell (file) |
gzFile file; |
{ |
return gzseek(file, 0L, SEEK_CUR); |
} |
/* =========================================================================== |
Returns 1 when EOF has previously been detected reading the given |
input stream, otherwise zero. |
*/ |
int ZEXPORT gzeof (file) |
gzFile file; |
{ |
gz_stream *s = (gz_stream*)file; |
return (s == NULL || s->mode != 'r') ? 0 : s->z_eof; |
} |
/* =========================================================================== |
Outputs a long in LSB order to the given file |
*/ |
local void putLong (file, x) |
FILE *file; |
uLong x; |
{ |
int n; |
for (n = 0; n < 4; n++) { |
fputc((int)(x & 0xff), file); |
x >>= 8; |
} |
} |
/* =========================================================================== |
Reads a long in LSB order from the given gz_stream. Sets z_err in case |
of error. |
*/ |
local uLong getLong (s) |
gz_stream *s; |
{ |
uLong x = (uLong)get_byte(s); |
int c; |
x += ((uLong)get_byte(s))<<8; |
x += ((uLong)get_byte(s))<<16; |
c = get_byte(s); |
if (c == EOF) s->z_err = Z_DATA_ERROR; |
x += ((uLong)c)<<24; |
return x; |
} |
/* =========================================================================== |
Flushes all pending output if necessary, closes the compressed file |
and deallocates all the (de)compression state. |
*/ |
int ZEXPORT gzclose (file) |
gzFile file; |
{ |
int err; |
gz_stream *s = (gz_stream*)file; |
if (s == NULL) return Z_STREAM_ERROR; |
if (s->mode == 'w') { |
#ifdef NO_DEFLATE |
return Z_STREAM_ERROR; |
#else |
err = do_flush (file, Z_FINISH); |
if (err != Z_OK) return destroy((gz_stream*)file); |
putLong (s->file, s->crc); |
putLong (s->file, s->stream.total_in); |
#endif |
} |
return destroy((gz_stream*)file); |
} |
/* =========================================================================== |
Returns the error message for the last error which occured on the |
given compressed file. errnum is set to zlib error number. If an |
error occured in the file system and not in the compression library, |
errnum is set to Z_ERRNO and the application may consult errno |
to get the exact error code. |
*/ |
const char* ZEXPORT gzerror (file, errnum) |
gzFile file; |
int *errnum; |
{ |
char *m; |
gz_stream *s = (gz_stream*)file; |
if (s == NULL) { |
*errnum = Z_STREAM_ERROR; |
return (const char*)ERR_MSG(Z_STREAM_ERROR); |
} |
*errnum = s->z_err; |
if (*errnum == Z_OK) return (const char*)""; |
m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg); |
if (m == NULL || *m == '\0') m = (char*)ERR_MSG(s->z_err); |
TRYFREE(s->msg); |
s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3); |
strcpy(s->msg, s->path); |
strcat(s->msg, ": "); |
strcat(s->msg, m); |
return (const char*)s->msg; |
} |
/shark/trunk/ports/png/deflate.h |
---|
0,0 → 1,318 |
/* deflate.h -- internal compression state |
* Copyright (C) 1995-2002 Jean-loup Gailly |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* WARNING: this file should *not* be used by applications. It is |
part of the implementation of the compression library and is |
subject to change. Applications should only use zlib.h. |
*/ |
/* @(#) $Id: deflate.h,v 1.1 2003-03-20 13:08:10 giacomo Exp $ */ |
#ifndef _DEFLATE_H |
#define _DEFLATE_H |
#include "zutil.h" |
/* =========================================================================== |
* Internal compression state. |
*/ |
#define LENGTH_CODES 29 |
/* number of length codes, not counting the special END_BLOCK code */ |
#define LITERALS 256 |
/* number of literal bytes 0..255 */ |
#define L_CODES (LITERALS+1+LENGTH_CODES) |
/* number of Literal or Length codes, including the END_BLOCK code */ |
#define D_CODES 30 |
/* number of distance codes */ |
#define BL_CODES 19 |
/* number of codes used to transfer the bit lengths */ |
#define HEAP_SIZE (2*L_CODES+1) |
/* maximum heap size */ |
#define MAX_BITS 15 |
/* All codes must not exceed MAX_BITS bits */ |
#define INIT_STATE 42 |
#define BUSY_STATE 113 |
#define FINISH_STATE 666 |
/* Stream status */ |
/* Data structure describing a single value and its code string. */ |
typedef struct ct_data_s { |
union { |
ush freq; /* frequency count */ |
ush code; /* bit string */ |
} fc; |
union { |
ush dad; /* father node in Huffman tree */ |
ush len; /* length of bit string */ |
} dl; |
} FAR ct_data; |
#define Freq fc.freq |
#define Code fc.code |
#define Dad dl.dad |
#define Len dl.len |
typedef struct static_tree_desc_s static_tree_desc; |
typedef struct tree_desc_s { |
ct_data *dyn_tree; /* the dynamic tree */ |
int max_code; /* largest code with non zero frequency */ |
static_tree_desc *stat_desc; /* the corresponding static tree */ |
} FAR tree_desc; |
typedef ush Pos; |
typedef Pos FAR Posf; |
typedef unsigned IPos; |
/* A Pos is an index in the character window. We use short instead of int to |
* save space in the various tables. IPos is used only for parameter passing. |
*/ |
typedef struct internal_state { |
z_streamp strm; /* pointer back to this zlib stream */ |
int status; /* as the name implies */ |
Bytef *pending_buf; /* output still pending */ |
ulg pending_buf_size; /* size of pending_buf */ |
Bytef *pending_out; /* next pending byte to output to the stream */ |
int pending; /* nb of bytes in the pending buffer */ |
int noheader; /* suppress zlib header and adler32 */ |
Byte data_type; /* UNKNOWN, BINARY or ASCII */ |
Byte method; /* STORED (for zip only) or DEFLATED */ |
int last_flush; /* value of flush param for previous deflate call */ |
/* used by deflate.c: */ |
uInt w_size; /* LZ77 window size (32K by default) */ |
uInt w_bits; /* log2(w_size) (8..16) */ |
uInt w_mask; /* w_size - 1 */ |
Bytef *window; |
/* Sliding window. Input bytes are read into the second half of the window, |
* and move to the first half later to keep a dictionary of at least wSize |
* bytes. With this organization, matches are limited to a distance of |
* wSize-MAX_MATCH bytes, but this ensures that IO is always |
* performed with a length multiple of the block size. Also, it limits |
* the window size to 64K, which is quite useful on MSDOS. |
* To do: use the user input buffer as sliding window. |
*/ |
ulg window_size; |
/* Actual size of window: 2*wSize, except when the user input buffer |
* is directly used as sliding window. |
*/ |
Posf *prev; |
/* Link to older string with same hash index. To limit the size of this |
* array to 64K, this link is maintained only for the last 32K strings. |
* An index in this array is thus a window index modulo 32K. |
*/ |
Posf *head; /* Heads of the hash chains or NIL. */ |
uInt ins_h; /* hash index of string to be inserted */ |
uInt hash_size; /* number of elements in hash table */ |
uInt hash_bits; /* log2(hash_size) */ |
uInt hash_mask; /* hash_size-1 */ |
uInt hash_shift; |
/* Number of bits by which ins_h must be shifted at each input |
* step. It must be such that after MIN_MATCH steps, the oldest |
* byte no longer takes part in the hash key, that is: |
* hash_shift * MIN_MATCH >= hash_bits |
*/ |
long block_start; |
/* Window position at the beginning of the current output block. Gets |
* negative when the window is moved backwards. |
*/ |
uInt match_length; /* length of best match */ |
IPos prev_match; /* previous match */ |
int match_available; /* set if previous match exists */ |
uInt strstart; /* start of string to insert */ |
uInt match_start; /* start of matching string */ |
uInt lookahead; /* number of valid bytes ahead in window */ |
uInt prev_length; |
/* Length of the best match at previous step. Matches not greater than this |
* are discarded. This is used in the lazy match evaluation. |
*/ |
uInt max_chain_length; |
/* To speed up deflation, hash chains are never searched beyond this |
* length. A higher limit improves compression ratio but degrades the |
* speed. |
*/ |
uInt max_lazy_match; |
/* Attempt to find a better match only when the current match is strictly |
* smaller than this value. This mechanism is used only for compression |
* levels >= 4. |
*/ |
# define max_insert_length max_lazy_match |
/* Insert new strings in the hash table only if the match length is not |
* greater than this length. This saves time but degrades compression. |
* max_insert_length is used only for compression levels <= 3. |
*/ |
int level; /* compression level (1..9) */ |
int strategy; /* favor or force Huffman coding*/ |
uInt good_match; |
/* Use a faster search when the previous match is longer than this */ |
int nice_match; /* Stop searching when current match exceeds this */ |
/* used by trees.c: */ |
/* Didn't use ct_data typedef below to supress compiler warning */ |
struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ |
struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ |
struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ |
struct tree_desc_s l_desc; /* desc. for literal tree */ |
struct tree_desc_s d_desc; /* desc. for distance tree */ |
struct tree_desc_s bl_desc; /* desc. for bit length tree */ |
ush bl_count[MAX_BITS+1]; |
/* number of codes at each bit length for an optimal tree */ |
int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ |
int heap_len; /* number of elements in the heap */ |
int heap_max; /* element of largest frequency */ |
/* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. |
* The same heap array is used to build all trees. |
*/ |
uch depth[2*L_CODES+1]; |
/* Depth of each subtree used as tie breaker for trees of equal frequency |
*/ |
uchf *l_buf; /* buffer for literals or lengths */ |
uInt lit_bufsize; |
/* Size of match buffer for literals/lengths. There are 4 reasons for |
* limiting lit_bufsize to 64K: |
* - frequencies can be kept in 16 bit counters |
* - if compression is not successful for the first block, all input |
* data is still in the window so we can still emit a stored block even |
* when input comes from standard input. (This can also be done for |
* all blocks if lit_bufsize is not greater than 32K.) |
* - if compression is not successful for a file smaller than 64K, we can |
* even emit a stored file instead of a stored block (saving 5 bytes). |
* This is applicable only for zip (not gzip or zlib). |
* - creating new Huffman trees less frequently may not provide fast |
* adaptation to changes in the input data statistics. (Take for |
* example a binary file with poorly compressible code followed by |
* a highly compressible string table.) Smaller buffer sizes give |
* fast adaptation but have of course the overhead of transmitting |
* trees more frequently. |
* - I can't count above 4 |
*/ |
uInt last_lit; /* running index in l_buf */ |
ushf *d_buf; |
/* Buffer for distances. To simplify the code, d_buf and l_buf have |
* the same number of elements. To use different lengths, an extra flag |
* array would be necessary. |
*/ |
ulg opt_len; /* bit length of current block with optimal trees */ |
ulg static_len; /* bit length of current block with static trees */ |
uInt matches; /* number of string matches in current block */ |
int last_eob_len; /* bit length of EOB code for last block */ |
#ifdef DEBUG |
ulg compressed_len; /* total bit length of compressed file mod 2^32 */ |
ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ |
#endif |
ush bi_buf; |
/* Output buffer. bits are inserted starting at the bottom (least |
* significant bits). |
*/ |
int bi_valid; |
/* Number of valid bits in bi_buf. All bits above the last valid bit |
* are always zero. |
*/ |
} FAR deflate_state; |
/* Output a byte on the stream. |
* IN assertion: there is enough room in pending_buf. |
*/ |
#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} |
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) |
/* Minimum amount of lookahead, except at the end of the input file. |
* See deflate.c for comments about the MIN_MATCH+1. |
*/ |
#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) |
/* In order to simplify the code, particularly on 16 bit machines, match |
* distances are limited to MAX_DIST instead of WSIZE. |
*/ |
/* in trees.c */ |
void _tr_init OF((deflate_state *s)); |
int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); |
void _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len, |
int eof)); |
void _tr_align OF((deflate_state *s)); |
void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len, |
int eof)); |
#define d_code(dist) \ |
((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) |
/* Mapping from a distance to a distance code. dist is the distance - 1 and |
* must not have side effects. _dist_code[256] and _dist_code[257] are never |
* used. |
*/ |
#ifndef DEBUG |
/* Inline versions of _tr_tally for speed: */ |
#if defined(GEN_TREES_H) || !defined(STDC) |
extern uch _length_code[]; |
extern uch _dist_code[]; |
#else |
extern const uch _length_code[]; |
extern const uch _dist_code[]; |
#endif |
# define _tr_tally_lit(s, c, flush) \ |
{ uch cc = (c); \ |
s->d_buf[s->last_lit] = 0; \ |
s->l_buf[s->last_lit++] = cc; \ |
s->dyn_ltree[cc].Freq++; \ |
flush = (s->last_lit == s->lit_bufsize-1); \ |
} |
# define _tr_tally_dist(s, distance, length, flush) \ |
{ uch len = (length); \ |
ush dist = (distance); \ |
s->d_buf[s->last_lit] = dist; \ |
s->l_buf[s->last_lit++] = len; \ |
dist--; \ |
s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ |
s->dyn_dtree[d_code(dist)].Freq++; \ |
flush = (s->last_lit == s->lit_bufsize-1); \ |
} |
#else |
# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) |
# define _tr_tally_dist(s, distance, length, flush) \ |
flush = _tr_tally(s, distance, length) |
#endif |
#endif |
/shark/trunk/ports/png/infutil.c |
---|
0,0 → 1,87 |
/* inflate_util.c -- data and routines common to blocks and codes |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
#include "zutil.h" |
#include "infblock.h" |
#include "inftrees.h" |
#include "infcodes.h" |
#include "infutil.h" |
struct inflate_codes_state {int dummy;}; /* for buggy compilers */ |
/* And'ing with mask[n] masks the lower n bits */ |
uInt inflate_mask[17] = { |
0x0000, |
0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, |
0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff |
}; |
/* copy as much as possible from the sliding window to the output area */ |
int inflate_flush(s, z, r) |
inflate_blocks_statef *s; |
z_streamp z; |
int r; |
{ |
uInt n; |
Bytef *p; |
Bytef *q; |
/* local copies of source and destination pointers */ |
p = z->next_out; |
q = s->read; |
/* compute number of bytes to copy as far as end of window */ |
n = (uInt)((q <= s->write ? s->write : s->end) - q); |
if (n > z->avail_out) n = z->avail_out; |
if (n && r == Z_BUF_ERROR) r = Z_OK; |
/* update counters */ |
z->avail_out -= n; |
z->total_out += n; |
/* update check information */ |
if (s->checkfn != Z_NULL) |
z->adler = s->check = (*s->checkfn)(s->check, q, n); |
/* copy as far as end of window */ |
zmemcpy(p, q, n); |
p += n; |
q += n; |
/* see if more to copy at beginning of window */ |
if (q == s->end) |
{ |
/* wrap pointers */ |
q = s->window; |
if (s->write == s->end) |
s->write = s->window; |
/* compute bytes to copy */ |
n = (uInt)(s->write - q); |
if (n > z->avail_out) n = z->avail_out; |
if (n && r == Z_BUF_ERROR) r = Z_OK; |
/* update counters */ |
z->avail_out -= n; |
z->total_out += n; |
/* update check information */ |
if (s->checkfn != Z_NULL) |
z->adler = s->check = (*s->checkfn)(s->check, q, n); |
/* copy */ |
zmemcpy(p, q, n); |
p += n; |
q += n; |
} |
/* update pointers */ |
z->next_out = p; |
s->read = q; |
/* done */ |
return r; |
} |
/shark/trunk/ports/png/zutil.h |
---|
0,0 → 1,220 |
/* zutil.h -- internal interface and configuration of the compression library |
* Copyright (C) 1995-2002 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* WARNING: this file should *not* be used by applications. It is |
part of the implementation of the compression library and is |
subject to change. Applications should only use zlib.h. |
*/ |
/* @(#) $Id: zutil.h,v 1.1 2003-03-20 13:08:13 giacomo Exp $ */ |
#ifndef _Z_UTIL_H |
#define _Z_UTIL_H |
#include "zlib.h" |
#ifdef STDC |
# include <stddef.h> |
# include <string.h> |
# include <stdlib.h> |
#endif |
#ifdef NO_ERRNO_H |
extern int errno; |
#else |
# include <errno.h> |
#endif |
#ifndef local |
# define local static |
#endif |
/* compile with -Dlocal if your debugger can't find static symbols */ |
typedef unsigned char uch; |
typedef uch FAR uchf; |
typedef unsigned short ush; |
typedef ush FAR ushf; |
typedef unsigned long ulg; |
extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */ |
/* (size given to avoid silly warnings with Visual C++) */ |
#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] |
#define ERR_RETURN(strm,err) \ |
return (strm->msg = (char*)ERR_MSG(err), (err)) |
/* To be used only when the state is known to be valid */ |
/* common constants */ |
#ifndef DEF_WBITS |
# define DEF_WBITS MAX_WBITS |
#endif |
/* default windowBits for decompression. MAX_WBITS is for compression only */ |
#if MAX_MEM_LEVEL >= 8 |
# define DEF_MEM_LEVEL 8 |
#else |
# define DEF_MEM_LEVEL MAX_MEM_LEVEL |
#endif |
/* default memLevel */ |
#define STORED_BLOCK 0 |
#define STATIC_TREES 1 |
#define DYN_TREES 2 |
/* The three kinds of block type */ |
#define MIN_MATCH 3 |
#define MAX_MATCH 258 |
/* The minimum and maximum match lengths */ |
#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ |
/* target dependencies */ |
#ifdef MSDOS |
# define OS_CODE 0x00 |
# if defined(__TURBOC__) || defined(__BORLANDC__) |
# if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) |
/* Allow compilation with ANSI keywords only enabled */ |
void _Cdecl farfree( void *block ); |
void *_Cdecl farmalloc( unsigned long nbytes ); |
# else |
# include <alloc.h> |
# endif |
# else /* MSC or DJGPP */ |
# include <malloc.h> |
# endif |
#endif |
#ifdef OS2 |
# define OS_CODE 0x06 |
#endif |
#ifdef WIN32 /* Window 95 & Windows NT */ |
# define OS_CODE 0x0b |
#endif |
#if defined(VAXC) || defined(VMS) |
# define OS_CODE 0x02 |
# define F_OPEN(name, mode) \ |
fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") |
#endif |
#ifdef AMIGA |
# define OS_CODE 0x01 |
#endif |
#if defined(ATARI) || defined(atarist) |
# define OS_CODE 0x05 |
#endif |
#if defined(MACOS) || defined(TARGET_OS_MAC) |
# define OS_CODE 0x07 |
# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os |
# include <unix.h> /* for fdopen */ |
# else |
# ifndef fdopen |
# define fdopen(fd,mode) NULL /* No fdopen() */ |
# endif |
# endif |
#endif |
#ifdef __50SERIES /* Prime/PRIMOS */ |
# define OS_CODE 0x0F |
#endif |
#ifdef TOPS20 |
# define OS_CODE 0x0a |
#endif |
#if defined(_BEOS_) || defined(RISCOS) |
# define fdopen(fd,mode) NULL /* No fdopen() */ |
#endif |
#if (defined(_MSC_VER) && (_MSC_VER > 600)) |
# define fdopen(fd,type) _fdopen(fd,type) |
#endif |
/* Common defaults */ |
#ifndef OS_CODE |
# define OS_CODE 0x03 /* assume Unix */ |
#endif |
#ifndef F_OPEN |
# define F_OPEN(name, mode) fopen((name), (mode)) |
#endif |
/* functions */ |
#ifdef HAVE_STRERROR |
extern char *strerror OF((int)); |
# define zstrerror(errnum) strerror(errnum) |
#else |
# define zstrerror(errnum) "" |
#endif |
#if defined(pyr) |
# define NO_MEMCPY |
#endif |
#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) |
/* Use our own functions for small and medium model with MSC <= 5.0. |
* You may have to use the same strategy for Borland C (untested). |
* The __SC__ check is for Symantec. |
*/ |
# define NO_MEMCPY |
#endif |
#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) |
# define HAVE_MEMCPY |
#endif |
#ifdef HAVE_MEMCPY |
# ifdef SMALL_MEDIUM /* MSDOS small or medium model */ |
# define zmemcpy _fmemcpy |
# define zmemcmp _fmemcmp |
# define zmemzero(dest, len) _fmemset(dest, 0, len) |
# else |
# define zmemcpy memcpy |
# define zmemcmp memcmp |
# define zmemzero(dest, len) memset(dest, 0, len) |
# endif |
#else |
extern void zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); |
extern int zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); |
extern void zmemzero OF((Bytef* dest, uInt len)); |
#endif |
/* Diagnostic functions */ |
#ifdef DEBUG |
# include <stdio.h> |
extern int z_verbose; |
extern void z_error OF((char *m)); |
# define Assert(cond,msg) {if(!(cond)) z_error(msg);} |
# define Trace(stderr,x) {if (z_verbose>=0) cprintf x ;} |
# define Tracev(stderr,x) {if (z_verbose>0) cprintf x ;} |
# define Tracevv(stderr,x) {if (z_verbose>1) cprintf x ;} |
# define Tracec(c,(stderr,x)) {if (z_verbose>0 && (c)) cprintf (x) ;} |
# define Tracecv(c,(stderr,x)) {if (z_verbose>1 && (c)) cprintf (x) ;} |
#else |
# define Assert(cond,msg) |
# define Trace(x) |
# define Tracev(x) |
# define Tracevv(x) |
# define Tracec(c,x) |
# define Tracecv(c,x) |
#endif |
typedef uLong (ZEXPORT *check_func) OF((uLong check, const Bytef *buf, |
uInt len)); |
voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size)); |
void zcfree OF((voidpf opaque, voidpf ptr)); |
#define ZALLOC(strm, items, size) \ |
(*((strm)->zalloc))((strm)->opaque, (items), (size)) |
#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) |
#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} |
#endif /* _Z_UTIL_H */ |
/shark/trunk/ports/png/crc32.c |
---|
0,0 → 1,162 |
/* crc32.c -- compute the CRC-32 of a data stream |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* @(#) $Id: crc32.c,v 1.1 2003-03-20 13:08:10 giacomo Exp $ */ |
#include "zlib.h" |
#define local static |
#ifdef DYNAMIC_CRC_TABLE |
local int crc_table_empty = 1; |
local uLongf crc_table[256]; |
local void make_crc_table OF((void)); |
/* |
Generate a table for a byte-wise 32-bit CRC calculation on the polynomial: |
x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. |
Polynomials over GF(2) are represented in binary, one bit per coefficient, |
with the lowest powers in the most significant bit. Then adding polynomials |
is just exclusive-or, and multiplying a polynomial by x is a right shift by |
one. If we call the above polynomial p, and represent a byte as the |
polynomial q, also with the lowest power in the most significant bit (so the |
byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, |
where a mod b means the remainder after dividing a by b. |
This calculation is done using the shift-register method of multiplying and |
taking the remainder. The register is initialized to zero, and for each |
incoming bit, x^32 is added mod p to the register if the bit is a one (where |
x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by |
x (which is shifting right by one and adding x^32 mod p if the bit shifted |
out is a one). We start with the highest power (least significant bit) of |
q and repeat for all eight bits of q. |
The table is simply the CRC of all possible eight bit values. This is all |
the information needed to generate CRC's on data a byte at a time for all |
combinations of CRC register values and incoming bytes. |
*/ |
local void make_crc_table() |
{ |
uLong c; |
int n, k; |
uLong poly; /* polynomial exclusive-or pattern */ |
/* terms of polynomial defining this crc (except x^32): */ |
static const Byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; |
/* make exclusive-or pattern from polynomial (0xedb88320L) */ |
poly = 0L; |
for (n = 0; n < sizeof(p)/sizeof(Byte); n++) |
poly |= 1L << (31 - p[n]); |
for (n = 0; n < 256; n++) |
{ |
c = (uLong)n; |
for (k = 0; k < 8; k++) |
c = c & 1 ? poly ^ (c >> 1) : c >> 1; |
crc_table[n] = c; |
} |
crc_table_empty = 0; |
} |
#else |
/* ======================================================================== |
* Table of CRC-32's of all single-byte values (made by make_crc_table) |
*/ |
local const uLongf crc_table[256] = { |
0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, |
0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, |
0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, |
0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, |
0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, |
0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, |
0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, |
0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, |
0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, |
0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, |
0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, |
0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, |
0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, |
0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, |
0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, |
0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, |
0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, |
0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, |
0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, |
0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, |
0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, |
0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, |
0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, |
0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, |
0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, |
0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, |
0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, |
0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, |
0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, |
0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, |
0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, |
0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, |
0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, |
0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, |
0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, |
0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, |
0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, |
0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, |
0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, |
0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, |
0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, |
0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, |
0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, |
0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, |
0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, |
0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, |
0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, |
0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, |
0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, |
0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, |
0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, |
0x2d02ef8dL |
}; |
#endif |
/* ========================================================================= |
* This function can be used by asm versions of crc32() |
*/ |
const uLongf * ZEXPORT get_crc_table() |
{ |
#ifdef DYNAMIC_CRC_TABLE |
if (crc_table_empty) make_crc_table(); |
#endif |
return (const uLongf *)crc_table; |
} |
/* ========================================================================= */ |
#define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8); |
#define DO2(buf) DO1(buf); DO1(buf); |
#define DO4(buf) DO2(buf); DO2(buf); |
#define DO8(buf) DO4(buf); DO4(buf); |
/* ========================================================================= */ |
uLong ZEXPORT crc32(crc, buf, len) |
uLong crc; |
const Bytef *buf; |
uInt len; |
{ |
if (buf == Z_NULL) return 0L; |
#ifdef DYNAMIC_CRC_TABLE |
if (crc_table_empty) |
make_crc_table(); |
#endif |
crc = crc ^ 0xffffffffL; |
while (len >= 8) |
{ |
DO8(buf); |
len -= 8; |
} |
if (len) do { |
DO1(buf); |
} while (--len); |
return crc ^ 0xffffffffL; |
} |
/shark/trunk/ports/png/infutil.h |
---|
0,0 → 1,98 |
/* infutil.h -- types and macros common to blocks and codes |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* WARNING: this file should *not* be used by applications. It is |
part of the implementation of the compression library and is |
subject to change. Applications should only use zlib.h. |
*/ |
#ifndef _INFUTIL_H |
#define _INFUTIL_H |
typedef enum { |
TYPE, /* get type bits (3, including end bit) */ |
LENS, /* get lengths for stored */ |
STORED, /* processing stored block */ |
TABLE, /* get table lengths */ |
BTREE, /* get bit lengths tree for a dynamic block */ |
DTREE, /* get length, distance trees for a dynamic block */ |
CODES, /* processing fixed or dynamic block */ |
DRY, /* output remaining window bytes */ |
DONE, /* finished last block, done */ |
BAD} /* got a data error--stuck here */ |
inflate_block_mode; |
/* inflate blocks semi-private state */ |
struct inflate_blocks_state { |
/* mode */ |
inflate_block_mode mode; /* current inflate_block mode */ |
/* mode dependent information */ |
union { |
uInt left; /* if STORED, bytes left to copy */ |
struct { |
uInt table; /* table lengths (14 bits) */ |
uInt index; /* index into blens (or border) */ |
uIntf *blens; /* bit lengths of codes */ |
uInt bb; /* bit length tree depth */ |
inflate_huft *tb; /* bit length decoding tree */ |
} trees; /* if DTREE, decoding info for trees */ |
struct { |
inflate_codes_statef |
*codes; |
} decode; /* if CODES, current state */ |
} sub; /* submode */ |
uInt last; /* true if this block is the last block */ |
/* mode independent information */ |
uInt bitk; /* bits in bit buffer */ |
uLong bitb; /* bit buffer */ |
inflate_huft *hufts; /* single malloc for tree space */ |
Bytef *window; /* sliding window */ |
Bytef *end; /* one byte after sliding window */ |
Bytef *read; /* window read pointer */ |
Bytef *write; /* window write pointer */ |
check_func checkfn; /* check function */ |
uLong check; /* check on output */ |
}; |
/* defines for inflate input/output */ |
/* update pointers and return */ |
#define UPDBITS {s->bitb=b;s->bitk=k;} |
#define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;} |
#define UPDOUT {s->write=q;} |
#define UPDATE {UPDBITS UPDIN UPDOUT} |
#define LEAVE {UPDATE return inflate_flush(s,z,r);} |
/* get bytes and bits */ |
#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;} |
#define NEEDBYTE {if(n)r=Z_OK;else LEAVE} |
#define NEXTBYTE (n--,*p++) |
#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}} |
#define DUMPBITS(j) {b>>=(j);k-=(j);} |
/* output bytes */ |
#define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q) |
#define LOADOUT {q=s->write;m=(uInt)WAVAIL;} |
#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}} |
#define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT} |
#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;} |
#define OUTBYTE(a) {*q++=(Byte)(a);m--;} |
/* load local pointers */ |
#define LOAD {LOADIN LOADOUT} |
/* masks for lower bits (size given to avoid silly warnings with Visual C++) */ |
extern uInt inflate_mask[17]; |
/* copy as much as possible from the sliding window to the output area */ |
extern int inflate_flush OF(( |
inflate_blocks_statef *, |
z_streamp , |
int)); |
struct internal_state {int dummy;}; /* for buggy compilers */ |
#endif |
/shark/trunk/ports/png/pngread.c |
---|
0,0 → 1,1424 |
/* pngread.c - read a PNG file |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file contains routines that an application calls directly to |
* read a PNG file or stream. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
/* Create a PNG structure for reading, and allocate any memory needed. */ |
png_structp PNGAPI |
png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn, |
warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); |
} |
/* Alternate create PNG structure for reading, and allocate any memory needed. */ |
png_structp PNGAPI |
png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_structp png_ptr; |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
jmp_buf jmpbuf; |
#endif |
#endif |
int i; |
png_debug(1, "in png_create_read_struct\n"); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, |
(png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); |
#else |
png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
#endif |
if (png_ptr == NULL) |
return (NULL); |
#if !defined(PNG_1_0_X) |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ |
#endif |
#endif /* PNG_1_0_X */ |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
#else |
if (setjmp(png_ptr->jmpbuf)) |
#endif |
{ |
png_free(png_ptr, png_ptr->zbuf); |
png_ptr->zbuf=NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)png_ptr, |
(png_free_ptr)free_fn, (png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)png_ptr); |
#endif |
return (NULL); |
} |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf)); |
#endif |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); |
#endif |
png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); |
i=0; |
do |
{ |
if(user_png_ver[i] != png_libpng_ver[i]) |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
} while (png_libpng_ver[i++]); |
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) |
{ |
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so |
* we must recompile any applications that use any older library version. |
* For versions after libpng 1.0, we will be compatible, so we need |
* only check the first digit. |
*/ |
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || |
(user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || |
(user_png_ver[0] == '0' && user_png_ver[2] < '9')) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char msg[80]; |
if (user_png_ver) |
{ |
sprintf(msg, "Application was compiled with png.h from libpng-%.20s", |
user_png_ver); |
png_warning(png_ptr, msg); |
} |
sprintf(msg, "Application is running with png.c from libpng-%.20s", |
png_libpng_ver); |
png_warning(png_ptr, msg); |
#endif |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"Incompatible libpng version in application and library"); |
} |
} |
/* initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)png_ptr->zbuf_size); |
png_ptr->zstream.zalloc = png_zalloc; |
png_ptr->zstream.zfree = png_zfree; |
png_ptr->zstream.opaque = (voidpf)png_ptr; |
switch (inflateInit(&png_ptr->zstream)) |
{ |
case Z_OK: /* Do nothing */ break; |
case Z_MEM_ERROR: |
case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break; |
case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); break; |
default: png_error(png_ptr, "Unknown zlib error"); |
} |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); |
#ifdef PNG_SETJMP_SUPPORTED |
/* Applications that neglect to set up their own setjmp() and then encounter |
a png_error() will longjmp here. Since the jmpbuf is then meaningless we |
abort instead of returning. */ |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
PNG_ABORT(); |
png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf)); |
#else |
if (setjmp(png_ptr->jmpbuf)) |
PNG_ABORT(); |
#endif |
#endif |
return (png_ptr); |
} |
/* Initialize PNG structure for reading, and allocate any memory needed. |
This interface is deprecated in favour of the png_create_read_struct(), |
and it will eventually disappear. */ |
#undef png_read_init |
void PNGAPI |
png_read_init(png_structp png_ptr) |
{ |
/* We only come here via pre-1.0.7-compiled applications */ |
png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0); |
} |
void PNGAPI |
png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver, |
png_size_t png_struct_size, png_size_t png_info_size) |
{ |
/* We only come here via pre-1.0.12-compiled applications */ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
if(sizeof(png_struct) > png_struct_size || sizeof(png_info) > png_info_size) |
{ |
char msg[80]; |
png_ptr->warning_fn=NULL; |
if (user_png_ver) |
{ |
sprintf(msg, "Application was compiled with png.h from libpng-%.20s", |
user_png_ver); |
png_warning(png_ptr, msg); |
} |
sprintf(msg, "Application is running with png.c from libpng-%.20s", |
png_libpng_ver); |
png_warning(png_ptr, msg); |
} |
#endif |
if(sizeof(png_struct) > png_struct_size) |
{ |
png_ptr->error_fn=NULL; |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"The png struct allocated by the application for reading is too small."); |
} |
if(sizeof(png_info) > png_info_size) |
{ |
png_ptr->error_fn=NULL; |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"The info struct allocated by application for reading is too small."); |
} |
png_read_init_3(&png_ptr, user_png_ver, png_struct_size); |
} |
void PNGAPI |
png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, |
png_size_t png_struct_size) |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf tmp_jmp; /* to save current jump buffer */ |
#endif |
int i=0; |
png_structp png_ptr=*ptr_ptr; |
do |
{ |
if(user_png_ver[i] != png_libpng_ver[i]) |
{ |
#ifdef PNG_LEGACY_SUPPORTED |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
#else |
png_ptr->warning_fn=NULL; |
png_warning(png_ptr, |
"Application uses deprecated png_read_init() and should be recompiled."); |
break; |
#endif |
} |
} while (png_libpng_ver[i++]); |
png_debug(1, "in png_read_init_3\n"); |
#ifdef PNG_SETJMP_SUPPORTED |
/* save jump buffer and error functions */ |
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf)); |
#endif |
if(sizeof(png_struct) > png_struct_size) |
{ |
png_destroy_struct(png_ptr); |
*ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
png_ptr = *ptr_ptr; |
} |
/* reset all variables to 0 */ |
png_memset(png_ptr, 0, sizeof (png_struct)); |
#ifdef PNG_SETJMP_SUPPORTED |
/* restore jump buffer */ |
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf)); |
#endif |
/* initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)png_ptr->zbuf_size); |
png_ptr->zstream.zalloc = png_zalloc; |
png_ptr->zstream.zfree = png_zfree; |
png_ptr->zstream.opaque = (voidpf)png_ptr; |
switch (inflateInit(&png_ptr->zstream)) |
{ |
case Z_OK: /* Do nothing */ break; |
case Z_MEM_ERROR: |
case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory"); break; |
case Z_VERSION_ERROR: png_error(png_ptr, "zlib version"); break; |
default: png_error(png_ptr, "Unknown zlib error"); |
} |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); |
} |
/* Read the information before the actual image data. This has been |
* changed in v0.90 to allow reading a file that already has the magic |
* bytes read from the stream. You can tell libpng how many bytes have |
* been read from the beginning of the stream (up to the maximum of 8) |
* via png_set_sig_bytes(), and we will only check the remaining bytes |
* here. The application can then have access to the signature bytes we |
* read if it is determined that this isn't a valid PNG file. |
*/ |
void PNGAPI |
png_read_info(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_read_info\n"); |
/* If we haven't checked all of the PNG signature bytes, do so now. */ |
if (png_ptr->sig_bytes < 8) |
{ |
png_size_t num_checked = png_ptr->sig_bytes, |
num_to_check = 8 - num_checked; |
png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check); |
png_ptr->sig_bytes = 8; |
if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) |
{ |
if (num_checked < 4 && |
png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) |
png_error(png_ptr, "Not a PNG file"); |
else |
png_error(png_ptr, "PNG file corrupted by ASCII conversion"); |
} |
if (num_checked < 3) |
png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; |
} |
for(;;) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#if defined(PNG_READ_bKGD_SUPPORTED) |
PNG_bKGD; |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
PNG_cHRM; |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
PNG_gAMA; |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
PNG_hIST; |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
PNG_iCCP; |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
PNG_iTXt; |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
PNG_oFFs; |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
PNG_pCAL; |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
PNG_pHYs; |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
PNG_sBIT; |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
PNG_sCAL; |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
PNG_sPLT; |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
PNG_sRGB; |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
PNG_tEXt; |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
PNG_tIME; |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
PNG_tRNS; |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
PNG_zTXt; |
#endif |
#endif /* PNG_GLOBAL_ARRAYS */ |
png_byte chunk_length[4]; |
png_uint_32 length; |
png_read_data(png_ptr, chunk_length, 4); |
length = png_get_uint_32(chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_debug2(0, "Reading %s chunk, length=%lu.\n", png_ptr->chunk_name, |
length); |
if (length > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid chunk length."); |
/* This should be a binary subdivision search or a hash for |
* matching the chunk name rather than a linear search. |
*/ |
if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) |
png_handle_IHDR(png_ptr, info_ptr, length); |
else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) |
png_handle_IEND(png_ptr, info_ptr, length); |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) |
{ |
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
png_ptr->mode |= PNG_HAVE_IDAT; |
png_handle_unknown(png_ptr, info_ptr, length); |
if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
png_ptr->mode |= PNG_HAVE_PLTE; |
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
break; |
} |
} |
#endif |
else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
png_handle_PLTE(png_ptr, info_ptr, length); |
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
png_ptr->idat_size = length; |
png_ptr->mode |= PNG_HAVE_IDAT; |
break; |
} |
#if defined(PNG_READ_bKGD_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) |
png_handle_bKGD(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) |
png_handle_cHRM(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) |
png_handle_gAMA(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) |
png_handle_hIST(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) |
png_handle_oFFs(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) |
png_handle_pCAL(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) |
png_handle_sCAL(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) |
png_handle_pHYs(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) |
png_handle_sBIT(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) |
png_handle_sRGB(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) |
png_handle_iCCP(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) |
png_handle_sPLT(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) |
png_handle_tEXt(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) |
png_handle_tIME(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) |
png_handle_tRNS(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) |
png_handle_zTXt(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) |
png_handle_iTXt(png_ptr, info_ptr, length); |
#endif |
else |
png_handle_unknown(png_ptr, info_ptr, length); |
} |
} |
/* optional call to update the users info_ptr structure */ |
void PNGAPI |
png_read_update_info(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_read_update_info\n"); |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
png_read_start_row(png_ptr); |
else |
png_warning(png_ptr, |
"Ignoring extra png_read_update_info() call; row buffer not reallocated"); |
png_read_transform_info(png_ptr, info_ptr); |
} |
/* Initialize palette, background, etc, after transformations |
* are set, but before any reading takes place. This allows |
* the user to obtain a gamma-corrected palette, for example. |
* If the user doesn't call this, we will do it ourselves. |
*/ |
void PNGAPI |
png_start_read_image(png_structp png_ptr) |
{ |
png_debug(1, "in png_start_read_image\n"); |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
png_read_start_row(png_ptr); |
} |
void PNGAPI |
png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IDAT; |
const int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; |
const int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; |
#endif |
int ret; |
png_debug2(1, "in png_read_row (row %lu, pass %d)\n", |
png_ptr->row_number, png_ptr->pass); |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
png_read_start_row(png_ptr); |
if (png_ptr->row_number == 0 && png_ptr->pass == 0) |
{ |
/* check for transforms that have been set but were defined out */ |
#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED) |
if (png_ptr->transformations & PNG_FILLER) |
png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && !defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED) |
if (png_ptr->transformations & PNG_PACK) |
png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) |
if (png_ptr->transformations & PNG_SHIFT) |
png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED) |
if (png_ptr->transformations & PNG_BGR) |
png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined."); |
#endif |
#if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined."); |
#endif |
} |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
/* if interlaced and we do not need a new row, combine row and return */ |
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) |
{ |
switch (png_ptr->pass) |
{ |
case 0: |
if (png_ptr->row_number & 0x07) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 1: |
if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 2: |
if ((png_ptr->row_number & 0x07) != 4) |
{ |
if (dsp_row != NULL && (png_ptr->row_number & 4)) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 3: |
if ((png_ptr->row_number & 3) || png_ptr->width < 3) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 4: |
if ((png_ptr->row_number & 3) != 2) |
{ |
if (dsp_row != NULL && (png_ptr->row_number & 2)) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 5: |
if ((png_ptr->row_number & 1) || png_ptr->width < 2) |
{ |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
case 6: |
if (!(png_ptr->row_number & 1)) |
{ |
png_read_finish_row(png_ptr); |
return; |
} |
break; |
} |
} |
#endif |
if (!(png_ptr->mode & PNG_HAVE_IDAT)) |
png_error(png_ptr, "Invalid attempt to read row data"); |
png_ptr->zstream.next_out = png_ptr->row_buf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; |
do |
{ |
if (!(png_ptr->zstream.avail_in)) |
{ |
while (!png_ptr->idat_size) |
{ |
png_byte chunk_length[4]; |
png_crc_finish(png_ptr, 0); |
png_read_data(png_ptr, chunk_length, 4); |
png_ptr->idat_size = png_get_uint_32(chunk_length); |
if (png_ptr->idat_size > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid chunk length."); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
png_error(png_ptr, "Not enough image data"); |
} |
png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_in = png_ptr->zbuf; |
if (png_ptr->zbuf_size > png_ptr->idat_size) |
png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; |
png_crc_read(png_ptr, png_ptr->zbuf, |
(png_size_t)png_ptr->zstream.avail_in); |
png_ptr->idat_size -= png_ptr->zstream.avail_in; |
} |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret == Z_STREAM_END) |
{ |
if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in || |
png_ptr->idat_size) |
png_error(png_ptr, "Extra compressed data"); |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
if (ret != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : |
"Decompression error"); |
} while (png_ptr->zstream.avail_out); |
png_ptr->row_info.color_type = png_ptr->color_type; |
png_ptr->row_info.width = png_ptr->iwidth; |
png_ptr->row_info.channels = png_ptr->channels; |
png_ptr->row_info.bit_depth = png_ptr->bit_depth; |
png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; |
png_ptr->row_info.rowbytes = ((png_ptr->row_info.width * |
(png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3); |
if(png_ptr->row_buf[0]) |
png_read_filter_row(png_ptr, &(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->prev_row + 1, |
(int)(png_ptr->row_buf[0])); |
png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, |
png_ptr->rowbytes + 1); |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
(png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) |
{ |
/* Intrapixel differencing */ |
png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); |
} |
#endif |
if (png_ptr->transformations) |
png_do_read_transformations(png_ptr); |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
/* blow up interlaced rows to full size */ |
if (png_ptr->interlaced && |
(png_ptr->transformations & PNG_INTERLACE)) |
{ |
if (png_ptr->pass < 6) |
/* old interface (pre-1.0.9): |
png_do_read_interlace(&(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); |
*/ |
png_do_read_interlace(png_ptr); |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, |
png_pass_dsp_mask[png_ptr->pass]); |
if (row != NULL) |
png_combine_row(png_ptr, row, |
png_pass_mask[png_ptr->pass]); |
} |
else |
#endif |
{ |
if (row != NULL) |
png_combine_row(png_ptr, row, 0xff); |
if (dsp_row != NULL) |
png_combine_row(png_ptr, dsp_row, 0xff); |
} |
png_read_finish_row(png_ptr); |
if (png_ptr->read_row_fn != NULL) |
(*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); |
} |
/* Read one or more rows of image data. If the image is interlaced, |
* and png_set_interlace_handling() has been called, the rows need to |
* contain the contents of the rows from the previous pass. If the |
* image has alpha or transparency, and png_handle_alpha()[*] has been |
* called, the rows contents must be initialized to the contents of the |
* screen. |
* |
* "row" holds the actual image, and pixels are placed in it |
* as they arrive. If the image is displayed after each pass, it will |
* appear to "sparkle" in. "display_row" can be used to display a |
* "chunky" progressive image, with finer detail added as it becomes |
* available. If you do not want this "chunky" display, you may pass |
* NULL for display_row. If you do not want the sparkle display, and |
* you have not called png_handle_alpha(), you may pass NULL for rows. |
* If you have called png_handle_alpha(), and the image has either an |
* alpha channel or a transparency chunk, you must provide a buffer for |
* rows. In this case, you do not have to provide a display_row buffer |
* also, but you may. If the image is not interlaced, or if you have |
* not called png_set_interlace_handling(), the display_row buffer will |
* be ignored, so pass NULL to it. |
* |
* [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.5 |
*/ |
void PNGAPI |
png_read_rows(png_structp png_ptr, png_bytepp row, |
png_bytepp display_row, png_uint_32 num_rows) |
{ |
png_uint_32 i; |
png_bytepp rp; |
png_bytepp dp; |
png_debug(1, "in png_read_rows\n"); |
rp = row; |
dp = display_row; |
if (rp != NULL && dp != NULL) |
for (i = 0; i < num_rows; i++) |
{ |
png_bytep rptr = *rp++; |
png_bytep dptr = *dp++; |
png_read_row(png_ptr, rptr, dptr); |
} |
else if(rp != NULL) |
for (i = 0; i < num_rows; i++) |
{ |
png_bytep rptr = *rp; |
png_read_row(png_ptr, rptr, png_bytep_NULL); |
rp++; |
} |
else if(dp != NULL) |
for (i = 0; i < num_rows; i++) |
{ |
png_bytep dptr = *dp; |
png_read_row(png_ptr, png_bytep_NULL, dptr); |
dp++; |
} |
} |
/* Read the entire image. If the image has an alpha channel or a tRNS |
* chunk, and you have called png_handle_alpha()[*], you will need to |
* initialize the image to the current image that PNG will be overlaying. |
* We set the num_rows again here, in case it was incorrectly set in |
* png_read_start_row() by a call to png_read_update_info() or |
* png_start_read_image() if png_set_interlace_handling() wasn't called |
* prior to either of these functions like it should have been. You can |
* only call this function once. If you desire to have an image for |
* each pass of a interlaced image, use png_read_rows() instead. |
* |
* [*] png_handle_alpha() does not exist yet, as of libpng version 1.2.5 |
*/ |
void PNGAPI |
png_read_image(png_structp png_ptr, png_bytepp image) |
{ |
png_uint_32 i,image_height; |
int pass, j; |
png_bytepp rp; |
png_debug(1, "in png_read_image\n"); |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
pass = png_set_interlace_handling(png_ptr); |
#else |
if (png_ptr->interlaced) |
png_error(png_ptr, |
"Cannot read interlaced image -- interlace handler disabled."); |
pass = 1; |
#endif |
image_height=png_ptr->height; |
png_ptr->num_rows = image_height; /* Make sure this is set correctly */ |
for (j = 0; j < pass; j++) |
{ |
rp = image; |
for (i = 0; i < image_height; i++) |
{ |
png_read_row(png_ptr, *rp, png_bytep_NULL); |
rp++; |
} |
} |
} |
/* Read the end of the PNG file. Will not read past the end of the |
* file, will verify the end is accurate, and will read any comments |
* or time information at the end of the file, if info is not NULL. |
*/ |
void PNGAPI |
png_read_end(png_structp png_ptr, png_infop info_ptr) |
{ |
png_byte chunk_length[4]; |
png_uint_32 length; |
png_debug(1, "in png_read_end\n"); |
png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ |
do |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#if defined(PNG_READ_bKGD_SUPPORTED) |
PNG_bKGD; |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
PNG_cHRM; |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
PNG_gAMA; |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
PNG_hIST; |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
PNG_iCCP; |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
PNG_iTXt; |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
PNG_oFFs; |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
PNG_pCAL; |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
PNG_pHYs; |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
PNG_sBIT; |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
PNG_sCAL; |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
PNG_sPLT; |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
PNG_sRGB; |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
PNG_tEXt; |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
PNG_tIME; |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
PNG_tRNS; |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
PNG_zTXt; |
#endif |
#endif /* PNG_GLOBAL_ARRAYS */ |
png_read_data(png_ptr, chunk_length, 4); |
length = png_get_uint_32(chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name); |
if (length > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid chunk length."); |
if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) |
png_handle_IHDR(png_ptr, info_ptr, length); |
else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) |
png_handle_IEND(png_ptr, info_ptr, length); |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) |
{ |
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
{ |
if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT) |
png_error(png_ptr, "Too many IDAT's found"); |
} |
else |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_handle_unknown(png_ptr, info_ptr, length); |
if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
png_ptr->mode |= PNG_HAVE_PLTE; |
} |
#endif |
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
{ |
/* Zero length IDATs are legal after the last IDAT has been |
* read, but not after other chunks have been read. |
*/ |
if (length > 0 || png_ptr->mode & PNG_AFTER_IDAT) |
png_error(png_ptr, "Too many IDAT's found"); |
png_crc_finish(png_ptr, length); |
} |
else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
png_handle_PLTE(png_ptr, info_ptr, length); |
#if defined(PNG_READ_bKGD_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) |
png_handle_bKGD(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) |
png_handle_cHRM(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) |
png_handle_gAMA(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) |
png_handle_hIST(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) |
png_handle_oFFs(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) |
png_handle_pCAL(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) |
png_handle_sCAL(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) |
png_handle_pHYs(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) |
png_handle_sBIT(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) |
png_handle_sRGB(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) |
png_handle_iCCP(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) |
png_handle_sPLT(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) |
png_handle_tEXt(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) |
png_handle_tIME(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) |
png_handle_tRNS(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) |
png_handle_zTXt(png_ptr, info_ptr, length); |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) |
png_handle_iTXt(png_ptr, info_ptr, length); |
#endif |
else |
png_handle_unknown(png_ptr, info_ptr, length); |
} while (!(png_ptr->mode & PNG_HAVE_IEND)); |
} |
/* free all memory used by the read */ |
void PNGAPI |
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, |
png_infopp end_info_ptr_ptr) |
{ |
png_structp png_ptr = NULL; |
png_infop info_ptr = NULL, end_info_ptr = NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn = NULL; |
png_voidp mem_ptr = NULL; |
#endif |
png_debug(1, "in png_destroy_read_struct\n"); |
if (png_ptr_ptr != NULL) |
png_ptr = *png_ptr_ptr; |
if (info_ptr_ptr != NULL) |
info_ptr = *info_ptr_ptr; |
if (end_info_ptr_ptr != NULL) |
end_info_ptr = *end_info_ptr_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
mem_ptr = png_ptr->mem_ptr; |
#endif |
png_read_destroy(png_ptr, info_ptr, end_info_ptr); |
if (info_ptr != NULL) |
{ |
#if defined(PNG_TEXT_SUPPORTED) |
png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1); |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)info_ptr); |
#endif |
*info_ptr_ptr = NULL; |
} |
if (end_info_ptr != NULL) |
{ |
#if defined(PNG_READ_TEXT_SUPPORTED) |
png_free_data(png_ptr, end_info_ptr, PNG_FREE_TEXT, -1); |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)end_info_ptr); |
#endif |
*end_info_ptr_ptr = NULL; |
} |
if (png_ptr != NULL) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)png_ptr); |
#endif |
*png_ptr_ptr = NULL; |
} |
} |
/* free all memory used by the read (old method) */ |
void /* PRIVATE */ |
png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr) |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf tmp_jmp; |
#endif |
png_error_ptr error_fn; |
png_error_ptr warning_fn; |
png_voidp error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn; |
#endif |
png_debug(1, "in png_read_destroy\n"); |
if (info_ptr != NULL) |
png_info_destroy(png_ptr, info_ptr); |
if (end_info_ptr != NULL) |
png_info_destroy(png_ptr, end_info_ptr); |
png_free(png_ptr, png_ptr->zbuf); |
png_free(png_ptr, png_ptr->big_row_buf); |
png_free(png_ptr, png_ptr->prev_row); |
#if defined(PNG_READ_DITHER_SUPPORTED) |
png_free(png_ptr, png_ptr->palette_lookup); |
png_free(png_ptr, png_ptr->dither_index); |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
png_free(png_ptr, png_ptr->gamma_table); |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
png_free(png_ptr, png_ptr->gamma_from_1); |
png_free(png_ptr, png_ptr->gamma_to_1); |
#endif |
#ifdef PNG_FREE_ME_SUPPORTED |
if (png_ptr->free_me & PNG_FREE_PLTE) |
png_zfree(png_ptr, png_ptr->palette); |
png_ptr->free_me &= ~PNG_FREE_PLTE; |
#else |
if (png_ptr->flags & PNG_FLAG_FREE_PLTE) |
png_zfree(png_ptr, png_ptr->palette); |
png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; |
#endif |
#if defined(PNG_tRNS_SUPPORTED) || \ |
defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
#ifdef PNG_FREE_ME_SUPPORTED |
if (png_ptr->free_me & PNG_FREE_TRNS) |
png_free(png_ptr, png_ptr->trans); |
png_ptr->free_me &= ~PNG_FREE_TRNS; |
#else |
if (png_ptr->flags & PNG_FLAG_FREE_TRNS) |
png_free(png_ptr, png_ptr->trans); |
png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; |
#endif |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
#ifdef PNG_FREE_ME_SUPPORTED |
if (png_ptr->free_me & PNG_FREE_HIST) |
png_free(png_ptr, png_ptr->hist); |
png_ptr->free_me &= ~PNG_FREE_HIST; |
#else |
if (png_ptr->flags & PNG_FLAG_FREE_HIST) |
png_free(png_ptr, png_ptr->hist); |
png_ptr->flags &= ~PNG_FLAG_FREE_HIST; |
#endif |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (png_ptr->gamma_16_table != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_table[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_table); |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_16_from_1 != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_from_1[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_from_1); |
} |
if (png_ptr->gamma_16_to_1 != NULL) |
{ |
int i; |
int istop = (1 << (8 - png_ptr->gamma_shift)); |
for (i = 0; i < istop; i++) |
{ |
png_free(png_ptr, png_ptr->gamma_16_to_1[i]); |
} |
png_free(png_ptr, png_ptr->gamma_16_to_1); |
} |
#endif |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
png_free(png_ptr, png_ptr->time_buffer); |
#endif |
inflateEnd(&png_ptr->zstream); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
png_free(png_ptr, png_ptr->save_buffer); |
#endif |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
#ifdef PNG_TEXT_SUPPORTED |
png_free(png_ptr, png_ptr->current_text); |
#endif /* PNG_TEXT_SUPPORTED */ |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
/* Save the important info out of the png_struct, in case it is |
* being used again. |
*/ |
#ifdef PNG_SETJMP_SUPPORTED |
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf)); |
#endif |
error_fn = png_ptr->error_fn; |
warning_fn = png_ptr->warning_fn; |
error_ptr = png_ptr->error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
#endif |
png_memset(png_ptr, 0, sizeof (png_struct)); |
png_ptr->error_fn = error_fn; |
png_ptr->warning_fn = warning_fn; |
png_ptr->error_ptr = error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr->free_fn = free_fn; |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf)); |
#endif |
} |
void PNGAPI |
png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) |
{ |
png_ptr->read_row_fn = read_row_fn; |
} |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
void PNGAPI |
png_read_png(png_structp png_ptr, png_infop info_ptr, |
int transforms, |
voidp params) |
{ |
int row; |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) |
/* invert the alpha channel from opacity to transparency */ |
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) |
png_set_invert_alpha(png_ptr); |
#endif |
/* The call to png_read_info() gives us all of the information from the |
* PNG file before the first IDAT (image data chunk). |
*/ |
png_read_info(png_ptr, info_ptr); |
/* -------------- image transformations start here ------------------- */ |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
/* tell libpng to strip 16 bit/color files down to 8 bits/color */ |
if (transforms & PNG_TRANSFORM_STRIP_16) |
png_set_strip_16(png_ptr); |
#endif |
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
/* Strip alpha bytes from the input data without combining with the |
* background (not recommended). |
*/ |
if (transforms & PNG_TRANSFORM_STRIP_ALPHA) |
png_set_strip_alpha(png_ptr); |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED) |
/* Extract multiple pixels with bit depths of 1, 2, and 4 from a single |
* byte into separate bytes (useful for paletted and grayscale images). |
*/ |
if (transforms & PNG_TRANSFORM_PACKING) |
png_set_packing(png_ptr); |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
/* Change the order of packed pixels to least significant bit first |
* (not useful if you are using png_set_packing). */ |
if (transforms & PNG_TRANSFORM_PACKSWAP) |
png_set_packswap(png_ptr); |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
/* Expand paletted colors into true RGB triplets |
* Expand grayscale images to full 8 bits from 1, 2, or 4 bits/pixel |
* Expand paletted or RGB images with transparency to full alpha |
* channels so the data will be available as RGBA quartets. |
*/ |
if (transforms & PNG_TRANSFORM_EXPAND) |
if ((png_ptr->bit_depth < 8) || |
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) || |
(png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) |
png_set_expand(png_ptr); |
#endif |
/* We don't handle background color or gamma transformation or dithering. */ |
#if defined(PNG_READ_INVERT_SUPPORTED) |
/* invert monochrome files to have 0 as white and 1 as black */ |
if (transforms & PNG_TRANSFORM_INVERT_MONO) |
png_set_invert_mono(png_ptr); |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) |
/* If you want to shift the pixel values from the range [0,255] or |
* [0,65535] to the original [0,7] or [0,31], or whatever range the |
* colors were originally in: |
*/ |
if ((transforms & PNG_TRANSFORM_SHIFT) |
&& png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) |
{ |
png_color_8p sig_bit; |
png_get_sBIT(png_ptr, info_ptr, &sig_bit); |
png_set_shift(png_ptr, sig_bit); |
} |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) |
/* flip the RGB pixels to BGR (or RGBA to BGRA) */ |
if (transforms & PNG_TRANSFORM_BGR) |
png_set_bgr(png_ptr); |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) |
/* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */ |
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) |
png_set_swap_alpha(png_ptr); |
#endif |
#if defined(PNG_READ_SWAP_SUPPORTED) |
/* swap bytes of 16 bit files to least significant byte first */ |
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) |
png_set_swap(png_ptr); |
#endif |
/* We don't handle adding filler bytes */ |
/* Optional call to gamma correct and add the background to the palette |
* and update info structure. REQUIRED if you are expecting libpng to |
* update the palette for you (i.e., you selected such a transform above). |
*/ |
png_read_update_info(png_ptr, info_ptr); |
/* -------------- image transformations end here ------------------- */ |
#ifdef PNG_FREE_ME_SUPPORTED |
png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); |
#endif |
if(info_ptr->row_pointers == NULL) |
{ |
info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, |
info_ptr->height * sizeof(png_bytep)); |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_ROWS; |
#endif |
for (row = 0; row < (int)info_ptr->height; row++) |
{ |
info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr, |
png_get_rowbytes(png_ptr, info_ptr)); |
} |
} |
png_read_image(png_ptr, info_ptr->row_pointers); |
info_ptr->valid |= PNG_INFO_IDAT; |
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */ |
png_read_end(png_ptr, info_ptr); |
if(transforms == 0 || params == NULL) |
/* quiet compiler warnings */ return; |
} |
#endif |
/shark/trunk/ports/png/trees.c |
---|
0,0 → 1,1214 |
/* trees.c -- output deflated data using Huffman coding |
* Copyright (C) 1995-2002 Jean-loup Gailly |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* |
* ALGORITHM |
* |
* The "deflation" process uses several Huffman trees. The more |
* common source values are represented by shorter bit sequences. |
* |
* Each code tree is stored in a compressed form which is itself |
* a Huffman encoding of the lengths of all the code strings (in |
* ascending order by source values). The actual code strings are |
* reconstructed from the lengths in the inflate process, as described |
* in the deflate specification. |
* |
* REFERENCES |
* |
* Deutsch, L.P.,"'Deflate' Compressed Data Format Specification". |
* Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc |
* |
* Storer, James A. |
* Data Compression: Methods and Theory, pp. 49-50. |
* Computer Science Press, 1988. ISBN 0-7167-8156-5. |
* |
* Sedgewick, R. |
* Algorithms, p290. |
* Addison-Wesley, 1983. ISBN 0-201-06672-6. |
*/ |
/* @(#) $Id: trees.c,v 1.1 2003-03-20 13:08:13 giacomo Exp $ */ |
/* #define GEN_TREES_H */ |
#include "deflate.h" |
#ifdef DEBUG |
# include <ctype.h> |
#endif |
/* =========================================================================== |
* Constants |
*/ |
#define MAX_BL_BITS 7 |
/* Bit length codes must not exceed MAX_BL_BITS bits */ |
#define END_BLOCK 256 |
/* end of block literal code */ |
#define REP_3_6 16 |
/* repeat previous bit length 3-6 times (2 bits of repeat count) */ |
#define REPZ_3_10 17 |
/* repeat a zero length 3-10 times (3 bits of repeat count) */ |
#define REPZ_11_138 18 |
/* repeat a zero length 11-138 times (7 bits of repeat count) */ |
local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ |
= {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}; |
local const int extra_dbits[D_CODES] /* extra bits for each distance code */ |
= {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}; |
local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ |
= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; |
local const uch bl_order[BL_CODES] |
= {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; |
/* The lengths of the bit length codes are sent in order of decreasing |
* probability, to avoid transmitting the lengths for unused bit length codes. |
*/ |
#define Buf_size (8 * 2*sizeof(char)) |
/* Number of bits used within bi_buf. (bi_buf might be implemented on |
* more than 16 bits on some systems.) |
*/ |
/* =========================================================================== |
* Local data. These are initialized only once. |
*/ |
#define DIST_CODE_LEN 512 /* see definition of array dist_code below */ |
#if defined(GEN_TREES_H) || !defined(STDC) |
/* non ANSI compilers may not accept trees.h */ |
local ct_data static_ltree[L_CODES+2]; |
/* The static literal tree. Since the bit lengths are imposed, there is no |
* need for the L_CODES extra codes used during heap construction. However |
* The codes 286 and 287 are needed to build a canonical tree (see _tr_init |
* below). |
*/ |
local ct_data static_dtree[D_CODES]; |
/* The static distance tree. (Actually a trivial tree since all codes use |
* 5 bits.) |
*/ |
uch _dist_code[DIST_CODE_LEN]; |
/* Distance codes. The first 256 values correspond to the distances |
* 3 .. 258, the last 256 values correspond to the top 8 bits of |
* the 15 bit distances. |
*/ |
uch _length_code[MAX_MATCH-MIN_MATCH+1]; |
/* length code for each normalized match length (0 == MIN_MATCH) */ |
local int base_length[LENGTH_CODES]; |
/* First normalized length for each code (0 = MIN_MATCH) */ |
local int base_dist[D_CODES]; |
/* First normalized distance for each code (0 = distance of 1) */ |
#else |
# include "trees.h" |
#endif /* GEN_TREES_H */ |
struct static_tree_desc_s { |
const ct_data *static_tree; /* static tree or NULL */ |
const intf *extra_bits; /* extra bits for each code or NULL */ |
int extra_base; /* base index for extra_bits */ |
int elems; /* max number of elements in the tree */ |
int max_length; /* max bit length for the codes */ |
}; |
local static_tree_desc static_l_desc = |
{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; |
local static_tree_desc static_d_desc = |
{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; |
local static_tree_desc static_bl_desc = |
{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; |
/* =========================================================================== |
* Local (static) routines in this file. |
*/ |
local void tr_static_init OF((void)); |
local void init_block OF((deflate_state *s)); |
local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); |
local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); |
local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); |
local void build_tree OF((deflate_state *s, tree_desc *desc)); |
local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); |
local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); |
local int build_bl_tree OF((deflate_state *s)); |
local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, |
int blcodes)); |
local void compress_block OF((deflate_state *s, ct_data *ltree, |
ct_data *dtree)); |
local void set_data_type OF((deflate_state *s)); |
local unsigned bi_reverse OF((unsigned value, int length)); |
local void bi_windup OF((deflate_state *s)); |
local void bi_flush OF((deflate_state *s)); |
local void copy_block OF((deflate_state *s, charf *buf, unsigned len, |
int header)); |
#ifdef GEN_TREES_H |
local void gen_trees_header OF((void)); |
#endif |
#ifndef DEBUG |
# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) |
/* Send a code of the given tree. c and tree must not have side effects */ |
#else /* DEBUG */ |
# define send_code(s, c, tree) \ |
{ if (z_verbose>2) cprintf("\ncd %3d ",(c)); \ |
send_bits(s, tree[c].Code, tree[c].Len); } |
#endif |
/* =========================================================================== |
* Output a short LSB first on the stream. |
* IN assertion: there is enough room in pendingBuf. |
*/ |
#define put_short(s, w) { \ |
put_byte(s, (uch)((w) & 0xff)); \ |
put_byte(s, (uch)((ush)(w) >> 8)); \ |
} |
/* =========================================================================== |
* Send a value on a given number of bits. |
* IN assertion: length <= 16 and value fits in length bits. |
*/ |
#ifdef DEBUG |
local void send_bits OF((deflate_state *s, int value, int length)); |
local void send_bits(s, value, length) |
deflate_state *s; |
int value; /* value to send */ |
int length; /* number of bits */ |
{ |
Tracevv((stderr," l %2d v %4x ", length, value)); |
Assert(length > 0 && length <= 15, "invalid length"); |
s->bits_sent += (ulg)length; |
/* If not enough room in bi_buf, use (valid) bits from bi_buf and |
* (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) |
* unused bits in value. |
*/ |
if (s->bi_valid > (int)Buf_size - length) { |
s->bi_buf |= (value << s->bi_valid); |
put_short(s, s->bi_buf); |
s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); |
s->bi_valid += length - Buf_size; |
} else { |
s->bi_buf |= value << s->bi_valid; |
s->bi_valid += length; |
} |
} |
#else /* !DEBUG */ |
#define send_bits(s, value, length) \ |
{ int len = length;\ |
if (s->bi_valid > (int)Buf_size - len) {\ |
int val = value;\ |
s->bi_buf |= (val << s->bi_valid);\ |
put_short(s, s->bi_buf);\ |
s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ |
s->bi_valid += len - Buf_size;\ |
} else {\ |
s->bi_buf |= (value) << s->bi_valid;\ |
s->bi_valid += len;\ |
}\ |
} |
#endif /* DEBUG */ |
#define MAX(a,b) (a >= b ? a : b) |
/* the arguments must not have side effects */ |
/* =========================================================================== |
* Initialize the various 'constant' tables. |
*/ |
local void tr_static_init() |
{ |
#if defined(GEN_TREES_H) || !defined(STDC) |
static int static_init_done = 0; |
int n; /* iterates over tree elements */ |
int bits; /* bit counter */ |
int length; /* length value */ |
int code; /* code value */ |
int dist; /* distance index */ |
ush bl_count[MAX_BITS+1]; |
/* number of codes at each bit length for an optimal tree */ |
if (static_init_done) return; |
/* For some embedded targets, global variables are not initialized: */ |
static_l_desc.static_tree = static_ltree; |
static_l_desc.extra_bits = extra_lbits; |
static_d_desc.static_tree = static_dtree; |
static_d_desc.extra_bits = extra_dbits; |
static_bl_desc.extra_bits = extra_blbits; |
/* Initialize the mapping length (0..255) -> length code (0..28) */ |
length = 0; |
for (code = 0; code < LENGTH_CODES-1; code++) { |
base_length[code] = length; |
for (n = 0; n < (1<<extra_lbits[code]); n++) { |
_length_code[length++] = (uch)code; |
} |
} |
Assert (length == 256, "tr_static_init: length != 256"); |
/* Note that the length 255 (match length 258) can be represented |
* in two different ways: code 284 + 5 bits or code 285, so we |
* overwrite length_code[255] to use the best encoding: |
*/ |
_length_code[length-1] = (uch)code; |
/* Initialize the mapping dist (0..32K) -> dist code (0..29) */ |
dist = 0; |
for (code = 0 ; code < 16; code++) { |
base_dist[code] = dist; |
for (n = 0; n < (1<<extra_dbits[code]); n++) { |
_dist_code[dist++] = (uch)code; |
} |
} |
Assert (dist == 256, "tr_static_init: dist != 256"); |
dist >>= 7; /* from now on, all distances are divided by 128 */ |
for ( ; code < D_CODES; code++) { |
base_dist[code] = dist << 7; |
for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { |
_dist_code[256 + dist++] = (uch)code; |
} |
} |
Assert (dist == 256, "tr_static_init: 256+dist != 512"); |
/* Construct the codes of the static literal tree */ |
for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; |
n = 0; |
while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; |
while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; |
while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; |
while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; |
/* Codes 286 and 287 do not exist, but we must include them in the |
* tree construction to get a canonical Huffman tree (longest code |
* all ones) |
*/ |
gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); |
/* The static distance tree is trivial: */ |
for (n = 0; n < D_CODES; n++) { |
static_dtree[n].Len = 5; |
static_dtree[n].Code = bi_reverse((unsigned)n, 5); |
} |
static_init_done = 1; |
# ifdef GEN_TREES_H |
gen_trees_header(); |
# endif |
#endif /* defined(GEN_TREES_H) || !defined(STDC) */ |
} |
/* =========================================================================== |
* Genererate the file trees.h describing the static trees. |
*/ |
#ifdef GEN_TREES_H |
# ifndef DEBUG |
# include <stdio.h> |
# endif |
# define SEPARATOR(i, last, width) \ |
((i) == (last)? "\n};\n\n" : \ |
((i) % (width) == (width)-1 ? ",\n" : ", ")) |
void gen_trees_header() |
{ |
FILE *header = fopen("trees.h", "w"); |
int i; |
Assert (header != NULL, "Can't open trees.h"); |
fprintf(header, |
"/* header created automatically with -DGEN_TREES_H */\n\n"); |
fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); |
for (i = 0; i < L_CODES+2; i++) { |
fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, |
static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); |
} |
fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); |
for (i = 0; i < D_CODES; i++) { |
fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, |
static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); |
} |
fprintf(header, "const uch _dist_code[DIST_CODE_LEN] = {\n"); |
for (i = 0; i < DIST_CODE_LEN; i++) { |
fprintf(header, "%2u%s", _dist_code[i], |
SEPARATOR(i, DIST_CODE_LEN-1, 20)); |
} |
fprintf(header, "const uch _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); |
for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { |
fprintf(header, "%2u%s", _length_code[i], |
SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); |
} |
fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); |
for (i = 0; i < LENGTH_CODES; i++) { |
fprintf(header, "%1u%s", base_length[i], |
SEPARATOR(i, LENGTH_CODES-1, 20)); |
} |
fprintf(header, "local const int base_dist[D_CODES] = {\n"); |
for (i = 0; i < D_CODES; i++) { |
fprintf(header, "%5u%s", base_dist[i], |
SEPARATOR(i, D_CODES-1, 10)); |
} |
fclose(header); |
} |
#endif /* GEN_TREES_H */ |
/* =========================================================================== |
* Initialize the tree data structures for a new zlib stream. |
*/ |
void _tr_init(s) |
deflate_state *s; |
{ |
tr_static_init(); |
s->l_desc.dyn_tree = s->dyn_ltree; |
s->l_desc.stat_desc = &static_l_desc; |
s->d_desc.dyn_tree = s->dyn_dtree; |
s->d_desc.stat_desc = &static_d_desc; |
s->bl_desc.dyn_tree = s->bl_tree; |
s->bl_desc.stat_desc = &static_bl_desc; |
s->bi_buf = 0; |
s->bi_valid = 0; |
s->last_eob_len = 8; /* enough lookahead for inflate */ |
#ifdef DEBUG |
s->compressed_len = 0L; |
s->bits_sent = 0L; |
#endif |
/* Initialize the first block of the first file: */ |
init_block(s); |
} |
/* =========================================================================== |
* Initialize a new block. |
*/ |
local void init_block(s) |
deflate_state *s; |
{ |
int n; /* iterates over tree elements */ |
/* Initialize the trees. */ |
for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; |
for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; |
for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; |
s->dyn_ltree[END_BLOCK].Freq = 1; |
s->opt_len = s->static_len = 0L; |
s->last_lit = s->matches = 0; |
} |
#define SMALLEST 1 |
/* Index within the heap array of least frequent node in the Huffman tree */ |
/* =========================================================================== |
* Remove the smallest element from the heap and recreate the heap with |
* one less element. Updates heap and heap_len. |
*/ |
#define pqremove(s, tree, top) \ |
{\ |
top = s->heap[SMALLEST]; \ |
s->heap[SMALLEST] = s->heap[s->heap_len--]; \ |
pqdownheap(s, tree, SMALLEST); \ |
} |
/* =========================================================================== |
* Compares to subtrees, using the tree depth as tie breaker when |
* the subtrees have equal frequency. This minimizes the worst case length. |
*/ |
#define smaller(tree, n, m, depth) \ |
(tree[n].Freq < tree[m].Freq || \ |
(tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) |
/* =========================================================================== |
* Restore the heap property by moving down the tree starting at node k, |
* exchanging a node with the smallest of its two sons if necessary, stopping |
* when the heap property is re-established (each father smaller than its |
* two sons). |
*/ |
local void pqdownheap(s, tree, k) |
deflate_state *s; |
ct_data *tree; /* the tree to restore */ |
int k; /* node to move down */ |
{ |
int v = s->heap[k]; |
int j = k << 1; /* left son of k */ |
while (j <= s->heap_len) { |
/* Set j to the smallest of the two sons: */ |
if (j < s->heap_len && |
smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { |
j++; |
} |
/* Exit if v is smaller than both sons */ |
if (smaller(tree, v, s->heap[j], s->depth)) break; |
/* Exchange v with the smallest son */ |
s->heap[k] = s->heap[j]; k = j; |
/* And continue down the tree, setting j to the left son of k */ |
j <<= 1; |
} |
s->heap[k] = v; |
} |
/* =========================================================================== |
* Compute the optimal bit lengths for a tree and update the total bit length |
* for the current block. |
* IN assertion: the fields freq and dad are set, heap[heap_max] and |
* above are the tree nodes sorted by increasing frequency. |
* OUT assertions: the field len is set to the optimal bit length, the |
* array bl_count contains the frequencies for each bit length. |
* The length opt_len is updated; static_len is also updated if stree is |
* not null. |
*/ |
local void gen_bitlen(s, desc) |
deflate_state *s; |
tree_desc *desc; /* the tree descriptor */ |
{ |
ct_data *tree = desc->dyn_tree; |
int max_code = desc->max_code; |
const ct_data *stree = desc->stat_desc->static_tree; |
const intf *extra = desc->stat_desc->extra_bits; |
int base = desc->stat_desc->extra_base; |
int max_length = desc->stat_desc->max_length; |
int h; /* heap index */ |
int n, m; /* iterate over the tree elements */ |
int bits; /* bit length */ |
int xbits; /* extra bits */ |
ush f; /* frequency */ |
int overflow = 0; /* number of elements with bit length too large */ |
for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0; |
/* In a first pass, compute the optimal bit lengths (which may |
* overflow in the case of the bit length tree). |
*/ |
tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ |
for (h = s->heap_max+1; h < HEAP_SIZE; h++) { |
n = s->heap[h]; |
bits = tree[tree[n].Dad].Len + 1; |
if (bits > max_length) bits = max_length, overflow++; |
tree[n].Len = (ush)bits; |
/* We overwrite tree[n].Dad which is no longer needed */ |
if (n > max_code) continue; /* not a leaf node */ |
s->bl_count[bits]++; |
xbits = 0; |
if (n >= base) xbits = extra[n-base]; |
f = tree[n].Freq; |
s->opt_len += (ulg)f * (bits + xbits); |
if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); |
} |
if (overflow == 0) return; |
Trace((stderr,"\nbit length overflow\n")); |
/* This happens for example on obj2 and pic of the Calgary corpus */ |
/* Find the first bit length which could increase: */ |
do { |
bits = max_length-1; |
while (s->bl_count[bits] == 0) bits--; |
s->bl_count[bits]--; /* move one leaf down the tree */ |
s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ |
s->bl_count[max_length]--; |
/* The brother of the overflow item also moves one step up, |
* but this does not affect bl_count[max_length] |
*/ |
overflow -= 2; |
} while (overflow > 0); |
/* Now recompute all bit lengths, scanning in increasing frequency. |
* h is still equal to HEAP_SIZE. (It is simpler to reconstruct all |
* lengths instead of fixing only the wrong ones. This idea is taken |
* from 'ar' written by Haruhiko Okumura.) |
*/ |
for (bits = max_length; bits != 0; bits--) { |
n = s->bl_count[bits]; |
while (n != 0) { |
m = s->heap[--h]; |
if (m > max_code) continue; |
if (tree[m].Len != (unsigned) bits) { |
Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); |
s->opt_len += ((long)bits - (long)tree[m].Len) |
*(long)tree[m].Freq; |
tree[m].Len = (ush)bits; |
} |
n--; |
} |
} |
} |
/* =========================================================================== |
* Generate the codes for a given tree and bit counts (which need not be |
* optimal). |
* IN assertion: the array bl_count contains the bit length statistics for |
* the given tree and the field len is set for all tree elements. |
* OUT assertion: the field code is set for all tree elements of non |
* zero code length. |
*/ |
local void gen_codes (tree, max_code, bl_count) |
ct_data *tree; /* the tree to decorate */ |
int max_code; /* largest code with non zero frequency */ |
ushf *bl_count; /* number of codes at each bit length */ |
{ |
ush next_code[MAX_BITS+1]; /* next code value for each bit length */ |
ush code = 0; /* running code value */ |
int bits; /* bit index */ |
int n; /* code index */ |
/* The distribution counts are first used to generate the code values |
* without bit reversal. |
*/ |
for (bits = 1; bits <= MAX_BITS; bits++) { |
next_code[bits] = code = (code + bl_count[bits-1]) << 1; |
} |
/* Check that the bit counts in bl_count are consistent. The last code |
* must be all ones. |
*/ |
Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1, |
"inconsistent bit counts"); |
Tracev((stderr,"\ngen_codes: max_code %d ", max_code)); |
for (n = 0; n <= max_code; n++) { |
int len = tree[n].Len; |
if (len == 0) continue; |
/* Now reverse the bits */ |
tree[n].Code = bi_reverse(next_code[len]++, len); |
Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ", |
n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1)); |
} |
} |
/* =========================================================================== |
* Construct one Huffman tree and assigns the code bit strings and lengths. |
* Update the total bit length for the current block. |
* IN assertion: the field freq is set for all tree elements. |
* OUT assertions: the fields len and code are set to the optimal bit length |
* and corresponding code. The length opt_len is updated; static_len is |
* also updated if stree is not null. The field max_code is set. |
*/ |
local void build_tree(s, desc) |
deflate_state *s; |
tree_desc *desc; /* the tree descriptor */ |
{ |
ct_data *tree = desc->dyn_tree; |
const ct_data *stree = desc->stat_desc->static_tree; |
int elems = desc->stat_desc->elems; |
int n, m; /* iterate over heap elements */ |
int max_code = -1; /* largest code with non zero frequency */ |
int node; /* new node being created */ |
/* Construct the initial heap, with least frequent element in |
* heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. |
* heap[0] is not used. |
*/ |
s->heap_len = 0, s->heap_max = HEAP_SIZE; |
for (n = 0; n < elems; n++) { |
if (tree[n].Freq != 0) { |
s->heap[++(s->heap_len)] = max_code = n; |
s->depth[n] = 0; |
} else { |
tree[n].Len = 0; |
} |
} |
/* The pkzip format requires that at least one distance code exists, |
* and that at least one bit should be sent even if there is only one |
* possible code. So to avoid special checks later on we force at least |
* two codes of non zero frequency. |
*/ |
while (s->heap_len < 2) { |
node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); |
tree[node].Freq = 1; |
s->depth[node] = 0; |
s->opt_len--; if (stree) s->static_len -= stree[node].Len; |
/* node is 0 or 1 so it does not have extra bits */ |
} |
desc->max_code = max_code; |
/* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, |
* establish sub-heaps of increasing lengths: |
*/ |
for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); |
/* Construct the Huffman tree by repeatedly combining the least two |
* frequent nodes. |
*/ |
node = elems; /* next internal node of the tree */ |
do { |
pqremove(s, tree, n); /* n = node of least frequency */ |
m = s->heap[SMALLEST]; /* m = node of next least frequency */ |
s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ |
s->heap[--(s->heap_max)] = m; |
/* Create a new node father of n and m */ |
tree[node].Freq = tree[n].Freq + tree[m].Freq; |
s->depth[node] = (uch) (MAX(s->depth[n], s->depth[m]) + 1); |
tree[n].Dad = tree[m].Dad = (ush)node; |
#ifdef DUMP_BL_TREE |
if (tree == s->bl_tree) { |
cprintf("\nnode %d(%d), sons %d(%d) %d(%d)", |
node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); |
} |
#endif |
/* and insert the new node in the heap */ |
s->heap[SMALLEST] = node++; |
pqdownheap(s, tree, SMALLEST); |
} while (s->heap_len >= 2); |
s->heap[--(s->heap_max)] = s->heap[SMALLEST]; |
/* At this point, the fields freq and dad are set. We can now |
* generate the bit lengths. |
*/ |
gen_bitlen(s, (tree_desc *)desc); |
/* The field len is now set, we can generate the bit codes */ |
gen_codes ((ct_data *)tree, max_code, s->bl_count); |
} |
/* =========================================================================== |
* Scan a literal or distance tree to determine the frequencies of the codes |
* in the bit length tree. |
*/ |
local void scan_tree (s, tree, max_code) |
deflate_state *s; |
ct_data *tree; /* the tree to be scanned */ |
int max_code; /* and its largest code of non zero frequency */ |
{ |
int n; /* iterates over all tree elements */ |
int prevlen = -1; /* last emitted length */ |
int curlen; /* length of current code */ |
int nextlen = tree[0].Len; /* length of next code */ |
int count = 0; /* repeat count of the current code */ |
int max_count = 7; /* max repeat count */ |
int min_count = 4; /* min repeat count */ |
if (nextlen == 0) max_count = 138, min_count = 3; |
tree[max_code+1].Len = (ush)0xffff; /* guard */ |
for (n = 0; n <= max_code; n++) { |
curlen = nextlen; nextlen = tree[n+1].Len; |
if (++count < max_count && curlen == nextlen) { |
continue; |
} else if (count < min_count) { |
s->bl_tree[curlen].Freq += count; |
} else if (curlen != 0) { |
if (curlen != prevlen) s->bl_tree[curlen].Freq++; |
s->bl_tree[REP_3_6].Freq++; |
} else if (count <= 10) { |
s->bl_tree[REPZ_3_10].Freq++; |
} else { |
s->bl_tree[REPZ_11_138].Freq++; |
} |
count = 0; prevlen = curlen; |
if (nextlen == 0) { |
max_count = 138, min_count = 3; |
} else if (curlen == nextlen) { |
max_count = 6, min_count = 3; |
} else { |
max_count = 7, min_count = 4; |
} |
} |
} |
/* =========================================================================== |
* Send a literal or distance tree in compressed form, using the codes in |
* bl_tree. |
*/ |
local void send_tree (s, tree, max_code) |
deflate_state *s; |
ct_data *tree; /* the tree to be scanned */ |
int max_code; /* and its largest code of non zero frequency */ |
{ |
int n; /* iterates over all tree elements */ |
int prevlen = -1; /* last emitted length */ |
int curlen; /* length of current code */ |
int nextlen = tree[0].Len; /* length of next code */ |
int count = 0; /* repeat count of the current code */ |
int max_count = 7; /* max repeat count */ |
int min_count = 4; /* min repeat count */ |
/* tree[max_code+1].Len = -1; */ /* guard already set */ |
if (nextlen == 0) max_count = 138, min_count = 3; |
for (n = 0; n <= max_code; n++) { |
curlen = nextlen; nextlen = tree[n+1].Len; |
if (++count < max_count && curlen == nextlen) { |
continue; |
} else if (count < min_count) { |
do { send_code(s, curlen, s->bl_tree); } while (--count != 0); |
} else if (curlen != 0) { |
if (curlen != prevlen) { |
send_code(s, curlen, s->bl_tree); count--; |
} |
Assert(count >= 3 && count <= 6, " 3_6?"); |
send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); |
} else if (count <= 10) { |
send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); |
} else { |
send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); |
} |
count = 0; prevlen = curlen; |
if (nextlen == 0) { |
max_count = 138, min_count = 3; |
} else if (curlen == nextlen) { |
max_count = 6, min_count = 3; |
} else { |
max_count = 7, min_count = 4; |
} |
} |
} |
/* =========================================================================== |
* Construct the Huffman tree for the bit lengths and return the index in |
* bl_order of the last bit length code to send. |
*/ |
local int build_bl_tree(s) |
deflate_state *s; |
{ |
int max_blindex; /* index of last bit length code of non zero freq */ |
/* Determine the bit length frequencies for literal and distance trees */ |
scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); |
scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); |
/* Build the bit length tree: */ |
build_tree(s, (tree_desc *)(&(s->bl_desc))); |
/* opt_len now includes the length of the tree representations, except |
* the lengths of the bit lengths codes and the 5+5+4 bits for the counts. |
*/ |
/* Determine the number of bit length codes to send. The pkzip format |
* requires that at least 4 bit length codes be sent. (appnote.txt says |
* 3 but the actual value used is 4.) |
*/ |
for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { |
if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; |
} |
/* Update opt_len to include the bit length tree and counts */ |
s->opt_len += 3*(max_blindex+1) + 5+5+4; |
Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", |
s->opt_len, s->static_len)); |
return max_blindex; |
} |
/* =========================================================================== |
* Send the header for a block using dynamic Huffman trees: the counts, the |
* lengths of the bit length codes, the literal tree and the distance tree. |
* IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. |
*/ |
local void send_all_trees(s, lcodes, dcodes, blcodes) |
deflate_state *s; |
int lcodes, dcodes, blcodes; /* number of codes for each tree */ |
{ |
int rank; /* index in bl_order */ |
Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); |
Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, |
"too many codes"); |
Tracev((stderr, "\nbl counts: ")); |
send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ |
send_bits(s, dcodes-1, 5); |
send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ |
for (rank = 0; rank < blcodes; rank++) { |
Tracev((stderr, "\nbl code %2d ", bl_order[rank])); |
send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); |
} |
Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); |
send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ |
Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); |
send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ |
Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); |
} |
/* =========================================================================== |
* Send a stored block |
*/ |
void _tr_stored_block(s, buf, stored_len, eof) |
deflate_state *s; |
charf *buf; /* input block */ |
ulg stored_len; /* length of input block */ |
int eof; /* true if this is the last block for a file */ |
{ |
send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */ |
#ifdef DEBUG |
s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; |
s->compressed_len += (stored_len + 4) << 3; |
#endif |
copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ |
} |
/* =========================================================================== |
* Send one empty static block to give enough lookahead for inflate. |
* This takes 10 bits, of which 7 may remain in the bit buffer. |
* The current inflate code requires 9 bits of lookahead. If the |
* last two codes for the previous block (real code plus EOB) were coded |
* on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode |
* the last real code. In this case we send two empty static blocks instead |
* of one. (There are no problems if the previous block is stored or fixed.) |
* To simplify the code, we assume the worst case of last real code encoded |
* on one bit only. |
*/ |
void _tr_align(s) |
deflate_state *s; |
{ |
send_bits(s, STATIC_TREES<<1, 3); |
send_code(s, END_BLOCK, static_ltree); |
#ifdef DEBUG |
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ |
#endif |
bi_flush(s); |
/* Of the 10 bits for the empty block, we have already sent |
* (10 - bi_valid) bits. The lookahead for the last real code (before |
* the EOB of the previous block) was thus at least one plus the length |
* of the EOB plus what we have just sent of the empty static block. |
*/ |
if (1 + s->last_eob_len + 10 - s->bi_valid < 9) { |
send_bits(s, STATIC_TREES<<1, 3); |
send_code(s, END_BLOCK, static_ltree); |
#ifdef DEBUG |
s->compressed_len += 10L; |
#endif |
bi_flush(s); |
} |
s->last_eob_len = 7; |
} |
/* =========================================================================== |
* Determine the best encoding for the current block: dynamic trees, static |
* trees or store, and output the encoded block to the zip file. |
*/ |
void _tr_flush_block(s, buf, stored_len, eof) |
deflate_state *s; |
charf *buf; /* input block, or NULL if too old */ |
ulg stored_len; /* length of input block */ |
int eof; /* true if this is the last block for a file */ |
{ |
ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ |
int max_blindex = 0; /* index of last bit length code of non zero freq */ |
/* Build the Huffman trees unless a stored block is forced */ |
if (s->level > 0) { |
/* Check if the file is ascii or binary */ |
if (s->data_type == Z_UNKNOWN) set_data_type(s); |
/* Construct the literal and distance trees */ |
build_tree(s, (tree_desc *)(&(s->l_desc))); |
Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, |
s->static_len)); |
build_tree(s, (tree_desc *)(&(s->d_desc))); |
Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, |
s->static_len)); |
/* At this point, opt_len and static_len are the total bit lengths of |
* the compressed block data, excluding the tree representations. |
*/ |
/* Build the bit length tree for the above two trees, and get the index |
* in bl_order of the last bit length code to send. |
*/ |
max_blindex = build_bl_tree(s); |
/* Determine the best encoding. Compute first the block length in bytes*/ |
opt_lenb = (s->opt_len+3+7)>>3; |
static_lenb = (s->static_len+3+7)>>3; |
Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", |
opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, |
s->last_lit)); |
if (static_lenb <= opt_lenb) opt_lenb = static_lenb; |
} else { |
Assert(buf != (char*)0, "lost buf"); |
opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ |
} |
#ifdef FORCE_STORED |
if (buf != (char*)0) { /* force stored block */ |
#else |
if (stored_len+4 <= opt_lenb && buf != (char*)0) { |
/* 4: two words for the lengths */ |
#endif |
/* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. |
* Otherwise we can't have processed more than WSIZE input bytes since |
* the last block flush, because compression would have been |
* successful. If LIT_BUFSIZE <= WSIZE, it is never too late to |
* transform a block into a stored block. |
*/ |
_tr_stored_block(s, buf, stored_len, eof); |
#ifdef FORCE_STATIC |
} else if (static_lenb >= 0) { /* force static trees */ |
#else |
} else if (static_lenb == opt_lenb) { |
#endif |
send_bits(s, (STATIC_TREES<<1)+eof, 3); |
compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); |
#ifdef DEBUG |
s->compressed_len += 3 + s->static_len; |
#endif |
} else { |
send_bits(s, (DYN_TREES<<1)+eof, 3); |
send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, |
max_blindex+1); |
compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); |
#ifdef DEBUG |
s->compressed_len += 3 + s->opt_len; |
#endif |
} |
Assert (s->compressed_len == s->bits_sent, "bad compressed size"); |
/* The above check is made mod 2^32, for files larger than 512 MB |
* and uLong implemented on 32 bits. |
*/ |
init_block(s); |
if (eof) { |
bi_windup(s); |
#ifdef DEBUG |
s->compressed_len += 7; /* align on byte boundary */ |
#endif |
} |
Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, |
s->compressed_len-7*eof)); |
} |
/* =========================================================================== |
* Save the match info and tally the frequency counts. Return true if |
* the current block must be flushed. |
*/ |
int _tr_tally (s, dist, lc) |
deflate_state *s; |
unsigned dist; /* distance of matched string */ |
unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ |
{ |
s->d_buf[s->last_lit] = (ush)dist; |
s->l_buf[s->last_lit++] = (uch)lc; |
if (dist == 0) { |
/* lc is the unmatched char */ |
s->dyn_ltree[lc].Freq++; |
} else { |
s->matches++; |
/* Here, lc is the match length - MIN_MATCH */ |
dist--; /* dist = match distance - 1 */ |
Assert((ush)dist < (ush)MAX_DIST(s) && |
(ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && |
(ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); |
s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; |
s->dyn_dtree[d_code(dist)].Freq++; |
} |
#ifdef TRUNCATE_BLOCK |
/* Try to guess if it is profitable to stop the current block here */ |
if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { |
/* Compute an upper bound for the compressed length */ |
ulg out_length = (ulg)s->last_lit*8L; |
ulg in_length = (ulg)((long)s->strstart - s->block_start); |
int dcode; |
for (dcode = 0; dcode < D_CODES; dcode++) { |
out_length += (ulg)s->dyn_dtree[dcode].Freq * |
(5L+extra_dbits[dcode]); |
} |
out_length >>= 3; |
Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", |
s->last_lit, in_length, out_length, |
100L - out_length*100L/in_length)); |
if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; |
} |
#endif |
return (s->last_lit == s->lit_bufsize-1); |
/* We avoid equality with lit_bufsize because of wraparound at 64K |
* on 16 bit machines and because stored blocks are restricted to |
* 64K-1 bytes. |
*/ |
} |
/* =========================================================================== |
* Send the block data compressed using the given Huffman trees |
*/ |
local void compress_block(s, ltree, dtree) |
deflate_state *s; |
ct_data *ltree; /* literal tree */ |
ct_data *dtree; /* distance tree */ |
{ |
unsigned dist; /* distance of matched string */ |
int lc; /* match length or unmatched char (if dist == 0) */ |
unsigned lx = 0; /* running index in l_buf */ |
unsigned code; /* the code to send */ |
int extra; /* number of extra bits to send */ |
if (s->last_lit != 0) do { |
dist = s->d_buf[lx]; |
lc = s->l_buf[lx++]; |
if (dist == 0) { |
send_code(s, lc, ltree); /* send a literal byte */ |
Tracecv(isgraph(lc), (stderr," '%c' ", lc)); |
} else { |
/* Here, lc is the match length - MIN_MATCH */ |
code = _length_code[lc]; |
send_code(s, code+LITERALS+1, ltree); /* send the length code */ |
extra = extra_lbits[code]; |
if (extra != 0) { |
lc -= base_length[code]; |
send_bits(s, lc, extra); /* send the extra length bits */ |
} |
dist--; /* dist is now the match distance - 1 */ |
code = d_code(dist); |
Assert (code < D_CODES, "bad d_code"); |
send_code(s, code, dtree); /* send the distance code */ |
extra = extra_dbits[code]; |
if (extra != 0) { |
dist -= base_dist[code]; |
send_bits(s, dist, extra); /* send the extra distance bits */ |
} |
} /* literal or match pair ? */ |
/* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ |
Assert(s->pending < s->lit_bufsize + 2*lx, "pendingBuf overflow"); |
} while (lx < s->last_lit); |
send_code(s, END_BLOCK, ltree); |
s->last_eob_len = ltree[END_BLOCK].Len; |
} |
/* =========================================================================== |
* Set the data type to ASCII or BINARY, using a crude approximation: |
* binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise. |
* IN assertion: the fields freq of dyn_ltree are set and the total of all |
* frequencies does not exceed 64K (to fit in an int on 16 bit machines). |
*/ |
local void set_data_type(s) |
deflate_state *s; |
{ |
int n = 0; |
unsigned ascii_freq = 0; |
unsigned bin_freq = 0; |
while (n < 7) bin_freq += s->dyn_ltree[n++].Freq; |
while (n < 128) ascii_freq += s->dyn_ltree[n++].Freq; |
while (n < LITERALS) bin_freq += s->dyn_ltree[n++].Freq; |
s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ? Z_BINARY : Z_ASCII); |
} |
/* =========================================================================== |
* Reverse the first len bits of a code, using straightforward code (a faster |
* method would use a table) |
* IN assertion: 1 <= len <= 15 |
*/ |
local unsigned bi_reverse(code, len) |
unsigned code; /* the value to invert */ |
int len; /* its bit length */ |
{ |
register unsigned res = 0; |
do { |
res |= code & 1; |
code >>= 1, res <<= 1; |
} while (--len > 0); |
return res >> 1; |
} |
/* =========================================================================== |
* Flush the bit buffer, keeping at most 7 bits in it. |
*/ |
local void bi_flush(s) |
deflate_state *s; |
{ |
if (s->bi_valid == 16) { |
put_short(s, s->bi_buf); |
s->bi_buf = 0; |
s->bi_valid = 0; |
} else if (s->bi_valid >= 8) { |
put_byte(s, (Byte)s->bi_buf); |
s->bi_buf >>= 8; |
s->bi_valid -= 8; |
} |
} |
/* =========================================================================== |
* Flush the bit buffer and align the output on a byte boundary |
*/ |
local void bi_windup(s) |
deflate_state *s; |
{ |
if (s->bi_valid > 8) { |
put_short(s, s->bi_buf); |
} else if (s->bi_valid > 0) { |
put_byte(s, (Byte)s->bi_buf); |
} |
s->bi_buf = 0; |
s->bi_valid = 0; |
#ifdef DEBUG |
s->bits_sent = (s->bits_sent+7) & ~7; |
#endif |
} |
/* =========================================================================== |
* Copy a stored block, storing first the length and its |
* one's complement if requested. |
*/ |
local void copy_block(s, buf, len, header) |
deflate_state *s; |
charf *buf; /* the input data */ |
unsigned len; /* its length */ |
int header; /* true if block header must be written */ |
{ |
bi_windup(s); /* align on byte boundary */ |
s->last_eob_len = 8; /* enough lookahead for inflate */ |
if (header) { |
put_short(s, (ush)len); |
put_short(s, (ush)~len); |
#ifdef DEBUG |
s->bits_sent += 2*16; |
#endif |
} |
#ifdef DEBUG |
s->bits_sent += (ulg)len<<3; |
#endif |
while (len--) { |
put_byte(s, *buf++); |
} |
} |
/shark/trunk/ports/png/pngmem.c |
---|
0,0 → 1,566 |
/* pngmem.c - stub functions for memory allocation |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file provides a location for all memory allocation. Users who |
* need special memory handling are expected to supply replacement |
* functions for png_malloc() and png_free(), and to use |
* png_create_read_struct_2() and png_create_write_struct_2() to |
* identify the replacement functions. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
/* Borland DOS special memory handler */ |
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) |
/* if you change this, be sure to change the one in png.h also */ |
/* Allocate memory for a png_struct. The malloc and memset can be replaced |
by a single call to calloc() if this is thought to improve performance. */ |
png_voidp /* PRIVATE */ |
png_create_struct(int type) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL)); |
} |
/* Alternate version of png_create_struct, for use with user-defined malloc. */ |
png_voidp /* PRIVATE */ |
png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_size_t size; |
png_voidp struct_ptr; |
if (type == PNG_STRUCT_INFO) |
size = sizeof(png_info); |
else if (type == PNG_STRUCT_PNG) |
size = sizeof(png_struct); |
else |
return (png_get_copyright()); |
#ifdef PNG_USER_MEM_SUPPORTED |
if(malloc_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size); |
} |
else |
#endif /* PNG_USER_MEM_SUPPORTED */ |
struct_ptr = (png_voidp)farmalloc(size)); |
if (struct_ptr != NULL) |
png_memset(struct_ptr, 0, size); |
return (struct_ptr); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct(png_voidp struct_ptr) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, |
png_voidp mem_ptr) |
{ |
#endif |
if (struct_ptr != NULL) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
if(free_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
(*(free_fn))(png_ptr, struct_ptr); |
return; |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
farfree (struct_ptr); |
} |
} |
/* Allocate memory. For reasonable files, size should never exceed |
* 64K. However, zlib may allocate more then 64K if you don't tell |
* it not to. See zconf.h and png.h for more information. zlib does |
* need to allocate exactly 64K, so whatever you call here must |
* have the ability to do that. |
* |
* Borland seems to have a problem in DOS mode for exactly 64K. |
* It gives you a segment with an offset of 8 (perhaps to store its |
* memory stuff). zlib doesn't like this at all, so we have to |
* detect and deal with it. This code should not be needed in |
* Windows or OS/2 modes, and only in 16 bit mode. This code has |
* been updated by Alexander Lehmann for version 0.89 to waste less |
* memory. |
* |
* Note that we can't use png_size_t for the "size" declaration, |
* since on some systems a png_size_t is a 16-bit quantity, and as a |
* result, we would be truncating potentially larger memory requests |
* (which should cause a fatal error) and introducing major problems. |
*/ |
png_voidp PNGAPI |
png_malloc(png_structp png_ptr, png_uint_32 size) |
{ |
png_voidp ret; |
if (png_ptr == NULL || size == 0) |
return (NULL); |
#ifdef PNG_USER_MEM_SUPPORTED |
if(png_ptr->malloc_fn != NULL) |
{ |
ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of memory!"); |
return (ret); |
} |
else |
return png_malloc_default(png_ptr, size); |
} |
png_voidp PNGAPI |
png_malloc_default(png_structp png_ptr, png_uint_32 size) |
{ |
png_voidp ret; |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#ifdef PNG_MAX_MALLOC_64K |
if (size > (png_uint_32)65536L) |
png_error(png_ptr, "Cannot Allocate > 64K"); |
#endif |
if (size == (png_uint_32)65536L) |
{ |
if (png_ptr->offset_table == NULL) |
{ |
/* try to see if we need to do any of this fancy stuff */ |
ret = farmalloc(size); |
if (ret == NULL || ((png_size_t)ret & 0xffff)) |
{ |
int num_blocks; |
png_uint_32 total_size; |
png_bytep table; |
int i; |
png_byte huge * hptr; |
if (ret != NULL) |
{ |
farfree(ret); |
ret = NULL; |
} |
if(png_ptr->zlib_window_bits > 14) |
num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14)); |
else |
num_blocks = 1; |
if (png_ptr->zlib_mem_level >= 7) |
num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7)); |
else |
num_blocks++; |
total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16; |
table = farmalloc(total_size); |
if (table == NULL) |
{ |
if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */ |
else |
png_warning(png_ptr, "Out Of Memory."); |
return (NULL); |
} |
if ((png_size_t)table & 0xfff0) |
{ |
if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, |
"Farmalloc didn't return normalized pointer"); |
else |
png_warning(png_ptr, |
"Farmalloc didn't return normalized pointer"); |
return (NULL); |
} |
png_ptr->offset_table = table; |
png_ptr->offset_table_ptr = farmalloc(num_blocks * |
sizeof (png_bytep)); |
if (png_ptr->offset_table_ptr == NULL) |
{ |
if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */ |
else |
png_warning(png_ptr, "Out Of memory."); |
return (NULL); |
} |
hptr = (png_byte huge *)table; |
if ((png_size_t)hptr & 0xf) |
{ |
hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L); |
hptr = hptr + 16L; /* "hptr += 16L" fails on Turbo C++ 3.0 */ |
} |
for (i = 0; i < num_blocks; i++) |
{ |
png_ptr->offset_table_ptr[i] = (png_bytep)hptr; |
hptr = hptr + (png_uint_32)65536L; /* "+=" fails on TC++3.0 */ |
} |
png_ptr->offset_table_number = num_blocks; |
png_ptr->offset_table_count = 0; |
png_ptr->offset_table_count_free = 0; |
} |
} |
if (png_ptr->offset_table_count >= png_ptr->offset_table_number) |
{ |
if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */ |
else |
png_warning(png_ptr, "Out of Memory."); |
return (NULL); |
} |
ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++]; |
} |
else |
ret = farmalloc(size); |
if (ret == NULL) |
{ |
if (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */ |
else |
png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */ |
} |
return (ret); |
} |
/* free a pointer allocated by png_malloc(). In the default |
configuration, png_ptr is not used, but is passed in case it |
is needed. If ptr is NULL, return without taking any action. */ |
void PNGAPI |
png_free(png_structp png_ptr, png_voidp ptr) |
{ |
if (png_ptr == NULL || ptr == NULL) |
return; |
#ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr->free_fn != NULL) |
{ |
(*(png_ptr->free_fn))(png_ptr, ptr); |
return; |
} |
else png_free_default(png_ptr, ptr); |
} |
void PNGAPI |
png_free_default(png_structp png_ptr, png_voidp ptr) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
if (png_ptr->offset_table != NULL) |
{ |
int i; |
for (i = 0; i < png_ptr->offset_table_count; i++) |
{ |
if (ptr == png_ptr->offset_table_ptr[i]) |
{ |
ptr = NULL; |
png_ptr->offset_table_count_free++; |
break; |
} |
} |
if (png_ptr->offset_table_count_free == png_ptr->offset_table_count) |
{ |
farfree(png_ptr->offset_table); |
farfree(png_ptr->offset_table_ptr); |
png_ptr->offset_table = NULL; |
png_ptr->offset_table_ptr = NULL; |
} |
} |
if (ptr != NULL) |
{ |
farfree(ptr); |
} |
} |
#else /* Not the Borland DOS special memory handler */ |
/* Allocate memory for a png_struct or a png_info. The malloc and |
memset can be replaced by a single call to calloc() if this is thought |
to improve performance noticably. */ |
png_voidp /* PRIVATE */ |
png_create_struct(int type) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL)); |
} |
/* Allocate memory for a png_struct or a png_info. The malloc and |
memset can be replaced by a single call to calloc() if this is thought |
to improve performance noticably. */ |
png_voidp /* PRIVATE */ |
png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_size_t size; |
png_voidp struct_ptr; |
if (type == PNG_STRUCT_INFO) |
size = sizeof(png_info); |
else if (type == PNG_STRUCT_PNG) |
size = sizeof(png_struct); |
else |
return (NULL); |
#ifdef PNG_USER_MEM_SUPPORTED |
if(malloc_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
struct_ptr = (*(malloc_fn))(png_ptr, size); |
if (struct_ptr != NULL) |
png_memset(struct_ptr, 0, size); |
return (struct_ptr); |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#if defined(__TURBOC__) && !defined(__FLAT__) |
if ((struct_ptr = (png_voidp)farmalloc(size)) != NULL) |
#else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
if ((struct_ptr = (png_voidp)halloc(size,1)) != NULL) |
# else |
if ((struct_ptr = (png_voidp)malloc(size)) != NULL) |
# endif |
#endif |
{ |
png_memset(struct_ptr, 0, size); |
} |
return (struct_ptr); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct(png_voidp struct_ptr) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL); |
} |
/* Free memory allocated by a png_create_struct() call */ |
void /* PRIVATE */ |
png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, |
png_voidp mem_ptr) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
if (struct_ptr != NULL) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
if(free_fn != NULL) |
{ |
png_struct dummy_struct; |
png_structp png_ptr = &dummy_struct; |
png_ptr->mem_ptr=mem_ptr; |
(*(free_fn))(png_ptr, struct_ptr); |
return; |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#if defined(__TURBOC__) && !defined(__FLAT__) |
farfree(struct_ptr); |
#else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
hfree(struct_ptr); |
# else |
free(struct_ptr); |
# endif |
#endif |
} |
} |
/* Allocate memory. For reasonable files, size should never exceed |
64K. However, zlib may allocate more then 64K if you don't tell |
it not to. See zconf.h and png.h for more information. zlib does |
need to allocate exactly 64K, so whatever you call here must |
have the ability to do that. */ |
png_voidp PNGAPI |
png_malloc(png_structp png_ptr, png_uint_32 size) |
{ |
png_voidp ret; |
if (png_ptr == NULL || size == 0) |
return (NULL); |
#ifdef PNG_USER_MEM_SUPPORTED |
if(png_ptr->malloc_fn != NULL) |
{ |
ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory!"); |
return (ret); |
} |
else |
return (png_malloc_default(png_ptr, size)); |
} |
png_voidp PNGAPI |
png_malloc_default(png_structp png_ptr, png_uint_32 size) |
{ |
png_voidp ret; |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#ifdef PNG_MAX_MALLOC_64K |
if (size > (png_uint_32)65536L) |
{ |
if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Cannot Allocate > 64K"); |
else |
return NULL; |
} |
#endif |
#if defined(__TURBOC__) && !defined(__FLAT__) |
ret = farmalloc(size); |
#else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
ret = halloc(size, 1); |
# else |
ret = malloc((size_t)size); |
# endif |
#endif |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory"); |
return (ret); |
} |
/* Free a pointer allocated by png_malloc(). If ptr is NULL, return |
without taking any action. */ |
void PNGAPI |
png_free(png_structp png_ptr, png_voidp ptr) |
{ |
if (png_ptr == NULL || ptr == NULL) |
return; |
#ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr->free_fn != NULL) |
{ |
(*(png_ptr->free_fn))(png_ptr, ptr); |
return; |
} |
else png_free_default(png_ptr, ptr); |
} |
void PNGAPI |
png_free_default(png_structp png_ptr, png_voidp ptr) |
{ |
if (png_ptr == NULL || ptr == NULL) |
return; |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#if defined(__TURBOC__) && !defined(__FLAT__) |
farfree(ptr); |
#else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
hfree(ptr); |
# else |
free(ptr); |
# endif |
#endif |
} |
#endif /* Not Borland DOS special memory handler */ |
#if defined(PNG_1_0_X) |
# define png_malloc_warn png_malloc |
#else |
/* This function was added at libpng version 1.2.3. The png_malloc_warn() |
* function will issue a png_warning and return NULL instead of issuing a |
* png_error, if it fails to allocate the requested memory. |
*/ |
png_voidp PNGAPI |
png_malloc_warn(png_structp png_ptr, png_uint_32 size) |
{ |
png_voidp ptr; |
png_uint_32 save_flags=png_ptr->flags; |
png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; |
ptr = (png_voidp)png_malloc((png_structp)png_ptr, size); |
png_ptr->flags=save_flags; |
return(ptr); |
} |
#endif |
png_voidp PNGAPI |
png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2, |
png_uint_32 length) |
{ |
png_size_t size; |
size = (png_size_t)length; |
if ((png_uint_32)size != length) |
png_error(png_ptr,"Overflow in png_memcpy_check."); |
return(png_memcpy (s1, s2, size)); |
} |
png_voidp PNGAPI |
png_memset_check (png_structp png_ptr, png_voidp s1, int value, |
png_uint_32 length) |
{ |
png_size_t size; |
size = (png_size_t)length; |
if ((png_uint_32)size != length) |
png_error(png_ptr,"Overflow in png_memset_check."); |
return (png_memset (s1, value, size)); |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
/* This function is called when the application wants to use another method |
* of allocating and freeing memory. |
*/ |
void PNGAPI |
png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr |
malloc_fn, png_free_ptr free_fn) |
{ |
png_ptr->mem_ptr = mem_ptr; |
png_ptr->malloc_fn = malloc_fn; |
png_ptr->free_fn = free_fn; |
} |
/* This function returns a pointer to the mem_ptr associated with the user |
* functions. The application should free any memory associated with this |
* pointer before png_write_destroy and png_read_destroy are called. |
*/ |
png_voidp PNGAPI |
png_get_mem_ptr(png_structp png_ptr) |
{ |
return ((png_voidp)png_ptr->mem_ptr); |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
/shark/trunk/ports/png/zconf.h |
---|
0,0 → 1,279 |
/* zconf.h -- configuration of the zlib compression library |
* Copyright (C) 1995-2002 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* @(#) $Id: zconf.h,v 1.1 2003-03-20 13:08:13 giacomo Exp $ */ |
#ifndef _ZCONF_H |
#define _ZCONF_H |
/* |
* If you *really* need a unique prefix for all types and library functions, |
* compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. |
*/ |
#ifdef Z_PREFIX |
# define deflateInit_ z_deflateInit_ |
# define deflate z_deflate |
# define deflateEnd z_deflateEnd |
# define inflateInit_ z_inflateInit_ |
# define inflate z_inflate |
# define inflateEnd z_inflateEnd |
# define deflateInit2_ z_deflateInit2_ |
# define deflateSetDictionary z_deflateSetDictionary |
# define deflateCopy z_deflateCopy |
# define deflateReset z_deflateReset |
# define deflateParams z_deflateParams |
# define inflateInit2_ z_inflateInit2_ |
# define inflateSetDictionary z_inflateSetDictionary |
# define inflateSync z_inflateSync |
# define inflateSyncPoint z_inflateSyncPoint |
# define inflateReset z_inflateReset |
# define compress z_compress |
# define compress2 z_compress2 |
# define uncompress z_uncompress |
# define adler32 z_adler32 |
# define crc32 z_crc32 |
# define get_crc_table z_get_crc_table |
# define Byte z_Byte |
# define uInt z_uInt |
# define uLong z_uLong |
# define Bytef z_Bytef |
# define charf z_charf |
# define intf z_intf |
# define uIntf z_uIntf |
# define uLongf z_uLongf |
# define voidpf z_voidpf |
# define voidp z_voidp |
#endif |
#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32) |
# define WIN32 |
#endif |
#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386) |
# ifndef __32BIT__ |
# define __32BIT__ |
# endif |
#endif |
#if defined(__MSDOS__) && !defined(MSDOS) |
# define MSDOS |
#endif |
/* |
* Compile with -DMAXSEG_64K if the alloc function cannot allocate more |
* than 64k bytes at a time (needed on systems with 16-bit int). |
*/ |
#if defined(MSDOS) && !defined(__32BIT__) |
# define MAXSEG_64K |
#endif |
#ifdef MSDOS |
# define UNALIGNED_OK |
#endif |
#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC) |
# define STDC |
#endif |
#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__) |
# ifndef STDC |
# define STDC |
# endif |
#endif |
#ifndef STDC |
# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ |
# define const |
# endif |
#endif |
/* Some Mac compilers merge all .h files incorrectly: */ |
#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__) |
# define NO_DUMMY_DECL |
#endif |
/* Old Borland C incorrectly complains about missing returns: */ |
#if defined(__BORLANDC__) && (__BORLANDC__ < 0x500) |
# define NEED_DUMMY_RETURN |
#endif |
/* Maximum value for memLevel in deflateInit2 */ |
#ifndef MAX_MEM_LEVEL |
# ifdef MAXSEG_64K |
# define MAX_MEM_LEVEL 8 |
# else |
# define MAX_MEM_LEVEL 9 |
# endif |
#endif |
/* Maximum value for windowBits in deflateInit2 and inflateInit2. |
* WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files |
* created by gzip. (Files created by minigzip can still be extracted by |
* gzip.) |
*/ |
#ifndef MAX_WBITS |
# define MAX_WBITS 15 /* 32K LZ77 window */ |
#endif |
/* The memory requirements for deflate are (in bytes): |
(1 << (windowBits+2)) + (1 << (memLevel+9)) |
that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) |
plus a few kilobytes for small objects. For example, if you want to reduce |
the default memory requirements from 256K to 128K, compile with |
make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" |
Of course this will generally degrade compression (there's no free lunch). |
The memory requirements for inflate are (in bytes) 1 << windowBits |
that is, 32K for windowBits=15 (default value) plus a few kilobytes |
for small objects. |
*/ |
/* Type declarations */ |
#ifndef OF /* function prototypes */ |
# ifdef STDC |
# define OF(args) args |
# else |
# define OF(args) () |
# endif |
#endif |
/* The following definitions for FAR are needed only for MSDOS mixed |
* model programming (small or medium model with some far allocations). |
* This was tested only with MSC; for other MSDOS compilers you may have |
* to define NO_MEMCPY in zutil.h. If you don't need the mixed model, |
* just define FAR to be empty. |
*/ |
#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__) |
/* MSC small or medium model */ |
# define SMALL_MEDIUM |
# ifdef _MSC_VER |
# define FAR _far |
# else |
# define FAR far |
# endif |
#endif |
#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__)) |
# ifndef __32BIT__ |
# define SMALL_MEDIUM |
# define FAR _far |
# endif |
#endif |
/* Compile with -DZLIB_DLL for Windows DLL support */ |
#if defined(ZLIB_DLL) |
# if defined(_WINDOWS) || defined(WINDOWS) |
# ifdef FAR |
# undef FAR |
# endif |
# include <windows.h> |
# define ZEXPORT WINAPI |
# ifdef WIN32 |
# define ZEXPORTVA WINAPIV |
# else |
# define ZEXPORTVA FAR _cdecl _export |
# endif |
# endif |
# if defined (__BORLANDC__) |
# if (__BORLANDC__ >= 0x0500) && defined (WIN32) |
# include <windows.h> |
# define ZEXPORT __declspec(dllexport) WINAPI |
# define ZEXPORTRVA __declspec(dllexport) WINAPIV |
# else |
# if defined (_Windows) && defined (__DLL__) |
# define ZEXPORT _export |
# define ZEXPORTVA _export |
# endif |
# endif |
# endif |
#endif |
#if defined (__BEOS__) |
# if defined (ZLIB_DLL) |
# define ZEXTERN extern __declspec(dllexport) |
# else |
# define ZEXTERN extern __declspec(dllimport) |
# endif |
#endif |
#ifndef ZEXPORT |
# define ZEXPORT |
#endif |
#ifndef ZEXPORTVA |
# define ZEXPORTVA |
#endif |
#ifndef ZEXTERN |
# define ZEXTERN extern |
#endif |
#ifndef FAR |
# define FAR |
#endif |
#if !defined(MACOS) && !defined(TARGET_OS_MAC) |
typedef unsigned char Byte; /* 8 bits */ |
#endif |
typedef unsigned int uInt; /* 16 bits or more */ |
typedef unsigned long uLong; /* 32 bits or more */ |
#ifdef SMALL_MEDIUM |
/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ |
# define Bytef Byte FAR |
#else |
typedef Byte FAR Bytef; |
#endif |
typedef char FAR charf; |
typedef int FAR intf; |
typedef uInt FAR uIntf; |
typedef uLong FAR uLongf; |
#ifdef STDC |
typedef void FAR *voidpf; |
typedef void *voidp; |
#else |
typedef Byte FAR *voidpf; |
typedef Byte *voidp; |
#endif |
#ifdef HAVE_UNISTD_H |
# include <sys/types.h> /* for off_t */ |
# include <unistd.h> /* for SEEK_* and off_t */ |
# define z_off_t off_t |
#endif |
#ifndef SEEK_SET |
# define SEEK_SET 0 /* Seek from beginning of file. */ |
# define SEEK_CUR 1 /* Seek from current position. */ |
# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ |
#endif |
#ifndef z_off_t |
# define z_off_t long |
#endif |
/* MVS linker does not support external names larger than 8 bytes */ |
#if defined(__MVS__) |
# pragma map(deflateInit_,"DEIN") |
# pragma map(deflateInit2_,"DEIN2") |
# pragma map(deflateEnd,"DEEND") |
# pragma map(inflateInit_,"ININ") |
# pragma map(inflateInit2_,"ININ2") |
# pragma map(inflateEnd,"INEND") |
# pragma map(inflateSync,"INSY") |
# pragma map(inflateSetDictionary,"INSEDI") |
# pragma map(inflate_blocks,"INBL") |
# pragma map(inflate_blocks_new,"INBLNE") |
# pragma map(inflate_blocks_free,"INBLFR") |
# pragma map(inflate_blocks_reset,"INBLRE") |
# pragma map(inflate_codes_free,"INCOFR") |
# pragma map(inflate_codes,"INCO") |
# pragma map(inflate_fast,"INFA") |
# pragma map(inflate_flush,"INFLU") |
# pragma map(inflate_mask,"INMA") |
# pragma map(inflate_set_dictionary,"INSEDI2") |
# pragma map(inflate_copyright,"INCOPY") |
# pragma map(inflate_trees_bits,"INTRBI") |
# pragma map(inflate_trees_dynamic,"INTRDY") |
# pragma map(inflate_trees_fixed,"INTRFI") |
# pragma map(inflate_trees_free,"INTRFR") |
#endif |
#endif /* _ZCONF_H */ |
/shark/trunk/ports/png/pngget.c |
---|
0,0 → 1,927 |
/* pngget.c - retrieval of values from info struct |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
png_uint_32 PNGAPI |
png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->valid & flag); |
else |
return(0); |
} |
png_uint_32 PNGAPI |
png_get_rowbytes(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->rowbytes); |
else |
return(0); |
} |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
png_bytepp PNGAPI |
png_get_rows(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->row_pointers); |
else |
return(0); |
} |
#endif |
#ifdef PNG_EASY_ACCESS_SUPPORTED |
/* easy access to info, added in libpng-0.99 */ |
png_uint_32 PNGAPI |
png_get_image_width(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->width; |
} |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_image_height(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->height; |
} |
return (0); |
} |
png_byte PNGAPI |
png_get_bit_depth(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->bit_depth; |
} |
return (0); |
} |
png_byte PNGAPI |
png_get_color_type(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->color_type; |
} |
return (0); |
} |
png_byte PNGAPI |
png_get_filter_type(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->filter_type; |
} |
return (0); |
} |
png_byte PNGAPI |
png_get_interlace_type(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->interlace_type; |
} |
return (0); |
} |
png_byte PNGAPI |
png_get_compression_type(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
{ |
return info_ptr->compression_type; |
} |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_pHYs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pHYs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_x_pixels_per_meter"); |
if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER) |
return (0); |
else return (info_ptr->x_pixels_per_unit); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_pHYs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pHYs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_y_pixels_per_meter"); |
if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER) |
return (0); |
else return (info_ptr->y_pixels_per_unit); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_pHYs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pHYs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_pixels_per_meter"); |
if(info_ptr->phys_unit_type != PNG_RESOLUTION_METER || |
info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit) |
return (0); |
else return (info_ptr->x_pixels_per_unit); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float PNGAPI |
png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_pHYs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pHYs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_aspect_ratio"); |
if (info_ptr->x_pixels_per_unit == 0) |
return ((float)0.0); |
else |
return ((float)((float)info_ptr->y_pixels_per_unit |
/(float)info_ptr->x_pixels_per_unit)); |
} |
#else |
return (0.0); |
#endif |
return ((float)0.0); |
} |
#endif |
png_int_32 PNGAPI |
png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_oFFs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_oFFs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns"); |
if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) |
return (0); |
else return (info_ptr->x_offset); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
png_int_32 PNGAPI |
png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_oFFs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_oFFs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns"); |
if(info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER) |
return (0); |
else return (info_ptr->y_offset); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
png_int_32 PNGAPI |
png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_oFFs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_oFFs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_x_offset_microns"); |
if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) |
return (0); |
else return (info_ptr->x_offset); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
png_int_32 PNGAPI |
png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
#if defined(PNG_oFFs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_oFFs) |
{ |
png_debug1(1, "in %s retrieval function\n", "png_get_y_offset_microns"); |
if(info_ptr->offset_unit_type != PNG_OFFSET_PIXEL) |
return (0); |
else return (info_ptr->y_offset); |
} |
#else |
return (0); |
#endif |
return (0); |
} |
#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) |
{ |
return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr) |
*.0254 +.5)); |
} |
png_uint_32 PNGAPI |
png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) |
{ |
return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr) |
*.0254 +.5)); |
} |
png_uint_32 PNGAPI |
png_get_y_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) |
{ |
return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr) |
*.0254 +.5)); |
} |
float PNGAPI |
png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr) |
{ |
return ((float)png_get_x_offset_microns(png_ptr, info_ptr) |
*.00003937); |
} |
float PNGAPI |
png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr) |
{ |
return ((float)png_get_y_offset_microns(png_ptr, info_ptr) |
*.00003937); |
} |
#if defined(PNG_pHYs_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) |
{ |
png_uint_32 retval = 0; |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_debug1(1, "in %s retrieval function\n", "pHYs"); |
if (res_x != NULL) |
{ |
*res_x = info_ptr->x_pixels_per_unit; |
retval |= PNG_INFO_pHYs; |
} |
if (res_y != NULL) |
{ |
*res_y = info_ptr->y_pixels_per_unit; |
retval |= PNG_INFO_pHYs; |
} |
if (unit_type != NULL) |
{ |
*unit_type = (int)info_ptr->phys_unit_type; |
retval |= PNG_INFO_pHYs; |
if(*unit_type == 1) |
{ |
if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50); |
if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50); |
} |
} |
} |
return (retval); |
} |
#endif /* PNG_pHYs_SUPPORTED */ |
#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ |
/* png_get_channels really belongs in here, too, but it's been around longer */ |
#endif /* PNG_EASY_ACCESS_SUPPORTED */ |
png_byte PNGAPI |
png_get_channels(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->channels); |
else |
return (0); |
} |
png_bytep PNGAPI |
png_get_signature(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->signature); |
else |
return (NULL); |
} |
#if defined(PNG_bKGD_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_bKGD(png_structp png_ptr, png_infop info_ptr, |
png_color_16p *background) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) |
&& background != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "bKGD"); |
*background = &(info_ptr->background); |
return (PNG_INFO_bKGD); |
} |
return (0); |
} |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_cHRM(png_structp png_ptr, png_infop info_ptr, |
double *white_x, double *white_y, double *red_x, double *red_y, |
double *green_x, double *green_y, double *blue_x, double *blue_y) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) |
{ |
png_debug1(1, "in %s retrieval function\n", "cHRM"); |
if (white_x != NULL) |
*white_x = (double)info_ptr->x_white; |
if (white_y != NULL) |
*white_y = (double)info_ptr->y_white; |
if (red_x != NULL) |
*red_x = (double)info_ptr->x_red; |
if (red_y != NULL) |
*red_y = (double)info_ptr->y_red; |
if (green_x != NULL) |
*green_x = (double)info_ptr->x_green; |
if (green_y != NULL) |
*green_y = (double)info_ptr->y_green; |
if (blue_x != NULL) |
*blue_x = (double)info_ptr->x_blue; |
if (blue_y != NULL) |
*blue_y = (double)info_ptr->y_blue; |
return (PNG_INFO_cHRM); |
} |
return (0); |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, |
png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x, |
png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y, |
png_fixed_point *blue_x, png_fixed_point *blue_y) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) |
{ |
png_debug1(1, "in %s retrieval function\n", "cHRM"); |
if (white_x != NULL) |
*white_x = info_ptr->int_x_white; |
if (white_y != NULL) |
*white_y = info_ptr->int_y_white; |
if (red_x != NULL) |
*red_x = info_ptr->int_x_red; |
if (red_y != NULL) |
*red_y = info_ptr->int_y_red; |
if (green_x != NULL) |
*green_x = info_ptr->int_x_green; |
if (green_y != NULL) |
*green_y = info_ptr->int_y_green; |
if (blue_x != NULL) |
*blue_x = info_ptr->int_x_blue; |
if (blue_y != NULL) |
*blue_y = info_ptr->int_y_blue; |
return (PNG_INFO_cHRM); |
} |
return (0); |
} |
#endif |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
&& file_gamma != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "gAMA"); |
*file_gamma = (double)info_ptr->gamma; |
return (PNG_INFO_gAMA); |
} |
return (0); |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, |
png_fixed_point *int_file_gamma) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
&& int_file_gamma != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "gAMA"); |
*int_file_gamma = info_ptr->int_gamma; |
return (PNG_INFO_gAMA); |
} |
return (0); |
} |
#endif |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB) |
&& file_srgb_intent != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "sRGB"); |
*file_srgb_intent = (int)info_ptr->srgb_intent; |
return (PNG_INFO_sRGB); |
} |
return (0); |
} |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_iCCP(png_structp png_ptr, png_infop info_ptr, |
png_charpp name, int *compression_type, |
png_charpp profile, png_uint_32 *proflen) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP) |
&& name != NULL && profile != NULL && proflen != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "iCCP"); |
*name = info_ptr->iccp_name; |
*profile = info_ptr->iccp_profile; |
/* compression_type is a dummy so the API won't have to change |
if we introduce multiple compression types later. */ |
*proflen = (int)info_ptr->iccp_proflen; |
*compression_type = (int)info_ptr->iccp_compression; |
return (PNG_INFO_iCCP); |
} |
return (0); |
} |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_sPLT(png_structp png_ptr, png_infop info_ptr, |
png_sPLT_tpp spalettes) |
{ |
if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL) |
*spalettes = info_ptr->splt_palettes; |
return ((png_uint_32)info_ptr->splt_palettes_num); |
} |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) |
&& hist != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "hIST"); |
*hist = info_ptr->hist; |
return (PNG_INFO_hIST); |
} |
return (0); |
} |
#endif |
png_uint_32 PNGAPI |
png_get_IHDR(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 *width, png_uint_32 *height, int *bit_depth, |
int *color_type, int *interlace_type, int *compression_type, |
int *filter_type) |
{ |
if (png_ptr != NULL && info_ptr != NULL && width != NULL && height != NULL && |
bit_depth != NULL && color_type != NULL) |
{ |
int pixel_depth, channels; |
png_uint_32 rowbytes_per_pixel; |
png_debug1(1, "in %s retrieval function\n", "IHDR"); |
*width = info_ptr->width; |
*height = info_ptr->height; |
*bit_depth = info_ptr->bit_depth; |
if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16) |
png_error(png_ptr, "Invalid bit depth"); |
*color_type = info_ptr->color_type; |
if (info_ptr->color_type > 6) |
png_error(png_ptr, "Invalid color type"); |
if (compression_type != NULL) |
*compression_type = info_ptr->compression_type; |
if (filter_type != NULL) |
*filter_type = info_ptr->filter_type; |
if (interlace_type != NULL) |
*interlace_type = info_ptr->interlace_type; |
/* check for potential overflow of rowbytes */ |
if (*color_type == PNG_COLOR_TYPE_PALETTE) |
channels = 1; |
else if (*color_type & PNG_COLOR_MASK_COLOR) |
channels = 3; |
else |
channels = 1; |
if (*color_type & PNG_COLOR_MASK_ALPHA) |
channels++; |
pixel_depth = *bit_depth * channels; |
rowbytes_per_pixel = (pixel_depth + 7) >> 3; |
if (width == 0 || *width > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid image width"); |
if (height == 0 || *height > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid image height"); |
if (*width > PNG_MAX_UINT/rowbytes_per_pixel - 64) |
{ |
png_error(png_ptr, |
"Width too large for libpng to process image data."); |
} |
return (1); |
} |
return (0); |
} |
#if defined(PNG_oFFs_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_oFFs(png_structp png_ptr, png_infop info_ptr, |
png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs) |
&& offset_x != NULL && offset_y != NULL && unit_type != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "oFFs"); |
*offset_x = info_ptr->x_offset; |
*offset_y = info_ptr->y_offset; |
*unit_type = (int)info_ptr->offset_unit_type; |
return (PNG_INFO_oFFs); |
} |
return (0); |
} |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_pCAL(png_structp png_ptr, png_infop info_ptr, |
png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, |
png_charp *units, png_charpp *params) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL) |
&& purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && |
nparams != NULL && units != NULL && params != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "pCAL"); |
*purpose = info_ptr->pcal_purpose; |
*X0 = info_ptr->pcal_X0; |
*X1 = info_ptr->pcal_X1; |
*type = (int)info_ptr->pcal_type; |
*nparams = (int)info_ptr->pcal_nparams; |
*units = info_ptr->pcal_units; |
*params = info_ptr->pcal_params; |
return (PNG_INFO_pCAL); |
} |
return (0); |
} |
#endif |
#if defined(PNG_sCAL_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sCAL(png_structp png_ptr, png_infop info_ptr, |
int *unit, double *width, double *height) |
{ |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->valid & PNG_INFO_sCAL)) |
{ |
*unit = info_ptr->scal_unit; |
*width = info_ptr->scal_pixel_width; |
*height = info_ptr->scal_pixel_height; |
return (PNG_INFO_sCAL); |
} |
return(0); |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr, |
int *unit, png_charpp width, png_charpp height) |
{ |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->valid & PNG_INFO_sCAL)) |
{ |
*unit = info_ptr->scal_unit; |
*width = info_ptr->scal_s_width; |
*height = info_ptr->scal_s_height; |
return (PNG_INFO_sCAL); |
} |
return(0); |
} |
#endif |
#endif |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_pHYs(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) |
{ |
png_uint_32 retval = 0; |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_debug1(1, "in %s retrieval function\n", "pHYs"); |
if (res_x != NULL) |
{ |
*res_x = info_ptr->x_pixels_per_unit; |
retval |= PNG_INFO_pHYs; |
} |
if (res_y != NULL) |
{ |
*res_y = info_ptr->y_pixels_per_unit; |
retval |= PNG_INFO_pHYs; |
} |
if (unit_type != NULL) |
{ |
*unit_type = (int)info_ptr->phys_unit_type; |
retval |= PNG_INFO_pHYs; |
} |
} |
return (retval); |
} |
#endif |
png_uint_32 PNGAPI |
png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette, |
int *num_palette) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE) |
&& palette != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "PLTE"); |
*palette = info_ptr->palette; |
*num_palette = info_ptr->num_palette; |
png_debug1(3, "num_palette = %d\n", *num_palette); |
return (PNG_INFO_PLTE); |
} |
return (0); |
} |
#if defined(PNG_sBIT_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) |
&& sig_bit != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "sBIT"); |
*sig_bit = &(info_ptr->sig_bit); |
return (PNG_INFO_sBIT); |
} |
return (0); |
} |
#endif |
#if defined(PNG_TEXT_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr, |
int *num_text) |
{ |
if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0) |
{ |
png_debug1(1, "in %s retrieval function\n", |
(png_ptr->chunk_name[0] == '\0' ? "text" |
: (png_const_charp)png_ptr->chunk_name)); |
if (text_ptr != NULL) |
*text_ptr = info_ptr->text; |
if (num_text != NULL) |
*num_text = info_ptr->num_text; |
return ((png_uint_32)info_ptr->num_text); |
} |
if (num_text != NULL) |
*num_text = 0; |
return(0); |
} |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time) |
{ |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME) |
&& mod_time != NULL) |
{ |
png_debug1(1, "in %s retrieval function\n", "tIME"); |
*mod_time = &(info_ptr->mod_time); |
return (PNG_INFO_tIME); |
} |
return (0); |
} |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_tRNS(png_structp png_ptr, png_infop info_ptr, |
png_bytep *trans, int *num_trans, png_color_16p *trans_values) |
{ |
png_uint_32 retval = 0; |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) |
{ |
png_debug1(1, "in %s retrieval function\n", "tRNS"); |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (trans != NULL) |
{ |
*trans = info_ptr->trans; |
retval |= PNG_INFO_tRNS; |
} |
if (trans_values != NULL) |
*trans_values = &(info_ptr->trans_values); |
} |
else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ |
{ |
if (trans_values != NULL) |
{ |
*trans_values = &(info_ptr->trans_values); |
retval |= PNG_INFO_tRNS; |
} |
if(trans != NULL) |
*trans = NULL; |
} |
if(num_trans != NULL) |
{ |
*num_trans = info_ptr->num_trans; |
retval |= PNG_INFO_tRNS; |
} |
} |
return (retval); |
} |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr, |
png_unknown_chunkpp unknowns) |
{ |
if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) |
*unknowns = info_ptr->unknown_chunks; |
return ((png_uint_32)info_ptr->unknown_chunks_num); |
} |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
png_byte PNGAPI |
png_get_rgb_to_gray_status (png_structp png_ptr) |
{ |
return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0); |
} |
#endif |
#if defined(PNG_USER_CHUNKS_SUPPORTED) |
png_voidp PNGAPI |
png_get_user_chunk_ptr(png_structp png_ptr) |
{ |
return (png_ptr? png_ptr->user_chunk_ptr : NULL); |
} |
#endif |
png_uint_32 PNGAPI |
png_get_compression_buffer_size(png_structp png_ptr) |
{ |
return (png_uint_32)(png_ptr? png_ptr->zbuf_size : 0L); |
} |
#ifndef PNG_1_0_X |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
/* this function was added to libpng 1.2.0 and should exist by default */ |
png_uint_32 PNGAPI |
png_get_asm_flags (png_structp png_ptr) |
{ |
return (png_uint_32)(png_ptr? png_ptr->asm_flags : 0L); |
} |
/* this function was added to libpng 1.2.0 and should exist by default */ |
png_uint_32 PNGAPI |
png_get_asm_flagmask (int flag_select) |
{ |
png_uint_32 settable_asm_flags = 0; |
if (flag_select & PNG_SELECT_READ) |
settable_asm_flags |= |
PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | |
PNG_ASM_FLAG_MMX_READ_INTERLACE | |
PNG_ASM_FLAG_MMX_READ_FILTER_SUB | |
PNG_ASM_FLAG_MMX_READ_FILTER_UP | |
PNG_ASM_FLAG_MMX_READ_FILTER_AVG | |
PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; |
/* no non-MMX flags yet */ |
#if 0 |
/* GRR: no write-flags yet, either, but someday... */ |
if (flag_select & PNG_SELECT_WRITE) |
settable_asm_flags |= |
PNG_ASM_FLAG_MMX_WRITE_ [whatever] ; |
#endif /* 0 */ |
return settable_asm_flags; /* _theoretically_ settable capabilities only */ |
} |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
/* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ |
/* this function was added to libpng 1.2.0 */ |
png_uint_32 PNGAPI |
png_get_mmx_flagmask (int flag_select, int *compilerID) |
{ |
png_uint_32 settable_mmx_flags = 0; |
if (flag_select & PNG_SELECT_READ) |
settable_mmx_flags |= |
PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | |
PNG_ASM_FLAG_MMX_READ_INTERLACE | |
PNG_ASM_FLAG_MMX_READ_FILTER_SUB | |
PNG_ASM_FLAG_MMX_READ_FILTER_UP | |
PNG_ASM_FLAG_MMX_READ_FILTER_AVG | |
PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; |
#if 0 |
/* GRR: no MMX write support yet, but someday... */ |
if (flag_select & PNG_SELECT_WRITE) |
settable_mmx_flags |= |
PNG_ASM_FLAG_MMX_WRITE_ [whatever] ; |
#endif /* 0 */ |
if (compilerID != NULL) { |
#ifdef PNG_USE_PNGVCRD |
*compilerID = 1; /* MSVC */ |
#else |
#ifdef PNG_USE_PNGGCCRD |
*compilerID = 2; /* gcc/gas */ |
#else |
*compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */ |
#endif |
#endif |
} |
return settable_mmx_flags; /* _theoretically_ settable capabilities only */ |
} |
/* this function was added to libpng 1.2.0 */ |
png_byte PNGAPI |
png_get_mmx_bitdepth_threshold (png_structp png_ptr) |
{ |
return (png_byte)(png_ptr? png_ptr->mmx_bitdepth_threshold : 0); |
} |
/* this function was added to libpng 1.2.0 */ |
png_uint_32 PNGAPI |
png_get_mmx_rowbytes_threshold (png_structp png_ptr) |
{ |
return (png_uint_32)(png_ptr? png_ptr->mmx_rowbytes_threshold : 0L); |
} |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
#endif /* PNG_1_0_X */ |
/shark/trunk/ports/png/png.c |
---|
0,0 → 1,805 |
/* png.c - location for general purpose libpng functions |
* |
* libpng version 1.2.5 - October 3, 2002 |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
*/ |
#define PNG_INTERNAL |
#define PNG_NO_EXTERN |
#include "png.h" |
/* Generate a compiler error if there is an old png.h in the search path. */ |
typedef version_1_2_5 Your_png_h_is_not_version_1_2_5; |
/* Version information for C files. This had better match the version |
* string defined in png.h. */ |
#ifdef PNG_USE_GLOBAL_ARRAYS |
/* png_libpng_ver was changed to a function in version 1.0.5c */ |
const char png_libpng_ver[18] = "1.2.5"; |
/* png_sig was changed to a function in version 1.0.5c */ |
/* Place to hold the signature string for a PNG file. */ |
const png_byte FARDATA png_sig[8] = {137, 80, 78, 71, 13, 10, 26, 10}; |
/* Invoke global declarations for constant strings for known chunk types */ |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
PNG_bKGD; |
PNG_cHRM; |
PNG_gAMA; |
PNG_hIST; |
PNG_iCCP; |
PNG_iTXt; |
PNG_oFFs; |
PNG_pCAL; |
PNG_sCAL; |
PNG_pHYs; |
PNG_sBIT; |
PNG_sPLT; |
PNG_sRGB; |
PNG_tEXt; |
PNG_tIME; |
PNG_tRNS; |
PNG_zTXt; |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; |
/* width of interlace block (used in assembler routines only) */ |
#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; |
#endif |
/* Height of interlace block. This is not currently used - if you need |
* it, uncomment it here and in png.h |
const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; |
*/ |
/* Mask to determine which pixels are valid in a pass */ |
const int FARDATA png_pass_mask[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; |
/* Mask to determine which pixels to overwrite while displaying */ |
const int FARDATA png_pass_dsp_mask[] |
= {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; |
#endif |
/* Tells libpng that we have already handled the first "num_bytes" bytes |
* of the PNG file signature. If the PNG data is embedded into another |
* stream we can set num_bytes = 8 so that libpng will not attempt to read |
* or write any of the magic bytes before it starts on the IHDR. |
*/ |
void PNGAPI |
png_set_sig_bytes(png_structp png_ptr, int num_bytes) |
{ |
png_debug(1, "in png_set_sig_bytes\n"); |
if (num_bytes > 8) |
png_error(png_ptr, "Too many bytes for PNG signature."); |
png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes); |
} |
/* Checks whether the supplied bytes match the PNG signature. We allow |
* checking less than the full 8-byte signature so that those apps that |
* already read the first few bytes of a file to determine the file type |
* can simply check the remaining bytes for extra assurance. Returns |
* an integer less than, equal to, or greater than zero if sig is found, |
* respectively, to be less than, to match, or be greater than the correct |
* PNG signature (this is the same behaviour as strcmp, memcmp, etc). |
*/ |
int PNGAPI |
png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check) |
{ |
png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; |
if (num_to_check > 8) |
num_to_check = 8; |
else if (num_to_check < 1) |
return (0); |
if (start > 7) |
return (0); |
if (start + num_to_check > 8) |
num_to_check = 8 - start; |
return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check))); |
} |
/* (Obsolete) function to check signature bytes. It does not allow one |
* to check a partial signature. This function might be removed in the |
* future - use png_sig_cmp(). Returns true (nonzero) if the file is a PNG. |
*/ |
int PNGAPI |
png_check_sig(png_bytep sig, int num) |
{ |
return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num)); |
} |
/* Function to allocate memory for zlib and clear it to 0. */ |
#ifdef PNG_1_0_X |
voidpf PNGAPI |
#else |
voidpf /* private */ |
#endif |
png_zalloc(voidpf png_ptr, uInt items, uInt size) |
{ |
png_uint_32 num_bytes = (png_uint_32)items * size; |
png_voidp ptr; |
png_structp p=png_ptr; |
png_uint_32 save_flags=p->flags; |
p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; |
ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes); |
p->flags=save_flags; |
#ifndef PNG_NO_ZALLOC_ZERO |
if (ptr == NULL) |
return ((voidpf)ptr); |
if (num_bytes > (png_uint_32)0x8000L) |
{ |
png_memset(ptr, 0, (png_size_t)0x8000L); |
png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0, |
(png_size_t)(num_bytes - (png_uint_32)0x8000L)); |
} |
else |
{ |
png_memset(ptr, 0, (png_size_t)num_bytes); |
} |
#endif |
return ((voidpf)ptr); |
} |
/* function to free memory for zlib */ |
#ifdef PNG_1_0_X |
void PNGAPI |
#else |
void /* private */ |
#endif |
png_zfree(voidpf png_ptr, voidpf ptr) |
{ |
png_free((png_structp)png_ptr, (png_voidp)ptr); |
} |
/* Reset the CRC variable to 32 bits of 1's. Care must be taken |
* in case CRC is > 32 bits to leave the top bits 0. |
*/ |
void /* PRIVATE */ |
png_reset_crc(png_structp png_ptr) |
{ |
png_ptr->crc = crc32(0, Z_NULL, 0); |
} |
/* Calculate the CRC over a section of data. We can only pass as |
* much data to this routine as the largest single buffer size. We |
* also check that this data will actually be used before going to the |
* trouble of calculating it. |
*/ |
void /* PRIVATE */ |
png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length) |
{ |
int need_crc = 1; |
if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ |
{ |
if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == |
(PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
need_crc = 0; |
} |
else /* critical */ |
{ |
if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) |
need_crc = 0; |
} |
if (need_crc) |
png_ptr->crc = crc32(png_ptr->crc, ptr, (uInt)length); |
} |
/* Allocate the memory for an info_struct for the application. We don't |
* really need the png_ptr, but it could potentially be useful in the |
* future. This should be used in favour of malloc(sizeof(png_info)) |
* and png_info_init() so that applications that want to use a shared |
* libpng don't have to be recompiled if png_info changes size. |
*/ |
png_infop PNGAPI |
png_create_info_struct(png_structp png_ptr) |
{ |
png_infop info_ptr; |
png_debug(1, "in png_create_info_struct\n"); |
if(png_ptr == NULL) return (NULL); |
#ifdef PNG_USER_MEM_SUPPORTED |
info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, |
png_ptr->malloc_fn, png_ptr->mem_ptr); |
#else |
info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); |
#endif |
if (info_ptr != NULL) |
png_info_init_3(&info_ptr, sizeof(png_info)); |
return (info_ptr); |
} |
/* This function frees the memory associated with a single info struct. |
* Normally, one would use either png_destroy_read_struct() or |
* png_destroy_write_struct() to free an info struct, but this may be |
* useful for some applications. |
*/ |
void PNGAPI |
png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) |
{ |
png_infop info_ptr = NULL; |
png_debug(1, "in png_destroy_info_struct\n"); |
if (info_ptr_ptr != NULL) |
info_ptr = *info_ptr_ptr; |
if (info_ptr != NULL) |
{ |
png_info_destroy(png_ptr, info_ptr); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn, |
png_ptr->mem_ptr); |
#else |
png_destroy_struct((png_voidp)info_ptr); |
#endif |
*info_ptr_ptr = NULL; |
} |
} |
/* Initialize the info structure. This is now an internal function (0.89) |
* and applications using it are urged to use png_create_info_struct() |
* instead. |
*/ |
#undef png_info_init |
void PNGAPI |
png_info_init(png_infop info_ptr) |
{ |
/* We only come here via pre-1.0.12-compiled applications */ |
png_info_init_3(&info_ptr, 0); |
} |
void PNGAPI |
png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size) |
{ |
png_infop info_ptr = *ptr_ptr; |
png_debug(1, "in png_info_init_3\n"); |
if(sizeof(png_info) > png_info_struct_size) |
{ |
png_destroy_struct(info_ptr); |
info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); |
*ptr_ptr = info_ptr; |
} |
/* set everything to 0 */ |
png_memset(info_ptr, 0, sizeof (png_info)); |
} |
#ifdef PNG_FREE_ME_SUPPORTED |
void PNGAPI |
png_data_freer(png_structp png_ptr, png_infop info_ptr, |
int freer, png_uint_32 mask) |
{ |
png_debug(1, "in png_data_freer\n"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if(freer == PNG_DESTROY_WILL_FREE_DATA) |
info_ptr->free_me |= mask; |
else if(freer == PNG_USER_WILL_FREE_DATA) |
info_ptr->free_me &= ~mask; |
else |
png_warning(png_ptr, |
"Unknown freer parameter in png_data_freer."); |
} |
#endif |
void PNGAPI |
png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, |
int num) |
{ |
png_debug(1, "in png_free_data\n"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
#if defined(PNG_TEXT_SUPPORTED) |
/* free text item num or (if num == -1) all text items */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_TEXT) |
#endif |
{ |
if (num != -1) |
{ |
if (info_ptr->text && info_ptr->text[num].key) |
{ |
png_free(png_ptr, info_ptr->text[num].key); |
info_ptr->text[num].key = NULL; |
} |
} |
else |
{ |
int i; |
for (i = 0; i < info_ptr->num_text; i++) |
png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i); |
png_free(png_ptr, info_ptr->text); |
info_ptr->text = NULL; |
info_ptr->num_text=0; |
} |
} |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
/* free any tRNS entry */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) |
#else |
if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS)) |
#endif |
{ |
png_free(png_ptr, info_ptr->trans); |
info_ptr->valid &= ~PNG_INFO_tRNS; |
#ifndef PNG_FREE_ME_SUPPORTED |
png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; |
#endif |
info_ptr->trans = NULL; |
} |
#endif |
#if defined(PNG_sCAL_SUPPORTED) |
/* free any sCAL entry */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_SCAL) |
#endif |
{ |
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) |
png_free(png_ptr, info_ptr->scal_s_width); |
png_free(png_ptr, info_ptr->scal_s_height); |
info_ptr->scal_s_width = NULL; |
info_ptr->scal_s_height = NULL; |
#endif |
info_ptr->valid &= ~PNG_INFO_sCAL; |
} |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
/* free any pCAL entry */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_PCAL) |
#endif |
{ |
png_free(png_ptr, info_ptr->pcal_purpose); |
png_free(png_ptr, info_ptr->pcal_units); |
info_ptr->pcal_purpose = NULL; |
info_ptr->pcal_units = NULL; |
if (info_ptr->pcal_params != NULL) |
{ |
int i; |
for (i = 0; i < (int)info_ptr->pcal_nparams; i++) |
{ |
png_free(png_ptr, info_ptr->pcal_params[i]); |
info_ptr->pcal_params[i]=NULL; |
} |
png_free(png_ptr, info_ptr->pcal_params); |
info_ptr->pcal_params = NULL; |
} |
info_ptr->valid &= ~PNG_INFO_pCAL; |
} |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
/* free any iCCP entry */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_ICCP) |
#endif |
{ |
png_free(png_ptr, info_ptr->iccp_name); |
png_free(png_ptr, info_ptr->iccp_profile); |
info_ptr->iccp_name = NULL; |
info_ptr->iccp_profile = NULL; |
info_ptr->valid &= ~PNG_INFO_iCCP; |
} |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
/* free a given sPLT entry, or (if num == -1) all sPLT entries */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_SPLT) |
#endif |
{ |
if (num != -1) |
{ |
if(info_ptr->splt_palettes) |
{ |
png_free(png_ptr, info_ptr->splt_palettes[num].name); |
png_free(png_ptr, info_ptr->splt_palettes[num].entries); |
info_ptr->splt_palettes[num].name = NULL; |
info_ptr->splt_palettes[num].entries = NULL; |
} |
} |
else |
{ |
if(info_ptr->splt_palettes_num) |
{ |
int i; |
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) |
png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i); |
png_free(png_ptr, info_ptr->splt_palettes); |
info_ptr->splt_palettes = NULL; |
info_ptr->splt_palettes_num = 0; |
} |
info_ptr->valid &= ~PNG_INFO_sPLT; |
} |
} |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_UNKN) |
#endif |
{ |
if (num != -1) |
{ |
if(info_ptr->unknown_chunks) |
{ |
png_free(png_ptr, info_ptr->unknown_chunks[num].data); |
info_ptr->unknown_chunks[num].data = NULL; |
} |
} |
else |
{ |
int i; |
if(info_ptr->unknown_chunks_num) |
{ |
for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++) |
png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i); |
png_free(png_ptr, info_ptr->unknown_chunks); |
info_ptr->unknown_chunks = NULL; |
info_ptr->unknown_chunks_num = 0; |
} |
} |
} |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
/* free any hIST entry */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_HIST) & info_ptr->free_me) |
#else |
if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST)) |
#endif |
{ |
png_free(png_ptr, info_ptr->hist); |
info_ptr->hist = NULL; |
info_ptr->valid &= ~PNG_INFO_hIST; |
#ifndef PNG_FREE_ME_SUPPORTED |
png_ptr->flags &= ~PNG_FLAG_FREE_HIST; |
#endif |
} |
#endif |
/* free any PLTE entry that was internally allocated */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) |
#else |
if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE)) |
#endif |
{ |
png_zfree(png_ptr, info_ptr->palette); |
info_ptr->palette = NULL; |
info_ptr->valid &= ~PNG_INFO_PLTE; |
#ifndef PNG_FREE_ME_SUPPORTED |
png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; |
#endif |
info_ptr->num_palette = 0; |
} |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
/* free any image bits attached to the info structure */ |
#ifdef PNG_FREE_ME_SUPPORTED |
if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) |
#else |
if (mask & PNG_FREE_ROWS) |
#endif |
{ |
if(info_ptr->row_pointers) |
{ |
int row; |
for (row = 0; row < (int)info_ptr->height; row++) |
{ |
png_free(png_ptr, info_ptr->row_pointers[row]); |
info_ptr->row_pointers[row]=NULL; |
} |
png_free(png_ptr, info_ptr->row_pointers); |
info_ptr->row_pointers=NULL; |
} |
info_ptr->valid &= ~PNG_INFO_IDAT; |
} |
#endif |
#ifdef PNG_FREE_ME_SUPPORTED |
if(num == -1) |
info_ptr->free_me &= ~mask; |
else |
info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL); |
#endif |
} |
/* This is an internal routine to free any memory that the info struct is |
* pointing to before re-using it or freeing the struct itself. Recall |
* that png_free() checks for NULL pointers for us. |
*/ |
void /* PRIVATE */ |
png_info_destroy(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_info_destroy\n"); |
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
if (png_ptr->num_chunk_list) |
{ |
png_free(png_ptr, png_ptr->chunk_list); |
png_ptr->chunk_list=NULL; |
png_ptr->num_chunk_list=0; |
} |
#endif |
png_info_init_3(&info_ptr, sizeof(png_info)); |
} |
/* This function returns a pointer to the io_ptr associated with the user |
* functions. The application should free any memory associated with this |
* pointer before png_write_destroy() or png_read_destroy() are called. |
*/ |
png_voidp PNGAPI |
png_get_io_ptr(png_structp png_ptr) |
{ |
return (png_ptr->io_ptr); |
} |
#if !defined(PNG_NO_STDIO) |
/* Initialize the default input/output functions for the PNG file. If you |
* use your own read or write routines, you can call either png_set_read_fn() |
* or png_set_write_fn() instead of png_init_io(). If you have defined |
* PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't |
* necessarily available. |
*/ |
void PNGAPI |
png_init_io(png_structp png_ptr, png_FILE_p fp) |
{ |
png_debug(1, "in png_init_io\n"); |
png_ptr->io_ptr = (png_voidp)fp; |
} |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
/* Convert the supplied time into an RFC 1123 string suitable for use in |
* a "Creation Time" or other text-based time string. |
*/ |
png_charp PNGAPI |
png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime) |
{ |
static PNG_CONST char short_months[12][4] = |
{"Jan", "Feb", "Mar", "Apr", "May", "Jun", |
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; |
if (png_ptr->time_buffer == NULL) |
{ |
png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* |
sizeof(char))); |
} |
#if defined(_WIN32_WCE) |
{ |
wchar_t time_buf[29]; |
wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"), |
ptime->day % 32, short_months[(ptime->month - 1) % 12], |
ptime->year, ptime->hour % 24, ptime->minute % 60, |
ptime->second % 61); |
WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, 29, |
NULL, NULL); |
} |
#else |
#ifdef USE_FAR_KEYWORD |
{ |
char near_time_buf[29]; |
sprintf(near_time_buf, "%d %s %d %02d:%02d:%02d +0000", |
ptime->day % 32, short_months[(ptime->month - 1) % 12], |
ptime->year, ptime->hour % 24, ptime->minute % 60, |
ptime->second % 61); |
png_memcpy(png_ptr->time_buffer, near_time_buf, |
29*sizeof(char)); |
} |
#else |
sprintf(png_ptr->time_buffer, "%d %s %d %02d:%02d:%02d +0000", |
ptime->day % 32, short_months[(ptime->month - 1) % 12], |
ptime->year, ptime->hour % 24, ptime->minute % 60, |
ptime->second % 61); |
#endif |
#endif /* _WIN32_WCE */ |
return ((png_charp)png_ptr->time_buffer); |
} |
#endif /* PNG_TIME_RFC1123_SUPPORTED */ |
#if 0 |
/* Signature string for a PNG file. */ |
png_bytep PNGAPI |
png_sig_bytes(void) |
{ |
return ((png_bytep)"\211\120\116\107\015\012\032\012"); |
} |
#endif |
png_charp PNGAPI |
png_get_copyright(png_structp png_ptr) |
{ |
if (png_ptr != NULL || png_ptr == NULL) /* silence compiler warning */ |
return ((png_charp) "\n libpng version 1.2.5 - October 3, 2002\n\ |
Copyright (c) 1998-2002 Glenn Randers-Pehrson\n\ |
Copyright (c) 1996-1997 Andreas Dilger\n\ |
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n"); |
return ((png_charp) ""); |
} |
/* The following return the library version as a short string in the |
* format 1.0.0 through 99.99.99zz. To get the version of *.h files used |
* with your application, print out PNG_LIBPNG_VER_STRING, which is defined |
* in png.h. |
*/ |
png_charp PNGAPI |
png_get_libpng_ver(png_structp png_ptr) |
{ |
/* Version of *.c files used when building libpng */ |
if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */ |
return((png_charp) "1.2.5"); |
return((png_charp) "1.2.5"); |
} |
png_charp PNGAPI |
png_get_header_ver(png_structp png_ptr) |
{ |
/* Version of *.h files used when building libpng */ |
if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */ |
return((png_charp) PNG_LIBPNG_VER_STRING); |
return((png_charp) PNG_LIBPNG_VER_STRING); |
} |
png_charp PNGAPI |
png_get_header_version(png_structp png_ptr) |
{ |
/* Returns longer string containing both version and date */ |
if(png_ptr != NULL) /* silence compiler warning about unused png_ptr */ |
return((png_charp) PNG_HEADER_VERSION_STRING); |
return((png_charp) PNG_HEADER_VERSION_STRING); |
} |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
int PNGAPI |
png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name) |
{ |
/* check chunk_name and return "keep" value if it's on the list, else 0 */ |
int i; |
png_bytep p; |
if((png_ptr == NULL && chunk_name == NULL) || png_ptr->num_chunk_list<=0) |
return 0; |
p=png_ptr->chunk_list+png_ptr->num_chunk_list*5-5; |
for (i = png_ptr->num_chunk_list; i; i--, p-=5) |
if (!png_memcmp(chunk_name, p, 4)) |
return ((int)*(p+4)); |
return 0; |
} |
#endif |
/* This function, added to libpng-1.0.6g, is untested. */ |
int PNGAPI |
png_reset_zstream(png_structp png_ptr) |
{ |
return (inflateReset(&png_ptr->zstream)); |
} |
/* This function was added to libpng-1.0.7 */ |
png_uint_32 PNGAPI |
png_access_version_number(void) |
{ |
/* Version of *.c files used when building libpng */ |
return((png_uint_32) 10205L); |
} |
#if !defined(PNG_1_0_X) |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
/* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ |
/* this INTERNAL function was added to libpng 1.2.0 */ |
void /* PRIVATE */ |
png_init_mmx_flags (png_structp png_ptr) |
{ |
png_ptr->mmx_rowbytes_threshold = 0; |
png_ptr->mmx_bitdepth_threshold = 0; |
# if (defined(PNG_USE_PNGVCRD) || defined(PNG_USE_PNGGCCRD)) |
png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_COMPILED; |
if (png_mmx_support() > 0) { |
png_ptr->asm_flags |= PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU |
# ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
| PNG_ASM_FLAG_MMX_READ_COMBINE_ROW |
# endif |
# ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE |
| PNG_ASM_FLAG_MMX_READ_INTERLACE |
# endif |
# ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
; |
# else |
| PNG_ASM_FLAG_MMX_READ_FILTER_SUB |
| PNG_ASM_FLAG_MMX_READ_FILTER_UP |
| PNG_ASM_FLAG_MMX_READ_FILTER_AVG |
| PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ; |
png_ptr->mmx_rowbytes_threshold = PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT; |
png_ptr->mmx_bitdepth_threshold = PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT; |
# endif |
} else { |
png_ptr->asm_flags &= ~( PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU |
| PNG_MMX_READ_FLAGS |
| PNG_MMX_WRITE_FLAGS ); |
} |
# else /* !((PNGVCRD || PNGGCCRD) && PNG_ASSEMBLER_CODE_SUPPORTED)) */ |
/* clear all MMX flags; no support is compiled in */ |
png_ptr->asm_flags &= ~( PNG_MMX_FLAGS ); |
# endif /* ?(PNGVCRD || PNGGCCRD) */ |
} |
#endif /* !(PNG_ASSEMBLER_CODE_SUPPORTED) */ |
/* this function was added to libpng 1.2.0 */ |
#if !defined(PNG_USE_PNGGCCRD) && \ |
!(defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_USE_PNGVCRD)) |
int PNGAPI |
png_mmx_support(void) |
{ |
return -1; |
} |
#endif |
#endif /* PNG_1_0_X */ |
/shark/trunk/ports/png/infblock.c |
---|
0,0 → 1,403 |
/* infblock.c -- interpret and process block types to last block |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
#include "zutil.h" |
#include "infblock.h" |
#include "inftrees.h" |
#include "infcodes.h" |
#include "infutil.h" |
struct inflate_codes_state {int dummy;}; /* for buggy compilers */ |
/* simplify the use of the inflate_huft type with some defines */ |
#define exop word.what.Exop |
#define bits word.what.Bits |
/* Table for deflate from PKZIP's appnote.txt. */ |
local const uInt border[] = { /* Order of the bit length code lengths */ |
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; |
/* |
Notes beyond the 1.93a appnote.txt: |
1. Distance pointers never point before the beginning of the output |
stream. |
2. Distance pointers can point back across blocks, up to 32k away. |
3. There is an implied maximum of 7 bits for the bit length table and |
15 bits for the actual data. |
4. If only one code exists, then it is encoded using one bit. (Zero |
would be more efficient, but perhaps a little confusing.) If two |
codes exist, they are coded using one bit each (0 and 1). |
5. There is no way of sending zero distance codes--a dummy must be |
sent if there are none. (History: a pre 2.0 version of PKZIP would |
store blocks with no distance codes, but this was discovered to be |
too harsh a criterion.) Valid only for 1.93a. 2.04c does allow |
zero distance codes, which is sent as one code of zero bits in |
length. |
6. There are up to 286 literal/length codes. Code 256 represents the |
end-of-block. Note however that the static length tree defines |
288 codes just to fill out the Huffman codes. Codes 286 and 287 |
cannot be used though, since there is no length base or extra bits |
defined for them. Similarily, there are up to 30 distance codes. |
However, static trees define 32 codes (all 5 bits) to fill out the |
Huffman codes, but the last two had better not show up in the data. |
7. Unzip can check dynamic Huffman blocks for complete code sets. |
The exception is that a single code would not be complete (see #4). |
8. The five bits following the block type is really the number of |
literal codes sent minus 257. |
9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits |
(1+6+6). Therefore, to output three times the length, you output |
three codes (1+1+1), whereas to output four times the same length, |
you only need two codes (1+3). Hmm. |
10. In the tree reconstruction algorithm, Code = Code + Increment |
only if BitLength(i) is not zero. (Pretty obvious.) |
11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19) |
12. Note: length code 284 can represent 227-258, but length code 285 |
really is 258. The last length deserves its own, short code |
since it gets used a lot in very redundant files. The length |
258 is special since 258 - 3 (the min match length) is 255. |
13. The literal/length and distance code bit lengths are read as a |
single stream of lengths. It is possible (and advantageous) for |
a repeat code (16, 17, or 18) to go across the boundary between |
the two sets of lengths. |
*/ |
void inflate_blocks_reset(s, z, c) |
inflate_blocks_statef *s; |
z_streamp z; |
uLongf *c; |
{ |
if (c != Z_NULL) |
*c = s->check; |
if (s->mode == BTREE || s->mode == DTREE) |
ZFREE(z, s->sub.trees.blens); |
if (s->mode == CODES) |
inflate_codes_free(s->sub.decode.codes, z); |
s->mode = TYPE; |
s->bitk = 0; |
s->bitb = 0; |
s->read = s->write = s->window; |
if (s->checkfn != Z_NULL) |
z->adler = s->check = (*s->checkfn)(0L, (const Bytef *)Z_NULL, 0); |
Tracev((stderr, "inflate: blocks reset\n")); |
} |
inflate_blocks_statef *inflate_blocks_new(z, c, w) |
z_streamp z; |
check_func c; |
uInt w; |
{ |
inflate_blocks_statef *s; |
if ((s = (inflate_blocks_statef *)ZALLOC |
(z,1,sizeof(struct inflate_blocks_state))) == Z_NULL) |
return s; |
if ((s->hufts = |
(inflate_huft *)ZALLOC(z, sizeof(inflate_huft), MANY)) == Z_NULL) |
{ |
ZFREE(z, s); |
return Z_NULL; |
} |
if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL) |
{ |
ZFREE(z, s->hufts); |
ZFREE(z, s); |
return Z_NULL; |
} |
s->end = s->window + w; |
s->checkfn = c; |
s->mode = TYPE; |
Tracev((stderr, "inflate: blocks allocated\n")); |
inflate_blocks_reset(s, z, Z_NULL); |
return s; |
} |
int inflate_blocks(s, z, r) |
inflate_blocks_statef *s; |
z_streamp z; |
int r; |
{ |
uInt t; /* temporary storage */ |
uLong b; /* bit buffer */ |
uInt k; /* bits in bit buffer */ |
Bytef *p; /* input data pointer */ |
uInt n; /* bytes available there */ |
Bytef *q; /* output window write pointer */ |
uInt m; /* bytes to end of window or read pointer */ |
/* copy input/output information to locals (UPDATE macro restores) */ |
LOAD |
/* process input based on current state */ |
while (1) switch (s->mode) |
{ |
case TYPE: |
NEEDBITS(3) |
t = (uInt)b & 7; |
s->last = t & 1; |
switch (t >> 1) |
{ |
case 0: /* stored */ |
Tracev((stderr, "inflate: stored block%s\n", |
s->last ? " (last)" : "")); |
DUMPBITS(3) |
t = k & 7; /* go to byte boundary */ |
DUMPBITS(t) |
s->mode = LENS; /* get length of stored block */ |
break; |
case 1: /* fixed */ |
Tracev((stderr, "inflate: fixed codes block%s\n", |
s->last ? " (last)" : "")); |
{ |
uInt bl, bd; |
inflate_huft *tl, *td; |
inflate_trees_fixed(&bl, &bd, &tl, &td, z); |
s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z); |
if (s->sub.decode.codes == Z_NULL) |
{ |
r = Z_MEM_ERROR; |
LEAVE |
} |
} |
DUMPBITS(3) |
s->mode = CODES; |
break; |
case 2: /* dynamic */ |
Tracev((stderr, "inflate: dynamic codes block%s\n", |
s->last ? " (last)" : "")); |
DUMPBITS(3) |
s->mode = TABLE; |
break; |
case 3: /* illegal */ |
DUMPBITS(3) |
s->mode = BAD; |
z->msg = (char*)"invalid block type"; |
r = Z_DATA_ERROR; |
LEAVE |
} |
break; |
case LENS: |
NEEDBITS(32) |
if ((((~b) >> 16) & 0xffff) != (b & 0xffff)) |
{ |
s->mode = BAD; |
z->msg = (char*)"invalid stored block lengths"; |
r = Z_DATA_ERROR; |
LEAVE |
} |
s->sub.left = (uInt)b & 0xffff; |
b = k = 0; /* dump bits */ |
Tracev((stderr, "inflate: stored length %u\n", s->sub.left)); |
s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE); |
break; |
case STORED: |
if (n == 0) |
LEAVE |
NEEDOUT |
t = s->sub.left; |
if (t > n) t = n; |
if (t > m) t = m; |
zmemcpy(q, p, t); |
p += t; n -= t; |
q += t; m -= t; |
if ((s->sub.left -= t) != 0) |
break; |
Tracev((stderr, "inflate: stored end, %lu total out\n", |
z->total_out + (q >= s->read ? q - s->read : |
(s->end - s->read) + (q - s->window)))); |
s->mode = s->last ? DRY : TYPE; |
break; |
case TABLE: |
NEEDBITS(14) |
s->sub.trees.table = t = (uInt)b & 0x3fff; |
#ifndef PKZIP_BUG_WORKAROUND |
if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) |
{ |
s->mode = BAD; |
z->msg = (char*)"too many length or distance symbols"; |
r = Z_DATA_ERROR; |
LEAVE |
} |
#endif |
t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f); |
if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL) |
{ |
r = Z_MEM_ERROR; |
LEAVE |
} |
DUMPBITS(14) |
s->sub.trees.index = 0; |
Tracev((stderr, "inflate: table sizes ok\n")); |
s->mode = BTREE; |
case BTREE: |
while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10)) |
{ |
NEEDBITS(3) |
s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7; |
DUMPBITS(3) |
} |
while (s->sub.trees.index < 19) |
s->sub.trees.blens[border[s->sub.trees.index++]] = 0; |
s->sub.trees.bb = 7; |
t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb, |
&s->sub.trees.tb, s->hufts, z); |
if (t != Z_OK) |
{ |
r = t; |
if (r == Z_DATA_ERROR) |
{ |
ZFREE(z, s->sub.trees.blens); |
s->mode = BAD; |
} |
LEAVE |
} |
s->sub.trees.index = 0; |
Tracev((stderr, "inflate: bits tree ok\n")); |
s->mode = DTREE; |
case DTREE: |
while (t = s->sub.trees.table, |
s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)) |
{ |
inflate_huft *h; |
uInt i, j, c; |
t = s->sub.trees.bb; |
NEEDBITS(t) |
h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]); |
t = h->bits; |
c = h->base; |
if (c < 16) |
{ |
DUMPBITS(t) |
s->sub.trees.blens[s->sub.trees.index++] = c; |
} |
else /* c == 16..18 */ |
{ |
i = c == 18 ? 7 : c - 14; |
j = c == 18 ? 11 : 3; |
NEEDBITS(t + i) |
DUMPBITS(t) |
j += (uInt)b & inflate_mask[i]; |
DUMPBITS(i) |
i = s->sub.trees.index; |
t = s->sub.trees.table; |
if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || |
(c == 16 && i < 1)) |
{ |
ZFREE(z, s->sub.trees.blens); |
s->mode = BAD; |
z->msg = (char*)"invalid bit length repeat"; |
r = Z_DATA_ERROR; |
LEAVE |
} |
c = c == 16 ? s->sub.trees.blens[i - 1] : 0; |
do { |
s->sub.trees.blens[i++] = c; |
} while (--j); |
s->sub.trees.index = i; |
} |
} |
s->sub.trees.tb = Z_NULL; |
{ |
uInt bl, bd; |
inflate_huft *tl, *td; |
inflate_codes_statef *c; |
bl = 9; /* must be <= 9 for lookahead assumptions */ |
bd = 6; /* must be <= 9 for lookahead assumptions */ |
t = s->sub.trees.table; |
t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), |
s->sub.trees.blens, &bl, &bd, &tl, &td, |
s->hufts, z); |
if (t != Z_OK) |
{ |
if (t == (uInt)Z_DATA_ERROR) |
{ |
ZFREE(z, s->sub.trees.blens); |
s->mode = BAD; |
} |
r = t; |
LEAVE |
} |
Tracev((stderr, "inflate: trees ok\n")); |
if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL) |
{ |
r = Z_MEM_ERROR; |
LEAVE |
} |
s->sub.decode.codes = c; |
} |
ZFREE(z, s->sub.trees.blens); |
s->mode = CODES; |
case CODES: |
UPDATE |
if ((r = inflate_codes(s, z, r)) != Z_STREAM_END) |
return inflate_flush(s, z, r); |
r = Z_OK; |
inflate_codes_free(s->sub.decode.codes, z); |
LOAD |
Tracev((stderr, "inflate: codes end, %lu total out\n", |
z->total_out + (q >= s->read ? q - s->read : |
(s->end - s->read) + (q - s->window)))); |
if (!s->last) |
{ |
s->mode = TYPE; |
break; |
} |
s->mode = DRY; |
case DRY: |
FLUSH |
if (s->read != s->write) |
LEAVE |
s->mode = DONE; |
case DONE: |
r = Z_STREAM_END; |
LEAVE |
case BAD: |
r = Z_DATA_ERROR; |
LEAVE |
default: |
r = Z_STREAM_ERROR; |
LEAVE |
} |
} |
int inflate_blocks_free(s, z) |
inflate_blocks_statef *s; |
z_streamp z; |
{ |
inflate_blocks_reset(s, z, Z_NULL); |
ZFREE(z, s->window); |
ZFREE(z, s->hufts); |
ZFREE(z, s); |
Tracev((stderr, "inflate: blocks freed\n")); |
return Z_OK; |
} |
void inflate_set_dictionary(s, d, n) |
inflate_blocks_statef *s; |
const Bytef *d; |
uInt n; |
{ |
zmemcpy(s->window, d, n); |
s->read = s->write = s->window + n; |
} |
/* Returns true if inflate is currently at the end of a block generated |
* by Z_SYNC_FLUSH or Z_FULL_FLUSH. |
* IN assertion: s != Z_NULL |
*/ |
int inflate_blocks_sync_point(s) |
inflate_blocks_statef *s; |
{ |
return s->mode == LENS; |
} |
/shark/trunk/ports/png/pnggccrd.c |
---|
0,0 → 1,5397 |
/* pnggccrd.c - mixed C/assembler version of utilities to read a PNG file |
* |
* For Intel x86 CPU (Pentium-MMX or later) and GNU C compiler. |
* |
* See http://www.intel.com/drg/pentiumII/appnotes/916/916.htm |
* and http://www.intel.com/drg/pentiumII/appnotes/923/923.htm |
* for Intel's performance analysis of the MMX vs. non-MMX code. |
* |
* libpng version 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* Copyright (c) 1998, Intel Corporation |
* |
* Based on MSVC code contributed by Nirav Chhatrapati, Intel Corp., 1998. |
* Interface to libpng contributed by Gilles Vollant, 1999. |
* GNU C port by Greg Roelofs, 1999-2001. |
* |
* Lines 2350-4300 converted in place with intel2gas 1.3.1: |
* |
* intel2gas -mdI pnggccrd.c.partially-msvc -o pnggccrd.c |
* |
* and then cleaned up by hand. See http://hermes.terminal.at/intel2gas/ . |
* |
* NOTE: A sufficiently recent version of GNU as (or as.exe under DOS/Windows) |
* is required to assemble the newer MMX instructions such as movq. |
* For djgpp, see |
* |
* ftp://ftp.simtel.net/pub/simtelnet/gnu/djgpp/v2gnu/bnu281b.zip |
* |
* (or a later version in the same directory). For Linux, check your |
* distribution's web site(s) or try these links: |
* |
* http://rufus.w3.org/linux/RPM/binutils.html |
* http://www.debian.org/Packages/stable/devel/binutils.html |
* ftp://ftp.slackware.com/pub/linux/slackware/slackware/slakware/d1/ |
* binutils.tgz |
* |
* For other platforms, see the main GNU site: |
* |
* ftp://ftp.gnu.org/pub/gnu/binutils/ |
* |
* Version 2.5.2l.15 is definitely too old... |
*/ |
/* |
* TEMPORARY PORTING NOTES AND CHANGELOG (mostly by Greg Roelofs) |
* ===================================== |
* |
* 19991006: |
* - fixed sign error in post-MMX cleanup code (16- & 32-bit cases) |
* |
* 19991007: |
* - additional optimizations (possible or definite): |
* x [DONE] write MMX code for 64-bit case (pixel_bytes == 8) [not tested] |
* - write MMX code for 48-bit case (pixel_bytes == 6) |
* - figure out what's up with 24-bit case (pixel_bytes == 3): |
* why subtract 8 from width_mmx in the pass 4/5 case? |
* (only width_mmx case) (near line 1606) |
* x [DONE] replace pixel_bytes within each block with the true |
* constant value (or are compilers smart enough to do that?) |
* - rewrite all MMX interlacing code so it's aligned with |
* the *beginning* of the row buffer, not the end. This |
* would not only allow one to eliminate half of the memory |
* writes for odd passes (that is, pass == odd), it may also |
* eliminate some unaligned-data-access exceptions (assuming |
* there's a penalty for not aligning 64-bit accesses on |
* 64-bit boundaries). The only catch is that the "leftover" |
* pixel(s) at the end of the row would have to be saved, |
* but there are enough unused MMX registers in every case, |
* so this is not a problem. A further benefit is that the |
* post-MMX cleanup code (C code) in at least some of the |
* cases could be done within the assembler block. |
* x [DONE] the "v3 v2 v1 v0 v7 v6 v5 v4" comments are confusing, |
* inconsistent, and don't match the MMX Programmer's Reference |
* Manual conventions anyway. They should be changed to |
* "b7 b6 b5 b4 b3 b2 b1 b0," where b0 indicates the byte that |
* was lowest in memory (e.g., corresponding to a left pixel) |
* and b7 is the byte that was highest (e.g., a right pixel). |
* |
* 19991016: |
* - Brennan's Guide notwithstanding, gcc under Linux does *not* |
* want globals prefixed by underscores when referencing them-- |
* i.e., if the variable is const4, then refer to it as const4, |
* not _const4. This seems to be a djgpp-specific requirement. |
* Also, such variables apparently *must* be declared outside |
* of functions; neither static nor automatic variables work if |
* defined within the scope of a single function, but both |
* static and truly global (multi-module) variables work fine. |
* |
* 19991023: |
* - fixed png_combine_row() non-MMX replication bug (odd passes only?) |
* - switched from string-concatenation-with-macros to cleaner method of |
* renaming global variables for djgpp--i.e., always use prefixes in |
* inlined assembler code (== strings) and conditionally rename the |
* variables, not the other way around. Hence _const4, _mask8_0, etc. |
* |
* 19991024: |
* - fixed mmxsupport()/png_do_read_interlace() first-row bug |
* This one was severely weird: even though mmxsupport() doesn't touch |
* ebx (where "row" pointer was stored), it nevertheless managed to zero |
* the register (even in static/non-fPIC code--see below), which in turn |
* caused png_do_read_interlace() to return prematurely on the first row of |
* interlaced images (i.e., without expanding the interlaced pixels). |
* Inspection of the generated assembly code didn't turn up any clues, |
* although it did point at a minor optimization (i.e., get rid of |
* mmx_supported_local variable and just use eax). Possibly the CPUID |
* instruction is more destructive than it looks? (Not yet checked.) |
* - "info gcc" was next to useless, so compared fPIC and non-fPIC assembly |
* listings... Apparently register spillage has to do with ebx, since |
* it's used to index the global offset table. Commenting it out of the |
* input-reg lists in png_combine_row() eliminated compiler barfage, so |
* ifdef'd with __PIC__ macro: if defined, use a global for unmask |
* |
* 19991107: |
* - verified CPUID clobberage: 12-char string constant ("GenuineIntel", |
* "AuthenticAMD", etc.) placed in ebx:ecx:edx. Still need to polish. |
* |
* 19991120: |
* - made "diff" variable (now "_dif") global to simplify conversion of |
* filtering routines (running out of regs, sigh). "diff" is still used |
* in interlacing routines, however. |
* - fixed up both versions of mmxsupport() (ORIG_THAT_USED_TO_CLOBBER_EBX |
* macro determines which is used); original not yet tested. |
* |
* 20000213: |
* - when compiling with gcc, be sure to use -fomit-frame-pointer |
* |
* 20000319: |
* - fixed a register-name typo in png_do_read_interlace(), default (MMX) case, |
* pass == 4 or 5, that caused visible corruption of interlaced images |
* |
* 20000623: |
* - Various problems were reported with gcc 2.95.2 in the Cygwin environment, |
* many of the form "forbidden register 0 (ax) was spilled for class AREG." |
* This is explained at http://gcc.gnu.org/fom_serv/cache/23.html, and |
* Chuck Wilson supplied a patch involving dummy output registers. See |
* http://sourceforge.net/bugs/?func=detailbug&bug_id=108741&group_id=5624 |
* for the original (anonymous) SourceForge bug report. |
* |
* 20000706: |
* - Chuck Wilson passed along these remaining gcc 2.95.2 errors: |
* pnggccrd.c: In function `png_combine_row': |
* pnggccrd.c:525: more than 10 operands in `asm' |
* pnggccrd.c:669: more than 10 operands in `asm' |
* pnggccrd.c:828: more than 10 operands in `asm' |
* pnggccrd.c:994: more than 10 operands in `asm' |
* pnggccrd.c:1177: more than 10 operands in `asm' |
* They are all the same problem and can be worked around by using the |
* global _unmask variable unconditionally, not just in the -fPIC case. |
* Reportedly earlier versions of gcc also have the problem with more than |
* 10 operands; they just don't report it. Much strangeness ensues, etc. |
* |
* 20000729: |
* - enabled png_read_filter_row_mmx_up() (shortest remaining unconverted |
* MMX routine); began converting png_read_filter_row_mmx_sub() |
* - to finish remaining sections: |
* - clean up indentation and comments |
* - preload local variables |
* - add output and input regs (order of former determines numerical |
* mapping of latter) |
* - avoid all usage of ebx (including bx, bh, bl) register [20000823] |
* - remove "$" from addressing of Shift and Mask variables [20000823] |
* |
* 20000731: |
* - global union vars causing segfaults in png_read_filter_row_mmx_sub()? |
* |
* 20000822: |
* - ARGH, stupid png_read_filter_row_mmx_sub() segfault only happens with |
* shared-library (-fPIC) version! Code works just fine as part of static |
* library. Damn damn damn damn damn, should have tested that sooner. |
* ebx is getting clobbered again (explicitly this time); need to save it |
* on stack or rewrite asm code to avoid using it altogether. Blargh! |
* |
* 20000823: |
* - first section was trickiest; all remaining sections have ebx -> edx now. |
* (-fPIC works again.) Also added missing underscores to various Shift* |
* and *Mask* globals and got rid of leading "$" signs. |
* |
* 20000826: |
* - added visual separators to help navigate microscopic printed copies |
* (http://pobox.com/~newt/code/gpr-latest.zip, mode 10); started working |
* on png_read_filter_row_mmx_avg() |
* |
* 20000828: |
* - finished png_read_filter_row_mmx_avg(): only Paeth left! (930 lines...) |
* What the hell, did png_read_filter_row_mmx_paeth(), too. Comments not |
* cleaned up/shortened in either routine, but functionality is complete |
* and seems to be working fine. |
* |
* 20000829: |
* - ahhh, figured out last(?) bit of gcc/gas asm-fu: if register is listed |
* as an input reg (with dummy output variables, etc.), then it *cannot* |
* also appear in the clobber list or gcc 2.95.2 will barf. The solution |
* is simple enough... |
* |
* 20000914: |
* - bug in png_read_filter_row_mmx_avg(): 16-bit grayscale not handled |
* correctly (but 48-bit RGB just fine) |
* |
* 20000916: |
* - fixed bug in png_read_filter_row_mmx_avg(), bpp == 2 case; three errors: |
* - "_ShiftBpp.use = 24;" should have been "_ShiftBpp.use = 16;" |
* - "_ShiftRem.use = 40;" should have been "_ShiftRem.use = 48;" |
* - "psllq _ShiftRem, %%mm2" should have been "psrlq _ShiftRem, %%mm2" |
* |
* 20010101: |
* - added new png_init_mmx_flags() function (here only because it needs to |
* call mmxsupport(), which should probably become global png_mmxsupport()); |
* modified other MMX routines to run conditionally (png_ptr->asm_flags) |
* |
* 20010103: |
* - renamed mmxsupport() to png_mmx_support(), with auto-set of mmx_supported, |
* and made it public; moved png_init_mmx_flags() to png.c as internal func |
* |
* 20010104: |
* - removed dependency on png_read_filter_row_c() (C code already duplicated |
* within MMX version of png_read_filter_row()) so no longer necessary to |
* compile it into pngrutil.o |
* |
* 20010310: |
* - fixed buffer-overrun bug in png_combine_row() C code (non-MMX) |
* |
* 20020304: |
* - eliminated incorrect use of width_mmx in pixel_bytes == 8 case |
* |
* STILL TO DO: |
* - test png_do_read_interlace() 64-bit case (pixel_bytes == 8) |
* - write MMX code for 48-bit case (pixel_bytes == 6) |
* - figure out what's up with 24-bit case (pixel_bytes == 3): |
* why subtract 8 from width_mmx in the pass 4/5 case? |
* (only width_mmx case) (near line 1606) |
* - rewrite all MMX interlacing code so it's aligned with beginning |
* of the row buffer, not the end (see 19991007 for details) |
* x pick one version of mmxsupport() and get rid of the other |
* - add error messages to any remaining bogus default cases |
* - enable pixel_depth == 8 cases in png_read_filter_row()? (test speed) |
* x add support for runtime enable/disable/query of various MMX routines |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#if defined(PNG_USE_PNGGCCRD) |
int PNGAPI png_mmx_support(void); |
#ifdef PNG_USE_LOCAL_ARRAYS |
static const int FARDATA png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
static const int FARDATA png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
static const int FARDATA png_pass_width[7] = {8, 4, 4, 2, 2, 1, 1}; |
#endif |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
/* djgpp, Win32, and Cygwin add their own underscores to global variables, |
* so define them without: */ |
#if defined(__DJGPP__) || defined(WIN32) || defined(__CYGWIN__) |
# define _mmx_supported mmx_supported |
# define _const4 const4 |
# define _const6 const6 |
# define _mask8_0 mask8_0 |
# define _mask16_1 mask16_1 |
# define _mask16_0 mask16_0 |
# define _mask24_2 mask24_2 |
# define _mask24_1 mask24_1 |
# define _mask24_0 mask24_0 |
# define _mask32_3 mask32_3 |
# define _mask32_2 mask32_2 |
# define _mask32_1 mask32_1 |
# define _mask32_0 mask32_0 |
# define _mask48_5 mask48_5 |
# define _mask48_4 mask48_4 |
# define _mask48_3 mask48_3 |
# define _mask48_2 mask48_2 |
# define _mask48_1 mask48_1 |
# define _mask48_0 mask48_0 |
# define _LBCarryMask LBCarryMask |
# define _HBClearMask HBClearMask |
# define _ActiveMask ActiveMask |
# define _ActiveMask2 ActiveMask2 |
# define _ActiveMaskEnd ActiveMaskEnd |
# define _ShiftBpp ShiftBpp |
# define _ShiftRem ShiftRem |
#ifdef PNG_THREAD_UNSAFE_OK |
# define _unmask unmask |
# define _FullLength FullLength |
# define _MMXLength MMXLength |
# define _dif dif |
# define _patemp patemp |
# define _pbtemp pbtemp |
# define _pctemp pctemp |
#endif |
#endif |
/* These constants are used in the inlined MMX assembly code. |
Ignore gcc's "At top level: defined but not used" warnings. */ |
/* GRR 20000706: originally _unmask was needed only when compiling with -fPIC, |
* since that case uses the %ebx register for indexing the Global Offset Table |
* and there were no other registers available. But gcc 2.95 and later emit |
* "more than 10 operands in `asm'" errors when %ebx is used to preload unmask |
* in the non-PIC case, so we'll just use the global unconditionally now. |
*/ |
#ifdef PNG_THREAD_UNSAFE_OK |
static int _unmask; |
#endif |
static unsigned long long _mask8_0 = 0x0102040810204080LL; |
static unsigned long long _mask16_1 = 0x0101020204040808LL; |
static unsigned long long _mask16_0 = 0x1010202040408080LL; |
static unsigned long long _mask24_2 = 0x0101010202020404LL; |
static unsigned long long _mask24_1 = 0x0408080810101020LL; |
static unsigned long long _mask24_0 = 0x2020404040808080LL; |
static unsigned long long _mask32_3 = 0x0101010102020202LL; |
static unsigned long long _mask32_2 = 0x0404040408080808LL; |
static unsigned long long _mask32_1 = 0x1010101020202020LL; |
static unsigned long long _mask32_0 = 0x4040404080808080LL; |
static unsigned long long _mask48_5 = 0x0101010101010202LL; |
static unsigned long long _mask48_4 = 0x0202020204040404LL; |
static unsigned long long _mask48_3 = 0x0404080808080808LL; |
static unsigned long long _mask48_2 = 0x1010101010102020LL; |
static unsigned long long _mask48_1 = 0x2020202040404040LL; |
static unsigned long long _mask48_0 = 0x4040808080808080LL; |
static unsigned long long _const4 = 0x0000000000FFFFFFLL; |
//static unsigned long long _const5 = 0x000000FFFFFF0000LL; // NOT USED |
static unsigned long long _const6 = 0x00000000000000FFLL; |
// These are used in the row-filter routines and should/would be local |
// variables if not for gcc addressing limitations. |
// WARNING: Their presence probably defeats the thread safety of libpng. |
#ifdef PNG_THREAD_UNSAFE_OK |
static png_uint_32 _FullLength; |
static png_uint_32 _MMXLength; |
static int _dif; |
static int _patemp; // temp variables for Paeth routine |
static int _pbtemp; |
static int _pctemp; |
#endif |
void /* PRIVATE */ |
png_squelch_warnings(void) |
{ |
#ifdef PNG_THREAD_UNSAFE_OK |
_dif = _dif; |
_patemp = _patemp; |
_pbtemp = _pbtemp; |
_pctemp = _pctemp; |
_MMXLength = _MMXLength; |
#endif |
_const4 = _const4; |
_const6 = _const6; |
_mask8_0 = _mask8_0; |
_mask16_1 = _mask16_1; |
_mask16_0 = _mask16_0; |
_mask24_2 = _mask24_2; |
_mask24_1 = _mask24_1; |
_mask24_0 = _mask24_0; |
_mask32_3 = _mask32_3; |
_mask32_2 = _mask32_2; |
_mask32_1 = _mask32_1; |
_mask32_0 = _mask32_0; |
_mask48_5 = _mask48_5; |
_mask48_4 = _mask48_4; |
_mask48_3 = _mask48_3; |
_mask48_2 = _mask48_2; |
_mask48_1 = _mask48_1; |
_mask48_0 = _mask48_0; |
} |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
static int _mmx_supported = 2; |
/*===========================================================================*/ |
/* */ |
/* P N G _ C O M B I N E _ R O W */ |
/* */ |
/*===========================================================================*/ |
#if defined(PNG_HAVE_ASSEMBLER_COMBINE_ROW) |
#define BPP2 2 |
#define BPP3 3 /* bytes per pixel (a.k.a. pixel_bytes) */ |
#define BPP4 4 |
#define BPP6 6 /* (defined only to help avoid cut-and-paste errors) */ |
#define BPP8 8 |
/* Combines the row recently read in with the previous row. |
This routine takes care of alpha and transparency if requested. |
This routine also handles the two methods of progressive display |
of interlaced images, depending on the mask value. |
The mask value describes which pixels are to be combined with |
the row. The pattern always repeats every 8 pixels, so just 8 |
bits are needed. A one indicates the pixel is to be combined; a |
zero indicates the pixel is to be skipped. This is in addition |
to any alpha or transparency value associated with the pixel. |
If you want all pixels to be combined, pass 0xff (255) in mask. */ |
/* Use this routine for the x86 platform - it uses a faster MMX routine |
if the machine supports MMX. */ |
void /* PRIVATE */ |
png_combine_row(png_structp png_ptr, png_bytep row, int mask) |
{ |
png_debug(1, "in png_combine_row (pnggccrd.c)\n"); |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
if (_mmx_supported == 2) { |
/* this should have happened in png_init_mmx_flags() already */ |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
png_mmx_support(); |
} |
#endif |
if (mask == 0xff) |
{ |
png_debug(2,"mask == 0xff: doing single png_memcpy()\n"); |
png_memcpy(row, png_ptr->row_buf + 1, |
(png_size_t)((png_ptr->width * png_ptr->row_info.pixel_depth + 7) >> 3)); |
} |
else /* (png_combine_row() is never called with mask == 0) */ |
{ |
switch (png_ptr->row_info.pixel_depth) |
{ |
case 1: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep sp; |
png_bytep dp; |
int s_inc, s_start, s_end; |
int m; |
int shift; |
png_uint_32 i; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
else |
#endif |
{ |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
int value; |
value = (*sp >> shift) & 0x1; |
*dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 2: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep sp; |
png_bytep dp; |
int s_start, s_end, s_inc; |
int m; |
int shift; |
png_uint_32 i; |
int value; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
else |
#endif |
{ |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0x3; |
*dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 4: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep sp; |
png_bytep dp; |
int s_start, s_end, s_inc; |
int m; |
int shift; |
png_uint_32 i; |
int value; |
sp = png_ptr->row_buf + 1; |
dp = row; |
m = 0x80; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
else |
#endif |
{ |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
shift = s_start; |
for (i = 0; i < png_ptr->width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0xf; |
*dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 8: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_uint_32 len; |
int diff; |
int dummy_value_a; // fix 'forbidden register spilled' error |
int dummy_value_d; |
int dummy_value_c; |
int dummy_value_S; |
int dummy_value_D; |
_unmask = ~mask; // global variable for -fPIC version |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
len = png_ptr->width &~7; // reduce to multiple of 8 |
diff = (int) (png_ptr->width & 7); // amount lost |
__asm__ __volatile__ ( |
"movd _unmask, %%mm7 \n\t" // load bit pattern |
"psubb %%mm6, %%mm6 \n\t" // zero mm6 |
"punpcklbw %%mm7, %%mm7 \n\t" |
"punpcklwd %%mm7, %%mm7 \n\t" |
"punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks |
"movq _mask8_0, %%mm0 \n\t" |
"pand %%mm7, %%mm0 \n\t" // nonzero if keep byte |
"pcmpeqb %%mm6, %%mm0 \n\t" // zeros->1s, v versa |
// preload "movl len, %%ecx \n\t" // load length of line |
// preload "movl srcptr, %%esi \n\t" // load source |
// preload "movl dstptr, %%edi \n\t" // load dest |
"cmpl $0, %%ecx \n\t" // len == 0 ? |
"je mainloop8end \n\t" |
"mainloop8: \n\t" |
"movq (%%esi), %%mm4 \n\t" // *srcptr |
"pand %%mm0, %%mm4 \n\t" |
"movq %%mm0, %%mm6 \n\t" |
"pandn (%%edi), %%mm6 \n\t" // *dstptr |
"por %%mm6, %%mm4 \n\t" |
"movq %%mm4, (%%edi) \n\t" |
"addl $8, %%esi \n\t" // inc by 8 bytes processed |
"addl $8, %%edi \n\t" |
"subl $8, %%ecx \n\t" // dec by 8 pixels processed |
"ja mainloop8 \n\t" |
"mainloop8end: \n\t" |
// preload "movl diff, %%ecx \n\t" // (diff is in eax) |
"movl %%eax, %%ecx \n\t" |
"cmpl $0, %%ecx \n\t" |
"jz end8 \n\t" |
// preload "movl mask, %%edx \n\t" |
"sall $24, %%edx \n\t" // make low byte, high byte |
"secondloop8: \n\t" |
"sall %%edx \n\t" // move high bit to CF |
"jnc skip8 \n\t" // if CF = 0 |
"movb (%%esi), %%al \n\t" |
"movb %%al, (%%edi) \n\t" |
"skip8: \n\t" |
"incl %%esi \n\t" |
"incl %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz secondloop8 \n\t" |
"end8: \n\t" |
"EMMS \n\t" // DONE |
: "=a" (dummy_value_a), // output regs (dummy) |
"=d" (dummy_value_d), |
"=c" (dummy_value_c), |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "3" (srcptr), // esi // input regs |
"4" (dstptr), // edi |
"0" (diff), // eax |
// was (unmask) "b" RESERVED // ebx // Global Offset Table idx |
"2" (len), // ecx |
"1" (mask) // edx |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm4", "%mm6", "%mm7" // clobber list |
#endif |
); |
} |
else /* mmx _not supported - Use modified C routine */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
register png_uint_32 i; |
png_uint_32 initial_val = png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff /* *BPP1 */ ; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
} /* end of else (_mmx_supported) */ |
break; |
} /* end 8 bpp */ |
case 16: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_uint_32 len; |
int diff; |
int dummy_value_a; // fix 'forbidden register spilled' error |
int dummy_value_d; |
int dummy_value_c; |
int dummy_value_S; |
int dummy_value_D; |
_unmask = ~mask; // global variable for -fPIC version |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
len = png_ptr->width &~7; // reduce to multiple of 8 |
diff = (int) (png_ptr->width & 7); // amount lost // |
__asm__ __volatile__ ( |
"movd _unmask, %%mm7 \n\t" // load bit pattern |
"psubb %%mm6, %%mm6 \n\t" // zero mm6 |
"punpcklbw %%mm7, %%mm7 \n\t" |
"punpcklwd %%mm7, %%mm7 \n\t" |
"punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks |
"movq _mask16_0, %%mm0 \n\t" |
"movq _mask16_1, %%mm1 \n\t" |
"pand %%mm7, %%mm0 \n\t" |
"pand %%mm7, %%mm1 \n\t" |
"pcmpeqb %%mm6, %%mm0 \n\t" |
"pcmpeqb %%mm6, %%mm1 \n\t" |
// preload "movl len, %%ecx \n\t" // load length of line |
// preload "movl srcptr, %%esi \n\t" // load source |
// preload "movl dstptr, %%edi \n\t" // load dest |
"cmpl $0, %%ecx \n\t" |
"jz mainloop16end \n\t" |
"mainloop16: \n\t" |
"movq (%%esi), %%mm4 \n\t" |
"pand %%mm0, %%mm4 \n\t" |
"movq %%mm0, %%mm6 \n\t" |
"movq (%%edi), %%mm7 \n\t" |
"pandn %%mm7, %%mm6 \n\t" |
"por %%mm6, %%mm4 \n\t" |
"movq %%mm4, (%%edi) \n\t" |
"movq 8(%%esi), %%mm5 \n\t" |
"pand %%mm1, %%mm5 \n\t" |
"movq %%mm1, %%mm7 \n\t" |
"movq 8(%%edi), %%mm6 \n\t" |
"pandn %%mm6, %%mm7 \n\t" |
"por %%mm7, %%mm5 \n\t" |
"movq %%mm5, 8(%%edi) \n\t" |
"addl $16, %%esi \n\t" // inc by 16 bytes processed |
"addl $16, %%edi \n\t" |
"subl $8, %%ecx \n\t" // dec by 8 pixels processed |
"ja mainloop16 \n\t" |
"mainloop16end: \n\t" |
// preload "movl diff, %%ecx \n\t" // (diff is in eax) |
"movl %%eax, %%ecx \n\t" |
"cmpl $0, %%ecx \n\t" |
"jz end16 \n\t" |
// preload "movl mask, %%edx \n\t" |
"sall $24, %%edx \n\t" // make low byte, high byte |
"secondloop16: \n\t" |
"sall %%edx \n\t" // move high bit to CF |
"jnc skip16 \n\t" // if CF = 0 |
"movw (%%esi), %%ax \n\t" |
"movw %%ax, (%%edi) \n\t" |
"skip16: \n\t" |
"addl $2, %%esi \n\t" |
"addl $2, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz secondloop16 \n\t" |
"end16: \n\t" |
"EMMS \n\t" // DONE |
: "=a" (dummy_value_a), // output regs (dummy) |
"=c" (dummy_value_c), |
"=d" (dummy_value_d), |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (diff), // eax // input regs |
// was (unmask) " " RESERVED // ebx // Global Offset Table idx |
"1" (len), // ecx |
"2" (mask), // edx |
"3" (srcptr), // esi |
"4" (dstptr) // edi |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm4" // clobber list |
, "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
else /* mmx _not supported - Use modified C routine */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
register png_uint_32 i; |
png_uint_32 initial_val = BPP2 * png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = BPP2 * png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = BPP2 * png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = BPP2 * len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff*BPP2; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
} /* end of else (_mmx_supported) */ |
break; |
} /* end 16 bpp */ |
case 24: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_uint_32 len; |
int diff; |
int dummy_value_a; // fix 'forbidden register spilled' error |
int dummy_value_d; |
int dummy_value_c; |
int dummy_value_S; |
int dummy_value_D; |
_unmask = ~mask; // global variable for -fPIC version |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
len = png_ptr->width &~7; // reduce to multiple of 8 |
diff = (int) (png_ptr->width & 7); // amount lost // |
__asm__ __volatile__ ( |
"movd _unmask, %%mm7 \n\t" // load bit pattern |
"psubb %%mm6, %%mm6 \n\t" // zero mm6 |
"punpcklbw %%mm7, %%mm7 \n\t" |
"punpcklwd %%mm7, %%mm7 \n\t" |
"punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks |
"movq _mask24_0, %%mm0 \n\t" |
"movq _mask24_1, %%mm1 \n\t" |
"movq _mask24_2, %%mm2 \n\t" |
"pand %%mm7, %%mm0 \n\t" |
"pand %%mm7, %%mm1 \n\t" |
"pand %%mm7, %%mm2 \n\t" |
"pcmpeqb %%mm6, %%mm0 \n\t" |
"pcmpeqb %%mm6, %%mm1 \n\t" |
"pcmpeqb %%mm6, %%mm2 \n\t" |
// preload "movl len, %%ecx \n\t" // load length of line |
// preload "movl srcptr, %%esi \n\t" // load source |
// preload "movl dstptr, %%edi \n\t" // load dest |
"cmpl $0, %%ecx \n\t" |
"jz mainloop24end \n\t" |
"mainloop24: \n\t" |
"movq (%%esi), %%mm4 \n\t" |
"pand %%mm0, %%mm4 \n\t" |
"movq %%mm0, %%mm6 \n\t" |
"movq (%%edi), %%mm7 \n\t" |
"pandn %%mm7, %%mm6 \n\t" |
"por %%mm6, %%mm4 \n\t" |
"movq %%mm4, (%%edi) \n\t" |
"movq 8(%%esi), %%mm5 \n\t" |
"pand %%mm1, %%mm5 \n\t" |
"movq %%mm1, %%mm7 \n\t" |
"movq 8(%%edi), %%mm6 \n\t" |
"pandn %%mm6, %%mm7 \n\t" |
"por %%mm7, %%mm5 \n\t" |
"movq %%mm5, 8(%%edi) \n\t" |
"movq 16(%%esi), %%mm6 \n\t" |
"pand %%mm2, %%mm6 \n\t" |
"movq %%mm2, %%mm4 \n\t" |
"movq 16(%%edi), %%mm7 \n\t" |
"pandn %%mm7, %%mm4 \n\t" |
"por %%mm4, %%mm6 \n\t" |
"movq %%mm6, 16(%%edi) \n\t" |
"addl $24, %%esi \n\t" // inc by 24 bytes processed |
"addl $24, %%edi \n\t" |
"subl $8, %%ecx \n\t" // dec by 8 pixels processed |
"ja mainloop24 \n\t" |
"mainloop24end: \n\t" |
// preload "movl diff, %%ecx \n\t" // (diff is in eax) |
"movl %%eax, %%ecx \n\t" |
"cmpl $0, %%ecx \n\t" |
"jz end24 \n\t" |
// preload "movl mask, %%edx \n\t" |
"sall $24, %%edx \n\t" // make low byte, high byte |
"secondloop24: \n\t" |
"sall %%edx \n\t" // move high bit to CF |
"jnc skip24 \n\t" // if CF = 0 |
"movw (%%esi), %%ax \n\t" |
"movw %%ax, (%%edi) \n\t" |
"xorl %%eax, %%eax \n\t" |
"movb 2(%%esi), %%al \n\t" |
"movb %%al, 2(%%edi) \n\t" |
"skip24: \n\t" |
"addl $3, %%esi \n\t" |
"addl $3, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz secondloop24 \n\t" |
"end24: \n\t" |
"EMMS \n\t" // DONE |
: "=a" (dummy_value_a), // output regs (dummy) |
"=d" (dummy_value_d), |
"=c" (dummy_value_c), |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "3" (srcptr), // esi // input regs |
"4" (dstptr), // edi |
"0" (diff), // eax |
// was (unmask) "b" RESERVED // ebx // Global Offset Table idx |
"2" (len), // ecx |
"1" (mask) // edx |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2" // clobber list |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
else /* mmx _not supported - Use modified C routine */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
register png_uint_32 i; |
png_uint_32 initial_val = BPP3 * png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = BPP3 * png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = BPP3 * png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = BPP3 * len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff*BPP3; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
} /* end of else (_mmx_supported) */ |
break; |
} /* end 24 bpp */ |
case 32: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_uint_32 len; |
int diff; |
int dummy_value_a; // fix 'forbidden register spilled' error |
int dummy_value_d; |
int dummy_value_c; |
int dummy_value_S; |
int dummy_value_D; |
_unmask = ~mask; // global variable for -fPIC version |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
len = png_ptr->width &~7; // reduce to multiple of 8 |
diff = (int) (png_ptr->width & 7); // amount lost // |
__asm__ __volatile__ ( |
"movd _unmask, %%mm7 \n\t" // load bit pattern |
"psubb %%mm6, %%mm6 \n\t" // zero mm6 |
"punpcklbw %%mm7, %%mm7 \n\t" |
"punpcklwd %%mm7, %%mm7 \n\t" |
"punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks |
"movq _mask32_0, %%mm0 \n\t" |
"movq _mask32_1, %%mm1 \n\t" |
"movq _mask32_2, %%mm2 \n\t" |
"movq _mask32_3, %%mm3 \n\t" |
"pand %%mm7, %%mm0 \n\t" |
"pand %%mm7, %%mm1 \n\t" |
"pand %%mm7, %%mm2 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pcmpeqb %%mm6, %%mm0 \n\t" |
"pcmpeqb %%mm6, %%mm1 \n\t" |
"pcmpeqb %%mm6, %%mm2 \n\t" |
"pcmpeqb %%mm6, %%mm3 \n\t" |
// preload "movl len, %%ecx \n\t" // load length of line |
// preload "movl srcptr, %%esi \n\t" // load source |
// preload "movl dstptr, %%edi \n\t" // load dest |
"cmpl $0, %%ecx \n\t" // lcr |
"jz mainloop32end \n\t" |
"mainloop32: \n\t" |
"movq (%%esi), %%mm4 \n\t" |
"pand %%mm0, %%mm4 \n\t" |
"movq %%mm0, %%mm6 \n\t" |
"movq (%%edi), %%mm7 \n\t" |
"pandn %%mm7, %%mm6 \n\t" |
"por %%mm6, %%mm4 \n\t" |
"movq %%mm4, (%%edi) \n\t" |
"movq 8(%%esi), %%mm5 \n\t" |
"pand %%mm1, %%mm5 \n\t" |
"movq %%mm1, %%mm7 \n\t" |
"movq 8(%%edi), %%mm6 \n\t" |
"pandn %%mm6, %%mm7 \n\t" |
"por %%mm7, %%mm5 \n\t" |
"movq %%mm5, 8(%%edi) \n\t" |
"movq 16(%%esi), %%mm6 \n\t" |
"pand %%mm2, %%mm6 \n\t" |
"movq %%mm2, %%mm4 \n\t" |
"movq 16(%%edi), %%mm7 \n\t" |
"pandn %%mm7, %%mm4 \n\t" |
"por %%mm4, %%mm6 \n\t" |
"movq %%mm6, 16(%%edi) \n\t" |
"movq 24(%%esi), %%mm7 \n\t" |
"pand %%mm3, %%mm7 \n\t" |
"movq %%mm3, %%mm5 \n\t" |
"movq 24(%%edi), %%mm4 \n\t" |
"pandn %%mm4, %%mm5 \n\t" |
"por %%mm5, %%mm7 \n\t" |
"movq %%mm7, 24(%%edi) \n\t" |
"addl $32, %%esi \n\t" // inc by 32 bytes processed |
"addl $32, %%edi \n\t" |
"subl $8, %%ecx \n\t" // dec by 8 pixels processed |
"ja mainloop32 \n\t" |
"mainloop32end: \n\t" |
// preload "movl diff, %%ecx \n\t" // (diff is in eax) |
"movl %%eax, %%ecx \n\t" |
"cmpl $0, %%ecx \n\t" |
"jz end32 \n\t" |
// preload "movl mask, %%edx \n\t" |
"sall $24, %%edx \n\t" // low byte => high byte |
"secondloop32: \n\t" |
"sall %%edx \n\t" // move high bit to CF |
"jnc skip32 \n\t" // if CF = 0 |
"movl (%%esi), %%eax \n\t" |
"movl %%eax, (%%edi) \n\t" |
"skip32: \n\t" |
"addl $4, %%esi \n\t" |
"addl $4, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz secondloop32 \n\t" |
"end32: \n\t" |
"EMMS \n\t" // DONE |
: "=a" (dummy_value_a), // output regs (dummy) |
"=d" (dummy_value_d), |
"=c" (dummy_value_c), |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "3" (srcptr), // esi // input regs |
"4" (dstptr), // edi |
"0" (diff), // eax |
// was (unmask) "b" RESERVED // ebx // Global Offset Table idx |
"2" (len), // ecx |
"1" (mask) // edx |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2", "%mm3" // clobber list |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
else /* mmx _not supported - Use modified C routine */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
register png_uint_32 i; |
png_uint_32 initial_val = BPP4 * png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = BPP4 * png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = BPP4 * png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = BPP4 * len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff*BPP4; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
} /* end of else (_mmx_supported) */ |
break; |
} /* end 32 bpp */ |
case 48: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_uint_32 len; |
int diff; |
int dummy_value_a; // fix 'forbidden register spilled' error |
int dummy_value_d; |
int dummy_value_c; |
int dummy_value_S; |
int dummy_value_D; |
_unmask = ~mask; // global variable for -fPIC version |
srcptr = png_ptr->row_buf + 1; |
dstptr = row; |
len = png_ptr->width &~7; // reduce to multiple of 8 |
diff = (int) (png_ptr->width & 7); // amount lost // |
__asm__ __volatile__ ( |
"movd _unmask, %%mm7 \n\t" // load bit pattern |
"psubb %%mm6, %%mm6 \n\t" // zero mm6 |
"punpcklbw %%mm7, %%mm7 \n\t" |
"punpcklwd %%mm7, %%mm7 \n\t" |
"punpckldq %%mm7, %%mm7 \n\t" // fill reg with 8 masks |
"movq _mask48_0, %%mm0 \n\t" |
"movq _mask48_1, %%mm1 \n\t" |
"movq _mask48_2, %%mm2 \n\t" |
"movq _mask48_3, %%mm3 \n\t" |
"movq _mask48_4, %%mm4 \n\t" |
"movq _mask48_5, %%mm5 \n\t" |
"pand %%mm7, %%mm0 \n\t" |
"pand %%mm7, %%mm1 \n\t" |
"pand %%mm7, %%mm2 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pand %%mm7, %%mm4 \n\t" |
"pand %%mm7, %%mm5 \n\t" |
"pcmpeqb %%mm6, %%mm0 \n\t" |
"pcmpeqb %%mm6, %%mm1 \n\t" |
"pcmpeqb %%mm6, %%mm2 \n\t" |
"pcmpeqb %%mm6, %%mm3 \n\t" |
"pcmpeqb %%mm6, %%mm4 \n\t" |
"pcmpeqb %%mm6, %%mm5 \n\t" |
// preload "movl len, %%ecx \n\t" // load length of line |
// preload "movl srcptr, %%esi \n\t" // load source |
// preload "movl dstptr, %%edi \n\t" // load dest |
"cmpl $0, %%ecx \n\t" |
"jz mainloop48end \n\t" |
"mainloop48: \n\t" |
"movq (%%esi), %%mm7 \n\t" |
"pand %%mm0, %%mm7 \n\t" |
"movq %%mm0, %%mm6 \n\t" |
"pandn (%%edi), %%mm6 \n\t" |
"por %%mm6, %%mm7 \n\t" |
"movq %%mm7, (%%edi) \n\t" |
"movq 8(%%esi), %%mm6 \n\t" |
"pand %%mm1, %%mm6 \n\t" |
"movq %%mm1, %%mm7 \n\t" |
"pandn 8(%%edi), %%mm7 \n\t" |
"por %%mm7, %%mm6 \n\t" |
"movq %%mm6, 8(%%edi) \n\t" |
"movq 16(%%esi), %%mm6 \n\t" |
"pand %%mm2, %%mm6 \n\t" |
"movq %%mm2, %%mm7 \n\t" |
"pandn 16(%%edi), %%mm7 \n\t" |
"por %%mm7, %%mm6 \n\t" |
"movq %%mm6, 16(%%edi) \n\t" |
"movq 24(%%esi), %%mm7 \n\t" |
"pand %%mm3, %%mm7 \n\t" |
"movq %%mm3, %%mm6 \n\t" |
"pandn 24(%%edi), %%mm6 \n\t" |
"por %%mm6, %%mm7 \n\t" |
"movq %%mm7, 24(%%edi) \n\t" |
"movq 32(%%esi), %%mm6 \n\t" |
"pand %%mm4, %%mm6 \n\t" |
"movq %%mm4, %%mm7 \n\t" |
"pandn 32(%%edi), %%mm7 \n\t" |
"por %%mm7, %%mm6 \n\t" |
"movq %%mm6, 32(%%edi) \n\t" |
"movq 40(%%esi), %%mm7 \n\t" |
"pand %%mm5, %%mm7 \n\t" |
"movq %%mm5, %%mm6 \n\t" |
"pandn 40(%%edi), %%mm6 \n\t" |
"por %%mm6, %%mm7 \n\t" |
"movq %%mm7, 40(%%edi) \n\t" |
"addl $48, %%esi \n\t" // inc by 48 bytes processed |
"addl $48, %%edi \n\t" |
"subl $8, %%ecx \n\t" // dec by 8 pixels processed |
"ja mainloop48 \n\t" |
"mainloop48end: \n\t" |
// preload "movl diff, %%ecx \n\t" // (diff is in eax) |
"movl %%eax, %%ecx \n\t" |
"cmpl $0, %%ecx \n\t" |
"jz end48 \n\t" |
// preload "movl mask, %%edx \n\t" |
"sall $24, %%edx \n\t" // make low byte, high byte |
"secondloop48: \n\t" |
"sall %%edx \n\t" // move high bit to CF |
"jnc skip48 \n\t" // if CF = 0 |
"movl (%%esi), %%eax \n\t" |
"movl %%eax, (%%edi) \n\t" |
"skip48: \n\t" |
"addl $4, %%esi \n\t" |
"addl $4, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz secondloop48 \n\t" |
"end48: \n\t" |
"EMMS \n\t" // DONE |
: "=a" (dummy_value_a), // output regs (dummy) |
"=d" (dummy_value_d), |
"=c" (dummy_value_c), |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "3" (srcptr), // esi // input regs |
"4" (dstptr), // edi |
"0" (diff), // eax |
// was (unmask) "b" RESERVED // ebx // Global Offset Table idx |
"2" (len), // ecx |
"1" (mask) // edx |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2", "%mm3" // clobber list |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
else /* mmx _not supported - Use modified C routine */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
register png_uint_32 i; |
png_uint_32 initial_val = BPP6 * png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = BPP6 * png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = BPP6 * png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = BPP6 * len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff*BPP6; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
} /* end of else (_mmx_supported) */ |
break; |
} /* end 48 bpp */ |
case 64: /* png_ptr->row_info.pixel_depth */ |
{ |
png_bytep srcptr; |
png_bytep dstptr; |
register png_uint_32 i; |
png_uint_32 initial_val = BPP8 * png_pass_start[png_ptr->pass]; |
/* png.c: png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; */ |
register int stride = BPP8 * png_pass_inc[png_ptr->pass]; |
/* png.c: png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; */ |
register int rep_bytes = BPP8 * png_pass_width[png_ptr->pass]; |
/* png.c: png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; */ |
png_uint_32 len = png_ptr->width &~7; /* reduce to mult. of 8 */ |
int diff = (int) (png_ptr->width & 7); /* amount lost */ |
register png_uint_32 final_val = BPP8 * len; /* GRR bugfix */ |
srcptr = png_ptr->row_buf + 1 + initial_val; |
dstptr = row + initial_val; |
for (i = initial_val; i < final_val; i += stride) |
{ |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
if (diff) /* number of leftover pixels: 3 for pngtest */ |
{ |
final_val+=diff*BPP8; |
for (; i < final_val; i += stride) |
{ |
if (rep_bytes > (int)(final_val-i)) |
rep_bytes = (int)(final_val-i); |
png_memcpy(dstptr, srcptr, rep_bytes); |
srcptr += stride; |
dstptr += stride; |
} |
} |
break; |
} /* end 64 bpp */ |
default: /* png_ptr->row_info.pixel_depth != 1,2,4,8,16,24,32,48,64 */ |
{ |
/* this should never happen */ |
png_warning(png_ptr, "Invalid row_info.pixel_depth in pnggccrd"); |
break; |
} |
} /* end switch (png_ptr->row_info.pixel_depth) */ |
} /* end if (non-trivial mask) */ |
} /* end png_combine_row() */ |
#endif /* PNG_HAVE_ASSEMBLER_COMBINE_ROW */ |
/*===========================================================================*/ |
/* */ |
/* P N G _ D O _ R E A D _ I N T E R L A C E */ |
/* */ |
/*===========================================================================*/ |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
#if defined(PNG_HAVE_ASSEMBLER_READ_INTERLACE) |
/* png_do_read_interlace() is called after any 16-bit to 8-bit conversion |
* has taken place. [GRR: what other steps come before and/or after?] |
*/ |
void /* PRIVATE */ |
png_do_read_interlace(png_structp png_ptr) |
{ |
png_row_infop row_info = &(png_ptr->row_info); |
png_bytep row = png_ptr->row_buf + 1; |
int pass = png_ptr->pass; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
png_uint_32 transformations = png_ptr->transformations; |
#endif |
png_debug(1, "in png_do_read_interlace (pnggccrd.c)\n"); |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
if (_mmx_supported == 2) { |
#if !defined(PNG_1_0_X) |
/* this should have happened in png_init_mmx_flags() already */ |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
#endif |
png_mmx_support(); |
} |
#endif |
if (row != NULL && row_info != NULL) |
{ |
png_uint_32 final_width; |
final_width = row_info->width * png_pass_inc[pass]; |
switch (row_info->pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_byte v; |
png_uint_32 i; |
int j; |
sp = row + (png_size_t)((row_info->width - 1) >> 3); |
dp = row + (png_size_t)((final_width - 1) >> 3); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (int)((row_info->width + 7) & 7); |
dshift = (int)((final_width + 7) & 7); |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
else |
#endif |
{ |
sshift = 7 - (int)((row_info->width + 7) & 7); |
dshift = 7 - (int)((final_width + 7) & 7); |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
for (i = row_info->width; i; i--) |
{ |
v = (png_byte)((*sp >> sshift) & 0x1); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_uint_32 i; |
sp = row + (png_size_t)((row_info->width - 1) >> 2); |
dp = row + (png_size_t)((final_width - 1) >> 2); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (png_size_t)(((row_info->width + 3) & 3) << 1); |
dshift = (png_size_t)(((final_width + 3) & 3) << 1); |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
else |
#endif |
{ |
sshift = (png_size_t)((3 - ((row_info->width + 3) & 3)) << 1); |
dshift = (png_size_t)((3 - ((final_width + 3) & 3)) << 1); |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
for (i = row_info->width; i; i--) |
{ |
png_byte v; |
int j; |
v = (png_byte)((*sp >> sshift) & 0x3); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp, dp; |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_uint_32 i; |
sp = row + (png_size_t)((row_info->width - 1) >> 1); |
dp = row + (png_size_t)((final_width - 1) >> 1); |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (png_size_t)(((row_info->width + 1) & 1) << 2); |
dshift = (png_size_t)(((final_width + 1) & 1) << 2); |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
else |
#endif |
{ |
sshift = (png_size_t)((1 - ((row_info->width + 1) & 1)) << 2); |
dshift = (png_size_t)((1 - ((final_width + 1) & 1)) << 2); |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
for (i = row_info->width; i; i--) |
{ |
png_byte v; |
int j; |
v = (png_byte)((*sp >> sshift) & 0xf); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
/*====================================================================*/ |
default: /* 8-bit or larger (this is where the routine is modified) */ |
{ |
#if 0 |
// static unsigned long long _const4 = 0x0000000000FFFFFFLL; no good |
// static unsigned long long const4 = 0x0000000000FFFFFFLL; no good |
// unsigned long long _const4 = 0x0000000000FFFFFFLL; no good |
// unsigned long long const4 = 0x0000000000FFFFFFLL; no good |
#endif |
png_bytep sptr, dp; |
png_uint_32 i; |
png_size_t pixel_bytes; |
int width = (int)row_info->width; |
pixel_bytes = (row_info->pixel_depth >> 3); |
/* point sptr at the last pixel in the pre-expanded row: */ |
sptr = row + (width - 1) * pixel_bytes; |
/* point dp at the last pixel position in the expanded row: */ |
dp = row + (final_width - 1) * pixel_bytes; |
/* New code by Nirav Chhatrapati - Intel Corporation */ |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE) |
/* && _mmx_supported */ ) |
#else |
if (_mmx_supported) |
#endif |
{ |
//-------------------------------------------------------------- |
if (pixel_bytes == 3) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $21, %%edi \n\t" |
// (png_pass_inc[pass] - 1)*pixel_bytes |
".loop3_pass0: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x x 2 1 0 |
"pand _const4, %%mm0 \n\t" // z z z z z 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // z z z z z 2 1 0 |
"psllq $16, %%mm0 \n\t" // z z z 2 1 0 z z |
"movq %%mm0, %%mm2 \n\t" // z z z 2 1 0 z z |
"psllq $24, %%mm0 \n\t" // 2 1 0 z z z z z |
"psrlq $8, %%mm1 \n\t" // z z z z z z 2 1 |
"por %%mm2, %%mm0 \n\t" // 2 1 0 2 1 0 z z |
"por %%mm1, %%mm0 \n\t" // 2 1 0 2 1 0 2 1 |
"movq %%mm0, %%mm3 \n\t" // 2 1 0 2 1 0 2 1 |
"psllq $16, %%mm0 \n\t" // 0 2 1 0 2 1 z z |
"movq %%mm3, %%mm4 \n\t" // 2 1 0 2 1 0 2 1 |
"punpckhdq %%mm0, %%mm3 \n\t" // 0 2 1 0 2 1 0 2 |
"movq %%mm4, 16(%%edi) \n\t" |
"psrlq $32, %%mm0 \n\t" // z z z z 0 2 1 0 |
"movq %%mm3, 8(%%edi) \n\t" |
"punpckldq %%mm4, %%mm0 \n\t" // 1 0 2 1 0 2 1 0 |
"subl $3, %%esi \n\t" |
"movq %%mm0, (%%edi) \n\t" |
"subl $24, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz .loop3_pass0 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width) // ecx |
// doesn't work "i" (0x0000000000FFFFFFLL) // %1 (a.k.a. _const4) |
#if 0 /* %mm0, ..., %mm4 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2" // clobber list |
, "%mm3", "%mm4" |
#endif |
); |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $9, %%edi \n\t" |
// (png_pass_inc[pass] - 1)*pixel_bytes |
".loop3_pass2: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x x 2 1 0 |
"pand _const4, %%mm0 \n\t" // z z z z z 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // z z z z z 2 1 0 |
"psllq $16, %%mm0 \n\t" // z z z 2 1 0 z z |
"movq %%mm0, %%mm2 \n\t" // z z z 2 1 0 z z |
"psllq $24, %%mm0 \n\t" // 2 1 0 z z z z z |
"psrlq $8, %%mm1 \n\t" // z z z z z z 2 1 |
"por %%mm2, %%mm0 \n\t" // 2 1 0 2 1 0 z z |
"por %%mm1, %%mm0 \n\t" // 2 1 0 2 1 0 2 1 |
"movq %%mm0, 4(%%edi) \n\t" |
"psrlq $16, %%mm0 \n\t" // z z 2 1 0 2 1 0 |
"subl $3, %%esi \n\t" |
"movd %%mm0, (%%edi) \n\t" |
"subl $12, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz .loop3_pass2 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width) // ecx |
#if 0 /* %mm0, ..., %mm2 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2" // clobber list |
#endif |
); |
} |
else if (width) /* && ((pass == 4) || (pass == 5)) */ |
{ |
int width_mmx = ((width >> 1) << 1) - 8; // GRR: huh? |
if (width_mmx < 0) |
width_mmx = 0; |
width -= width_mmx; // 8 or 9 pix, 24 or 27 bytes |
if (width_mmx) |
{ |
// png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; |
// sptr points at last pixel in pre-expanded row |
// dp points at last pixel position in expanded row |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $3, %%esi \n\t" |
"subl $9, %%edi \n\t" |
// (png_pass_inc[pass] + 1)*pixel_bytes |
".loop3_pass4: \n\t" |
"movq (%%esi), %%mm0 \n\t" // x x 5 4 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // x x 5 4 3 2 1 0 |
"movq %%mm0, %%mm2 \n\t" // x x 5 4 3 2 1 0 |
"psllq $24, %%mm0 \n\t" // 4 3 2 1 0 z z z |
"pand _const4, %%mm1 \n\t" // z z z z z 2 1 0 |
"psrlq $24, %%mm2 \n\t" // z z z x x 5 4 3 |
"por %%mm1, %%mm0 \n\t" // 4 3 2 1 0 2 1 0 |
"movq %%mm2, %%mm3 \n\t" // z z z x x 5 4 3 |
"psllq $8, %%mm2 \n\t" // z z x x 5 4 3 z |
"movq %%mm0, (%%edi) \n\t" |
"psrlq $16, %%mm3 \n\t" // z z z z z x x 5 |
"pand _const6, %%mm3 \n\t" // z z z z z z z 5 |
"por %%mm3, %%mm2 \n\t" // z z x x 5 4 3 5 |
"subl $6, %%esi \n\t" |
"movd %%mm2, 8(%%edi) \n\t" |
"subl $12, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop3_pass4 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, ..., %mm3 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
, "%mm2", "%mm3" |
#endif |
); |
} |
sptr -= width_mmx*3; |
dp -= width_mmx*6; |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 3); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 3); |
dp -= 3; |
} |
sptr -= 3; |
} |
} |
} /* end of pixel_bytes == 3 */ |
//-------------------------------------------------------------- |
else if (pixel_bytes == 1) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 2) << 2); |
width -= width_mmx; // 0-3 pixels => 0-3 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $3, %%esi \n\t" |
"subl $31, %%edi \n\t" |
".loop1_pass0: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // x x x x 3 2 1 0 |
"punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 |
"movq %%mm0, %%mm2 \n\t" // 3 3 2 2 1 1 0 0 |
"punpcklwd %%mm0, %%mm0 \n\t" // 1 1 1 1 0 0 0 0 |
"movq %%mm0, %%mm3 \n\t" // 1 1 1 1 0 0 0 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 0 0 0 0 0 0 0 0 |
"punpckhdq %%mm3, %%mm3 \n\t" // 1 1 1 1 1 1 1 1 |
"movq %%mm0, (%%edi) \n\t" |
"punpckhwd %%mm2, %%mm2 \n\t" // 3 3 3 3 2 2 2 2 |
"movq %%mm3, 8(%%edi) \n\t" |
"movq %%mm2, %%mm4 \n\t" // 3 3 3 3 2 2 2 2 |
"punpckldq %%mm2, %%mm2 \n\t" // 2 2 2 2 2 2 2 2 |
"punpckhdq %%mm4, %%mm4 \n\t" // 3 3 3 3 3 3 3 3 |
"movq %%mm2, 16(%%edi) \n\t" |
"subl $4, %%esi \n\t" |
"movq %%mm4, 24(%%edi) \n\t" |
"subl $32, %%edi \n\t" |
"subl $4, %%ecx \n\t" |
"jnz .loop1_pass0 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, ..., %mm4 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1", "%mm2" // clobber list |
, "%mm3", "%mm4" |
#endif |
); |
} |
sptr -= width_mmx; |
dp -= width_mmx*8; |
for (i = width; i; i--) |
{ |
int j; |
/* I simplified this part in version 1.0.4e |
* here and in several other instances where |
* pixel_bytes == 1 -- GR-P |
* |
* Original code: |
* |
* png_byte v[8]; |
* png_memcpy(v, sptr, pixel_bytes); |
* for (j = 0; j < png_pass_inc[pass]; j++) |
* { |
* png_memcpy(dp, v, pixel_bytes); |
* dp -= pixel_bytes; |
* } |
* sptr -= pixel_bytes; |
* |
* Replacement code is in the next three lines: |
*/ |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
--sptr; |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 2) << 2); |
width -= width_mmx; // 0-3 pixels => 0-3 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $3, %%esi \n\t" |
"subl $15, %%edi \n\t" |
".loop1_pass2: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 |
"punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 |
"movq %%mm0, %%mm1 \n\t" // 3 3 2 2 1 1 0 0 |
"punpcklwd %%mm0, %%mm0 \n\t" // 1 1 1 1 0 0 0 0 |
"punpckhwd %%mm1, %%mm1 \n\t" // 3 3 3 3 2 2 2 2 |
"movq %%mm0, (%%edi) \n\t" |
"subl $4, %%esi \n\t" |
"movq %%mm1, 8(%%edi) \n\t" |
"subl $16, %%edi \n\t" |
"subl $4, %%ecx \n\t" |
"jnz .loop1_pass2 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= width_mmx; |
dp -= width_mmx*4; |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
--sptr; |
} |
} |
else if (width) /* && ((pass == 4) || (pass == 5)) */ |
{ |
int width_mmx = ((width >> 3) << 3); |
width -= width_mmx; // 0-3 pixels => 0-3 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $7, %%esi \n\t" |
"subl $15, %%edi \n\t" |
".loop1_pass4: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 |
"punpcklbw %%mm0, %%mm0 \n\t" // 3 3 2 2 1 1 0 0 |
"punpckhbw %%mm1, %%mm1 \n\t" // 7 7 6 6 5 5 4 4 |
"movq %%mm1, 8(%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm0, (%%edi) \n\t" |
"subl $16, %%edi \n\t" |
"subl $8, %%ecx \n\t" |
"jnz .loop1_pass4 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (none) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= width_mmx; |
dp -= width_mmx*2; |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
--sptr; |
} |
} |
} /* end of pixel_bytes == 1 */ |
//-------------------------------------------------------------- |
else if (pixel_bytes == 2) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 1) << 1); |
width -= width_mmx; // 0,1 pixels => 0,2 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $2, %%esi \n\t" |
"subl $30, %%edi \n\t" |
".loop2_pass0: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 |
"punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 |
"movq %%mm0, %%mm1 \n\t" // 3 2 3 2 1 0 1 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 1 0 1 0 1 0 1 0 |
"punpckhdq %%mm1, %%mm1 \n\t" // 3 2 3 2 3 2 3 2 |
"movq %%mm0, (%%edi) \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"movq %%mm1, 16(%%edi) \n\t" |
"subl $4, %%esi \n\t" |
"movq %%mm1, 24(%%edi) \n\t" |
"subl $32, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop2_pass0 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*16 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; // 0,1 pixels => 0,2 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $2, %%esi \n\t" |
"subl $14, %%edi \n\t" |
".loop2_pass2: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 |
"punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 |
"movq %%mm0, %%mm1 \n\t" // 3 2 3 2 1 0 1 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 1 0 1 0 1 0 1 0 |
"punpckhdq %%mm1, %%mm1 \n\t" // 3 2 3 2 3 2 3 2 |
"movq %%mm0, (%%edi) \n\t" |
"subl $4, %%esi \n\t" |
"movq %%mm1, 8(%%edi) \n\t" |
"subl $16, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop2_pass2 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*8 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
else if (width) // pass == 4 or 5 |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; // 0,1 pixels => 0,2 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $2, %%esi \n\t" |
"subl $6, %%edi \n\t" |
".loop2_pass4: \n\t" |
"movd (%%esi), %%mm0 \n\t" // x x x x 3 2 1 0 |
"punpcklwd %%mm0, %%mm0 \n\t" // 3 2 3 2 1 0 1 0 |
"subl $4, %%esi \n\t" |
"movq %%mm0, (%%edi) \n\t" |
"subl $8, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop2_pass4 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*2 - 2); // sign fixed |
dp -= (width_mmx*4 - 2); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 2; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 2; |
png_memcpy(dp, v, 2); |
} |
} |
} |
} /* end of pixel_bytes == 2 */ |
//-------------------------------------------------------------- |
else if (pixel_bytes == 4) |
{ |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int width_mmx = ((width >> 1) << 1); |
width -= width_mmx; // 0,1 pixels => 0,4 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $4, %%esi \n\t" |
"subl $60, %%edi \n\t" |
".loop4_pass0: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 |
"punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 |
"movq %%mm0, (%%edi) \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"movq %%mm0, 16(%%edi) \n\t" |
"movq %%mm0, 24(%%edi) \n\t" |
"movq %%mm1, 32(%%edi) \n\t" |
"movq %%mm1, 40(%%edi) \n\t" |
"movq %%mm1, 48(%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm1, 56(%%edi) \n\t" |
"subl $64, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop4_pass0 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*32 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
int width_mmx = ((width >> 1) << 1); |
width -= width_mmx; // 0,1 pixels => 0,4 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $4, %%esi \n\t" |
"subl $28, %%edi \n\t" |
".loop4_pass2: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 |
"punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 |
"movq %%mm0, (%%edi) \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"movq %%mm1, 16(%%edi) \n\t" |
"movq %%mm1, 24(%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"subl $32, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop4_pass2 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*16 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
else if (width) // pass == 4 or 5 |
{ |
int width_mmx = ((width >> 1) << 1) ; |
width -= width_mmx; // 0,1 pixels => 0,4 bytes |
if (width_mmx) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $4, %%esi \n\t" |
"subl $12, %%edi \n\t" |
".loop4_pass4: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, %%mm1 \n\t" // 7 6 5 4 3 2 1 0 |
"punpckldq %%mm0, %%mm0 \n\t" // 3 2 1 0 3 2 1 0 |
"punpckhdq %%mm1, %%mm1 \n\t" // 7 6 5 4 7 6 5 4 |
"movq %%mm0, (%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm1, 8(%%edi) \n\t" |
"subl $16, %%edi \n\t" |
"subl $2, %%ecx \n\t" |
"jnz .loop4_pass4 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width_mmx) // ecx |
#if 0 /* %mm0, %mm1 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0", "%mm1" // clobber list |
#endif |
); |
} |
sptr -= (width_mmx*4 - 4); // sign fixed |
dp -= (width_mmx*8 - 4); // sign fixed |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
sptr -= 4; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
dp -= 4; |
png_memcpy(dp, v, 4); |
} |
} |
} |
} /* end of pixel_bytes == 4 */ |
//-------------------------------------------------------------- |
else if (pixel_bytes == 8) |
{ |
// GRR TEST: should work, but needs testing (special 64-bit version of rpng2?) |
// GRR NOTE: no need to combine passes here! |
if (((pass == 0) || (pass == 1)) && width) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
// source is 8-byte RRGGBBAA |
// dest is 64-byte RRGGBBAA RRGGBBAA RRGGBBAA RRGGBBAA ... |
__asm__ __volatile__ ( |
"subl $56, %%edi \n\t" // start of last block |
".loop8_pass0: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, (%%edi) \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"movq %%mm0, 16(%%edi) \n\t" |
"movq %%mm0, 24(%%edi) \n\t" |
"movq %%mm0, 32(%%edi) \n\t" |
"movq %%mm0, 40(%%edi) \n\t" |
"movq %%mm0, 48(%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm0, 56(%%edi) \n\t" |
"subl $64, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz .loop8_pass0 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width) // ecx |
#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0" // clobber list |
#endif |
); |
} |
else if (((pass == 2) || (pass == 3)) && width) |
{ |
// source is 8-byte RRGGBBAA |
// dest is 32-byte RRGGBBAA RRGGBBAA RRGGBBAA RRGGBBAA |
// (recall that expansion is _in place_: sptr and dp |
// both point at locations within same row buffer) |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $24, %%edi \n\t" // start of last block |
".loop8_pass2: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, (%%edi) \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"movq %%mm0, 16(%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm0, 24(%%edi) \n\t" |
"subl $32, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz .loop8_pass2 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width) // ecx |
#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0" // clobber list |
#endif |
); |
} |
} |
else if (width) // pass == 4 or 5 |
{ |
// source is 8-byte RRGGBBAA |
// dest is 16-byte RRGGBBAA RRGGBBAA |
{ |
int dummy_value_c; // fix 'forbidden register spilled' |
int dummy_value_S; |
int dummy_value_D; |
__asm__ __volatile__ ( |
"subl $8, %%edi \n\t" // start of last block |
".loop8_pass4: \n\t" |
"movq (%%esi), %%mm0 \n\t" // 7 6 5 4 3 2 1 0 |
"movq %%mm0, (%%edi) \n\t" |
"subl $8, %%esi \n\t" |
"movq %%mm0, 8(%%edi) \n\t" |
"subl $16, %%edi \n\t" |
"decl %%ecx \n\t" |
"jnz .loop8_pass4 \n\t" |
"EMMS \n\t" // DONE |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "1" (sptr), // esi // input regs |
"2" (dp), // edi |
"0" (width) // ecx |
#if 0 /* %mm0 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
: "%mm0" // clobber list |
#endif |
); |
} |
} |
} /* end of pixel_bytes == 8 */ |
//-------------------------------------------------------------- |
else if (pixel_bytes == 6) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 6); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 6); |
dp -= 6; |
} |
sptr -= 6; |
} |
} /* end of pixel_bytes == 6 */ |
//-------------------------------------------------------------- |
else |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr-= pixel_bytes; |
} |
} |
} // end of _mmx_supported ======================================== |
else /* MMX not supported: use modified C code - takes advantage |
* of inlining of png_memcpy for a constant */ |
/* GRR 19991007: does it? or should pixel_bytes in each |
* block be replaced with immediate value (e.g., 1)? */ |
/* GRR 19991017: replaced with constants in each case */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
if (pixel_bytes == 1) |
{ |
for (i = width; i; i--) |
{ |
int j; |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
*dp-- = *sptr; |
} |
--sptr; |
} |
} |
else if (pixel_bytes == 3) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 3); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 3); |
dp -= 3; |
} |
sptr -= 3; |
} |
} |
else if (pixel_bytes == 2) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 2); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 2); |
dp -= 2; |
} |
sptr -= 2; |
} |
} |
else if (pixel_bytes == 4) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 4); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
#ifdef PNG_DEBUG |
if (dp < row || dp+3 > row+png_ptr->row_buf_size) |
{ |
printf("dp out of bounds: row=%d, dp=%d, rp=%d\n", |
row, dp, row+png_ptr->row_buf_size); |
printf("row_buf=%d\n",png_ptr->row_buf_size); |
} |
#endif |
png_memcpy(dp, v, 4); |
dp -= 4; |
} |
sptr -= 4; |
} |
} |
else if (pixel_bytes == 6) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 6); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 6); |
dp -= 6; |
} |
sptr -= 6; |
} |
} |
else if (pixel_bytes == 8) |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, 8); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, 8); |
dp -= 8; |
} |
sptr -= 8; |
} |
} |
else /* GRR: should never be reached */ |
{ |
for (i = width; i; i--) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sptr, pixel_bytes); |
for (j = 0; j < png_pass_inc[pass]; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sptr -= pixel_bytes; |
} |
} |
} /* end if (MMX not supported) */ |
break; |
} |
} /* end switch (row_info->pixel_depth) */ |
row_info->width = final_width; |
row_info->rowbytes = ((final_width * |
(png_uint_32)row_info->pixel_depth + 7) >> 3); |
} |
} /* end png_do_read_interlace() */ |
#endif /* PNG_HAVE_ASSEMBLER_READ_INTERLACE */ |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
#if defined(PNG_HAVE_ASSEMBLER_READ_FILTER_ROW) |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
// These variables are utilized in the functions below. They are declared |
// globally here to ensure alignment on 8-byte boundaries. |
union uAll { |
long long use; |
double align; |
} _LBCarryMask = {0x0101010101010101LL}, |
_HBClearMask = {0x7f7f7f7f7f7f7f7fLL}, |
_ActiveMask, _ActiveMask2, _ActiveMaskEnd, _ShiftBpp, _ShiftRem; |
#ifdef PNG_THREAD_UNSAFE_OK |
//===========================================================================// |
// // |
// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ A V G // |
// // |
//===========================================================================// |
// Optimized code for PNG Average filter decoder |
static void /* PRIVATE */ |
png_read_filter_row_mmx_avg(png_row_infop row_info, png_bytep row, |
png_bytep prev_row) |
{ |
int bpp; |
int dummy_value_c; // fix 'forbidden register 2 (cx) was spilled' error |
int dummy_value_S; |
int dummy_value_D; |
bpp = (row_info->pixel_depth + 7) >> 3; // get # bytes per pixel |
_FullLength = row_info->rowbytes; // # of bytes to filter |
__asm__ __volatile__ ( |
// initialize address pointers and offset |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save index to Global Offset Table |
#endif |
//pre "movl row, %%edi \n\t" // edi: Avg(x) |
"xorl %%ebx, %%ebx \n\t" // ebx: x |
"movl %%edi, %%edx \n\t" |
//pre "movl prev_row, %%esi \n\t" // esi: Prior(x) |
//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) |
"subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) |
"xorl %%eax,%%eax \n\t" |
// Compute the Raw value for the first bpp bytes |
// Raw(x) = Avg(x) + (Prior(x)/2) |
"avg_rlp: \n\t" |
"movb (%%esi,%%ebx,),%%al \n\t" // load al with Prior(x) |
"incl %%ebx \n\t" |
"shrb %%al \n\t" // divide by 2 |
"addb -1(%%edi,%%ebx,),%%al \n\t" // add Avg(x); -1 to offset inc ebx |
//pre "cmpl bpp, %%ebx \n\t" // (bpp is preloaded into ecx) |
"cmpl %%ecx, %%ebx \n\t" |
"movb %%al,-1(%%edi,%%ebx,) \n\t" // write Raw(x); -1 to offset inc ebx |
"jb avg_rlp \n\t" // mov does not affect flags |
// get # of bytes to alignment |
"movl %%edi, _dif \n\t" // take start of row |
"addl %%ebx, _dif \n\t" // add bpp |
"addl $0xf, _dif \n\t" // add 7+8 to incr past alignment bdry |
"andl $0xfffffff8, _dif \n\t" // mask to alignment boundary |
"subl %%edi, _dif \n\t" // subtract from start => value ebx at |
"jz avg_go \n\t" // alignment |
// fix alignment |
// Compute the Raw value for the bytes up to the alignment boundary |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
"xorl %%ecx, %%ecx \n\t" |
"avg_lp1: \n\t" |
"xorl %%eax, %%eax \n\t" |
"movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) |
"movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) |
"addw %%cx, %%ax \n\t" |
"incl %%ebx \n\t" |
"shrw %%ax \n\t" // divide by 2 |
"addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset inc ebx |
"cmpl _dif, %%ebx \n\t" // check if at alignment boundary |
"movb %%al, -1(%%edi,%%ebx,) \n\t" // write Raw(x); -1 to offset inc ebx |
"jb avg_lp1 \n\t" // repeat until at alignment boundary |
"avg_go: \n\t" |
"movl _FullLength, %%eax \n\t" |
"movl %%eax, %%ecx \n\t" |
"subl %%ebx, %%eax \n\t" // subtract alignment fix |
"andl $0x00000007, %%eax \n\t" // calc bytes over mult of 8 |
"subl %%eax, %%ecx \n\t" // drop over bytes from original length |
"movl %%ecx, _MMXLength \n\t" |
#ifdef __PIC__ |
"popl %%ebx \n\t" // restore index to Global Offset Table |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list |
#ifndef __PIC__ |
, "%ebx" |
#endif |
// GRR: INCLUDE "memory" as clobbered? (_dif, _MMXLength) |
// (seems to work fine without...) |
); |
// now do the math for the rest of the row |
switch (bpp) |
{ |
case 3: |
{ |
_ActiveMask.use = 0x0000000000ffffffLL; |
_ShiftBpp.use = 24; // == 3 * 8 |
_ShiftRem.use = 40; // == 64 - 24 |
__asm__ __volatile__ ( |
// re-init address pointers and offset |
"movq _ActiveMask, %%mm7 \n\t" |
"movl _dif, %%ecx \n\t" // ecx: x = offset to |
"movq _LBCarryMask, %%mm5 \n\t" // alignment boundary |
// preload "movl row, %%edi \n\t" // edi: Avg(x) |
"movq _HBClearMask, %%mm4 \n\t" |
// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes |
// (correct pos. in loop below) |
"avg_3lp: \n\t" |
"movq (%%edi,%%ecx,), %%mm0 \n\t" // load mm0 with Avg(x) |
"movq %%mm5, %%mm3 \n\t" |
"psrlq _ShiftRem, %%mm2 \n\t" // correct position Raw(x-bpp) |
// data |
"movq (%%esi,%%ecx,), %%mm1 \n\t" // load mm1 with Prior(x) |
"movq %%mm7, %%mm6 \n\t" |
"pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte |
"psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 |
"pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for |
// each byte |
// add 1st active group (Raw(x-bpp)/2) to average with LBCarry |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 1 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active |
// byte |
// add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry |
"psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover |
// bytes 3-5 |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active |
// byte |
// add 3rd active group (Raw(x-bpp)/2) to average with _LBCarry |
"psllq _ShiftBpp, %%mm6 \n\t" // shift mm6 mask to cover last |
// two |
// bytes |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
// Data only needs to be shifted once here to |
// get the correct x-bpp offset. |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"addl $8, %%ecx \n\t" |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active |
// byte |
// now ready to write back to memory |
"movq %%mm0, -8(%%edi,%%ecx,) \n\t" |
// move updated Raw(x) to use as Raw(x-bpp) for next loop |
"cmpl _MMXLength, %%ecx \n\t" |
"movq %%mm0, %%mm2 \n\t" // mov updated Raw(x) to mm2 |
"jb avg_3lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 3 bpp |
case 6: |
case 4: |
//case 7: // who wrote this? PNG doesn't support 5 or 7 bytes/pixel |
//case 5: // GRR BOGUS |
{ |
_ActiveMask.use = 0xffffffffffffffffLL; // use shift below to clear |
// appropriate inactive bytes |
_ShiftBpp.use = bpp << 3; |
_ShiftRem.use = 64 - _ShiftBpp.use; |
__asm__ __volatile__ ( |
"movq _HBClearMask, %%mm4 \n\t" |
// re-init address pointers and offset |
"movl _dif, %%ecx \n\t" // ecx: x = offset to |
// alignment boundary |
// load _ActiveMask and clear all bytes except for 1st active group |
"movq _ActiveMask, %%mm7 \n\t" |
// preload "movl row, %%edi \n\t" // edi: Avg(x) |
"psrlq _ShiftRem, %%mm7 \n\t" |
// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) |
"movq %%mm7, %%mm6 \n\t" |
"movq _LBCarryMask, %%mm5 \n\t" |
"psllq _ShiftBpp, %%mm6 \n\t" // create mask for 2nd active |
// group |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes |
// (we correct pos. in loop below) |
"avg_4lp: \n\t" |
"movq (%%edi,%%ecx,), %%mm0 \n\t" |
"psrlq _ShiftRem, %%mm2 \n\t" // shift data to pos. correctly |
"movq (%%esi,%%ecx,), %%mm1 \n\t" |
// add (Prev_row/2) to average |
"movq %%mm5, %%mm3 \n\t" |
"pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte |
"psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 |
"pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for |
// each byte |
// add 1st active group (Raw(x-bpp)/2) to average with _LBCarry |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm7, %%mm2 \n\t" // leave only Active Group 1 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to Avg |
// for each Active |
// byte |
// add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
"addl $8, %%ecx \n\t" |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active |
// byte |
"cmpl _MMXLength, %%ecx \n\t" |
// now ready to write back to memory |
"movq %%mm0, -8(%%edi,%%ecx,) \n\t" |
// prep Raw(x-bpp) for next loop |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"jb avg_4lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 4,6 bpp |
case 2: |
{ |
_ActiveMask.use = 0x000000000000ffffLL; |
_ShiftBpp.use = 16; // == 2 * 8 |
_ShiftRem.use = 48; // == 64 - 16 |
__asm__ __volatile__ ( |
// load _ActiveMask |
"movq _ActiveMask, %%mm7 \n\t" |
// re-init address pointers and offset |
"movl _dif, %%ecx \n\t" // ecx: x = offset to alignment |
// boundary |
"movq _LBCarryMask, %%mm5 \n\t" |
// preload "movl row, %%edi \n\t" // edi: Avg(x) |
"movq _HBClearMask, %%mm4 \n\t" |
// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes |
// (we correct pos. in loop below) |
"avg_2lp: \n\t" |
"movq (%%edi,%%ecx,), %%mm0 \n\t" |
"psrlq _ShiftRem, %%mm2 \n\t" // shift data to pos. correctly |
"movq (%%esi,%%ecx,), %%mm1 \n\t" // (GRR BUGFIX: was psllq) |
// add (Prev_row/2) to average |
"movq %%mm5, %%mm3 \n\t" |
"pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte |
"psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 |
"pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each |
// byte |
"movq %%mm7, %%mm6 \n\t" |
"paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for |
// each byte |
// add 1st active group (Raw(x-bpp)/2) to average with _LBCarry |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid |
// for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 1 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to Avg |
// for each Active byte |
// add 2nd active group (Raw(x-bpp)/2) to average with _LBCarry |
"psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover |
// bytes 2 & 3 |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid |
// for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active byte |
// add 3rd active group (Raw(x-bpp)/2) to average with _LBCarry |
"psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover |
// bytes 4 & 5 |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both lsb's were == 1 |
// (only valid for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active byte |
// add 4th active group (Raw(x-bpp)/2) to average with _LBCarry |
"psllq _ShiftBpp, %%mm6 \n\t" // shift the mm6 mask to cover |
// bytes 6 & 7 |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"psllq _ShiftBpp, %%mm2 \n\t" // shift data to pos. correctly |
"addl $8, %%ecx \n\t" |
"movq %%mm3, %%mm1 \n\t" // now use mm1 for getting |
// LBCarrys |
"pand %%mm2, %%mm1 \n\t" // get LBCarrys for each byte |
// where both |
// lsb's were == 1 (only valid |
// for active group) |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm2 \n\t" // add LBCarrys to (Raw(x-bpp)/2) |
// for each byte |
"pand %%mm6, %%mm2 \n\t" // leave only Active Group 2 |
// bytes to add to Avg |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) + LBCarrys to |
// Avg for each Active byte |
"cmpl _MMXLength, %%ecx \n\t" |
// now ready to write back to memory |
"movq %%mm0, -8(%%edi,%%ecx,) \n\t" |
// prep Raw(x-bpp) for next loop |
"movq %%mm0, %%mm2 \n\t" // mov updated Raws to mm2 |
"jb avg_2lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 2 bpp |
case 1: |
{ |
__asm__ __volatile__ ( |
// re-init address pointers and offset |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save Global Offset Table index |
#endif |
"movl _dif, %%ebx \n\t" // ebx: x = offset to alignment |
// boundary |
// preload "movl row, %%edi \n\t" // edi: Avg(x) |
"cmpl _FullLength, %%ebx \n\t" // test if offset at end of array |
"jnb avg_1end \n\t" |
// do Paeth decode for remaining bytes |
// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) |
"movl %%edi, %%edx \n\t" |
// preload "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) |
"subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) |
"xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx |
// in loop below |
"avg_1lp: \n\t" |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
"xorl %%eax, %%eax \n\t" |
"movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) |
"movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) |
"addw %%cx, %%ax \n\t" |
"incl %%ebx \n\t" |
"shrw %%ax \n\t" // divide by 2 |
"addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset |
// inc ebx |
"cmpl _FullLength, %%ebx \n\t" // check if at end of array |
"movb %%al, -1(%%edi,%%ebx,) \n\t" // write back Raw(x); |
// mov does not affect flags; -1 to offset inc ebx |
"jb avg_1lp \n\t" |
"avg_1end: \n\t" |
#ifdef __PIC__ |
"popl %%ebx \n\t" // Global Offset Table index |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list |
#ifndef __PIC__ |
, "%ebx" |
#endif |
); |
} |
return; // end 1 bpp |
case 8: |
{ |
__asm__ __volatile__ ( |
// re-init address pointers and offset |
"movl _dif, %%ecx \n\t" // ecx: x == offset to alignment |
"movq _LBCarryMask, %%mm5 \n\t" // boundary |
// preload "movl row, %%edi \n\t" // edi: Avg(x) |
"movq _HBClearMask, %%mm4 \n\t" |
// preload "movl prev_row, %%esi \n\t" // esi: Prior(x) |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm2 \n\t" // load previous aligned 8 bytes |
// (NO NEED to correct pos. in loop below) |
"avg_8lp: \n\t" |
"movq (%%edi,%%ecx,), %%mm0 \n\t" |
"movq %%mm5, %%mm3 \n\t" |
"movq (%%esi,%%ecx,), %%mm1 \n\t" |
"addl $8, %%ecx \n\t" |
"pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte |
"psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 |
"pand %%mm2, %%mm3 \n\t" // get LBCarrys for each byte |
// where both lsb's were == 1 |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm1 \n\t" // clear invalid bit 7, each byte |
"paddb %%mm3, %%mm0 \n\t" // add LBCarrys to Avg, each byte |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7, each byte |
"paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg, each |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) to Avg for each |
"cmpl _MMXLength, %%ecx \n\t" |
"movq %%mm0, -8(%%edi,%%ecx,) \n\t" |
"movq %%mm0, %%mm2 \n\t" // reuse as Raw(x-bpp) |
"jb avg_8lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm5 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2" |
, "%mm3", "%mm4", "%mm5" |
#endif |
); |
} |
break; // end 8 bpp |
default: // bpp greater than 8 (!= 1,2,3,4,[5],6,[7],8) |
{ |
#ifdef PNG_DEBUG |
// GRR: PRINT ERROR HERE: SHOULD NEVER BE REACHED |
png_debug(1, |
"Internal logic error in pnggccrd (png_read_filter_row_mmx_avg())\n"); |
#endif |
#if 0 |
__asm__ __volatile__ ( |
"movq _LBCarryMask, %%mm5 \n\t" |
// re-init address pointers and offset |
"movl _dif, %%ebx \n\t" // ebx: x = offset to |
// alignment boundary |
"movl row, %%edi \n\t" // edi: Avg(x) |
"movq _HBClearMask, %%mm4 \n\t" |
"movl %%edi, %%edx \n\t" |
"movl prev_row, %%esi \n\t" // esi: Prior(x) |
"subl bpp, %%edx \n\t" // edx: Raw(x-bpp) |
"avg_Alp: \n\t" |
"movq (%%edi,%%ebx,), %%mm0 \n\t" |
"movq %%mm5, %%mm3 \n\t" |
"movq (%%esi,%%ebx,), %%mm1 \n\t" |
"pand %%mm1, %%mm3 \n\t" // get lsb for each prev_row byte |
"movq (%%edx,%%ebx,), %%mm2 \n\t" |
"psrlq $1, %%mm1 \n\t" // divide prev_row bytes by 2 |
"pand %%mm2, %%mm3 \n\t" // get LBCarrys for each byte |
// where both lsb's were == 1 |
"psrlq $1, %%mm2 \n\t" // divide raw bytes by 2 |
"pand %%mm4, %%mm1 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm3, %%mm0 \n\t" // add LBCarrys to Avg for each |
// byte |
"pand %%mm4, %%mm2 \n\t" // clear invalid bit 7 of each |
// byte |
"paddb %%mm1, %%mm0 \n\t" // add (Prev_row/2) to Avg for |
// each byte |
"addl $8, %%ebx \n\t" |
"paddb %%mm2, %%mm0 \n\t" // add (Raw/2) to Avg for each |
// byte |
"cmpl _MMXLength, %%ebx \n\t" |
"movq %%mm0, -8(%%edi,%%ebx,) \n\t" |
"jb avg_Alp \n\t" |
: // FIXASM: output regs/vars go here, e.g.: "=m" (memory_var) |
: // FIXASM: input regs, e.g.: "c" (count), "S" (src), "D" (dest) |
: "%ebx", "%edx", "%edi", "%esi" // CHECKASM: clobber list |
); |
#endif /* 0 - NEVER REACHED */ |
} |
break; |
} // end switch (bpp) |
__asm__ __volatile__ ( |
// MMX acceleration complete; now do clean-up |
// check if any remaining bytes left to decode |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save index to Global Offset Table |
#endif |
"movl _MMXLength, %%ebx \n\t" // ebx: x == offset bytes after MMX |
//pre "movl row, %%edi \n\t" // edi: Avg(x) |
"cmpl _FullLength, %%ebx \n\t" // test if offset at end of array |
"jnb avg_end \n\t" |
// do Avg decode for remaining bytes |
//pre "movl prev_row, %%esi \n\t" // esi: Prior(x) |
"movl %%edi, %%edx \n\t" |
//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) |
"subl %%ecx, %%edx \n\t" // edx: Raw(x-bpp) |
"xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx below |
"avg_lp2: \n\t" |
// Raw(x) = Avg(x) + ((Raw(x-bpp) + Prior(x))/2) |
"xorl %%eax, %%eax \n\t" |
"movb (%%esi,%%ebx,), %%cl \n\t" // load cl with Prior(x) |
"movb (%%edx,%%ebx,), %%al \n\t" // load al with Raw(x-bpp) |
"addw %%cx, %%ax \n\t" |
"incl %%ebx \n\t" |
"shrw %%ax \n\t" // divide by 2 |
"addb -1(%%edi,%%ebx,), %%al \n\t" // add Avg(x); -1 to offset inc ebx |
"cmpl _FullLength, %%ebx \n\t" // check if at end of array |
"movb %%al, -1(%%edi,%%ebx,) \n\t" // write back Raw(x) [mov does not |
"jb avg_lp2 \n\t" // affect flags; -1 to offset inc ebx] |
"avg_end: \n\t" |
"EMMS \n\t" // end MMX; prep for poss. FP instrs. |
#ifdef __PIC__ |
"popl %%ebx \n\t" // restore index to Global Offset Table |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list |
#ifndef __PIC__ |
, "%ebx" |
#endif |
); |
} /* end png_read_filter_row_mmx_avg() */ |
#endif |
#ifdef PNG_THREAD_UNSAFE_OK |
//===========================================================================// |
// // |
// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ P A E T H // |
// // |
//===========================================================================// |
// Optimized code for PNG Paeth filter decoder |
static void /* PRIVATE */ |
png_read_filter_row_mmx_paeth(png_row_infop row_info, png_bytep row, |
png_bytep prev_row) |
{ |
int bpp; |
int dummy_value_c; // fix 'forbidden register 2 (cx) was spilled' error |
int dummy_value_S; |
int dummy_value_D; |
bpp = (row_info->pixel_depth + 7) >> 3; // Get # bytes per pixel |
_FullLength = row_info->rowbytes; // # of bytes to filter |
__asm__ __volatile__ ( |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save index to Global Offset Table |
#endif |
"xorl %%ebx, %%ebx \n\t" // ebx: x offset |
//pre "movl row, %%edi \n\t" |
"xorl %%edx, %%edx \n\t" // edx: x-bpp offset |
//pre "movl prev_row, %%esi \n\t" |
"xorl %%eax, %%eax \n\t" |
// Compute the Raw value for the first bpp bytes |
// Note: the formula works out to be always |
// Paeth(x) = Raw(x) + Prior(x) where x < bpp |
"paeth_rlp: \n\t" |
"movb (%%edi,%%ebx,), %%al \n\t" |
"addb (%%esi,%%ebx,), %%al \n\t" |
"incl %%ebx \n\t" |
//pre "cmpl bpp, %%ebx \n\t" (bpp is preloaded into ecx) |
"cmpl %%ecx, %%ebx \n\t" |
"movb %%al, -1(%%edi,%%ebx,) \n\t" |
"jb paeth_rlp \n\t" |
// get # of bytes to alignment |
"movl %%edi, _dif \n\t" // take start of row |
"addl %%ebx, _dif \n\t" // add bpp |
"xorl %%ecx, %%ecx \n\t" |
"addl $0xf, _dif \n\t" // add 7 + 8 to incr past alignment |
// boundary |
"andl $0xfffffff8, _dif \n\t" // mask to alignment boundary |
"subl %%edi, _dif \n\t" // subtract from start ==> value ebx |
// at alignment |
"jz paeth_go \n\t" |
// fix alignment |
"paeth_lp1: \n\t" |
"xorl %%eax, %%eax \n\t" |
// pav = p - a = (a + b - c) - a = b - c |
"movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, _patemp \n\t" // Save pav for later use |
"xorl %%eax, %%eax \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, %%ecx \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"addl _patemp, %%eax \n\t" // pcv = pav + pbv |
// pc = abs(pcv) |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_pca \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_pca: \n\t" |
"movl %%eax, _pctemp \n\t" // save pc for later use |
// pb = abs(pbv) |
"testl $0x80000000, %%ecx \n\t" |
"jz paeth_pba \n\t" |
"negl %%ecx \n\t" // reverse sign of neg values |
"paeth_pba: \n\t" |
"movl %%ecx, _pbtemp \n\t" // save pb for later use |
// pa = abs(pav) |
"movl _patemp, %%eax \n\t" |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_paa \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_paa: \n\t" |
"movl %%eax, _patemp \n\t" // save pa for later use |
// test if pa <= pb |
"cmpl %%ecx, %%eax \n\t" |
"jna paeth_abb \n\t" |
// pa > pb; now test if pb <= pc |
"cmpl _pctemp, %%ecx \n\t" |
"jna paeth_bbc \n\t" |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_paeth \n\t" |
"paeth_bbc: \n\t" |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
"movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl |
"jmp paeth_paeth \n\t" |
"paeth_abb: \n\t" |
// pa <= pb; now test if pa <= pc |
"cmpl _pctemp, %%eax \n\t" |
"jna paeth_abc \n\t" |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_paeth \n\t" |
"paeth_abc: \n\t" |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
"movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl |
"paeth_paeth: \n\t" |
"incl %%ebx \n\t" |
"incl %%edx \n\t" |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
"addb %%cl, -1(%%edi,%%ebx,) \n\t" |
"cmpl _dif, %%ebx \n\t" |
"jb paeth_lp1 \n\t" |
"paeth_go: \n\t" |
"movl _FullLength, %%ecx \n\t" |
"movl %%ecx, %%eax \n\t" |
"subl %%ebx, %%eax \n\t" // subtract alignment fix |
"andl $0x00000007, %%eax \n\t" // calc bytes over mult of 8 |
"subl %%eax, %%ecx \n\t" // drop over bytes from original length |
"movl %%ecx, _MMXLength \n\t" |
#ifdef __PIC__ |
"popl %%ebx \n\t" // restore index to Global Offset Table |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list |
#ifndef __PIC__ |
, "%ebx" |
#endif |
); |
// now do the math for the rest of the row |
switch (bpp) |
{ |
case 3: |
{ |
_ActiveMask.use = 0x0000000000ffffffLL; |
_ActiveMaskEnd.use = 0xffff000000000000LL; |
_ShiftBpp.use = 24; // == bpp(3) * 8 |
_ShiftRem.use = 40; // == 64 - 24 |
__asm__ __volatile__ ( |
"movl _dif, %%ecx \n\t" |
// preload "movl row, %%edi \n\t" |
// preload "movl prev_row, %%esi \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" |
"paeth_3lp: \n\t" |
"psrlq _ShiftRem, %%mm1 \n\t" // shift last 3 bytes to 1st |
// 3 bytes |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"punpcklbw %%mm0, %%mm1 \n\t" // unpack High bytes of a |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // prep c=Prior(x-bpp) bytes |
"punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
"psrlq _ShiftRem, %%mm3 \n\t" // shift last 3 bytes to 1st |
// 3 bytes |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"packuswb %%mm1, %%mm7 \n\t" |
"movq (%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) |
"pand _ActiveMask, %%mm7 \n\t" |
"movq %%mm3, %%mm2 \n\t" // load b=Prior(x) step 1 |
"paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) |
"punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
"movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value |
"movq %%mm7, %%mm1 \n\t" // now mm1 will be used as |
// Raw(x-bpp) |
// now do Paeth for 2nd set of bytes (3-5) |
"psrlq _ShiftBpp, %%mm2 \n\t" // load b=Prior(x) step 2 |
"punpcklbw %%mm0, %%mm1 \n\t" // unpack High bytes of a |
"pxor %%mm7, %%mm7 \n\t" |
"punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = |
// pav + pbv = pbv + pav |
"movq %%mm5, %%mm6 \n\t" |
"paddw %%mm4, %%mm6 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm5, %%mm0 \n\t" // create mask pbv bytes < 0 |
"pcmpgtw %%mm4, %%mm7 \n\t" // create mask pav bytes < 0 |
"pand %%mm5, %%mm0 \n\t" // only pbv bytes < 0 in mm0 |
"pand %%mm4, %%mm7 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm0, %%mm5 \n\t" |
"psubw %%mm7, %%mm4 \n\t" |
"psubw %%mm0, %%mm5 \n\t" |
"psubw %%mm7, %%mm4 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"pxor %%mm1, %%mm1 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"packuswb %%mm1, %%mm7 \n\t" |
"movq %%mm2, %%mm3 \n\t" // load c=Prior(x-bpp) step 1 |
"pand _ActiveMask, %%mm7 \n\t" |
"punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
"psllq _ShiftBpp, %%mm7 \n\t" // shift bytes to 2nd group of |
// 3 bytes |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) |
"psllq _ShiftBpp, %%mm3 \n\t" // load c=Prior(x-bpp) step 2 |
"movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value |
"movq %%mm7, %%mm1 \n\t" |
"punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
"psllq _ShiftBpp, %%mm1 \n\t" // shift bytes |
// now mm1 will be used as Raw(x-bpp) |
// now do Paeth for 3rd, and final, set of bytes (6-7) |
"pxor %%mm7, %%mm7 \n\t" |
"punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a |
"psubw %%mm3, %%mm4 \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"paddw %%mm5, %%mm6 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm1, %%mm1 \n\t" |
"packuswb %%mm7, %%mm1 \n\t" |
// step ecx to next set of 8 bytes and repeat loop til done |
"addl $8, %%ecx \n\t" |
"pand _ActiveMaskEnd, %%mm1 \n\t" |
"paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with |
// Raw(x) |
"cmpl _MMXLength, %%ecx \n\t" |
"pxor %%mm0, %%mm0 \n\t" // pxor does not affect flags |
"movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
// mm3 ready to be used as Prior(x-bpp) next loop |
"jb paeth_3lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 3 bpp |
case 6: |
//case 7: // GRR BOGUS |
//case 5: // GRR BOGUS |
{ |
_ActiveMask.use = 0x00000000ffffffffLL; |
_ActiveMask2.use = 0xffffffff00000000LL; |
_ShiftBpp.use = bpp << 3; // == bpp * 8 |
_ShiftRem.use = 64 - _ShiftBpp.use; |
__asm__ __volatile__ ( |
"movl _dif, %%ecx \n\t" |
// preload "movl row, %%edi \n\t" |
// preload "movl prev_row, %%esi \n\t" |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"paeth_6lp: \n\t" |
// must shift to position Raw(x-bpp) data |
"psrlq _ShiftRem, %%mm1 \n\t" |
// do first set of 4 bytes |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes |
"punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"punpcklbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b |
// must shift to position Prior(x-bpp) data |
"psrlq _ShiftRem, %%mm3 \n\t" |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"punpcklbw %%mm0, %%mm3 \n\t" // unpack Low bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"packuswb %%mm1, %%mm7 \n\t" |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) |
"pand _ActiveMask, %%mm7 \n\t" |
"psrlq _ShiftRem, %%mm3 \n\t" |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) step 1 |
"paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor and Raw(x) |
"movq %%mm2, %%mm6 \n\t" |
"movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" |
"psllq _ShiftBpp, %%mm6 \n\t" |
"movq %%mm7, %%mm5 \n\t" |
"psrlq _ShiftRem, %%mm1 \n\t" |
"por %%mm6, %%mm3 \n\t" |
"psllq _ShiftBpp, %%mm5 \n\t" |
"punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
"por %%mm5, %%mm1 \n\t" |
// do second set of 4 bytes |
"punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
"punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"pxor %%mm1, %%mm1 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// step ecx to next set of 8 bytes and repeat loop til done |
"addl $8, %%ecx \n\t" |
"packuswb %%mm7, %%mm1 \n\t" |
"paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with Raw(x) |
"cmpl _MMXLength, %%ecx \n\t" |
"movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
"jb paeth_6lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 6 bpp |
case 4: |
{ |
_ActiveMask.use = 0x00000000ffffffffLL; |
__asm__ __volatile__ ( |
"movl _dif, %%ecx \n\t" |
// preload "movl row, %%edi \n\t" |
// preload "movl prev_row, %%esi \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" // only time should need to read |
// a=Raw(x-bpp) bytes |
"paeth_4lp: \n\t" |
// do first set of 4 bytes |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes |
"punpckhbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"punpcklbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"packuswb %%mm1, %%mm7 \n\t" |
"movq (%%esi,%%ecx,), %%mm3 \n\t" // load c=Prior(x-bpp) |
"pand _ActiveMask, %%mm7 \n\t" |
"movq %%mm3, %%mm2 \n\t" // load b=Prior(x) step 1 |
"paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) |
"punpcklbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
"movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value |
"movq %%mm7, %%mm1 \n\t" // now mm1 will be used as Raw(x-bpp) |
// do second set of 4 bytes |
"punpckhbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b |
"punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"pxor %%mm1, %%mm1 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// step ecx to next set of 8 bytes and repeat loop til done |
"addl $8, %%ecx \n\t" |
"packuswb %%mm7, %%mm1 \n\t" |
"paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add predictor with Raw(x) |
"cmpl _MMXLength, %%ecx \n\t" |
"movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
"jb paeth_4lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 4 bpp |
case 8: // bpp == 8 |
{ |
_ActiveMask.use = 0x00000000ffffffffLL; |
__asm__ __volatile__ ( |
"movl _dif, %%ecx \n\t" |
// preload "movl row, %%edi \n\t" |
// preload "movl prev_row, %%esi \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" // only time should need to read |
// a=Raw(x-bpp) bytes |
"paeth_8lp: \n\t" |
// do first set of 4 bytes |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes |
"punpcklbw %%mm0, %%mm1 \n\t" // unpack Low bytes of a |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"punpcklbw %%mm0, %%mm2 \n\t" // unpack Low bytes of b |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
"punpcklbw %%mm0, %%mm3 \n\t" // unpack Low bytes of c |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"packuswb %%mm1, %%mm7 \n\t" |
"movq -8(%%esi,%%ecx,), %%mm3 \n\t" // read c=Prior(x-bpp) bytes |
"pand _ActiveMask, %%mm7 \n\t" |
"movq (%%esi,%%ecx,), %%mm2 \n\t" // load b=Prior(x) |
"paddb (%%edi,%%ecx,), %%mm7 \n\t" // add Paeth predictor with Raw(x) |
"punpckhbw %%mm0, %%mm3 \n\t" // unpack High bytes of c |
"movq %%mm7, (%%edi,%%ecx,) \n\t" // write back updated value |
"movq -8(%%edi,%%ecx,), %%mm1 \n\t" // read a=Raw(x-bpp) bytes |
// do second set of 4 bytes |
"punpckhbw %%mm0, %%mm2 \n\t" // unpack High bytes of b |
"punpckhbw %%mm0, %%mm1 \n\t" // unpack High bytes of a |
// pav = p - a = (a + b - c) - a = b - c |
"movq %%mm2, %%mm4 \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movq %%mm1, %%mm5 \n\t" |
"psubw %%mm3, %%mm4 \n\t" |
"pxor %%mm7, %%mm7 \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"movq %%mm4, %%mm6 \n\t" |
"psubw %%mm3, %%mm5 \n\t" |
// pa = abs(p-a) = abs(pav) |
// pb = abs(p-b) = abs(pbv) |
// pc = abs(p-c) = abs(pcv) |
"pcmpgtw %%mm4, %%mm0 \n\t" // create mask pav bytes < 0 |
"paddw %%mm5, %%mm6 \n\t" |
"pand %%mm4, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"pcmpgtw %%mm5, %%mm7 \n\t" // create mask pbv bytes < 0 |
"psubw %%mm0, %%mm4 \n\t" |
"pand %%mm5, %%mm7 \n\t" // only pbv bytes < 0 in mm0 |
"psubw %%mm0, %%mm4 \n\t" |
"psubw %%mm7, %%mm5 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
"pcmpgtw %%mm6, %%mm0 \n\t" // create mask pcv bytes < 0 |
"pand %%mm6, %%mm0 \n\t" // only pav bytes < 0 in mm7 |
"psubw %%mm7, %%mm5 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
// test pa <= pb |
"movq %%mm4, %%mm7 \n\t" |
"psubw %%mm0, %%mm6 \n\t" |
"pcmpgtw %%mm5, %%mm7 \n\t" // pa > pb? |
"movq %%mm7, %%mm0 \n\t" |
// use mm7 mask to merge pa & pb |
"pand %%mm7, %%mm5 \n\t" |
// use mm0 mask copy to merge a & b |
"pand %%mm0, %%mm2 \n\t" |
"pandn %%mm4, %%mm7 \n\t" |
"pandn %%mm1, %%mm0 \n\t" |
"paddw %%mm5, %%mm7 \n\t" |
"paddw %%mm2, %%mm0 \n\t" |
// test ((pa <= pb)? pa:pb) <= pc |
"pcmpgtw %%mm6, %%mm7 \n\t" // pab > pc? |
"pxor %%mm1, %%mm1 \n\t" |
"pand %%mm7, %%mm3 \n\t" |
"pandn %%mm0, %%mm7 \n\t" |
"pxor %%mm1, %%mm1 \n\t" |
"paddw %%mm3, %%mm7 \n\t" |
"pxor %%mm0, %%mm0 \n\t" |
// step ecx to next set of 8 bytes and repeat loop til done |
"addl $8, %%ecx \n\t" |
"packuswb %%mm7, %%mm1 \n\t" |
"paddb -8(%%edi,%%ecx,), %%mm1 \n\t" // add Paeth predictor with Raw(x) |
"cmpl _MMXLength, %%ecx \n\t" |
"movq %%mm1, -8(%%edi,%%ecx,) \n\t" // write back updated value |
// mm1 will be used as Raw(x-bpp) next loop |
"jb paeth_8lp \n\t" |
: "=S" (dummy_value_S), // output regs (dummy) |
"=D" (dummy_value_D) |
: "0" (prev_row), // esi // input regs |
"1" (row) // edi |
: "%ecx" // clobber list |
#if 0 /* %mm0, ..., %mm7 not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; // end 8 bpp |
case 1: // bpp = 1 |
case 2: // bpp = 2 |
default: // bpp > 8 |
{ |
__asm__ __volatile__ ( |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save Global Offset Table index |
#endif |
"movl _dif, %%ebx \n\t" |
"cmpl _FullLength, %%ebx \n\t" |
"jnb paeth_dend \n\t" |
// preload "movl row, %%edi \n\t" |
// preload "movl prev_row, %%esi \n\t" |
// do Paeth decode for remaining bytes |
"movl %%ebx, %%edx \n\t" |
// preload "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) |
"subl %%ecx, %%edx \n\t" // edx = ebx - bpp |
"xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx |
"paeth_dlp: \n\t" |
"xorl %%eax, %%eax \n\t" |
// pav = p - a = (a + b - c) - a = b - c |
"movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, _patemp \n\t" // Save pav for later use |
"xorl %%eax, %%eax \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, %%ecx \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"addl _patemp, %%eax \n\t" // pcv = pav + pbv |
// pc = abs(pcv) |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_dpca \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_dpca: \n\t" |
"movl %%eax, _pctemp \n\t" // save pc for later use |
// pb = abs(pbv) |
"testl $0x80000000, %%ecx \n\t" |
"jz paeth_dpba \n\t" |
"negl %%ecx \n\t" // reverse sign of neg values |
"paeth_dpba: \n\t" |
"movl %%ecx, _pbtemp \n\t" // save pb for later use |
// pa = abs(pav) |
"movl _patemp, %%eax \n\t" |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_dpaa \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_dpaa: \n\t" |
"movl %%eax, _patemp \n\t" // save pa for later use |
// test if pa <= pb |
"cmpl %%ecx, %%eax \n\t" |
"jna paeth_dabb \n\t" |
// pa > pb; now test if pb <= pc |
"cmpl _pctemp, %%ecx \n\t" |
"jna paeth_dbbc \n\t" |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_dpaeth \n\t" |
"paeth_dbbc: \n\t" |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
"movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl |
"jmp paeth_dpaeth \n\t" |
"paeth_dabb: \n\t" |
// pa <= pb; now test if pa <= pc |
"cmpl _pctemp, %%eax \n\t" |
"jna paeth_dabc \n\t" |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_dpaeth \n\t" |
"paeth_dabc: \n\t" |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
"movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl |
"paeth_dpaeth: \n\t" |
"incl %%ebx \n\t" |
"incl %%edx \n\t" |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
"addb %%cl, -1(%%edi,%%ebx,) \n\t" |
"cmpl _FullLength, %%ebx \n\t" |
"jb paeth_dlp \n\t" |
"paeth_dend: \n\t" |
#ifdef __PIC__ |
"popl %%ebx \n\t" // index to Global Offset Table |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list |
#ifndef __PIC__ |
, "%ebx" |
#endif |
); |
} |
return; // No need to go further with this one |
} // end switch (bpp) |
__asm__ __volatile__ ( |
// MMX acceleration complete; now do clean-up |
// check if any remaining bytes left to decode |
#ifdef __PIC__ |
"pushl %%ebx \n\t" // save index to Global Offset Table |
#endif |
"movl _MMXLength, %%ebx \n\t" |
"cmpl _FullLength, %%ebx \n\t" |
"jnb paeth_end \n\t" |
//pre "movl row, %%edi \n\t" |
//pre "movl prev_row, %%esi \n\t" |
// do Paeth decode for remaining bytes |
"movl %%ebx, %%edx \n\t" |
//pre "subl bpp, %%edx \n\t" // (bpp is preloaded into ecx) |
"subl %%ecx, %%edx \n\t" // edx = ebx - bpp |
"xorl %%ecx, %%ecx \n\t" // zero ecx before using cl & cx below |
"paeth_lp2: \n\t" |
"xorl %%eax, %%eax \n\t" |
// pav = p - a = (a + b - c) - a = b - c |
"movb (%%esi,%%ebx,), %%al \n\t" // load Prior(x) into al |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, _patemp \n\t" // Save pav for later use |
"xorl %%eax, %%eax \n\t" |
// pbv = p - b = (a + b - c) - b = a - c |
"movb (%%edi,%%edx,), %%al \n\t" // load Raw(x-bpp) into al |
"subl %%ecx, %%eax \n\t" // subtract Prior(x-bpp) |
"movl %%eax, %%ecx \n\t" |
// pcv = p - c = (a + b - c) -c = (a - c) + (b - c) = pav + pbv |
"addl _patemp, %%eax \n\t" // pcv = pav + pbv |
// pc = abs(pcv) |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_pca2 \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_pca2: \n\t" |
"movl %%eax, _pctemp \n\t" // save pc for later use |
// pb = abs(pbv) |
"testl $0x80000000, %%ecx \n\t" |
"jz paeth_pba2 \n\t" |
"negl %%ecx \n\t" // reverse sign of neg values |
"paeth_pba2: \n\t" |
"movl %%ecx, _pbtemp \n\t" // save pb for later use |
// pa = abs(pav) |
"movl _patemp, %%eax \n\t" |
"testl $0x80000000, %%eax \n\t" |
"jz paeth_paa2 \n\t" |
"negl %%eax \n\t" // reverse sign of neg values |
"paeth_paa2: \n\t" |
"movl %%eax, _patemp \n\t" // save pa for later use |
// test if pa <= pb |
"cmpl %%ecx, %%eax \n\t" |
"jna paeth_abb2 \n\t" |
// pa > pb; now test if pb <= pc |
"cmpl _pctemp, %%ecx \n\t" |
"jna paeth_bbc2 \n\t" |
// pb > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_paeth2 \n\t" |
"paeth_bbc2: \n\t" |
// pb <= pc; Raw(x) = Paeth(x) + Prior(x) |
"movb (%%esi,%%ebx,), %%cl \n\t" // load Prior(x) into cl |
"jmp paeth_paeth2 \n\t" |
"paeth_abb2: \n\t" |
// pa <= pb; now test if pa <= pc |
"cmpl _pctemp, %%eax \n\t" |
"jna paeth_abc2 \n\t" |
// pa > pc; Raw(x) = Paeth(x) + Prior(x-bpp) |
"movb (%%esi,%%edx,), %%cl \n\t" // load Prior(x-bpp) into cl |
"jmp paeth_paeth2 \n\t" |
"paeth_abc2: \n\t" |
// pa <= pc; Raw(x) = Paeth(x) + Raw(x-bpp) |
"movb (%%edi,%%edx,), %%cl \n\t" // load Raw(x-bpp) into cl |
"paeth_paeth2: \n\t" |
"incl %%ebx \n\t" |
"incl %%edx \n\t" |
// Raw(x) = (Paeth(x) + Paeth_Predictor( a, b, c )) mod 256 |
"addb %%cl, -1(%%edi,%%ebx,) \n\t" |
"cmpl _FullLength, %%ebx \n\t" |
"jb paeth_lp2 \n\t" |
"paeth_end: \n\t" |
"EMMS \n\t" // end MMX; prep for poss. FP instrs. |
#ifdef __PIC__ |
"popl %%ebx \n\t" // restore index to Global Offset Table |
#endif |
: "=c" (dummy_value_c), // output regs (dummy) |
"=S" (dummy_value_S), |
"=D" (dummy_value_D) |
: "0" (bpp), // ecx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%edx" // clobber list (no input regs!) |
#ifndef __PIC__ |
, "%ebx" |
#endif |
); |
} /* end png_read_filter_row_mmx_paeth() */ |
#endif |
#ifdef PNG_THREAD_UNSAFE_OK |
//===========================================================================// |
// // |
// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ S U B // |
// // |
//===========================================================================// |
// Optimized code for PNG Sub filter decoder |
static void /* PRIVATE */ |
png_read_filter_row_mmx_sub(png_row_infop row_info, png_bytep row) |
{ |
int bpp; |
int dummy_value_a; |
int dummy_value_D; |
bpp = (row_info->pixel_depth + 7) >> 3; // calc number of bytes per pixel |
_FullLength = row_info->rowbytes - bpp; // number of bytes to filter |
__asm__ __volatile__ ( |
//pre "movl row, %%edi \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
//pre "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
//irr "xorl %%eax, %%eax \n\t" |
// get # of bytes to alignment |
"movl %%edi, _dif \n\t" // take start of row |
"addl $0xf, _dif \n\t" // add 7 + 8 to incr past |
// alignment boundary |
"xorl %%ecx, %%ecx \n\t" |
"andl $0xfffffff8, _dif \n\t" // mask to alignment boundary |
"subl %%edi, _dif \n\t" // subtract from start ==> value |
"jz sub_go \n\t" // ecx at alignment |
"sub_lp1: \n\t" // fix alignment |
"movb (%%esi,%%ecx,), %%al \n\t" |
"addb %%al, (%%edi,%%ecx,) \n\t" |
"incl %%ecx \n\t" |
"cmpl _dif, %%ecx \n\t" |
"jb sub_lp1 \n\t" |
"sub_go: \n\t" |
"movl _FullLength, %%eax \n\t" |
"movl %%eax, %%edx \n\t" |
"subl %%ecx, %%edx \n\t" // subtract alignment fix |
"andl $0x00000007, %%edx \n\t" // calc bytes over mult of 8 |
"subl %%edx, %%eax \n\t" // drop over bytes from length |
"movl %%eax, _MMXLength \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%ebx", "%ecx", "%edx" // clobber list |
, "%esi" |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
// now do the math for the rest of the row |
switch (bpp) |
{ |
case 3: |
{ |
_ActiveMask.use = 0x0000ffffff000000LL; |
_ShiftBpp.use = 24; // == 3 * 8 |
_ShiftRem.use = 40; // == 64 - 24 |
__asm__ __volatile__ ( |
// preload "movl row, %%edi \n\t" |
"movq _ActiveMask, %%mm7 \n\t" // load _ActiveMask for 2nd |
// active byte group |
"movl %%edi, %%esi \n\t" // lp = row |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"movq %%mm7, %%mm6 \n\t" |
"movl _dif, %%edx \n\t" |
"psllq _ShiftBpp, %%mm6 \n\t" // move mask in mm6 to cover |
// 3rd active byte group |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%edx,), %%mm1 \n\t" |
"sub_3lp: \n\t" // shift data for adding first |
"psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; |
// shift clears inactive bytes) |
// add 1st active group |
"movq (%%edi,%%edx,), %%mm0 \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
// add 2nd active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"pand %%mm7, %%mm1 \n\t" // mask to use 2nd active group |
"paddb %%mm1, %%mm0 \n\t" |
// add 3rd active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"pand %%mm6, %%mm1 \n\t" // mask to use 3rd active group |
"addl $8, %%edx \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"movq %%mm0, -8(%%edi,%%edx,) \n\t" // write updated Raws to array |
"movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop |
"jb sub_3lp \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm6", "%mm7" |
#endif |
); |
} |
break; |
case 1: |
{ |
__asm__ __volatile__ ( |
"movl _dif, %%edx \n\t" |
// preload "movl row, %%edi \n\t" |
"cmpl _FullLength, %%edx \n\t" |
"jnb sub_1end \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
"xorl %%eax, %%eax \n\t" |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"sub_1lp: \n\t" |
"movb (%%esi,%%edx,), %%al \n\t" |
"addb %%al, (%%edi,%%edx,) \n\t" |
"incl %%edx \n\t" |
"cmpl _FullLength, %%edx \n\t" |
"jb sub_1lp \n\t" |
"sub_1end: \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
); |
} |
return; |
case 6: |
case 4: |
//case 7: // GRR BOGUS |
//case 5: // GRR BOGUS |
{ |
_ShiftBpp.use = bpp << 3; |
_ShiftRem.use = 64 - _ShiftBpp.use; |
__asm__ __volatile__ ( |
// preload "movl row, %%edi \n\t" |
"movl _dif, %%edx \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%edx,), %%mm1 \n\t" |
"sub_4lp: \n\t" // shift data for adding first |
"psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; |
// shift clears inactive bytes) |
"movq (%%edi,%%edx,), %%mm0 \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
// add 2nd active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"addl $8, %%edx \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"movq %%mm0, -8(%%edi,%%edx,) \n\t" |
"movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop |
"jb sub_4lp \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1" |
#endif |
); |
} |
break; |
case 2: |
{ |
_ActiveMask.use = 0x00000000ffff0000LL; |
_ShiftBpp.use = 16; // == 2 * 8 |
_ShiftRem.use = 48; // == 64 - 16 |
__asm__ __volatile__ ( |
"movq _ActiveMask, %%mm7 \n\t" // load _ActiveMask for 2nd |
// active byte group |
"movl _dif, %%edx \n\t" |
"movq %%mm7, %%mm6 \n\t" |
// preload "movl row, %%edi \n\t" |
"psllq _ShiftBpp, %%mm6 \n\t" // move mask in mm6 to cover |
// 3rd active byte group |
"movl %%edi, %%esi \n\t" // lp = row |
"movq %%mm6, %%mm5 \n\t" |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"psllq _ShiftBpp, %%mm5 \n\t" // move mask in mm5 to cover |
// 4th active byte group |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%edx,), %%mm1 \n\t" |
"sub_2lp: \n\t" // shift data for adding first |
"psrlq _ShiftRem, %%mm1 \n\t" // bpp bytes (no need for mask; |
// shift clears inactive bytes) |
// add 1st active group |
"movq (%%edi,%%edx,), %%mm0 \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
// add 2nd active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"pand %%mm7, %%mm1 \n\t" // mask to use 2nd active group |
"paddb %%mm1, %%mm0 \n\t" |
// add 3rd active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"pand %%mm6, %%mm1 \n\t" // mask to use 3rd active group |
"paddb %%mm1, %%mm0 \n\t" |
// add 4th active group |
"movq %%mm0, %%mm1 \n\t" // mov updated Raws to mm1 |
"psllq _ShiftBpp, %%mm1 \n\t" // shift data to pos. correctly |
"pand %%mm5, %%mm1 \n\t" // mask to use 4th active group |
"addl $8, %%edx \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"movq %%mm0, -8(%%edi,%%edx,) \n\t" // write updated Raws to array |
"movq %%mm0, %%mm1 \n\t" // prep 1st add at top of loop |
"jb sub_2lp \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; |
case 8: |
{ |
__asm__ __volatile__ ( |
// preload "movl row, %%edi \n\t" |
"movl _dif, %%edx \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"movl _MMXLength, %%ecx \n\t" |
// prime the pump: load the first Raw(x-bpp) data set |
"movq -8(%%edi,%%edx,), %%mm7 \n\t" |
"andl $0x0000003f, %%ecx \n\t" // calc bytes over mult of 64 |
"sub_8lp: \n\t" |
"movq (%%edi,%%edx,), %%mm0 \n\t" // load Sub(x) for 1st 8 bytes |
"paddb %%mm7, %%mm0 \n\t" |
"movq 8(%%edi,%%edx,), %%mm1 \n\t" // load Sub(x) for 2nd 8 bytes |
"movq %%mm0, (%%edi,%%edx,) \n\t" // write Raw(x) for 1st 8 bytes |
// Now mm0 will be used as Raw(x-bpp) for the 2nd group of 8 bytes. |
// This will be repeated for each group of 8 bytes with the 8th |
// group being used as the Raw(x-bpp) for the 1st group of the |
// next loop. |
"paddb %%mm0, %%mm1 \n\t" |
"movq 16(%%edi,%%edx,), %%mm2 \n\t" // load Sub(x) for 3rd 8 bytes |
"movq %%mm1, 8(%%edi,%%edx,) \n\t" // write Raw(x) for 2nd 8 bytes |
"paddb %%mm1, %%mm2 \n\t" |
"movq 24(%%edi,%%edx,), %%mm3 \n\t" // load Sub(x) for 4th 8 bytes |
"movq %%mm2, 16(%%edi,%%edx,) \n\t" // write Raw(x) for 3rd 8 bytes |
"paddb %%mm2, %%mm3 \n\t" |
"movq 32(%%edi,%%edx,), %%mm4 \n\t" // load Sub(x) for 5th 8 bytes |
"movq %%mm3, 24(%%edi,%%edx,) \n\t" // write Raw(x) for 4th 8 bytes |
"paddb %%mm3, %%mm4 \n\t" |
"movq 40(%%edi,%%edx,), %%mm5 \n\t" // load Sub(x) for 6th 8 bytes |
"movq %%mm4, 32(%%edi,%%edx,) \n\t" // write Raw(x) for 5th 8 bytes |
"paddb %%mm4, %%mm5 \n\t" |
"movq 48(%%edi,%%edx,), %%mm6 \n\t" // load Sub(x) for 7th 8 bytes |
"movq %%mm5, 40(%%edi,%%edx,) \n\t" // write Raw(x) for 6th 8 bytes |
"paddb %%mm5, %%mm6 \n\t" |
"movq 56(%%edi,%%edx,), %%mm7 \n\t" // load Sub(x) for 8th 8 bytes |
"movq %%mm6, 48(%%edi,%%edx,) \n\t" // write Raw(x) for 7th 8 bytes |
"addl $64, %%edx \n\t" |
"paddb %%mm6, %%mm7 \n\t" |
"cmpl %%ecx, %%edx \n\t" |
"movq %%mm7, -8(%%edi,%%edx,) \n\t" // write Raw(x) for 8th 8 bytes |
"jb sub_8lp \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"jnb sub_8lt8 \n\t" |
"sub_8lpA: \n\t" |
"movq (%%edi,%%edx,), %%mm0 \n\t" |
"addl $8, %%edx \n\t" |
"paddb %%mm7, %%mm0 \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"movq %%mm0, -8(%%edi,%%edx,) \n\t" // -8 to offset early addl edx |
"movq %%mm0, %%mm7 \n\t" // move calculated Raw(x) data |
// to mm1 to be new Raw(x-bpp) |
// for next loop |
"jb sub_8lpA \n\t" |
"sub_8lt8: \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%ecx", "%edx", "%esi" // clobber list |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} |
break; |
default: // bpp greater than 8 bytes GRR BOGUS |
{ |
__asm__ __volatile__ ( |
"movl _dif, %%edx \n\t" |
// preload "movl row, %%edi \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
// preload "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"sub_Alp: \n\t" |
"movq (%%edi,%%edx,), %%mm0 \n\t" |
"movq (%%esi,%%edx,), %%mm1 \n\t" |
"addl $8, %%edx \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"cmpl _MMXLength, %%edx \n\t" |
"movq %%mm0, -8(%%edi,%%edx,) \n\t" // mov does not affect flags; |
// -8 to offset addl edx |
"jb sub_Alp \n\t" |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1" |
#endif |
); |
} |
break; |
} // end switch (bpp) |
__asm__ __volatile__ ( |
"movl _MMXLength, %%edx \n\t" |
//pre "movl row, %%edi \n\t" |
"cmpl _FullLength, %%edx \n\t" |
"jnb sub_end \n\t" |
"movl %%edi, %%esi \n\t" // lp = row |
//pre "movl bpp, %%eax \n\t" |
"addl %%eax, %%edi \n\t" // rp = row + bpp |
"xorl %%eax, %%eax \n\t" |
"sub_lp2: \n\t" |
"movb (%%esi,%%edx,), %%al \n\t" |
"addb %%al, (%%edi,%%edx,) \n\t" |
"incl %%edx \n\t" |
"cmpl _FullLength, %%edx \n\t" |
"jb sub_lp2 \n\t" |
"sub_end: \n\t" |
"EMMS \n\t" // end MMX instructions |
: "=a" (dummy_value_a), // 0 // output regs (dummy) |
"=D" (dummy_value_D) // 1 |
: "0" (bpp), // eax // input regs |
"1" (row) // edi |
: "%edx", "%esi" // clobber list |
); |
} // end of png_read_filter_row_mmx_sub() |
#endif |
//===========================================================================// |
// // |
// P N G _ R E A D _ F I L T E R _ R O W _ M M X _ U P // |
// // |
//===========================================================================// |
// Optimized code for PNG Up filter decoder |
static void /* PRIVATE */ |
png_read_filter_row_mmx_up(png_row_infop row_info, png_bytep row, |
png_bytep prev_row) |
{ |
png_uint_32 len; |
int dummy_value_d; // fix 'forbidden register 3 (dx) was spilled' error |
int dummy_value_S; |
int dummy_value_D; |
len = row_info->rowbytes; // number of bytes to filter |
__asm__ __volatile__ ( |
//pre "movl row, %%edi \n\t" |
// get # of bytes to alignment |
#ifdef __PIC__ |
"pushl %%ebx \n\t" |
#endif |
"movl %%edi, %%ecx \n\t" |
"xorl %%ebx, %%ebx \n\t" |
"addl $0x7, %%ecx \n\t" |
"xorl %%eax, %%eax \n\t" |
"andl $0xfffffff8, %%ecx \n\t" |
//pre "movl prev_row, %%esi \n\t" |
"subl %%edi, %%ecx \n\t" |
"jz up_go \n\t" |
"up_lp1: \n\t" // fix alignment |
"movb (%%edi,%%ebx,), %%al \n\t" |
"addb (%%esi,%%ebx,), %%al \n\t" |
"incl %%ebx \n\t" |
"cmpl %%ecx, %%ebx \n\t" |
"movb %%al, -1(%%edi,%%ebx,) \n\t" // mov does not affect flags; -1 to |
"jb up_lp1 \n\t" // offset incl ebx |
"up_go: \n\t" |
//pre "movl len, %%edx \n\t" |
"movl %%edx, %%ecx \n\t" |
"subl %%ebx, %%edx \n\t" // subtract alignment fix |
"andl $0x0000003f, %%edx \n\t" // calc bytes over mult of 64 |
"subl %%edx, %%ecx \n\t" // drop over bytes from length |
// unrolled loop - use all MMX registers and interleave to reduce |
// number of branch instructions (loops) and reduce partial stalls |
"up_loop: \n\t" |
"movq (%%esi,%%ebx,), %%mm1 \n\t" |
"movq (%%edi,%%ebx,), %%mm0 \n\t" |
"movq 8(%%esi,%%ebx,), %%mm3 \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"movq 8(%%edi,%%ebx,), %%mm2 \n\t" |
"movq %%mm0, (%%edi,%%ebx,) \n\t" |
"paddb %%mm3, %%mm2 \n\t" |
"movq 16(%%esi,%%ebx,), %%mm5 \n\t" |
"movq %%mm2, 8(%%edi,%%ebx,) \n\t" |
"movq 16(%%edi,%%ebx,), %%mm4 \n\t" |
"movq 24(%%esi,%%ebx,), %%mm7 \n\t" |
"paddb %%mm5, %%mm4 \n\t" |
"movq 24(%%edi,%%ebx,), %%mm6 \n\t" |
"movq %%mm4, 16(%%edi,%%ebx,) \n\t" |
"paddb %%mm7, %%mm6 \n\t" |
"movq 32(%%esi,%%ebx,), %%mm1 \n\t" |
"movq %%mm6, 24(%%edi,%%ebx,) \n\t" |
"movq 32(%%edi,%%ebx,), %%mm0 \n\t" |
"movq 40(%%esi,%%ebx,), %%mm3 \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"movq 40(%%edi,%%ebx,), %%mm2 \n\t" |
"movq %%mm0, 32(%%edi,%%ebx,) \n\t" |
"paddb %%mm3, %%mm2 \n\t" |
"movq 48(%%esi,%%ebx,), %%mm5 \n\t" |
"movq %%mm2, 40(%%edi,%%ebx,) \n\t" |
"movq 48(%%edi,%%ebx,), %%mm4 \n\t" |
"movq 56(%%esi,%%ebx,), %%mm7 \n\t" |
"paddb %%mm5, %%mm4 \n\t" |
"movq 56(%%edi,%%ebx,), %%mm6 \n\t" |
"movq %%mm4, 48(%%edi,%%ebx,) \n\t" |
"addl $64, %%ebx \n\t" |
"paddb %%mm7, %%mm6 \n\t" |
"cmpl %%ecx, %%ebx \n\t" |
"movq %%mm6, -8(%%edi,%%ebx,) \n\t" // (+56)movq does not affect flags; |
"jb up_loop \n\t" // -8 to offset addl ebx |
"cmpl $0, %%edx \n\t" // test for bytes over mult of 64 |
"jz up_end \n\t" |
"cmpl $8, %%edx \n\t" // test for less than 8 bytes |
"jb up_lt8 \n\t" // [added by lcreeve@netins.net] |
"addl %%edx, %%ecx \n\t" |
"andl $0x00000007, %%edx \n\t" // calc bytes over mult of 8 |
"subl %%edx, %%ecx \n\t" // drop over bytes from length |
"jz up_lt8 \n\t" |
"up_lpA: \n\t" // use MMX regs to update 8 bytes sim. |
"movq (%%esi,%%ebx,), %%mm1 \n\t" |
"movq (%%edi,%%ebx,), %%mm0 \n\t" |
"addl $8, %%ebx \n\t" |
"paddb %%mm1, %%mm0 \n\t" |
"cmpl %%ecx, %%ebx \n\t" |
"movq %%mm0, -8(%%edi,%%ebx,) \n\t" // movq does not affect flags; -8 to |
"jb up_lpA \n\t" // offset add ebx |
"cmpl $0, %%edx \n\t" // test for bytes over mult of 8 |
"jz up_end \n\t" |
"up_lt8: \n\t" |
"xorl %%eax, %%eax \n\t" |
"addl %%edx, %%ecx \n\t" // move over byte count into counter |
"up_lp2: \n\t" // use x86 regs for remaining bytes |
"movb (%%edi,%%ebx,), %%al \n\t" |
"addb (%%esi,%%ebx,), %%al \n\t" |
"incl %%ebx \n\t" |
"cmpl %%ecx, %%ebx \n\t" |
"movb %%al, -1(%%edi,%%ebx,) \n\t" // mov does not affect flags; -1 to |
"jb up_lp2 \n\t" // offset inc ebx |
"up_end: \n\t" |
"EMMS \n\t" // conversion of filtered row complete |
#ifdef __PIC__ |
"popl %%ebx \n\t" |
#endif |
: "=d" (dummy_value_d), // 0 // output regs (dummy) |
"=S" (dummy_value_S), // 1 |
"=D" (dummy_value_D) // 2 |
: "0" (len), // edx // input regs |
"1" (prev_row), // esi |
"2" (row) // edi |
: "%eax", "%ebx", "%ecx" // clobber list (no input regs!) |
#if 0 /* MMX regs (%mm0, etc.) not supported by gcc 2.7.2.3 or egcs 1.1 */ |
, "%mm0", "%mm1", "%mm2", "%mm3" |
, "%mm4", "%mm5", "%mm6", "%mm7" |
#endif |
); |
} // end of png_read_filter_row_mmx_up() |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
/*===========================================================================*/ |
/* */ |
/* P N G _ R E A D _ F I L T E R _ R O W */ |
/* */ |
/*===========================================================================*/ |
/* Optimized png_read_filter_row routines */ |
void /* PRIVATE */ |
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep |
row, png_bytep prev_row, int filter) |
{ |
#ifdef PNG_DEBUG |
char filnm[10]; |
#endif |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
/* GRR: these are superseded by png_ptr->asm_flags: */ |
#define UseMMX_sub 1 // GRR: converted 20000730 |
#define UseMMX_up 1 // GRR: converted 20000729 |
#define UseMMX_avg 1 // GRR: converted 20000828 (+ 16-bit bugfix 20000916) |
#define UseMMX_paeth 1 // GRR: converted 20000828 |
if (_mmx_supported == 2) { |
/* this should have happened in png_init_mmx_flags() already */ |
#if !defined(PNG_1_0_X) |
png_warning(png_ptr, "asm_flags may not have been initialized"); |
#endif |
png_mmx_support(); |
} |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
#ifdef PNG_DEBUG |
png_debug(1, "in png_read_filter_row (pnggccrd.c)\n"); |
switch (filter) |
{ |
case 0: sprintf(filnm, "none"); |
break; |
case 1: sprintf(filnm, "sub-%s", |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "MMX" : |
#endif |
#endif |
"x86"); |
break; |
case 2: sprintf(filnm, "up-%s", |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
#if !defined(PNG_1_0_X) |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "MMX" : |
#endif |
#endif |
"x86"); |
break; |
case 3: sprintf(filnm, "avg-%s", |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "MMX" : |
#endif |
#endif |
"x86"); |
break; |
case 4: sprintf(filnm, "Paeth-%s", |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "MMX": |
#endif |
#endif |
"x86"); |
break; |
default: sprintf(filnm, "unknw"); |
break; |
} |
png_debug2(0, "row_number=%5ld, %5s, ", png_ptr->row_number, filnm); |
png_debug1(0, "row=0x%08lx, ", (unsigned long)row); |
png_debug2(0, "pixdepth=%2d, bytes=%d, ", (int)row_info->pixel_depth, |
(int)((row_info->pixel_depth + 7) >> 3)); |
png_debug1(0,"rowbytes=%8ld\n", row_info->rowbytes); |
#endif /* PNG_DEBUG */ |
switch (filter) |
{ |
case PNG_FILTER_VALUE_NONE: |
break; |
case PNG_FILTER_VALUE_SUB: |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_read_filter_row_mmx_sub(row_info, row); |
} |
else |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_bytep rp = row + bpp; |
png_bytep lp = row; |
for (i = bpp; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); |
rp++; |
} |
} /* end !UseMMX_sub */ |
break; |
case PNG_FILTER_VALUE_UP: |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_read_filter_row_mmx_up(row_info, row, prev_row); |
} |
else |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
for (i = 0; i < istop; ++i) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
} /* end !UseMMX_up */ |
break; |
case PNG_FILTER_VALUE_AVG: |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_read_filter_row_mmx_avg(row_info, row, prev_row); |
} |
else |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop = row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
((int)(*pp++) >> 1)) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
((int)(*pp++ + *lp++) >> 1)) & 0xff); |
rp++; |
} |
} /* end !UseMMX_avg */ |
break; |
case PNG_FILTER_VALUE_PAETH: |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && defined(PNG_THREAD_UNSAFE_OK) |
#if !defined(PNG_1_0_X) |
if ((png_ptr->asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH) && |
(row_info->pixel_depth >= png_ptr->mmx_bitdepth_threshold) && |
(row_info->rowbytes >= png_ptr->mmx_rowbytes_threshold)) |
#else |
if (_mmx_supported) |
#endif |
{ |
png_read_filter_row_mmx_paeth(row_info, row, prev_row); |
} |
else |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_bytep cp = prev_row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop = row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) /* use leftover rp,pp */ |
{ |
int a, b, c, pa, pb, pc, p; |
a = *lp++; |
b = *pp++; |
c = *cp++; |
p = b - c; |
pc = a - c; |
#ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
#else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
/* |
if (pa <= pb && pa <= pc) |
p = a; |
else if (pb <= pc) |
p = b; |
else |
p = c; |
*/ |
p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c; |
*rp = (png_byte)(((int)(*rp) + p) & 0xff); |
rp++; |
} |
} /* end !UseMMX_paeth */ |
break; |
default: |
png_warning(png_ptr, "Ignoring bad row-filter type"); |
*row=0; |
break; |
} |
} |
#endif /* PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */ |
/*===========================================================================*/ |
/* */ |
/* P N G _ M M X _ S U P P O R T */ |
/* */ |
/*===========================================================================*/ |
/* GRR NOTES: (1) the following code assumes 386 or better (pushfl/popfl) |
* (2) all instructions compile with gcc 2.7.2.3 and later |
* (3) the function is moved down here to prevent gcc from |
* inlining it in multiple places and then barfing be- |
* cause the ".NOT_SUPPORTED" label is multiply defined |
* [is there a way to signal that a *single* function should |
* not be inlined? is there a way to modify the label for |
* each inlined instance, e.g., by appending _1, _2, etc.? |
* maybe if don't use leading "." in label name? (nope...sigh)] |
*/ |
int PNGAPI |
png_mmx_support(void) |
{ |
#if defined(PNG_MMX_CODE_SUPPORTED) |
__asm__ __volatile__ ( |
"pushl %%ebx \n\t" // ebx gets clobbered by CPUID instruction |
"pushl %%ecx \n\t" // so does ecx... |
"pushl %%edx \n\t" // ...and edx (but ecx & edx safe on Linux) |
// ".byte 0x66 \n\t" // convert 16-bit pushf to 32-bit pushfd |
// "pushf \n\t" // 16-bit pushf |
"pushfl \n\t" // save Eflag to stack |
"popl %%eax \n\t" // get Eflag from stack into eax |
"movl %%eax, %%ecx \n\t" // make another copy of Eflag in ecx |
"xorl $0x200000, %%eax \n\t" // toggle ID bit in Eflag (i.e., bit 21) |
"pushl %%eax \n\t" // save modified Eflag back to stack |
// ".byte 0x66 \n\t" // convert 16-bit popf to 32-bit popfd |
// "popf \n\t" // 16-bit popf |
"popfl \n\t" // restore modified value to Eflag reg |
"pushfl \n\t" // save Eflag to stack |
"popl %%eax \n\t" // get Eflag from stack |
"pushl %%ecx \n\t" // save original Eflag to stack |
"popfl \n\t" // restore original Eflag |
"xorl %%ecx, %%eax \n\t" // compare new Eflag with original Eflag |
"jz 0f \n\t" // if same, CPUID instr. is not supported |
"xorl %%eax, %%eax \n\t" // set eax to zero |
// ".byte 0x0f, 0xa2 \n\t" // CPUID instruction (two-byte opcode) |
"cpuid \n\t" // get the CPU identification info |
"cmpl $1, %%eax \n\t" // make sure eax return non-zero value |
"jl 0f \n\t" // if eax is zero, MMX is not supported |
"xorl %%eax, %%eax \n\t" // set eax to zero and... |
"incl %%eax \n\t" // ...increment eax to 1. This pair is |
// faster than the instruction "mov eax, 1" |
"cpuid \n\t" // get the CPU identification info again |
"andl $0x800000, %%edx \n\t" // mask out all bits but MMX bit (23) |
"cmpl $0, %%edx \n\t" // 0 = MMX not supported |
"jz 0f \n\t" // non-zero = yes, MMX IS supported |
"movl $1, %%eax \n\t" // set return value to 1 |
"jmp 1f \n\t" // DONE: have MMX support |
"0: \n\t" // .NOT_SUPPORTED: target label for jump instructions |
"movl $0, %%eax \n\t" // set return value to 0 |
"1: \n\t" // .RETURN: target label for jump instructions |
"movl %%eax, _mmx_supported \n\t" // save in global static variable, too |
"popl %%edx \n\t" // restore edx |
"popl %%ecx \n\t" // restore ecx |
"popl %%ebx \n\t" // restore ebx |
// "ret \n\t" // DONE: no MMX support |
// (fall through to standard C "ret") |
: // output list (none) |
: // any variables used on input (none) |
: "%eax" // clobber list |
// , "%ebx", "%ecx", "%edx" // GRR: we handle these manually |
// , "memory" // if write to a variable gcc thought was in a reg |
// , "cc" // "condition codes" (flag bits) |
); |
#else |
_mmx_supported = 0; |
#endif /* PNG_MMX_CODE_SUPPORTED */ |
return _mmx_supported; |
} |
#endif /* PNG_USE_PNGGCCRD */ |
/shark/trunk/ports/png/trees.h |
---|
0,0 → 1,128 |
/* header created automatically with -DGEN_TREES_H */ |
local const ct_data static_ltree[L_CODES+2] = { |
{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, |
{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, |
{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, |
{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, |
{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, |
{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, |
{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, |
{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, |
{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, |
{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, |
{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, |
{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, |
{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, |
{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, |
{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, |
{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, |
{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, |
{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, |
{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, |
{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, |
{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, |
{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, |
{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, |
{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, |
{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, |
{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, |
{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, |
{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, |
{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, |
{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, |
{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, |
{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, |
{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, |
{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, |
{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, |
{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, |
{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, |
{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, |
{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, |
{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, |
{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, |
{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, |
{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, |
{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, |
{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, |
{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, |
{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, |
{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, |
{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, |
{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, |
{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, |
{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, |
{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, |
{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, |
{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, |
{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, |
{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, |
{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} |
}; |
local const ct_data static_dtree[D_CODES] = { |
{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, |
{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, |
{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, |
{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, |
{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, |
{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} |
}; |
const uch _dist_code[DIST_CODE_LEN] = { |
0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, |
8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, |
10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, |
11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, |
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, |
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, |
13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, |
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, |
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, |
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, |
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, |
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, |
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, |
18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, |
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, |
24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, |
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, |
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, |
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, |
27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, |
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, |
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, |
28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, |
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, |
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, |
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 |
}; |
const uch _length_code[MAX_MATCH-MIN_MATCH+1]= { |
0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, |
13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, |
17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, |
19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, |
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, |
22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, |
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, |
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, |
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, |
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, |
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, |
26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, |
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 |
}; |
local const int base_length[LENGTH_CODES] = { |
0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, |
64, 80, 96, 112, 128, 160, 192, 224, 0 |
}; |
local const int base_dist[D_CODES] = { |
0, 1, 2, 3, 4, 6, 8, 12, 16, 24, |
32, 48, 64, 96, 128, 192, 256, 384, 512, 768, |
1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 |
}; |
/shark/trunk/ports/png/png.h |
---|
0,0 → 1,3283 |
/* png.h - header file for PNG reference library |
* |
* libpng version 1.2.5 - October 3, 2002 |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* Authors and maintainers: |
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat |
* libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger |
* libpng versions 0.97, January 1998, through 1.2.5 - October 3, 2002: Glenn |
* See also "Contributing Authors", below. |
* |
* Note about libpng version numbers: |
* |
* Due to various miscommunications, unforeseen code incompatibilities |
* and occasional factors outside the authors' control, version numbering |
* on the library has not always been consistent and straightforward. |
* The following table summarizes matters since version 0.89c, which was |
* the first widely used release: |
* |
* source png.h png.h shared-lib |
* version string int version |
* ------- ------ ----- ---------- |
* 0.89c "1.0 beta 3" 0.89 89 1.0.89 |
* 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] |
* 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] |
* 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] |
* 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] |
* 0.97c 0.97 97 2.0.97 |
* 0.98 0.98 98 2.0.98 |
* 0.99 0.99 98 2.0.99 |
* 0.99a-m 0.99 99 2.0.99 |
* 1.00 1.00 100 2.1.0 [100 should be 10000] |
* 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] |
* 1.0.1 png.h string is 10001 2.1.0 |
* 1.0.1a-e identical to the 10002 from here on, the shared library |
* 1.0.2 source version) 10002 is 2.V where V is the source code |
* 1.0.2a-b 10003 version, except as noted. |
* 1.0.3 10003 |
* 1.0.3a-d 10004 |
* 1.0.4 10004 |
* 1.0.4a-f 10005 |
* 1.0.5 (+ 2 patches) 10005 |
* 1.0.5a-d 10006 |
* 1.0.5e-r 10100 (not source compatible) |
* 1.0.5s-v 10006 (not binary compatible) |
* 1.0.6 (+ 3 patches) 10006 (still binary incompatible) |
* 1.0.6d-f 10007 (still binary incompatible) |
* 1.0.6g 10007 |
* 1.0.6h 10007 10.6h (testing xy.z so-numbering) |
* 1.0.6i 10007 10.6i |
* 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) |
* 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) |
* 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) |
* 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) |
* 1.0.7 1 10007 (still compatible) |
* 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 |
* 1.0.8rc1 1 10008 2.1.0.8rc1 |
* 1.0.8 1 10008 2.1.0.8 |
* 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 |
* 1.0.9rc1 1 10009 2.1.0.9rc1 |
* 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 |
* 1.0.9rc2 1 10009 2.1.0.9rc2 |
* 1.0.9 1 10009 2.1.0.9 |
* 1.0.10beta1 1 10010 2.1.0.10beta1 |
* 1.0.10rc1 1 10010 2.1.0.10rc1 |
* 1.0.10 1 10010 2.1.0.10 |
* 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 |
* 1.0.11rc1 1 10011 2.1.0.11rc1 |
* 1.0.11 1 10011 2.1.0.11 |
* 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 |
* 1.0.12rc1 2 10012 2.1.0.12rc1 |
* 1.0.12 2 10012 2.1.0.12 |
* 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) |
* 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 |
* 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 |
* 1.2.0rc1 3 10200 3.1.2.0rc1 |
* 1.2.0 3 10200 3.1.2.0 |
* 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 |
* 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 |
* 1.2.1 3 10201 3.1.2.1 |
* 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 |
* 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 |
* 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 |
* 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 |
* 1.0.13 10 10013 10.so.0.1.0.13 |
* 1.2.2 12 10202 12.so.0.1.2.2 |
* 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 |
* 1.2.3 12 10203 12.so.0.1.2.3 |
* 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 |
* 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 |
* 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 |
* 1.0.14 10 10014 10.so.0.1.0.14 |
* 1.2.4 13 10204 12.so.0.1.2.4 |
* 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 |
* 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 |
* 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 |
* 1.0.15 10 10015 10.so.0.1.0.15 |
* 1.2.5 13 10205 12.so.0.1.2.5 |
* |
* Henceforth the source version will match the shared-library major |
* and minor numbers; the shared-library major version number will be |
* used for changes in backward compatibility, as it is intended. The |
* PNG_LIBPNG_VER macro, which is not used within libpng but is available |
* for applications, is an unsigned integer of the form xyyzz corresponding |
* to the source version x.y.z (leading zeros in y and z). Beta versions |
* were given the previous public release number plus a letter, until |
* version 1.0.6j; from then on they were given the upcoming public |
* release number plus "betaNN" or "rcN". |
* |
* Binary incompatibility exists only when applications make direct access |
* to the info_ptr or png_ptr members through png.h, and the compiled |
* application is loaded with a different version of the library. |
* |
* DLLNUM will change each time there are forward or backward changes |
* in binary compatibility (e.g., when a new feature is added). |
* |
* See libpng.txt or libpng.3 for more information. The PNG specification |
* is available as RFC 2083 <ftp://ftp.uu.net/graphics/png/documents/> |
* and as a W3C Recommendation <http://www.w3.org/TR/REC.png.html> |
*/ |
/* |
* COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: |
* |
* If you modify libpng you may insert additional notices immediately following |
* this sentence. |
* |
* libpng versions 1.0.7, July 1, 2000, through 1.2.5, October 3, 2002, are |
* Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are |
* distributed according to the same disclaimer and license as libpng-1.0.6 |
* with the following individuals added to the list of Contributing Authors |
* |
* Simon-Pierre Cadieux |
* Eric S. Raymond |
* Gilles Vollant |
* |
* and with the following additions to the disclaimer: |
* |
* There is no warranty against interference with your enjoyment of the |
* library or against infringement. There is no warranty that our |
* efforts or the library will fulfill any of your particular purposes |
* or needs. This library is provided with all faults, and the entire |
* risk of satisfactory quality, performance, accuracy, and effort is with |
* the user. |
* |
* libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are |
* Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson |
* Distributed according to the same disclaimer and license as libpng-0.96, |
* with the following individuals added to the list of Contributing Authors: |
* |
* Tom Lane |
* Glenn Randers-Pehrson |
* Willem van Schaik |
* |
* libpng versions 0.89, June 1996, through 0.96, May 1997, are |
* Copyright (c) 1996, 1997 Andreas Dilger |
* Distributed according to the same disclaimer and license as libpng-0.88, |
* with the following individuals added to the list of Contributing Authors: |
* |
* John Bowler |
* Kevin Bracey |
* Sam Bushell |
* Magnus Holmgren |
* Greg Roelofs |
* Tom Tanner |
* |
* libpng versions 0.5, May 1995, through 0.88, January 1996, are |
* Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. |
* |
* For the purposes of this copyright and license, "Contributing Authors" |
* is defined as the following set of individuals: |
* |
* Andreas Dilger |
* Dave Martindale |
* Guy Eric Schalnat |
* Paul Schmidt |
* Tim Wegner |
* |
* The PNG Reference Library is supplied "AS IS". The Contributing Authors |
* and Group 42, Inc. disclaim all warranties, expressed or implied, |
* including, without limitation, the warranties of merchantability and of |
* fitness for any purpose. The Contributing Authors and Group 42, Inc. |
* assume no liability for direct, indirect, incidental, special, exemplary, |
* or consequential damages, which may result from the use of the PNG |
* Reference Library, even if advised of the possibility of such damage. |
* |
* Permission is hereby granted to use, copy, modify, and distribute this |
* source code, or portions hereof, for any purpose, without fee, subject |
* to the following restrictions: |
* |
* 1. The origin of this source code must not be misrepresented. |
* |
* 2. Altered versions must be plainly marked as such and |
* must not be misrepresented as being the original source. |
* |
* 3. This Copyright notice may not be removed or altered from |
* any source or altered source distribution. |
* |
* The Contributing Authors and Group 42, Inc. specifically permit, without |
* fee, and encourage the use of this source code as a component to |
* supporting the PNG file format in commercial products. If you use this |
* source code in a product, acknowledgment is not required but would be |
* appreciated. |
*/ |
/* |
* A "png_get_copyright" function is available, for convenient use in "about" |
* boxes and the like: |
* |
* printf("%s",png_get_copyright(NULL)); |
* |
* Also, the PNG logo (in PNG format, of course) is supplied in the |
* files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). |
*/ |
/* |
* Libpng is OSI Certified Open Source Software. OSI Certified is a |
* certification mark of the Open Source Initiative. |
*/ |
/* |
* The contributing authors would like to thank all those who helped |
* with testing, bug fixes, and patience. This wouldn't have been |
* possible without all of you. |
* |
* Thanks to Frank J. T. Wojcik for helping with the documentation. |
*/ |
/* |
* Y2K compliance in libpng: |
* ========================= |
* |
* October 3, 2002 |
* |
* Since the PNG Development group is an ad-hoc body, we can't make |
* an official declaration. |
* |
* This is your unofficial assurance that libpng from version 0.71 and |
* upward through 1.2.5 are Y2K compliant. It is my belief that earlier |
* versions were also Y2K compliant. |
* |
* Libpng only has three year fields. One is a 2-byte unsigned integer |
* that will hold years up to 65535. The other two hold the date in text |
* format, and will hold years up to 9999. |
* |
* The integer is |
* "png_uint_16 year" in png_time_struct. |
* |
* The strings are |
* "png_charp time_buffer" in png_struct and |
* "near_time_buffer", which is a local character string in png.c. |
* |
* There are seven time-related functions: |
* png.c: png_convert_to_rfc_1123() in png.c |
* (formerly png_convert_to_rfc_1152() in error) |
* png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c |
* png_convert_from_time_t() in pngwrite.c |
* png_get_tIME() in pngget.c |
* png_handle_tIME() in pngrutil.c, called in pngread.c |
* png_set_tIME() in pngset.c |
* png_write_tIME() in pngwutil.c, called in pngwrite.c |
* |
* All handle dates properly in a Y2K environment. The |
* png_convert_from_time_t() function calls gmtime() to convert from system |
* clock time, which returns (year - 1900), which we properly convert to |
* the full 4-digit year. There is a possibility that applications using |
* libpng are not passing 4-digit years into the png_convert_to_rfc_1123() |
* function, or that they are incorrectly passing only a 2-digit year |
* instead of "year - 1900" into the png_convert_from_struct_tm() function, |
* but this is not under our control. The libpng documentation has always |
* stated that it works with 4-digit years, and the APIs have been |
* documented as such. |
* |
* The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned |
* integer to hold the year, and can hold years as large as 65535. |
* |
* zlib, upon which libpng depends, is also Y2K compliant. It contains |
* no date-related code. |
* |
* Glenn Randers-Pehrson |
* libpng maintainer |
* PNG Development Group |
*/ |
#ifndef PNG_H |
#define PNG_H |
/* This is not the place to learn how to use libpng. The file libpng.txt |
* describes how to use libpng, and the file example.c summarizes it |
* with some code on which to build. This file is useful for looking |
* at the actual function definitions and structure components. |
*/ |
/* Version information for png.h - this should match the version in png.c */ |
#define PNG_LIBPNG_VER_STRING "1.2.5" |
#define PNG_LIBPNG_VER_SONUM 0 |
#define PNG_LIBPNG_VER_DLLNUM %DLLNUM% |
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ |
#define PNG_LIBPNG_VER_MAJOR 1 |
#define PNG_LIBPNG_VER_MINOR 2 |
#define PNG_LIBPNG_VER_RELEASE 5 |
/* This should match the numeric part of the final component of |
* PNG_LIBPNG_VER_STRING, omitting any leading zero: */ |
#define PNG_LIBPNG_VER_BUILD 0 |
#define PNG_LIBPNG_BUILD_ALPHA 1 |
#define PNG_LIBPNG_BUILD_BETA 2 |
#define PNG_LIBPNG_BUILD_RC 3 |
#define PNG_LIBPNG_BUILD_STABLE 4 |
#define PNG_LIBPNG_BUILD_TYPEMASK 7 |
#define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with STABLE only */ |
#define PNG_LIBPNG_BUILD_TYPE 4 |
/* Careful here. At one time, Guy wanted to use 082, but that would be octal. |
* We must not include leading zeros. |
* Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only |
* version 1.0.0 was mis-numbered 100 instead of 10000). From |
* version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release */ |
#define PNG_LIBPNG_VER 10205 /* 1.2.5 */ |
#ifndef PNG_VERSION_INFO_ONLY |
/* include the compression library's header */ |
#include "zlib.h" |
/* include all user configurable info, including optional assembler routines */ |
#include "pngconf.h" |
/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ |
#ifdef __cplusplus |
extern "C" { |
#endif /* __cplusplus */ |
/* This file is arranged in several sections. The first section contains |
* structure and type definitions. The second section contains the external |
* library functions, while the third has the internal library functions, |
* which applications aren't expected to use directly. |
*/ |
#ifndef PNG_NO_TYPECAST_NULL |
#define int_p_NULL (int *)NULL |
#define png_bytep_NULL (png_bytep)NULL |
#define png_bytepp_NULL (png_bytepp)NULL |
#define png_doublep_NULL (png_doublep)NULL |
#define png_error_ptr_NULL (png_error_ptr)NULL |
#define png_flush_ptr_NULL (png_flush_ptr)NULL |
#define png_free_ptr_NULL (png_free_ptr)NULL |
#define png_infopp_NULL (png_infopp)NULL |
#define png_malloc_ptr_NULL (png_malloc_ptr)NULL |
#define png_read_status_ptr_NULL (png_read_status_ptr)NULL |
#define png_rw_ptr_NULL (png_rw_ptr)NULL |
#define png_structp_NULL (png_structp)NULL |
#define png_uint_16p_NULL (png_uint_16p)NULL |
#define png_voidp_NULL (png_voidp)NULL |
#define png_write_status_ptr_NULL (png_write_status_ptr)NULL |
#else |
#define int_p_NULL NULL |
#define png_bytep_NULL NULL |
#define png_bytepp_NULL NULL |
#define png_doublep_NULL NULL |
#define png_error_ptr_NULL NULL |
#define png_flush_ptr_NULL NULL |
#define png_free_ptr_NULL NULL |
#define png_infopp_NULL NULL |
#define png_malloc_ptr_NULL NULL |
#define png_read_status_ptr_NULL NULL |
#define png_rw_ptr_NULL NULL |
#define png_structp_NULL NULL |
#define png_uint_16p_NULL NULL |
#define png_voidp_NULL NULL |
#define png_write_status_ptr_NULL NULL |
#endif |
/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ |
#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) |
/* Version information for C files, stored in png.c. This had better match |
* the version above. |
*/ |
#ifdef PNG_USE_GLOBAL_ARRAYS |
PNG_EXPORT_VAR (const char) png_libpng_ver[18]; |
/* need room for 99.99.99beta99z */ |
#else |
#define png_libpng_ver png_get_header_ver(NULL) |
#endif |
#ifdef PNG_USE_GLOBAL_ARRAYS |
/* This was removed in version 1.0.5c */ |
/* Structures to facilitate easy interlacing. See png.c for more details */ |
PNG_EXPORT_VAR (const int FARDATA) png_pass_start[7]; |
PNG_EXPORT_VAR (const int FARDATA) png_pass_inc[7]; |
PNG_EXPORT_VAR (const int FARDATA) png_pass_ystart[7]; |
PNG_EXPORT_VAR (const int FARDATA) png_pass_yinc[7]; |
PNG_EXPORT_VAR (const int FARDATA) png_pass_mask[7]; |
PNG_EXPORT_VAR (const int FARDATA) png_pass_dsp_mask[7]; |
#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
PNG_EXPORT_VAR (const int FARDATA) png_pass_width[7]; |
#endif |
/* This isn't currently used. If you need it, see png.c for more details. |
PNG_EXPORT_VAR (const int FARDATA) png_pass_height[7]; |
*/ |
#endif |
#endif /* PNG_NO_EXTERN */ |
/* Three color definitions. The order of the red, green, and blue, (and the |
* exact size) is not important, although the size of the fields need to |
* be png_byte or png_uint_16 (as defined below). |
*/ |
typedef struct png_color_struct |
{ |
png_byte red; |
png_byte green; |
png_byte blue; |
} png_color; |
typedef png_color FAR * png_colorp; |
typedef png_color FAR * FAR * png_colorpp; |
typedef struct png_color_16_struct |
{ |
png_byte index; /* used for palette files */ |
png_uint_16 red; /* for use in red green blue files */ |
png_uint_16 green; |
png_uint_16 blue; |
png_uint_16 gray; /* for use in grayscale files */ |
} png_color_16; |
typedef png_color_16 FAR * png_color_16p; |
typedef png_color_16 FAR * FAR * png_color_16pp; |
typedef struct png_color_8_struct |
{ |
png_byte red; /* for use in red green blue files */ |
png_byte green; |
png_byte blue; |
png_byte gray; /* for use in grayscale files */ |
png_byte alpha; /* for alpha channel files */ |
} png_color_8; |
typedef png_color_8 FAR * png_color_8p; |
typedef png_color_8 FAR * FAR * png_color_8pp; |
/* |
* The following two structures are used for the in-core representation |
* of sPLT chunks. |
*/ |
typedef struct png_sPLT_entry_struct |
{ |
png_uint_16 red; |
png_uint_16 green; |
png_uint_16 blue; |
png_uint_16 alpha; |
png_uint_16 frequency; |
} png_sPLT_entry; |
typedef png_sPLT_entry FAR * png_sPLT_entryp; |
typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp; |
/* When the depth of the sPLT palette is 8 bits, the color and alpha samples |
* occupy the LSB of their respective members, and the MSB of each member |
* is zero-filled. The frequency member always occupies the full 16 bits. |
*/ |
typedef struct png_sPLT_struct |
{ |
png_charp name; /* palette name */ |
png_byte depth; /* depth of palette samples */ |
png_sPLT_entryp entries; /* palette entries */ |
png_int_32 nentries; /* number of palette entries */ |
} png_sPLT_t; |
typedef png_sPLT_t FAR * png_sPLT_tp; |
typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; |
#ifdef PNG_TEXT_SUPPORTED |
/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file, |
* and whether that contents is compressed or not. The "key" field |
* points to a regular zero-terminated C string. The "text", "lang", and |
* "lang_key" fields can be regular C strings, empty strings, or NULL pointers. |
* However, the * structure returned by png_get_text() will always contain |
* regular zero-terminated C strings (possibly empty), never NULL pointers, |
* so they can be safely used in printf() and other string-handling functions. |
*/ |
typedef struct png_text_struct |
{ |
int compression; /* compression value: |
-1: tEXt, none |
0: zTXt, deflate |
1: iTXt, none |
2: iTXt, deflate */ |
png_charp key; /* keyword, 1-79 character description of "text" */ |
png_charp text; /* comment, may be an empty string (ie "") |
or a NULL pointer */ |
png_size_t text_length; /* length of the text string */ |
#ifdef PNG_iTXt_SUPPORTED |
png_size_t itxt_length; /* length of the itxt string */ |
png_charp lang; /* language code, 0-79 characters |
or a NULL pointer */ |
png_charp lang_key; /* keyword translated UTF-8 string, 0 or more |
chars or a NULL pointer */ |
#endif |
} png_text; |
typedef png_text FAR * png_textp; |
typedef png_text FAR * FAR * png_textpp; |
#endif |
/* Supported compression types for text in PNG files (tEXt, and zTXt). |
* The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */ |
#define PNG_TEXT_COMPRESSION_NONE_WR -3 |
#define PNG_TEXT_COMPRESSION_zTXt_WR -2 |
#define PNG_TEXT_COMPRESSION_NONE -1 |
#define PNG_TEXT_COMPRESSION_zTXt 0 |
#define PNG_ITXT_COMPRESSION_NONE 1 |
#define PNG_ITXT_COMPRESSION_zTXt 2 |
#define PNG_TEXT_COMPRESSION_LAST 3 /* Not a valid value */ |
/* png_time is a way to hold the time in an machine independent way. |
* Two conversions are provided, both from time_t and struct tm. There |
* is no portable way to convert to either of these structures, as far |
* as I know. If you know of a portable way, send it to me. As a side |
* note - PNG has always been Year 2000 compliant! |
*/ |
typedef struct png_time_struct |
{ |
png_uint_16 year; /* full year, as in, 1995 */ |
png_byte month; /* month of year, 1 - 12 */ |
png_byte day; /* day of month, 1 - 31 */ |
png_byte hour; /* hour of day, 0 - 23 */ |
png_byte minute; /* minute of hour, 0 - 59 */ |
png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ |
} png_time; |
typedef png_time FAR * png_timep; |
typedef png_time FAR * FAR * png_timepp; |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
/* png_unknown_chunk is a structure to hold queued chunks for which there is |
* no specific support. The idea is that we can use this to queue |
* up private chunks for output even though the library doesn't actually |
* know about their semantics. |
*/ |
typedef struct png_unknown_chunk_t |
{ |
png_byte name[5]; |
png_byte *data; |
png_size_t size; |
/* libpng-using applications should NOT directly modify this byte. */ |
png_byte location; /* mode of operation at read time */ |
} |
png_unknown_chunk; |
typedef png_unknown_chunk FAR * png_unknown_chunkp; |
typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; |
#endif |
/* png_info is a structure that holds the information in a PNG file so |
* that the application can find out the characteristics of the image. |
* If you are reading the file, this structure will tell you what is |
* in the PNG file. If you are writing the file, fill in the information |
* you want to put into the PNG file, then call png_write_info(). |
* The names chosen should be very close to the PNG specification, so |
* consult that document for information about the meaning of each field. |
* |
* With libpng < 0.95, it was only possible to directly set and read the |
* the values in the png_info_struct, which meant that the contents and |
* order of the values had to remain fixed. With libpng 0.95 and later, |
* however, there are now functions that abstract the contents of |
* png_info_struct from the application, so this makes it easier to use |
* libpng with dynamic libraries, and even makes it possible to use |
* libraries that don't have all of the libpng ancillary chunk-handing |
* functionality. |
* |
* In any case, the order of the parameters in png_info_struct should NOT |
* be changed for as long as possible to keep compatibility with applications |
* that use the old direct-access method with png_info_struct. |
* |
* The following members may have allocated storage attached that should be |
* cleaned up before the structure is discarded: palette, trans, text, |
* pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile, |
* splt_palettes, scal_unit, row_pointers, and unknowns. By default, these |
* are automatically freed when the info structure is deallocated, if they were |
* allocated internally by libpng. This behavior can be changed by means |
* of the png_data_freer() function. |
* |
* More allocation details: all the chunk-reading functions that |
* change these members go through the corresponding png_set_* |
* functions. A function to clear these members is available: see |
* png_free_data(). The png_set_* functions do not depend on being |
* able to point info structure members to any of the storage they are |
* passed (they make their own copies), EXCEPT that the png_set_text |
* functions use the same storage passed to them in the text_ptr or |
* itxt_ptr structure argument, and the png_set_rows and png_set_unknowns |
* functions do not make their own copies. |
*/ |
typedef struct png_info_struct |
{ |
/* the following are necessary for every PNG file */ |
png_uint_32 width; /* width of image in pixels (from IHDR) */ |
png_uint_32 height; /* height of image in pixels (from IHDR) */ |
png_uint_32 valid; /* valid chunk data (see PNG_INFO_ below) */ |
png_uint_32 rowbytes; /* bytes needed to hold an untransformed row */ |
png_colorp palette; /* array of color values (valid & PNG_INFO_PLTE) */ |
png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */ |
png_uint_16 num_trans; /* number of transparent palette color (tRNS) */ |
png_byte bit_depth; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */ |
png_byte color_type; /* see PNG_COLOR_TYPE_ below (from IHDR) */ |
/* The following three should have been named *_method not *_type */ |
png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */ |
png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */ |
png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ |
/* The following is informational only on read, and not used on writes. */ |
png_byte channels; /* number of data channels per pixel (1, 2, 3, 4) */ |
png_byte pixel_depth; /* number of bits per pixel */ |
png_byte spare_byte; /* to align the data, and for future use */ |
png_byte signature[8]; /* magic bytes read by libpng from start of file */ |
/* The rest of the data is optional. If you are reading, check the |
* valid field to see if the information in these are valid. If you |
* are writing, set the valid field to those chunks you want written, |
* and initialize the appropriate fields below. |
*/ |
#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) |
/* The gAMA chunk describes the gamma characteristics of the system |
* on which the image was created, normally in the range [1.0, 2.5]. |
* Data is valid if (valid & PNG_INFO_gAMA) is non-zero. |
*/ |
float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */ |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
/* GR-P, 0.96a */ |
/* Data valid if (valid & PNG_INFO_sRGB) non-zero. */ |
png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */ |
#endif |
#if defined(PNG_TEXT_SUPPORTED) |
/* The tEXt, and zTXt chunks contain human-readable textual data in |
* uncompressed, compressed, and optionally compressed forms, respectively. |
* The data in "text" is an array of pointers to uncompressed, |
* null-terminated C strings. Each chunk has a keyword that describes the |
* textual data contained in that chunk. Keywords are not required to be |
* unique, and the text string may be empty. Any number of text chunks may |
* be in an image. |
*/ |
int num_text; /* number of comments read/to write */ |
int max_text; /* current size of text array */ |
png_textp text; /* array of comments read/to write */ |
#endif /* PNG_TEXT_SUPPORTED */ |
#if defined(PNG_tIME_SUPPORTED) |
/* The tIME chunk holds the last time the displayed image data was |
* modified. See the png_time struct for the contents of this struct. |
*/ |
png_time mod_time; |
#endif |
#if defined(PNG_sBIT_SUPPORTED) |
/* The sBIT chunk specifies the number of significant high-order bits |
* in the pixel data. Values are in the range [1, bit_depth], and are |
* only specified for the channels in the pixel data. The contents of |
* the low-order bits is not specified. Data is valid if |
* (valid & PNG_INFO_sBIT) is non-zero. |
*/ |
png_color_8 sig_bit; /* significant bits in color channels */ |
#endif |
#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \ |
defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* The tRNS chunk supplies transparency data for paletted images and |
* other image types that don't need a full alpha channel. There are |
* "num_trans" transparency values for a paletted image, stored in the |
* same order as the palette colors, starting from index 0. Values |
* for the data are in the range [0, 255], ranging from fully transparent |
* to fully opaque, respectively. For non-paletted images, there is a |
* single color specified that should be treated as fully transparent. |
* Data is valid if (valid & PNG_INFO_tRNS) is non-zero. |
*/ |
png_bytep trans; /* transparent values for paletted image */ |
png_color_16 trans_values; /* transparent color for non-palette image */ |
#endif |
#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* The bKGD chunk gives the suggested image background color if the |
* display program does not have its own background color and the image |
* is needs to composited onto a background before display. The colors |
* in "background" are normally in the same color space/depth as the |
* pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero. |
*/ |
png_color_16 background; |
#endif |
#if defined(PNG_oFFs_SUPPORTED) |
/* The oFFs chunk gives the offset in "offset_unit_type" units rightwards |
* and downwards from the top-left corner of the display, page, or other |
* application-specific co-ordinate space. See the PNG_OFFSET_ defines |
* below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero. |
*/ |
png_int_32 x_offset; /* x offset on page */ |
png_int_32 y_offset; /* y offset on page */ |
png_byte offset_unit_type; /* offset units type */ |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
/* The pHYs chunk gives the physical pixel density of the image for |
* display or printing in "phys_unit_type" units (see PNG_RESOLUTION_ |
* defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero. |
*/ |
png_uint_32 x_pixels_per_unit; /* horizontal pixel density */ |
png_uint_32 y_pixels_per_unit; /* vertical pixel density */ |
png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */ |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
/* The hIST chunk contains the relative frequency or importance of the |
* various palette entries, so that a viewer can intelligently select a |
* reduced-color palette, if required. Data is an array of "num_palette" |
* values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST) |
* is non-zero. |
*/ |
png_uint_16p hist; |
#endif |
#ifdef PNG_cHRM_SUPPORTED |
/* The cHRM chunk describes the CIE color characteristics of the monitor |
* on which the PNG was created. This data allows the viewer to do gamut |
* mapping of the input image to ensure that the viewer sees the same |
* colors in the image as the creator. Values are in the range |
* [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero. |
*/ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float x_white; |
float y_white; |
float x_red; |
float y_red; |
float x_green; |
float y_green; |
float x_blue; |
float y_blue; |
#endif |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
/* The pCAL chunk describes a transformation between the stored pixel |
* values and original physical data values used to create the image. |
* The integer range [0, 2^bit_depth - 1] maps to the floating-point |
* range given by [pcal_X0, pcal_X1], and are further transformed by a |
* (possibly non-linear) transformation function given by "pcal_type" |
* and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_ |
* defines below, and the PNG-Group's PNG extensions document for a |
* complete description of the transformations and how they should be |
* implemented, and for a description of the ASCII parameter strings. |
* Data values are valid if (valid & PNG_INFO_pCAL) non-zero. |
*/ |
png_charp pcal_purpose; /* pCAL chunk description string */ |
png_int_32 pcal_X0; /* minimum value */ |
png_int_32 pcal_X1; /* maximum value */ |
png_charp pcal_units; /* Latin-1 string giving physical units */ |
png_charpp pcal_params; /* ASCII strings containing parameter values */ |
png_byte pcal_type; /* equation type (see PNG_EQUATION_ below) */ |
png_byte pcal_nparams; /* number of parameters given in pcal_params */ |
#endif |
/* New members added in libpng-1.0.6 */ |
#ifdef PNG_FREE_ME_SUPPORTED |
png_uint_32 free_me; /* flags items libpng is responsible for freeing */ |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
/* storage for unknown chunks that the library doesn't recognize. */ |
png_unknown_chunkp unknown_chunks; |
png_size_t unknown_chunks_num; |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
/* iCCP chunk data. */ |
png_charp iccp_name; /* profile name */ |
png_charp iccp_profile; /* International Color Consortium profile data */ |
/* Note to maintainer: should be png_bytep */ |
png_uint_32 iccp_proflen; /* ICC profile data length */ |
png_byte iccp_compression; /* Always zero */ |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
/* data on sPLT chunks (there may be more than one). */ |
png_sPLT_tp splt_palettes; |
png_uint_32 splt_palettes_num; |
#endif |
#if defined(PNG_sCAL_SUPPORTED) |
/* The sCAL chunk describes the actual physical dimensions of the |
* subject matter of the graphic. The chunk contains a unit specification |
* a byte value, and two ASCII strings representing floating-point |
* values. The values are width and height corresponsing to one pixel |
* in the image. This external representation is converted to double |
* here. Data values are valid if (valid & PNG_INFO_sCAL) is non-zero. |
*/ |
png_byte scal_unit; /* unit of physical scale */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
double scal_pixel_width; /* width of one pixel */ |
double scal_pixel_height; /* height of one pixel */ |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_charp scal_s_width; /* string containing height */ |
png_charp scal_s_height; /* string containing width */ |
#endif |
#endif |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
/* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */ |
/* Data valid if (valid & PNG_INFO_IDAT) non-zero */ |
png_bytepp row_pointers; /* the image bits */ |
#endif |
#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED) |
png_fixed_point int_gamma; /* gamma of image, if (valid & PNG_INFO_gAMA) */ |
#endif |
#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED) |
png_fixed_point int_x_white; |
png_fixed_point int_y_white; |
png_fixed_point int_x_red; |
png_fixed_point int_y_red; |
png_fixed_point int_x_green; |
png_fixed_point int_y_green; |
png_fixed_point int_x_blue; |
png_fixed_point int_y_blue; |
#endif |
} png_info; |
typedef png_info FAR * png_infop; |
typedef png_info FAR * FAR * png_infopp; |
/* Maximum positive integer used in PNG is (2^31)-1 */ |
#define PNG_MAX_UINT ((png_uint_32)0x7fffffffL) |
/* These describe the color_type field in png_info. */ |
/* color type masks */ |
#define PNG_COLOR_MASK_PALETTE 1 |
#define PNG_COLOR_MASK_COLOR 2 |
#define PNG_COLOR_MASK_ALPHA 4 |
/* color types. Note that not all combinations are legal */ |
#define PNG_COLOR_TYPE_GRAY 0 |
#define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE) |
#define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR) |
#define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA) |
#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA) |
/* aliases */ |
#define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA |
#define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA |
/* This is for compression type. PNG 1.0-1.2 only define the single type. */ |
#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */ |
#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE |
/* This is for filter type. PNG 1.0-1.2 only define the single type. */ |
#define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */ |
#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */ |
#define PNG_FILTER_TYPE_DEFAULT PNG_FILTER_TYPE_BASE |
/* These are for the interlacing type. These values should NOT be changed. */ |
#define PNG_INTERLACE_NONE 0 /* Non-interlaced image */ |
#define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */ |
#define PNG_INTERLACE_LAST 2 /* Not a valid value */ |
/* These are for the oFFs chunk. These values should NOT be changed. */ |
#define PNG_OFFSET_PIXEL 0 /* Offset in pixels */ |
#define PNG_OFFSET_MICROMETER 1 /* Offset in micrometers (1/10^6 meter) */ |
#define PNG_OFFSET_LAST 2 /* Not a valid value */ |
/* These are for the pCAL chunk. These values should NOT be changed. */ |
#define PNG_EQUATION_LINEAR 0 /* Linear transformation */ |
#define PNG_EQUATION_BASE_E 1 /* Exponential base e transform */ |
#define PNG_EQUATION_ARBITRARY 2 /* Arbitrary base exponential transform */ |
#define PNG_EQUATION_HYPERBOLIC 3 /* Hyperbolic sine transformation */ |
#define PNG_EQUATION_LAST 4 /* Not a valid value */ |
/* These are for the sCAL chunk. These values should NOT be changed. */ |
#define PNG_SCALE_UNKNOWN 0 /* unknown unit (image scale) */ |
#define PNG_SCALE_METER 1 /* meters per pixel */ |
#define PNG_SCALE_RADIAN 2 /* radians per pixel */ |
#define PNG_SCALE_LAST 3 /* Not a valid value */ |
/* These are for the pHYs chunk. These values should NOT be changed. */ |
#define PNG_RESOLUTION_UNKNOWN 0 /* pixels/unknown unit (aspect ratio) */ |
#define PNG_RESOLUTION_METER 1 /* pixels/meter */ |
#define PNG_RESOLUTION_LAST 2 /* Not a valid value */ |
/* These are for the sRGB chunk. These values should NOT be changed. */ |
#define PNG_sRGB_INTENT_PERCEPTUAL 0 |
#define PNG_sRGB_INTENT_RELATIVE 1 |
#define PNG_sRGB_INTENT_SATURATION 2 |
#define PNG_sRGB_INTENT_ABSOLUTE 3 |
#define PNG_sRGB_INTENT_LAST 4 /* Not a valid value */ |
/* This is for text chunks */ |
#define PNG_KEYWORD_MAX_LENGTH 79 |
/* Maximum number of entries in PLTE/sPLT/tRNS arrays */ |
#define PNG_MAX_PALETTE_LENGTH 256 |
/* These determine if an ancillary chunk's data has been successfully read |
* from the PNG header, or if the application has filled in the corresponding |
* data in the info_struct to be written into the output file. The values |
* of the PNG_INFO_<chunk> defines should NOT be changed. |
*/ |
#define PNG_INFO_gAMA 0x0001 |
#define PNG_INFO_sBIT 0x0002 |
#define PNG_INFO_cHRM 0x0004 |
#define PNG_INFO_PLTE 0x0008 |
#define PNG_INFO_tRNS 0x0010 |
#define PNG_INFO_bKGD 0x0020 |
#define PNG_INFO_hIST 0x0040 |
#define PNG_INFO_pHYs 0x0080 |
#define PNG_INFO_oFFs 0x0100 |
#define PNG_INFO_tIME 0x0200 |
#define PNG_INFO_pCAL 0x0400 |
#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ |
#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ |
#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ |
#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ |
#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ |
/* This is used for the transformation routines, as some of them |
* change these values for the row. It also should enable using |
* the routines for other purposes. |
*/ |
typedef struct png_row_info_struct |
{ |
png_uint_32 width; /* width of row */ |
png_uint_32 rowbytes; /* number of bytes in row */ |
png_byte color_type; /* color type of row */ |
png_byte bit_depth; /* bit depth of row */ |
png_byte channels; /* number of channels (1, 2, 3, or 4) */ |
png_byte pixel_depth; /* bits per pixel (depth * channels) */ |
} png_row_info; |
typedef png_row_info FAR * png_row_infop; |
typedef png_row_info FAR * FAR * png_row_infopp; |
/* These are the function types for the I/O functions and for the functions |
* that allow the user to override the default I/O functions with his or her |
* own. The png_error_ptr type should match that of user-supplied warning |
* and error functions, while the png_rw_ptr type should match that of the |
* user read/write data functions. |
*/ |
typedef struct png_struct_def png_struct; |
typedef png_struct FAR * png_structp; |
typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); |
typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); |
typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); |
typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, |
int)); |
typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, |
int)); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); |
typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); |
typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, |
png_uint_32, int)); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, |
png_row_infop, png_bytep)); |
#endif |
#if defined(PNG_USER_CHUNKS_SUPPORTED) |
typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); |
#endif |
/* Transform masks for the high-level interface */ |
#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ |
#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ |
#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ |
#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ |
#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ |
#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ |
#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ |
#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ |
#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ |
#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ |
#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ |
#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ |
#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */ |
/* Flags for MNG supported features */ |
#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 |
#define PNG_FLAG_MNG_FILTER_64 0x04 |
#define PNG_ALL_MNG_FEATURES 0x05 |
typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); |
typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); |
/* The structure that holds the information to read and write PNG files. |
* The only people who need to care about what is inside of this are the |
* people who will be modifying the library for their own special needs. |
* It should NOT be accessed directly by an application, except to store |
* the jmp_buf. |
*/ |
struct png_struct_def |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf jmpbuf; /* used in png_error */ |
#endif |
png_error_ptr error_fn; /* function for printing errors and aborting */ |
png_error_ptr warning_fn; /* function for printing warnings */ |
png_voidp error_ptr; /* user supplied struct for error functions */ |
png_rw_ptr write_data_fn; /* function for writing output data */ |
png_rw_ptr read_data_fn; /* function for reading input data */ |
png_voidp io_ptr; /* ptr to application struct for I/O functions */ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
png_user_transform_ptr read_user_transform_fn; /* user read transform */ |
#endif |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
png_user_transform_ptr write_user_transform_fn; /* user write transform */ |
#endif |
/* These were added in libpng-1.0.2 */ |
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
png_voidp user_transform_ptr; /* user supplied struct for user transform */ |
png_byte user_transform_depth; /* bit depth of user transformed pixels */ |
png_byte user_transform_channels; /* channels in user transformed pixels */ |
#endif |
#endif |
png_uint_32 mode; /* tells us where we are in the PNG file */ |
png_uint_32 flags; /* flags indicating various things to libpng */ |
png_uint_32 transformations; /* which transformations to perform */ |
z_stream zstream; /* pointer to decompression structure (below) */ |
png_bytep zbuf; /* buffer for zlib */ |
png_size_t zbuf_size; /* size of zbuf */ |
int zlib_level; /* holds zlib compression level */ |
int zlib_method; /* holds zlib compression method */ |
int zlib_window_bits; /* holds zlib compression window bits */ |
int zlib_mem_level; /* holds zlib compression memory level */ |
int zlib_strategy; /* holds zlib compression strategy */ |
png_uint_32 width; /* width of image in pixels */ |
png_uint_32 height; /* height of image in pixels */ |
png_uint_32 num_rows; /* number of rows in current pass */ |
png_uint_32 usr_width; /* width of row at start of write */ |
png_uint_32 rowbytes; /* size of row in bytes */ |
png_uint_32 irowbytes; /* size of current interlaced row in bytes */ |
png_uint_32 iwidth; /* width of current interlaced row in pixels */ |
png_uint_32 row_number; /* current row in interlace pass */ |
png_bytep prev_row; /* buffer to save previous (unfiltered) row */ |
png_bytep row_buf; /* buffer to save current (unfiltered) row */ |
png_bytep sub_row; /* buffer to save "sub" row when filtering */ |
png_bytep up_row; /* buffer to save "up" row when filtering */ |
png_bytep avg_row; /* buffer to save "avg" row when filtering */ |
png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ |
png_row_info row_info; /* used for transformation routines */ |
png_uint_32 idat_size; /* current IDAT size for read */ |
png_uint_32 crc; /* current chunk CRC value */ |
png_colorp palette; /* palette from the input file */ |
png_uint_16 num_palette; /* number of color entries in palette */ |
png_uint_16 num_trans; /* number of transparency values */ |
png_byte chunk_name[5]; /* null-terminated name of current chunk */ |
png_byte compression; /* file compression type (always 0) */ |
png_byte filter; /* file filter type (always 0) */ |
png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ |
png_byte pass; /* current interlace pass (0 - 6) */ |
png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ |
png_byte color_type; /* color type of file */ |
png_byte bit_depth; /* bit depth of file */ |
png_byte usr_bit_depth; /* bit depth of users row */ |
png_byte pixel_depth; /* number of bits per pixel */ |
png_byte channels; /* number of channels in file */ |
png_byte usr_channels; /* channels at start of write */ |
png_byte sig_bytes; /* magic bytes read/written from start of file */ |
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
#ifdef PNG_LEGACY_SUPPORTED |
png_byte filler; /* filler byte for pixel expansion */ |
#else |
png_uint_16 filler; /* filler bytes for pixel expansion */ |
#endif |
#endif |
#if defined(PNG_bKGD_SUPPORTED) |
png_byte background_gamma_type; |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
float background_gamma; |
# endif |
png_color_16 background; /* background color in screen gamma space */ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
png_color_16 background_1; /* background normalized to gamma 1.0 */ |
#endif |
#endif /* PNG_bKGD_SUPPORTED */ |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
png_flush_ptr output_flush_fn;/* Function for flushing output */ |
png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ |
png_uint_32 flush_rows; /* number of rows written since last flush */ |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
int gamma_shift; /* number of "insignificant" bits 16-bit gamma */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float gamma; /* file gamma value */ |
float screen_gamma; /* screen gamma value (display_exponent) */ |
#endif |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
png_bytep gamma_table; /* gamma table for 8-bit depth files */ |
png_bytep gamma_from_1; /* converts from 1.0 to screen */ |
png_bytep gamma_to_1; /* converts from file to 1.0 */ |
png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ |
png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ |
png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) |
png_color_8 sig_bit; /* significant bits in each available channel */ |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
png_color_8 shift; /* shift for significant bit tranformation */ |
#endif |
#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ |
|| defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
png_bytep trans; /* transparency values for paletted files */ |
png_color_16 trans_values; /* transparency values for non-paletted files */ |
#endif |
png_read_status_ptr read_row_fn; /* called after each row is decoded */ |
png_write_status_ptr write_row_fn; /* called after each row is encoded */ |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
png_progressive_info_ptr info_fn; /* called after header data fully read */ |
png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */ |
png_progressive_end_ptr end_fn; /* called after image is complete */ |
png_bytep save_buffer_ptr; /* current location in save_buffer */ |
png_bytep save_buffer; /* buffer for previously read data */ |
png_bytep current_buffer_ptr; /* current location in current_buffer */ |
png_bytep current_buffer; /* buffer for recently used data */ |
png_uint_32 push_length; /* size of current input chunk */ |
png_uint_32 skip_length; /* bytes to skip in input data */ |
png_size_t save_buffer_size; /* amount of data now in save_buffer */ |
png_size_t save_buffer_max; /* total size of save_buffer */ |
png_size_t buffer_size; /* total amount of available input data */ |
png_size_t current_buffer_size; /* amount of data now in current_buffer */ |
int process_mode; /* what push library is currently doing */ |
int cur_palette; /* current push library palette index */ |
# if defined(PNG_TEXT_SUPPORTED) |
png_size_t current_text_size; /* current size of text input data */ |
png_size_t current_text_left; /* how much text left to read in input */ |
png_charp current_text; /* current text chunk buffer */ |
png_charp current_text_ptr; /* current location in current_text */ |
# endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */ |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) |
/* for the Borland special 64K segment handler */ |
png_bytepp offset_table_ptr; |
png_bytep offset_table; |
png_uint_16 offset_table_number; |
png_uint_16 offset_table_count; |
png_uint_16 offset_table_count_free; |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
png_bytep palette_lookup; /* lookup table for dithering */ |
png_bytep dither_index; /* index translation for palette files */ |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) |
png_uint_16p hist; /* histogram */ |
#endif |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
png_byte heuristic_method; /* heuristic for row filter selection */ |
png_byte num_prev_filters; /* number of weights for previous rows */ |
png_bytep prev_filters; /* filter type(s) of previous row(s) */ |
png_uint_16p filter_weights; /* weight(s) for previous line(s) */ |
png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */ |
png_uint_16p filter_costs; /* relative filter calculation cost */ |
png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
png_charp time_buffer; /* String to hold RFC 1123 time text */ |
#endif |
/* New members added in libpng-1.0.6 */ |
#ifdef PNG_FREE_ME_SUPPORTED |
png_uint_32 free_me; /* flags items libpng is responsible for freeing */ |
#endif |
#if defined(PNG_USER_CHUNKS_SUPPORTED) |
png_voidp user_chunk_ptr; |
png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
int num_chunk_list; |
png_bytep chunk_list; |
#endif |
/* New members added in libpng-1.0.3 */ |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
png_byte rgb_to_gray_status; |
/* These were changed from png_byte in libpng-1.0.6 */ |
png_uint_16 rgb_to_gray_red_coeff; |
png_uint_16 rgb_to_gray_green_coeff; |
png_uint_16 rgb_to_gray_blue_coeff; |
#endif |
/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ |
#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ |
defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ |
defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) |
/* changed from png_byte to png_uint_32 at version 1.2.0 */ |
#ifdef PNG_1_0_X |
png_byte mng_features_permitted; |
#else |
png_uint_32 mng_features_permitted; |
#endif /* PNG_1_0_X */ |
#endif |
/* New member added in libpng-1.0.7 */ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
png_fixed_point int_gamma; |
#endif |
/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
png_byte filter_type; |
#endif |
#if defined(PNG_1_0_X) || (defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD)) |
/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ |
png_uint_32 row_buf_size; |
#endif |
/* New members added in libpng-1.2.0 */ |
#if !defined(PNG_1_0_X) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
png_byte mmx_bitdepth_threshold; |
png_uint_32 mmx_rowbytes_threshold; |
png_uint_32 asm_flags; |
#endif |
/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ |
#ifdef PNG_USER_MEM_SUPPORTED |
png_voidp mem_ptr; /* user supplied struct for mem functions */ |
png_malloc_ptr malloc_fn; /* function for allocating memory */ |
png_free_ptr free_fn; /* function for freeing memory */ |
#endif |
/* New member added in libpng-1.0.13 and 1.2.0 */ |
png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ |
#if defined(PNG_READ_DITHER_SUPPORTED) |
/* The following three members were added at version 1.0.14 and 1.2.4 */ |
png_bytep dither_sort; /* working sort array */ |
png_bytep index_to_palette; /* where the original index currently is */ |
/* in the palette */ |
png_bytep palette_to_index; /* which original index points to this */ |
/* palette color */ |
#endif |
}; |
/* This prevents a compiler error in png.c if png.c and png.h are both at |
version 1.2.5 |
*/ |
typedef png_structp version_1_2_5; |
typedef png_struct FAR * FAR * png_structpp; |
/* Here are the function definitions most commonly used. This is not |
* the place to find out how to use libpng. See libpng.txt for the |
* full explanation, see example.c for the summary. This just provides |
* a simple one line description of the use of each function. |
*/ |
/* Returns the version number of the library */ |
extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); |
/* Tell lib we have already handled the first <num_bytes> magic bytes. |
* Handling more than 8 bytes from the beginning of the file is an error. |
*/ |
extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, |
int num_bytes)); |
/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a |
* PNG file. Returns zero if the supplied bytes match the 8-byte PNG |
* signature, and non-zero otherwise. Having num_to_check == 0 or |
* start > 7 will always fail (ie return non-zero). |
*/ |
extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, |
png_size_t num_to_check)); |
/* Simple signature checking function. This is the same as calling |
* png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). |
*/ |
extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)); |
/* Allocate and initialize png_ptr struct for reading, and any other memory. */ |
extern PNG_EXPORT(png_structp,png_create_read_struct) |
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn)); |
/* Allocate and initialize png_ptr struct for writing, and any other memory */ |
extern PNG_EXPORT(png_structp,png_create_write_struct) |
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn)); |
extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) |
PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(void,png_set_compression_buffer_size) |
PNGARG((png_structp png_ptr, png_uint_32 size)); |
/* Reset the compression stream */ |
extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); |
/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ |
#ifdef PNG_USER_MEM_SUPPORTED |
extern PNG_EXPORT(png_structp,png_create_read_struct_2) |
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn)); |
extern PNG_EXPORT(png_structp,png_create_write_struct_2) |
PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn)); |
#endif |
/* Write a PNG chunk - size, type, (optional) data, CRC. */ |
extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, |
png_bytep chunk_name, png_bytep data, png_size_t length)); |
/* Write the start of a PNG chunk - length and chunk name. */ |
extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, |
png_bytep chunk_name, png_uint_32 length)); |
/* Write the data of a PNG chunk started with png_write_chunk_start(). */ |
extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, |
png_bytep data, png_size_t length)); |
/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ |
extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); |
/* Allocate and initialize the info structure */ |
extern PNG_EXPORT(png_infop,png_create_info_struct) |
PNGARG((png_structp png_ptr)); |
/* Initialize the info structure (old interface - DEPRECATED) */ |
extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)); |
#undef png_info_init |
#define png_info_init(info_ptr) png_info_init_3(&info_ptr, sizeof(png_info)); |
extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, |
png_size_t png_info_struct_size)); |
/* Writes all the PNG information before the image. */ |
extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* read the information before the actual image data. */ |
extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) |
PNGARG((png_structp png_ptr, png_timep ptime)); |
#endif |
#if !defined(_WIN32_WCE) |
/* "time.h" functions are not supported on WindowsCE */ |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
/* convert from a struct tm to png_time */ |
extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, |
struct tm FAR * ttime)); |
/* convert from time_t to png_time. Uses gmtime() */ |
extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, |
time_t ttime)); |
#endif /* PNG_WRITE_tIME_SUPPORTED */ |
#endif /* _WIN32_WCE */ |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ |
extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
/* Use blue, green, red order for pixels. */ |
extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
/* Expand the grayscale to 24-bit RGB if necessary. */ |
extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
/* Reduce RGB to grayscale. */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, |
int error_action, double red, double green )); |
#endif |
extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, |
int error_action, png_fixed_point red, png_fixed_point green )); |
extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp |
png_ptr)); |
#endif |
extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, |
png_colorp palette)); |
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
/* Add a filler byte to 24-bit RGB images. */ |
extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, |
png_uint_32 filler, int flags)); |
/* The values of the PNG_FILLER_ defines should NOT be changed */ |
#define PNG_FILLER_BEFORE 0 |
#define PNG_FILLER_AFTER 1 |
#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
/* Swap bytes in 16-bit depth files. */ |
extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) |
/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ |
extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
/* Swap packing order of pixels in bytes. */ |
extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
/* Converts files to legal bit depths. */ |
extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, |
png_color_8p true_bits)); |
#endif |
#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ |
defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* Have the code handle the interlacing. Returns the number of passes. */ |
extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
/* Invert monochrome files */ |
extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* Handle alpha and tRNS by replacing with a background color. */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, |
png_color_16p background_color, int background_gamma_code, |
int need_expand, double background_gamma)); |
#endif |
#define PNG_BACKGROUND_GAMMA_UNKNOWN 0 |
#define PNG_BACKGROUND_GAMMA_SCREEN 1 |
#define PNG_BACKGROUND_GAMMA_FILE 2 |
#define PNG_BACKGROUND_GAMMA_UNIQUE 3 |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
/* strip the second byte of information from a 16-bit depth file. */ |
extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
/* Turn on dithering, and reduce the palette to the number of colors available. */ |
extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, |
png_colorp palette, int num_palette, int maximum_colors, |
png_uint_16p histogram, int full_dither)); |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
/* Handle gamma correction. Screen_gamma=(display_exponent) */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, |
double screen_gamma, double default_file_gamma)); |
#endif |
#endif |
#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ |
defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) |
/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ |
/* Deprecated and will be removed. Use png_permit_mng_features() instead. */ |
extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, |
int empty_plte_permitted)); |
#endif |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
/* Set how many lines between output flushes - 0 for no flushing */ |
extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); |
/* Flush the current PNG output buffer */ |
extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); |
#endif |
/* optional update palette with requested transformations */ |
extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); |
/* optional call to update the users info structure */ |
extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* read one or more rows of image data. */ |
extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, |
png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); |
/* read a row of data. */ |
extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, |
png_bytep row, |
png_bytep display_row)); |
/* read the whole image into memory at once. */ |
extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, |
png_bytepp image)); |
/* write a row of image data */ |
extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, |
png_bytep row)); |
/* write a few rows of image data */ |
extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, |
png_bytepp row, png_uint_32 num_rows)); |
/* write the image data */ |
extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, |
png_bytepp image)); |
/* writes the end of the PNG file. */ |
extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* read the end of the PNG file. */ |
extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* free any memory associated with the png_info_struct */ |
extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, |
png_infopp info_ptr_ptr)); |
/* free any memory associated with the png_struct and the png_info_structs */ |
extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp |
png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); |
/* free all memory used by the read (old method - NOT DLL EXPORTED) */ |
extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_infop end_info_ptr)); |
/* free any memory associated with the png_struct and the png_info_structs */ |
extern PNG_EXPORT(void,png_destroy_write_struct) |
PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); |
/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ |
extern void png_write_destroy PNGARG((png_structp png_ptr)); |
/* set the libpng method of handling chunk CRC errors */ |
extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, |
int crit_action, int ancil_action)); |
/* Values for png_set_crc_action() to say how to handle CRC errors in |
* ancillary and critical chunks, and whether to use the data contained |
* therein. Note that it is impossible to "discard" data in a critical |
* chunk. For versions prior to 0.90, the action was always error/quit, |
* whereas in version 0.90 and later, the action for CRC errors in ancillary |
* chunks is warn/discard. These values should NOT be changed. |
* |
* value action:critical action:ancillary |
*/ |
#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ |
#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ |
#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ |
#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ |
#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ |
#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ |
/* These functions give the user control over the scan-line filtering in |
* libpng and the compression methods used by zlib. These functions are |
* mainly useful for testing, as the defaults should work with most users. |
* Those users who are tight on memory or want faster performance at the |
* expense of compression can modify them. See the compression library |
* header file (zlib.h) for an explination of the compression functions. |
*/ |
/* set the filtering method(s) used by libpng. Currently, the only valid |
* value for "method" is 0. |
*/ |
extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, |
int filters)); |
/* Flags for png_set_filter() to say which filters to use. The flags |
* are chosen so that they don't conflict with real filter types |
* below, in case they are supplied instead of the #defined constants. |
* These values should NOT be changed. |
*/ |
#define PNG_NO_FILTERS 0x00 |
#define PNG_FILTER_NONE 0x08 |
#define PNG_FILTER_SUB 0x10 |
#define PNG_FILTER_UP 0x20 |
#define PNG_FILTER_AVG 0x40 |
#define PNG_FILTER_PAETH 0x80 |
#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ |
PNG_FILTER_AVG | PNG_FILTER_PAETH) |
/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. |
* These defines should NOT be changed. |
*/ |
#define PNG_FILTER_VALUE_NONE 0 |
#define PNG_FILTER_VALUE_SUB 1 |
#define PNG_FILTER_VALUE_UP 2 |
#define PNG_FILTER_VALUE_AVG 3 |
#define PNG_FILTER_VALUE_PAETH 4 |
#define PNG_FILTER_VALUE_LAST 5 |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */ |
/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ |
* defines, either the default (minimum-sum-of-absolute-differences), or |
* the experimental method (weighted-minimum-sum-of-absolute-differences). |
* |
* Weights are factors >= 1.0, indicating how important it is to keep the |
* filter type consistent between rows. Larger numbers mean the current |
* filter is that many times as likely to be the same as the "num_weights" |
* previous filters. This is cumulative for each previous row with a weight. |
* There needs to be "num_weights" values in "filter_weights", or it can be |
* NULL if the weights aren't being specified. Weights have no influence on |
* the selection of the first row filter. Well chosen weights can (in theory) |
* improve the compression for a given image. |
* |
* Costs are factors >= 1.0 indicating the relative decoding costs of a |
* filter type. Higher costs indicate more decoding expense, and are |
* therefore less likely to be selected over a filter with lower computational |
* costs. There needs to be a value in "filter_costs" for each valid filter |
* type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't |
* setting the costs. Costs try to improve the speed of decompression without |
* unduly increasing the compressed image size. |
* |
* A negative weight or cost indicates the default value is to be used, and |
* values in the range [0.0, 1.0) indicate the value is to remain unchanged. |
* The default values for both weights and costs are currently 1.0, but may |
* change if good general weighting/cost heuristics can be found. If both |
* the weights and costs are set to 1.0, this degenerates the WEIGHTED method |
* to the UNWEIGHTED method, but with added encoding time/computation. |
*/ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, |
int heuristic_method, int num_weights, png_doublep filter_weights, |
png_doublep filter_costs)); |
#endif |
#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ |
/* Heuristic used for row filter selection. These defines should NOT be |
* changed. |
*/ |
#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ |
#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ |
#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ |
#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ |
/* Set the library compression level. Currently, valid values range from |
* 0 - 9, corresponding directly to the zlib compression levels 0 - 9 |
* (0 - no compression, 9 - "maximal" compression). Note that tests have |
* shown that zlib compression levels 3-6 usually perform as well as level 9 |
* for PNG images, and do considerably fewer caclulations. In the future, |
* these values may not correspond directly to the zlib compression levels. |
*/ |
extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, |
int level)); |
extern PNG_EXPORT(void,png_set_compression_mem_level) |
PNGARG((png_structp png_ptr, int mem_level)); |
extern PNG_EXPORT(void,png_set_compression_strategy) |
PNGARG((png_structp png_ptr, int strategy)); |
extern PNG_EXPORT(void,png_set_compression_window_bits) |
PNGARG((png_structp png_ptr, int window_bits)); |
extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, |
int method)); |
/* These next functions are called for input/output, memory, and error |
* handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, |
* and call standard C I/O routines such as fread(), fwrite(), and |
* fprintf(). These functions can be made to use other I/O routines |
* at run time for those applications that need to handle I/O in a |
* different manner by calling png_set_???_fn(). See libpng.txt for |
* more information. |
*/ |
#if !defined(PNG_NO_STDIO) |
/* Initialize the input/output for the PNG file to the default functions. */ |
extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); |
#endif |
/* Replace the (error and abort), and warning functions with user |
* supplied functions. If no messages are to be printed you must still |
* write and use replacement functions. The replacement error_fn should |
* still do a longjmp to the last setjmp location if you are using this |
* method of error handling. If error_fn or warning_fn is NULL, the |
* default function will be used. |
*/ |
extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, |
png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); |
/* Return the user pointer associated with the error functions */ |
extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); |
/* Replace the default data output functions with a user supplied one(s). |
* If buffered output is not used, then output_flush_fn can be set to NULL. |
* If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time |
* output_flush_fn will be ignored (and thus can be NULL). |
*/ |
extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, |
png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); |
/* Replace the default data input function with a user supplied one. */ |
extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, |
png_voidp io_ptr, png_rw_ptr read_data_fn)); |
/* Return the user pointer associated with the I/O functions */ |
extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, |
png_read_status_ptr read_row_fn)); |
extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, |
png_write_status_ptr write_row_fn)); |
#ifdef PNG_USER_MEM_SUPPORTED |
/* Replace the default memory allocation functions with user supplied one(s). */ |
extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, |
png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); |
/* Return the user pointer associated with the memory functions */ |
extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp |
png_ptr, png_user_transform_ptr read_user_transform_fn)); |
#endif |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp |
png_ptr, png_user_transform_ptr write_user_transform_fn)); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp |
png_ptr, png_voidp user_transform_ptr, int user_transform_depth, |
int user_transform_channels)); |
/* Return the user pointer associated with the user transform functions */ |
extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) |
PNGARG((png_structp png_ptr)); |
#endif |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, |
png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); |
extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp |
png_ptr)); |
#endif |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
/* Sets the function callbacks for the push reader, and a pointer to a |
* user-defined structure available to the callback functions. |
*/ |
extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, |
png_voidp progressive_ptr, |
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, |
png_progressive_end_ptr end_fn)); |
/* returns the user pointer associated with the push read functions */ |
extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) |
PNGARG((png_structp png_ptr)); |
/* function to be called when data becomes available */ |
extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); |
/* function that combines rows. Not very much different than the |
* png_combine_row() call. Is this even used????? |
*/ |
extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, |
png_bytep old_row, png_bytep new_row)); |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, |
png_uint_32 size)); |
#if defined(PNG_1_0_X) |
# define png_malloc_warn png_malloc |
#else |
/* Added at libpng version 1.2.4 */ |
extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, |
png_uint_32 size)); |
#endif |
/* frees a pointer allocated by png_malloc() */ |
extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); |
#if defined(PNG_1_0_X) |
/* Function to allocate memory for zlib. */ |
extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, |
uInt size)); |
/* Function to free memory for zlib */ |
extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); |
#endif |
/* Free data that was allocated internally */ |
extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 free_me, int num)); |
#ifdef PNG_FREE_ME_SUPPORTED |
/* Reassign responsibility for freeing existing data, whether allocated |
* by libpng or by the application */ |
extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int freer, png_uint_32 mask)); |
#endif |
/* assignments for png_data_freer */ |
#define PNG_DESTROY_WILL_FREE_DATA 1 |
#define PNG_SET_WILL_FREE_DATA 1 |
#define PNG_USER_WILL_FREE_DATA 2 |
/* Flags for png_ptr->free_me and info_ptr->free_me */ |
#define PNG_FREE_HIST 0x0008 |
#define PNG_FREE_ICCP 0x0010 |
#define PNG_FREE_SPLT 0x0020 |
#define PNG_FREE_ROWS 0x0040 |
#define PNG_FREE_PCAL 0x0080 |
#define PNG_FREE_SCAL 0x0100 |
#define PNG_FREE_UNKN 0x0200 |
#define PNG_FREE_LIST 0x0400 |
#define PNG_FREE_PLTE 0x1000 |
#define PNG_FREE_TRNS 0x2000 |
#define PNG_FREE_TEXT 0x4000 |
#define PNG_FREE_ALL 0x7fff |
#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ |
#ifdef PNG_USER_MEM_SUPPORTED |
extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, |
png_uint_32 size)); |
extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, |
png_voidp ptr)); |
#endif |
extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, |
png_voidp s1, png_voidp s2, png_uint_32 size)); |
extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, |
png_voidp s1, int value, png_uint_32 size)); |
#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ |
extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, |
int check)); |
#endif /* USE_FAR_KEYWORD */ |
/* Fatal error in PNG image of libpng - can't continue */ |
extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, |
png_const_charp error_message)); |
/* The same, but the chunk name is prepended to the error string. */ |
extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, |
png_const_charp error_message)); |
/* Non-fatal error in libpng. Can continue, but may have a problem. */ |
extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, |
png_const_charp warning_message)); |
/* Non-fatal error in libpng, chunk name is prepended to message. */ |
extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, |
png_const_charp warning_message)); |
/* The png_set_<chunk> functions are for storing values in the png_info_struct. |
* Similarly, the png_get_<chunk> calls are used to read values from the |
* png_info_struct, either storing the parameters in the passed variables, or |
* setting pointers into the png_info_struct where the data is stored. The |
* png_get_<chunk> functions return a non-zero value if the data was available |
* in info_ptr, or return zero and do not change any of the parameters if the |
* data was not available. |
* |
* These functions should be used instead of directly accessing png_info |
* to avoid problems with future changes in the size and internal layout of |
* png_info_struct. |
*/ |
/* Returns "flag" if chunk data is valid in info_ptr. */ |
extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 flag)); |
/* Returns number of bytes needed to hold a transformed row. */ |
extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
/* Returns row_pointers, which is an array of pointers to scanlines that was |
returned from png_read_png(). */ |
extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* Set row_pointers, which is an array of pointers to scanlines for use |
by png_write_png(). */ |
extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_bytepp row_pointers)); |
#endif |
/* Returns number of color channels in image. */ |
extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#ifdef PNG_EASY_ACCESS_SUPPORTED |
/* Returns image width in pixels. */ |
extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image height in pixels. */ |
extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image bit_depth. */ |
extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image color_type. */ |
extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image filter_type. */ |
extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image interlace_type. */ |
extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image compression_type. */ |
extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns image resolution in pixels per meter, from pHYs chunk data. */ |
extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
/* Returns pixel aspect ratio, computed from pHYs chunk data. */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
#endif |
/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ |
extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp |
png_ptr, png_infop info_ptr)); |
#endif /* PNG_EASY_ACCESS_SUPPORTED */ |
/* Returns pointer to signature string read from PNG header */ |
extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#if defined(PNG_bKGD_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_color_16p *background)); |
#endif |
#if defined(PNG_bKGD_SUPPORTED) |
extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_color_16p background)); |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, |
png_infop info_ptr, double *white_x, double *white_y, double *red_x, |
double *red_y, double *green_x, double *green_y, double *blue_x, |
double *blue_y)); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point |
*int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, |
png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point |
*int_blue_x, png_fixed_point *int_blue_y)); |
#endif |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, |
png_infop info_ptr, double white_x, double white_y, double red_x, |
double red_y, double green_x, double green_y, double blue_x, double blue_y)); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, |
png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point |
int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, |
png_fixed_point int_blue_y)); |
#endif |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, |
png_infop info_ptr, double *file_gamma)); |
#endif |
extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_fixed_point *int_file_gamma)); |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, |
png_infop info_ptr, double file_gamma)); |
#endif |
extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_fixed_point int_file_gamma)); |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_16p *hist)); |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_16p hist)); |
#endif |
extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, |
int *bit_depth, int *color_type, int *interlace_method, |
int *compression_method, int *filter_method)); |
extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, |
int color_type, int interlace_method, int compression_method, |
int filter_method)); |
#if defined(PNG_oFFs_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, |
int *unit_type)); |
#endif |
#if defined(PNG_oFFs_SUPPORTED) |
extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, |
int unit_type)); |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, |
int *type, int *nparams, png_charp *units, png_charpp *params)); |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, |
int type, int nparams, png_charp units, png_charpp params)); |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); |
#endif |
extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_colorp *palette, int *num_palette)); |
extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_colorp palette, int num_palette)); |
#if defined(PNG_sBIT_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_color_8p *sig_bit)); |
#endif |
#if defined(PNG_sBIT_SUPPORTED) |
extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_color_8p sig_bit)); |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int *intent)); |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int intent)); |
extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int intent)); |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_charpp name, int *compression_type, |
png_charpp profile, png_uint_32 *proflen)); |
/* Note to maintainer: profile should be png_bytepp */ |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_charp name, int compression_type, |
png_charp profile, png_uint_32 proflen)); |
/* Note to maintainer: profile should be png_bytep */ |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_sPLT_tpp entries)); |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_sPLT_tp entries, int nentries)); |
#endif |
#if defined(PNG_TEXT_SUPPORTED) |
/* png_get_text also returns the number of text chunks in *num_text */ |
extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_textp *text_ptr, int *num_text)); |
#endif |
/* |
* Note while png_set_text() will accept a structure whose text, |
* language, and translated keywords are NULL pointers, the structure |
* returned by png_get_text will always contain regular |
* zero-terminated C strings. They might be empty strings but |
* they will never be NULL pointers. |
*/ |
#if defined(PNG_TEXT_SUPPORTED) |
extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_textp text_ptr, int num_text)); |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_timep *mod_time)); |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_timep mod_time)); |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_bytep *trans, int *num_trans, |
png_color_16p *trans_values)); |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_bytep trans, int num_trans, |
png_color_16p trans_values)); |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
#endif |
#if defined(PNG_sCAL_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int *unit, double *width, double *height)); |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); |
#endif |
#endif |
#endif /* PNG_sCAL_SUPPORTED */ |
#if defined(PNG_sCAL_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int unit, double width, double height)); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); |
#endif |
#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
/* provide a list of chunks and how they are to be handled, if the built-in |
handling or default unknown chunk handling is not desired. Any chunks not |
listed will be handled in the default manner. The IHDR and IEND chunks |
must not be listed. |
keep = 0: follow default behavour |
= 1: do not keep |
= 2: keep only if safe-to-copy |
= 3: keep even if unsafe-to-copy |
*/ |
extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp |
png_ptr, int keep, png_bytep chunk_list, int num_chunks)); |
extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); |
extern PNG_EXPORT(void, png_set_unknown_chunk_location) |
PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); |
extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp |
png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); |
#endif |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep |
chunk_name)); |
#endif |
/* Png_free_data() will turn off the "valid" flag for anything it frees. |
If you need to turn it off for a chunk that your application has freed, |
you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */ |
extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, |
png_infop info_ptr, int mask)); |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
/* The "params" pointer is currently not used and is for future expansion. */ |
extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, |
png_infop info_ptr, |
int transforms, |
png_voidp params)); |
extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, |
png_infop info_ptr, |
int transforms, |
png_voidp params)); |
#endif |
/* Define PNG_DEBUG at compile time for debugging information. Higher |
* numbers for PNG_DEBUG mean more debugging information. This has |
* only been added since version 0.95 so it is not implemented throughout |
* libpng yet, but more support will be added as needed. |
*/ |
#ifdef PNG_DEBUG |
#if (PNG_DEBUG > 0) |
#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) |
#include <crtdbg.h> |
#if (PNG_DEBUG > 1) |
#define png_debug(l,m) _RPT0(_CRT_WARN,m) |
#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1) |
#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2) |
#endif |
#else /* PNG_DEBUG_FILE || !_MSC_VER */ |
#ifndef PNG_DEBUG_FILE |
#define PNG_DEBUG_FILE stderr |
#endif /* PNG_DEBUG_FILE */ |
#if (PNG_DEBUG > 1) |
#define png_debug(l,m) \ |
{ \ |
int num_tabs=l; \ |
fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ |
} |
#define png_debug1(l,m,p1) \ |
{ \ |
int num_tabs=l; \ |
fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ |
} |
#define png_debug2(l,m,p1,p2) \ |
{ \ |
int num_tabs=l; \ |
fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ |
} |
#endif /* (PNG_DEBUG > 1) */ |
#endif /* _MSC_VER */ |
#endif /* (PNG_DEBUG > 0) */ |
#endif /* PNG_DEBUG */ |
#ifndef png_debug |
#define png_debug(l, m) |
#endif |
#ifndef png_debug1 |
#define png_debug1(l, m, p1) |
#endif |
#ifndef png_debug2 |
#define png_debug2(l, m, p1, p2) |
#endif |
extern PNG_EXPORT(png_bytep,png_sig_bytes) PNGARG((void)); |
extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)); |
extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp |
png_ptr, png_uint_32 mng_features_permitted)); |
#endif |
/* Added to version 1.2.0 */ |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ |
#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ |
#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 |
#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 |
#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 |
#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 |
#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 |
#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 |
#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ |
#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ |
| PNG_ASM_FLAG_MMX_READ_INTERLACE \ |
| PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ |
| PNG_ASM_FLAG_MMX_READ_FILTER_UP \ |
| PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ |
| PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) |
#define PNG_MMX_WRITE_FLAGS ( 0 ) |
#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ |
| PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ |
| PNG_MMX_READ_FLAGS \ |
| PNG_MMX_WRITE_FLAGS ) |
#define PNG_SELECT_READ 1 |
#define PNG_SELECT_WRITE 2 |
#if !defined(PNG_1_0_X) |
/* pngget.c */ |
extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) |
PNGARG((int flag_select, int *compilerID)); |
/* pngget.c */ |
extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) |
PNGARG((int flag_select)); |
/* pngget.c */ |
extern PNG_EXPORT(png_uint_32,png_get_asm_flags) |
PNGARG((png_structp png_ptr)); |
/* pngget.c */ |
extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) |
PNGARG((png_structp png_ptr)); |
/* pngget.c */ |
extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) |
PNGARG((png_structp png_ptr)); |
/* pngset.c */ |
extern PNG_EXPORT(void,png_set_asm_flags) |
PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); |
/* pngset.c */ |
extern PNG_EXPORT(void,png_set_mmx_thresholds) |
PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, |
png_uint_32 mmx_rowbytes_threshold)); |
#endif /* PNG_1_0_X */ |
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ |
#if !defined(PNG_1_0_X) |
/* png.c, pnggccrd.c, or pngvcrd.c */ |
extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); |
/* Strip the prepended error numbers ("#nnn ") from error and warning |
* messages before passing them to the error or warning handler. */ |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp |
png_ptr, png_uint_32 strip_mode)); |
#endif |
#endif /* PNG_1_0_X */ |
/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */ |
#define PNG_HEADER_VERSION_STRING \ |
" libpng version 1.2.5 - October 3, 2002 (header)\n" |
#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED |
/* With these routines we avoid an integer divide, which will be slower on |
* most machines. However, it does take more operations than the corresponding |
* divide method, so it may be slower on a few RISC systems. There are two |
* shifts (by 8 or 16 bits) and an addition, versus a single integer divide. |
* |
* Note that the rounding factors are NOT supposed to be the same! 128 and |
* 32768 are correct for the NODIV code; 127 and 32767 are correct for the |
* standard method. |
* |
* [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] |
*/ |
/* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ |
# define png_composite(composite, fg, alpha, bg) \ |
{ png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ |
+ (png_uint_16)(bg)*(png_uint_16)(255 - \ |
(png_uint_16)(alpha)) + (png_uint_16)128); \ |
(composite) = (png_byte)((temp + (temp >> 8)) >> 8); } |
# define png_composite_16(composite, fg, alpha, bg) \ |
{ png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ |
+ (png_uint_32)(bg)*(png_uint_32)(65535L - \ |
(png_uint_32)(alpha)) + (png_uint_32)32768L); \ |
(composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } |
#else /* standard method using integer division */ |
# define png_composite(composite, fg, alpha, bg) \ |
(composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ |
(png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ |
(png_uint_16)127) / 255) |
# define png_composite_16(composite, fg, alpha, bg) \ |
(composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ |
(png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ |
(png_uint_32)32767) / (png_uint_32)65535L) |
#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ |
/* These next functions are used internally in the code. They generally |
* shouldn't be used unless you are writing code to add or replace some |
* functionality in libpng. More information about most functions can |
* be found in the files where the functions are located. |
*/ |
#if defined(PNG_INTERNAL) |
/* Various modes of operation. Note that after an init, mode is set to |
* zero automatically when the structure is created. |
*/ |
#define PNG_HAVE_IHDR 0x01 |
#define PNG_HAVE_PLTE 0x02 |
#define PNG_HAVE_IDAT 0x04 |
#define PNG_AFTER_IDAT 0x08 |
#define PNG_HAVE_IEND 0x10 |
#define PNG_HAVE_gAMA 0x20 |
#define PNG_HAVE_cHRM 0x40 |
#define PNG_HAVE_sRGB 0x80 |
#define PNG_HAVE_CHUNK_HEADER 0x100 |
#define PNG_WROTE_tIME 0x200 |
#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 |
#define PNG_BACKGROUND_IS_GRAY 0x800 |
#define PNG_HAVE_PNG_SIGNATURE 0x1000 |
/* flags for the transformations the PNG library does on the image data */ |
#define PNG_BGR 0x0001 |
#define PNG_INTERLACE 0x0002 |
#define PNG_PACK 0x0004 |
#define PNG_SHIFT 0x0008 |
#define PNG_SWAP_BYTES 0x0010 |
#define PNG_INVERT_MONO 0x0020 |
#define PNG_DITHER 0x0040 |
#define PNG_BACKGROUND 0x0080 |
#define PNG_BACKGROUND_EXPAND 0x0100 |
/* 0x0200 unused */ |
#define PNG_16_TO_8 0x0400 |
#define PNG_RGBA 0x0800 |
#define PNG_EXPAND 0x1000 |
#define PNG_GAMMA 0x2000 |
#define PNG_GRAY_TO_RGB 0x4000 |
#define PNG_FILLER 0x8000L |
#define PNG_PACKSWAP 0x10000L |
#define PNG_SWAP_ALPHA 0x20000L |
#define PNG_STRIP_ALPHA 0x40000L |
#define PNG_INVERT_ALPHA 0x80000L |
#define PNG_USER_TRANSFORM 0x100000L |
#define PNG_RGB_TO_GRAY_ERR 0x200000L |
#define PNG_RGB_TO_GRAY_WARN 0x400000L |
#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ |
/* flags for png_create_struct */ |
#define PNG_STRUCT_PNG 0x0001 |
#define PNG_STRUCT_INFO 0x0002 |
/* Scaling factor for filter heuristic weighting calculations */ |
#define PNG_WEIGHT_SHIFT 8 |
#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) |
#define PNG_COST_SHIFT 3 |
#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) |
/* flags for the png_ptr->flags rather than declaring a byte for each one */ |
#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 |
#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 |
#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 |
#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 |
#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 |
#define PNG_FLAG_ZLIB_FINISHED 0x0020 |
#define PNG_FLAG_ROW_INIT 0x0040 |
#define PNG_FLAG_FILLER_AFTER 0x0080 |
#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 |
#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 |
#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 |
#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 |
#define PNG_FLAG_FREE_PLTE 0x1000 |
#define PNG_FLAG_FREE_TRNS 0x2000 |
#define PNG_FLAG_FREE_HIST 0x4000 |
#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L |
#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L |
#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L |
#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L |
#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L |
#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L |
/* For use in png_set_keep_unknown, png_handle_as_unknown */ |
#define HANDLE_CHUNK_AS_DEFAULT 0 |
#define HANDLE_CHUNK_NEVER 1 |
#define HANDLE_CHUNK_IF_SAFE 2 |
#define HANDLE_CHUNK_ALWAYS 3 |
#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ |
PNG_FLAG_CRC_ANCILLARY_NOWARN) |
#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ |
PNG_FLAG_CRC_CRITICAL_IGNORE) |
#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ |
PNG_FLAG_CRC_CRITICAL_MASK) |
/* save typing and make code easier to understand */ |
#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ |
abs((int)((c1).green) - (int)((c2).green)) + \ |
abs((int)((c1).blue) - (int)((c2).blue))) |
/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ |
#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) |
/* place to hold the signature string for a PNG file. */ |
#ifdef PNG_USE_GLOBAL_ARRAYS |
PNG_EXPORT_VAR (const png_byte FARDATA) png_sig[8]; |
#else |
#define png_sig png_sig_bytes(NULL) |
#endif |
#endif /* PNG_NO_EXTERN */ |
/* Constant strings for known chunk types. If you need to add a chunk, |
* define the name here, and add an invocation of the macro in png.c and |
* wherever it's needed. |
*/ |
#define PNG_IHDR const png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} |
#define PNG_IDAT const png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} |
#define PNG_IEND const png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} |
#define PNG_PLTE const png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} |
#define PNG_bKGD const png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} |
#define PNG_cHRM const png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} |
#define PNG_gAMA const png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} |
#define PNG_hIST const png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} |
#define PNG_iCCP const png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} |
#define PNG_iTXt const png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} |
#define PNG_oFFs const png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} |
#define PNG_pCAL const png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} |
#define PNG_sCAL const png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} |
#define PNG_pHYs const png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} |
#define PNG_sBIT const png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} |
#define PNG_sPLT const png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} |
#define PNG_sRGB const png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} |
#define PNG_tEXt const png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} |
#define PNG_tIME const png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} |
#define PNG_tRNS const png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} |
#define PNG_zTXt const png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} |
#ifdef PNG_USE_GLOBAL_ARRAYS |
PNG_EXPORT_VAR (const png_byte FARDATA) png_IHDR[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_IDAT[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_IEND[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_PLTE[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_bKGD[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_cHRM[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_gAMA[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_hIST[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_iCCP[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_iTXt[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_oFFs[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_pCAL[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_sCAL[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_pHYs[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_sBIT[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_sPLT[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_sRGB[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_tEXt[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_tIME[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_tRNS[5]; |
PNG_EXPORT_VAR (const png_byte FARDATA) png_zTXt[5]; |
#endif /* PNG_USE_GLOBAL_ARRAYS */ |
/* Inline macros to do direct reads of bytes from the input buffer. These |
* require that you are using an architecture that uses PNG byte ordering |
* (MSB first) and supports unaligned data storage. I think that PowerPC |
* in big-endian mode and 680x0 are the only ones that will support this. |
* The x86 line of processors definitely do not. The png_get_int_32() |
* routine also assumes we are using two's complement format for negative |
* values, which is almost certainly true. |
*/ |
#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED) |
# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) |
# define png_get_int_32(buf) ( *((png_int_32p) (buf))) |
# endif |
# define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) |
# define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) |
#else |
# if defined(PNG_pCAL_SUPPORTED) || defined(PNG_oFFs_SUPPORTED) |
PNG_EXTERN png_int_32 png_get_int_32 PNGARG((png_bytep buf)); |
# endif |
PNG_EXTERN png_uint_32 png_get_uint_32 PNGARG((png_bytep buf)); |
PNG_EXTERN png_uint_16 png_get_uint_16 PNGARG((png_bytep buf)); |
#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ |
/* Initialize png_ptr struct for reading, and allocate any other memory. |
* (old interface - DEPRECATED - use png_create_read_struct instead). |
*/ |
extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)); |
#undef png_read_init |
#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ |
PNG_LIBPNG_VER_STRING, sizeof(png_struct)); |
extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, |
png_const_charp user_png_ver, png_size_t png_struct_size)); |
extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, |
png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t |
png_info_size)); |
/* Initialize png_ptr struct for writing, and allocate any other memory. |
* (old interface - DEPRECATED - use png_create_write_struct instead). |
*/ |
extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)); |
#undef png_write_init |
#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ |
PNG_LIBPNG_VER_STRING, sizeof(png_struct)); |
extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, |
png_const_charp user_png_ver, png_size_t png_struct_size)); |
extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, |
png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t |
png_info_size)); |
/* Allocate memory for an internal libpng struct */ |
PNG_EXTERN png_voidp png_create_struct PNGARG((int type)); |
/* Free memory from internal libpng struct */ |
PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); |
PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr |
malloc_fn, png_voidp mem_ptr)); |
PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, |
png_free_ptr free_fn, png_voidp mem_ptr)); |
/* Free any memory that info_ptr points to and reset struct. */ |
PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#ifndef PNG_1_0_X |
/* Function to allocate memory for zlib. */ |
PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size)); |
/* Function to free memory for zlib */ |
PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); |
/* Next four functions are used internally as callbacks. PNGAPI is required |
* but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */ |
PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, |
png_bytep data, png_size_t length)); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, |
png_bytep buffer, png_size_t length)); |
#endif |
PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, |
png_bytep data, png_size_t length)); |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
#if !defined(PNG_NO_STDIO) |
PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)); |
#endif |
#endif |
#else /* PNG_1_0_X */ |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, |
png_bytep buffer, png_size_t length)); |
#endif |
#endif /* PNG_1_0_X */ |
/* Reset the CRC variable */ |
PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); |
/* Write the "data" buffer to whatever output you are using. */ |
PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, |
png_size_t length)); |
/* Read data from whatever input you are using into the "data" buffer */ |
PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, |
png_size_t length)); |
/* Read bytes into buf, and update png_ptr->crc */ |
PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, |
png_size_t length)); |
/* Decompress data in a chunk that uses compression */ |
#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ |
defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) |
PNG_EXTERN png_charp png_decompress_chunk PNGARG((png_structp png_ptr, |
int comp_type, png_charp chunkdata, png_size_t chunklength, |
png_size_t prefix_length, png_size_t *data_length)); |
#endif |
/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ |
PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); |
/* Read the CRC from the file and compare it to the libpng calculated CRC */ |
PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); |
/* Calculate the CRC over a section of data. Note that we are only |
* passing a maximum of 64K on systems that have this as a memory limit, |
* since this is the maximum buffer size we can specify. |
*/ |
PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, |
png_size_t length)); |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); |
#endif |
/* Place a 32-bit number into a buffer in PNG byte order (big-endian). |
* The only currently known PNG chunks that use signed numbers are |
* the ancillary extension chunks, oFFs and pCAL. |
*/ |
PNG_EXTERN void png_save_uint_32 PNGARG((png_bytep buf, png_uint_32 i)); |
#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) |
PNG_EXTERN void png_save_int_32 PNGARG((png_bytep buf, png_int_32 i)); |
#endif |
/* Place a 16-bit number into a buffer in PNG byte order. |
* The parameter is declared unsigned int, not png_uint_16, |
* just to avoid potential problems on pre-ANSI C compilers. |
*/ |
PNG_EXTERN void png_save_uint_16 PNGARG((png_bytep buf, unsigned int i)); |
/* simple function to write the signature */ |
PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)); |
/* write various chunks */ |
/* Write the IHDR chunk, and update the png_struct with the necessary |
* information. |
*/ |
PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, |
png_uint_32 height, |
int bit_depth, int color_type, int compression_method, int filter_method, |
int interlace_method)); |
PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, |
png_uint_32 num_pal)); |
PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, |
png_size_t length)); |
PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); |
#if defined(PNG_WRITE_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point |
file_gamma)); |
#endif |
#endif |
#if defined(PNG_WRITE_sBIT_SUPPORTED) |
PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, |
int color_type)); |
#endif |
#if defined(PNG_WRITE_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, |
double white_x, double white_y, |
double red_x, double red_y, double green_x, double green_y, |
double blue_x, double blue_y)); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, |
png_fixed_point int_white_x, png_fixed_point int_white_y, |
png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point |
int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, |
png_fixed_point int_blue_y)); |
#endif |
#endif |
#if defined(PNG_WRITE_sRGB_SUPPORTED) |
PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, |
int intent)); |
#endif |
#if defined(PNG_WRITE_iCCP_SUPPORTED) |
PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, |
png_charp name, int compression_type, |
png_charp profile, int proflen)); |
/* Note to maintainer: profile should be png_bytep */ |
#endif |
#if defined(PNG_WRITE_sPLT_SUPPORTED) |
PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, |
png_sPLT_tp palette)); |
#endif |
#if defined(PNG_WRITE_tRNS_SUPPORTED) |
PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, |
png_color_16p values, int number, int color_type)); |
#endif |
#if defined(PNG_WRITE_bKGD_SUPPORTED) |
PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, |
png_color_16p values, int color_type)); |
#endif |
#if defined(PNG_WRITE_hIST_SUPPORTED) |
PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, |
int num_hist)); |
#endif |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ |
defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, |
png_charp key, png_charpp new_key)); |
#endif |
#if defined(PNG_WRITE_tEXt_SUPPORTED) |
PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, |
png_charp text, png_size_t text_len)); |
#endif |
#if defined(PNG_WRITE_zTXt_SUPPORTED) |
PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, |
png_charp text, png_size_t text_len, int compression)); |
#endif |
#if defined(PNG_WRITE_iTXt_SUPPORTED) |
PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, |
int compression, png_charp key, png_charp lang, png_charp lang_key, |
png_charp text)); |
#endif |
#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */ |
PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_textp text_ptr, int num_text)); |
#endif |
#if defined(PNG_WRITE_oFFs_SUPPORTED) |
PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, |
png_int_32 x_offset, png_int_32 y_offset, int unit_type)); |
#endif |
#if defined(PNG_WRITE_pCAL_SUPPORTED) |
PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, |
png_int_32 X0, png_int_32 X1, int type, int nparams, |
png_charp units, png_charpp params)); |
#endif |
#if defined(PNG_WRITE_pHYs_SUPPORTED) |
PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, |
png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, |
int unit_type)); |
#endif |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, |
png_timep mod_time)); |
#endif |
#if defined(PNG_WRITE_sCAL_SUPPORTED) |
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) |
PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, |
int unit, double width, double height)); |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, |
int unit, png_charp width, png_charp height)); |
#endif |
#endif |
#endif |
/* Called when finished processing a row of data */ |
PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); |
/* Internal use only. Called before first row of data */ |
PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)); |
#endif |
/* combine a row of data, dealing with alpha, etc. if requested */ |
PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, |
int mask)); |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
/* expand an interlaced row */ |
/* OLD pre-1.0.9 interface: |
PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, |
png_bytep row, int pass, png_uint_32 transformations)); |
*/ |
PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)); |
#endif |
/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* grab pixels out of a row for an interlaced pass */ |
PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, |
png_bytep row, int pass)); |
#endif |
/* unfilter a row */ |
PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, |
png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter)); |
/* Choose the best filter to use and filter the row data */ |
PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, |
png_row_infop row_info)); |
/* Write out the filtered row. */ |
PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, |
png_bytep filtered_row)); |
/* finish a row while reading, dealing with interlacing passes, etc. */ |
PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); |
/* initialize the row buffers, etc. */ |
PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); |
/* optional call to update the users info structure */ |
PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
/* these are the functions that do the transformations */ |
#if defined(PNG_READ_FILLER_SUPPORTED) |
PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, |
png_bytep row, png_uint_32 filler, png_uint_32 flags)); |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) |
PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) |
PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ |
defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, |
png_bytep row, png_uint_32 flags)); |
#endif |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop |
row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) |
PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) |
PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, |
png_color_8p sig_bits)); |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, |
png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup)); |
# if defined(PNG_CORRECT_PALETTE_SUPPORTED) |
PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, |
png_colorp palette, int num_palette)); |
# endif |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row)); |
#endif |
#if defined(PNG_WRITE_PACK_SUPPORTED) |
PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, |
png_bytep row, png_uint_32 bit_depth)); |
#endif |
#if defined(PNG_WRITE_SHIFT_SUPPORTED) |
PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, |
png_color_8p bit_depth)); |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, |
png_color_16p trans_values, png_color_16p background, |
png_color_16p background_1, |
png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, |
png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, |
png_uint_16pp gamma_16_to_1, int gamma_shift)); |
#else |
PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, |
png_color_16p trans_values, png_color_16p background)); |
#endif |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, |
png_bytep gamma_table, png_uint_16pp gamma_16_table, |
int gamma_shift)); |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, |
png_bytep row, png_colorp palette, png_bytep trans, int num_trans)); |
PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, |
png_bytep row, png_color_16p trans_value)); |
#endif |
/* The following decodes the appropriate chunks, and does error correction, |
* then calls the appropriate callback for the chunk if it is valid. |
*/ |
/* decode the IHDR chunk */ |
PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#if defined(PNG_READ_bKGD_SUPPORTED) |
PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif /* PNG_READ_iCCP_SUPPORTED */ |
#if defined(PNG_READ_iTXt_SUPPORTED) |
PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif /* PNG_READ_sPLT_SUPPORTED */ |
#if defined(PNG_READ_sRGB_SUPPORTED) |
PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 length)); |
PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, |
png_bytep chunk_name)); |
/* handle the transformations for reading and writing */ |
PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, |
png_uint_32 length)); |
PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, |
png_bytep buffer, png_size_t buffer_length)); |
PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, |
png_bytep buffer, png_size_t buffer_length)); |
PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); |
PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 length)); |
PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); |
PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); |
#if defined(PNG_READ_tEXt_SUPPORTED) |
PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 length)); |
PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 length)); |
PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_uint_32 length)); |
PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, |
png_infop info_ptr)); |
#endif |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, |
png_bytep row)); |
PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) |
/* png.c */ /* PRIVATE */ |
PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)); |
#endif |
/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ |
#endif /* PNG_INTERNAL */ |
#ifdef __cplusplus |
} |
#endif |
#endif /* PNG_VERSION_INFO_ONLY */ |
/* do not put anything past this line */ |
#endif /* PNG_H */ |
/shark/trunk/ports/png/inffast.c |
---|
0,0 → 1,183 |
/* inffast.c -- process literals and length/distance pairs fast |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
#include "zutil.h" |
#include "inftrees.h" |
#include "infblock.h" |
#include "infcodes.h" |
#include "infutil.h" |
#include "inffast.h" |
struct inflate_codes_state {int dummy;}; /* for buggy compilers */ |
/* simplify the use of the inflate_huft type with some defines */ |
#define exop word.what.Exop |
#define bits word.what.Bits |
/* macros for bit input with no checking and for returning unused bytes */ |
#define GRABBITS(j) {while(k<(j)){b|=((uLong)NEXTBYTE)<<k;k+=8;}} |
#define UNGRAB {c=z->avail_in-n;c=(k>>3)<c?k>>3:c;n+=c;p-=c;k-=c<<3;} |
/* Called with number of bytes left to write in window at least 258 |
(the maximum string length) and number of input bytes available |
at least ten. The ten bytes are six bytes for the longest length/ |
distance pair plus four bytes for overloading the bit buffer. */ |
int inflate_fast(bl, bd, tl, td, s, z) |
uInt bl, bd; |
inflate_huft *tl; |
inflate_huft *td; /* need separate declaration for Borland C++ */ |
inflate_blocks_statef *s; |
z_streamp z; |
{ |
inflate_huft *t; /* temporary pointer */ |
uInt e; /* extra bits or operation */ |
uLong b; /* bit buffer */ |
uInt k; /* bits in bit buffer */ |
Bytef *p; /* input data pointer */ |
uInt n; /* bytes available there */ |
Bytef *q; /* output window write pointer */ |
uInt m; /* bytes to end of window or read pointer */ |
uInt ml; /* mask for literal/length tree */ |
uInt md; /* mask for distance tree */ |
uInt c; /* bytes to copy */ |
uInt d; /* distance back to copy from */ |
Bytef *r; /* copy source pointer */ |
/* load input, output, bit values */ |
LOAD |
/* initialize masks */ |
ml = inflate_mask[bl]; |
md = inflate_mask[bd]; |
/* do until not enough input or output space for fast loop */ |
do { /* assume called with m >= 258 && n >= 10 */ |
/* get literal/length code */ |
GRABBITS(20) /* max bits for literal/length code */ |
if ((e = (t = tl + ((uInt)b & ml))->exop) == 0) |
{ |
DUMPBITS(t->bits) |
Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ? |
"inflate: * literal '%c'\n" : |
"inflate: * literal 0x%02x\n", t->base)); |
*q++ = (Byte)t->base; |
m--; |
continue; |
} |
do { |
DUMPBITS(t->bits) |
if (e & 16) |
{ |
/* get extra bits for length */ |
e &= 15; |
c = t->base + ((uInt)b & inflate_mask[e]); |
DUMPBITS(e) |
Tracevv((stderr, "inflate: * length %u\n", c)); |
/* decode distance base of block to copy */ |
GRABBITS(15); /* max bits for distance code */ |
e = (t = td + ((uInt)b & md))->exop; |
do { |
DUMPBITS(t->bits) |
if (e & 16) |
{ |
/* get extra bits to add to distance base */ |
e &= 15; |
GRABBITS(e) /* get extra bits (up to 13) */ |
d = t->base + ((uInt)b & inflate_mask[e]); |
DUMPBITS(e) |
Tracevv((stderr, "inflate: * distance %u\n", d)); |
/* do the copy */ |
m -= c; |
r = q - d; |
if (r < s->window) /* wrap if needed */ |
{ |
do { |
r += s->end - s->window; /* force pointer in window */ |
} while (r < s->window); /* covers invalid distances */ |
e = s->end - r; |
if (c > e) |
{ |
c -= e; /* wrapped copy */ |
do { |
*q++ = *r++; |
} while (--e); |
r = s->window; |
do { |
*q++ = *r++; |
} while (--c); |
} |
else /* normal copy */ |
{ |
*q++ = *r++; c--; |
*q++ = *r++; c--; |
do { |
*q++ = *r++; |
} while (--c); |
} |
} |
else /* normal copy */ |
{ |
*q++ = *r++; c--; |
*q++ = *r++; c--; |
do { |
*q++ = *r++; |
} while (--c); |
} |
break; |
} |
else if ((e & 64) == 0) |
{ |
t += t->base; |
e = (t += ((uInt)b & inflate_mask[e]))->exop; |
} |
else |
{ |
z->msg = (char*)"invalid distance code"; |
UNGRAB |
UPDATE |
return Z_DATA_ERROR; |
} |
} while (1); |
break; |
} |
if ((e & 64) == 0) |
{ |
t += t->base; |
if ((e = (t += ((uInt)b & inflate_mask[e]))->exop) == 0) |
{ |
DUMPBITS(t->bits) |
Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ? |
"inflate: * literal '%c'\n" : |
"inflate: * literal 0x%02x\n", t->base)); |
*q++ = (Byte)t->base; |
m--; |
break; |
} |
} |
else if (e & 32) |
{ |
Tracevv((stderr, "inflate: * end of block\n")); |
UNGRAB |
UPDATE |
return Z_STREAM_END; |
} |
else |
{ |
z->msg = (char*)"invalid literal/length code"; |
UNGRAB |
UPDATE |
return Z_DATA_ERROR; |
} |
} while (1); |
} while (m >= 258 && n >= 10); |
/* not enough input or output--restore pointers and return */ |
UNGRAB |
UPDATE |
return Z_OK; |
} |
/shark/trunk/ports/png/example.c |
---|
0,0 → 1,804 |
#if 0 /* in case someone actually tries to compile this */ |
/* example.c - an example of using libpng */ |
/* This is an example of how to use libpng to read and write PNG files. |
* The file libpng.txt is much more verbose then this. If you have not |
* read it, do so first. This was designed to be a starting point of an |
* implementation. This is not officially part of libpng, is hereby placed |
* in the public domain, and therefore does not require a copyright notice. |
* |
* This file does not currently compile, because it is missing certain |
* parts, like allocating memory to hold an image. You will have to |
* supply these parts to get it to compile. For an example of a minimal |
* working PNG reader/writer, see pngtest.c, included in this distribution; |
* see also the programs in the contrib directory. |
*/ |
#include "png.h" |
/* The png_jmpbuf() macro, used in error handling, became available in |
* libpng version 1.0.6. If you want to be able to run your code with older |
* versions of libpng, you must define the macro yourself (but only if it |
* is not already defined by libpng!). |
*/ |
#ifndef png_jmpbuf |
# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) |
#endif |
/* Check to see if a file is a PNG file using png_sig_cmp(). png_sig_cmp() |
* returns zero if the image is a PNG and nonzero if it isn't a PNG. |
* |
* The function check_if_png() shown here, but not used, returns nonzero (true) |
* if the file can be opened and is a PNG, 0 (false) otherwise. |
* |
* If this call is successful, and you are going to keep the file open, |
* you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once |
* you have created the png_ptr, so that libpng knows your application |
* has read that many bytes from the start of the file. Make sure you |
* don't call png_set_sig_bytes() with more than 8 bytes read or give it |
* an incorrect number of bytes read, or you will either have read too |
* many bytes (your fault), or you are telling libpng to read the wrong |
* number of magic bytes (also your fault). |
* |
* Many applications already read the first 2 or 4 bytes from the start |
* of the image to determine the file type, so it would be easiest just |
* to pass the bytes to png_sig_cmp() or even skip that if you know |
* you have a PNG file, and call png_set_sig_bytes(). |
*/ |
#define PNG_BYTES_TO_CHECK 4 |
int check_if_png(char *file_name, FILE **fp) |
{ |
char buf[PNG_BYTES_TO_CHECK]; |
/* Open the prospective PNG file. */ |
if ((*fp = fopen(file_name, "rb")) == NULL) |
return 0; |
/* Read in some of the signature bytes */ |
if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK) |
return 0; |
/* Compare the first PNG_BYTES_TO_CHECK bytes of the signature. |
Return nonzero (true) if they match */ |
return(!png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK)); |
} |
/* Read a PNG file. You may want to return an error code if the read |
* fails (depending upon the failure). There are two "prototypes" given |
* here - one where we are given the filename, and we need to open the |
* file, and the other where we are given an open file (possibly with |
* some or all of the magic bytes read - see comments above). |
*/ |
#ifdef open_file /* prototype 1 */ |
void read_png(char *file_name) /* We need to open the file */ |
{ |
png_structp png_ptr; |
png_infop info_ptr; |
unsigned int sig_read = 0; |
png_uint_32 width, height; |
int bit_depth, color_type, interlace_type; |
FILE *fp; |
if ((fp = fopen(file_name, "rb")) == NULL) |
return (ERROR); |
#else no_open_file /* prototype 2 */ |
void read_png(FILE *fp, unsigned int sig_read) /* file is already open */ |
{ |
png_structp png_ptr; |
png_infop info_ptr; |
png_uint_32 width, height; |
int bit_depth, color_type, interlace_type; |
#endif no_open_file /* only use one prototype! */ |
/* Create and initialize the png_struct with the desired error handler |
* functions. If you want to use the default stderr and longjump method, |
* you can supply NULL for the last three parameters. We also supply the |
* the compiler header file version, so that we know if the application |
* was compiled with a compatible version of the library. REQUIRED |
*/ |
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, |
png_voidp user_error_ptr, user_error_fn, user_warning_fn); |
if (png_ptr == NULL) |
{ |
fclose(fp); |
return (ERROR); |
} |
/* Allocate/initialize the memory for image information. REQUIRED. */ |
info_ptr = png_create_info_struct(png_ptr); |
if (info_ptr == NULL) |
{ |
fclose(fp); |
png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL); |
return (ERROR); |
} |
/* Set error handling if you are using the setjmp/longjmp method (this is |
* the normal method of doing things with libpng). REQUIRED unless you |
* set up your own error handlers in the png_create_read_struct() earlier. |
*/ |
if (setjmp(png_jmpbuf(png_ptr))) |
{ |
/* Free all of the memory associated with the png_ptr and info_ptr */ |
png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); |
fclose(fp); |
/* If we get here, we had a problem reading the file */ |
return (ERROR); |
} |
/* One of the following I/O initialization methods is REQUIRED */ |
#ifdef streams /* PNG file I/O method 1 */ |
/* Set up the input control if you are using standard C streams */ |
png_init_io(png_ptr, fp); |
#else no_streams /* PNG file I/O method 2 */ |
/* If you are using replacement read functions, instead of calling |
* png_init_io() here you would call: |
*/ |
png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn); |
/* where user_io_ptr is a structure you want available to the callbacks */ |
#endif no_streams /* Use only one I/O method! */ |
/* If we have already read some of the signature */ |
png_set_sig_bytes(png_ptr, sig_read); |
#ifdef hilevel |
/* |
* If you have enough memory to read in the entire image at once, |
* and you need to specify only transforms that can be controlled |
* with one of the PNG_TRANSFORM_* bits (this presently excludes |
* dithering, filling, setting background, and doing gamma |
* adjustment), then you can read the entire image (including |
* pixels) into the info structure with this call: |
*/ |
png_read_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL); |
#else |
/* OK, you're doing it the hard way, with the lower-level functions */ |
/* The call to png_read_info() gives us all of the information from the |
* PNG file before the first IDAT (image data chunk). REQUIRED |
*/ |
png_read_info(png_ptr, info_ptr); |
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, |
&interlace_type, int_p_NULL, int_p_NULL); |
/* Set up the data transformations you want. Note that these are all |
* optional. Only call them if you want/need them. Many of the |
* transformations only work on specific types of images, and many |
* are mutually exclusive. |
*/ |
/* tell libpng to strip 16 bit/color files down to 8 bits/color */ |
png_set_strip_16(png_ptr); |
/* Strip alpha bytes from the input data without combining with the |
* background (not recommended). |
*/ |
png_set_strip_alpha(png_ptr); |
/* Extract multiple pixels with bit depths of 1, 2, and 4 from a single |
* byte into separate bytes (useful for paletted and grayscale images). |
*/ |
png_set_packing(png_ptr); |
/* Change the order of packed pixels to least significant bit first |
* (not useful if you are using png_set_packing). */ |
png_set_packswap(png_ptr); |
/* Expand paletted colors into true RGB triplets */ |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
png_set_palette_rgb(png_ptr); |
/* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */ |
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) |
png_set_gray_1_2_4_to_8(png_ptr); |
/* Expand paletted or RGB images with transparency to full alpha channels |
* so the data will be available as RGBA quartets. |
*/ |
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) |
png_set_tRNS_to_alpha(png_ptr); |
/* Set the background color to draw transparent and alpha images over. |
* It is possible to set the red, green, and blue components directly |
* for paletted images instead of supplying a palette index. Note that |
* even if the PNG file supplies a background, you are not required to |
* use it - you should use the (solid) application background if it has one. |
*/ |
png_color_16 my_background, *image_background; |
if (png_get_bKGD(png_ptr, info_ptr, &image_background)) |
png_set_background(png_ptr, image_background, |
PNG_BACKGROUND_GAMMA_FILE, 1, 1.0); |
else |
png_set_background(png_ptr, &my_background, |
PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); |
/* Some suggestions as to how to get a screen gamma value */ |
/* Note that screen gamma is the display_exponent, which includes |
* the CRT_exponent and any correction for viewing conditions */ |
if (/* We have a user-defined screen gamma value */) |
{ |
screen_gamma = user-defined screen_gamma; |
} |
/* This is one way that applications share the same screen gamma value */ |
else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL) |
{ |
screen_gamma = atof(gamma_str); |
} |
/* If we don't have another value */ |
else |
{ |
screen_gamma = 2.2; /* A good guess for a PC monitors in a dimly |
lit room */ |
screen_gamma = 1.7 or 1.0; /* A good guess for Mac systems */ |
} |
/* Tell libpng to handle the gamma conversion for you. The final call |
* is a good guess for PC generated images, but it should be configurable |
* by the user at run time by the user. It is strongly suggested that |
* your application support gamma correction. |
*/ |
int intent; |
if (png_get_sRGB(png_ptr, info_ptr, &intent)) |
png_set_gamma(png_ptr, screen_gamma, 0.45455); |
else |
{ |
double image_gamma; |
if (png_get_gAMA(png_ptr, info_ptr, &image_gamma)) |
png_set_gamma(png_ptr, screen_gamma, image_gamma); |
else |
png_set_gamma(png_ptr, screen_gamma, 0.45455); |
} |
/* Dither RGB files down to 8 bit palette or reduce palettes |
* to the number of colors available on your screen. |
*/ |
if (color_type & PNG_COLOR_MASK_COLOR) |
{ |
int num_palette; |
png_colorp palette; |
/* This reduces the image to the application supplied palette */ |
if (/* we have our own palette */) |
{ |
/* An array of colors to which the image should be dithered */ |
png_color std_color_cube[MAX_SCREEN_COLORS]; |
png_set_dither(png_ptr, std_color_cube, MAX_SCREEN_COLORS, |
MAX_SCREEN_COLORS, png_uint_16p_NULL, 0); |
} |
/* This reduces the image to the palette supplied in the file */ |
else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette)) |
{ |
png_uint_16p histogram = NULL; |
png_get_hIST(png_ptr, info_ptr, &histogram); |
png_set_dither(png_ptr, palette, num_palette, |
max_screen_colors, histogram, 0); |
} |
} |
/* invert monochrome files to have 0 as white and 1 as black */ |
png_set_invert_mono(png_ptr); |
/* If you want to shift the pixel values from the range [0,255] or |
* [0,65535] to the original [0,7] or [0,31], or whatever range the |
* colors were originally in: |
*/ |
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) |
{ |
png_color_8p sig_bit; |
png_get_sBIT(png_ptr, info_ptr, &sig_bit); |
png_set_shift(png_ptr, sig_bit); |
} |
/* flip the RGB pixels to BGR (or RGBA to BGRA) */ |
if (color_type & PNG_COLOR_MASK_COLOR) |
png_set_bgr(png_ptr); |
/* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */ |
png_set_swap_alpha(png_ptr); |
/* swap bytes of 16 bit files to least significant byte first */ |
png_set_swap(png_ptr); |
/* Add filler (or alpha) byte (before/after each RGB triplet) */ |
png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER); |
/* Turn on interlace handling. REQUIRED if you are not using |
* png_read_image(). To see how to handle interlacing passes, |
* see the png_read_row() method below: |
*/ |
number_passes = png_set_interlace_handling(png_ptr); |
/* Optional call to gamma correct and add the background to the palette |
* and update info structure. REQUIRED if you are expecting libpng to |
* update the palette for you (ie you selected such a transform above). |
*/ |
png_read_update_info(png_ptr, info_ptr); |
/* Allocate the memory to hold the image using the fields of info_ptr. */ |
/* The easiest way to read the image: */ |
png_bytep row_pointers[height]; |
for (row = 0; row < height; row++) |
{ |
row_pointers[row] = png_malloc(png_ptr, png_get_rowbytes(png_ptr, |
info_ptr)); |
} |
/* Now it's time to read the image. One of these methods is REQUIRED */ |
#ifdef entire /* Read the entire image in one go */ |
png_read_image(png_ptr, row_pointers); |
#else no_entire /* Read the image one or more scanlines at a time */ |
/* The other way to read images - deal with interlacing: */ |
for (pass = 0; pass < number_passes; pass++) |
{ |
#ifdef single /* Read the image a single row at a time */ |
for (y = 0; y < height; y++) |
{ |
png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL, 1); |
} |
#else no_single /* Read the image several rows at a time */ |
for (y = 0; y < height; y += number_of_rows) |
{ |
#ifdef sparkle /* Read the image using the "sparkle" effect. */ |
png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL, |
number_of_rows); |
#else no_sparkle /* Read the image using the "rectangle" effect */ |
png_read_rows(png_ptr, png_bytepp_NULL, &row_pointers[y], |
number_of_rows); |
#endif no_sparkle /* use only one of these two methods */ |
} |
/* if you want to display the image after every pass, do |
so here */ |
#endif no_single /* use only one of these two methods */ |
} |
#endif no_entire /* use only one of these two methods */ |
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */ |
png_read_end(png_ptr, info_ptr); |
#endif hilevel |
/* At this point you have read the entire image */ |
/* clean up after the read, and free any memory allocated - REQUIRED */ |
png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); |
/* close the file */ |
fclose(fp); |
/* that's it */ |
return (OK); |
} |
/* progressively read a file */ |
int |
initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr) |
{ |
/* Create and initialize the png_struct with the desired error handler |
* functions. If you want to use the default stderr and longjump method, |
* you can supply NULL for the last three parameters. We also check that |
* the library version is compatible in case we are using dynamically |
* linked libraries. |
*/ |
*png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, |
png_voidp user_error_ptr, user_error_fn, user_warning_fn); |
if (*png_ptr == NULL) |
{ |
*info_ptr = NULL; |
return (ERROR); |
} |
*info_ptr = png_create_info_struct(png_ptr); |
if (*info_ptr == NULL) |
{ |
png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL); |
return (ERROR); |
} |
if (setjmp(png_jmpbuf((*png_ptr)))) |
{ |
png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL); |
return (ERROR); |
} |
/* This one's new. You will need to provide all three |
* function callbacks, even if you aren't using them all. |
* If you aren't using all functions, you can specify NULL |
* parameters. Even when all three functions are NULL, |
* you need to call png_set_progressive_read_fn(). |
* These functions shouldn't be dependent on global or |
* static variables if you are decoding several images |
* simultaneously. You should store stream specific data |
* in a separate struct, given as the second parameter, |
* and retrieve the pointer from inside the callbacks using |
* the function png_get_progressive_ptr(png_ptr). |
*/ |
png_set_progressive_read_fn(*png_ptr, (void *)stream_data, |
info_callback, row_callback, end_callback); |
return (OK); |
} |
int |
process_data(png_structp *png_ptr, png_infop *info_ptr, |
png_bytep buffer, png_uint_32 length) |
{ |
if (setjmp(png_jmpbuf((*png_ptr)))) |
{ |
/* Free the png_ptr and info_ptr memory on error */ |
png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL); |
return (ERROR); |
} |
/* This one's new also. Simply give it chunks of data as |
* they arrive from the data stream (in order, of course). |
* On Segmented machines, don't give it any more than 64K. |
* The library seems to run fine with sizes of 4K, although |
* you can give it much less if necessary (I assume you can |
* give it chunks of 1 byte, but I haven't tried with less |
* than 256 bytes yet). When this function returns, you may |
* want to display any rows that were generated in the row |
* callback, if you aren't already displaying them there. |
*/ |
png_process_data(*png_ptr, *info_ptr, buffer, length); |
return (OK); |
} |
info_callback(png_structp png_ptr, png_infop info) |
{ |
/* do any setup here, including setting any of the transformations |
* mentioned in the Reading PNG files section. For now, you _must_ |
* call either png_start_read_image() or png_read_update_info() |
* after all the transformations are set (even if you don't set |
* any). You may start getting rows before png_process_data() |
* returns, so this is your last chance to prepare for that. |
*/ |
} |
row_callback(png_structp png_ptr, png_bytep new_row, |
png_uint_32 row_num, int pass) |
{ |
/* |
* This function is called for every row in the image. If the |
* image is interlaced, and you turned on the interlace handler, |
* this function will be called for every row in every pass. |
* |
* In this function you will receive a pointer to new row data from |
* libpng called new_row that is to replace a corresponding row (of |
* the same data format) in a buffer allocated by your application. |
* |
* The new row data pointer new_row may be NULL, indicating there is |
* no new data to be replaced (in cases of interlace loading). |
* |
* If new_row is not NULL then you need to call |
* png_progressive_combine_row() to replace the corresponding row as |
* shown below: |
*/ |
/* Check if row_num is in bounds. */ |
if((row_num >= 0) && (row_num < height)) |
{ |
/* Get pointer to corresponding row in our |
* PNG read buffer. |
*/ |
png_bytep old_row = ((png_bytep *)our_data)[row_num]; |
/* If both rows are allocated then copy the new row |
* data to the corresponding row data. |
*/ |
if((old_row != NULL) && (new_row != NULL)) |
png_progressive_combine_row(png_ptr, old_row, new_row); |
} |
/* |
* The rows and passes are called in order, so you don't really |
* need the row_num and pass, but I'm supplying them because it |
* may make your life easier. |
* |
* For the non-NULL rows of interlaced images, you must call |
* png_progressive_combine_row() passing in the new row and the |
* old row, as demonstrated above. You can call this function for |
* NULL rows (it will just return) and for non-interlaced images |
* (it just does the png_memcpy for you) if it will make the code |
* easier. Thus, you can just do this for all cases: |
*/ |
png_progressive_combine_row(png_ptr, old_row, new_row); |
/* where old_row is what was displayed for previous rows. Note |
* that the first pass (pass == 0 really) will completely cover |
* the old row, so the rows do not have to be initialized. After |
* the first pass (and only for interlaced images), you will have |
* to pass the current row as new_row, and the function will combine |
* the old row and the new row. |
*/ |
} |
end_callback(png_structp png_ptr, png_infop info) |
{ |
/* this function is called when the whole image has been read, |
* including any chunks after the image (up to and including |
* the IEND). You will usually have the same info chunk as you |
* had in the header, although some data may have been added |
* to the comments and time fields. |
* |
* Most people won't do much here, perhaps setting a flag that |
* marks the image as finished. |
*/ |
} |
/* write a png file */ |
void write_png(char *file_name /* , ... other image information ... */) |
{ |
FILE *fp; |
png_structp png_ptr; |
png_infop info_ptr; |
png_colorp palette; |
/* open the file */ |
fp = fopen(file_name, "wb"); |
if (fp == NULL) |
return (ERROR); |
/* Create and initialize the png_struct with the desired error handler |
* functions. If you want to use the default stderr and longjump method, |
* you can supply NULL for the last three parameters. We also check that |
* the library version is compatible with the one used at compile time, |
* in case we are using dynamically linked libraries. REQUIRED. |
*/ |
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, |
png_voidp user_error_ptr, user_error_fn, user_warning_fn); |
if (png_ptr == NULL) |
{ |
fclose(fp); |
return (ERROR); |
} |
/* Allocate/initialize the image information data. REQUIRED */ |
info_ptr = png_create_info_struct(png_ptr); |
if (info_ptr == NULL) |
{ |
fclose(fp); |
png_destroy_write_struct(&png_ptr, png_infopp_NULL); |
return (ERROR); |
} |
/* Set error handling. REQUIRED if you aren't supplying your own |
* error handling functions in the png_create_write_struct() call. |
*/ |
if (setjmp(png_jmpbuf(png_ptr))) |
{ |
/* If we get here, we had a problem reading the file */ |
fclose(fp); |
png_destroy_write_struct(&png_ptr, &info_ptr); |
return (ERROR); |
} |
/* One of the following I/O initialization functions is REQUIRED */ |
#ifdef streams /* I/O initialization method 1 */ |
/* set up the output control if you are using standard C streams */ |
png_init_io(png_ptr, fp); |
#else no_streams /* I/O initialization method 2 */ |
/* If you are using replacement read functions, instead of calling |
* png_init_io() here you would call */ |
png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn, |
user_IO_flush_function); |
/* where user_io_ptr is a structure you want available to the callbacks */ |
#endif no_streams /* only use one initialization method */ |
#ifdef hilevel |
/* This is the easy way. Use it if you already have all the |
* image info living info in the structure. You could "|" many |
* PNG_TRANSFORM flags into the png_transforms integer here. |
*/ |
png_write_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL); |
#else |
/* This is the hard way */ |
/* Set the image information here. Width and height are up to 2^31, |
* bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on |
* the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY, |
* PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB, |
* or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or |
* PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST |
* currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED |
*/ |
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_???, |
PNG_INTERLACE_????, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); |
/* set the palette if there is one. REQUIRED for indexed-color images */ |
palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH |
* sizeof (png_color)); |
/* ... set palette colors ... */ |
png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH); |
/* You must not free palette here, because png_set_PLTE only makes a link to |
the palette that you malloced. Wait until you are about to destroy |
the png structure. */ |
/* optional significant bit chunk */ |
/* if we are dealing with a grayscale image then */ |
sig_bit.gray = true_bit_depth; |
/* otherwise, if we are dealing with a color image then */ |
sig_bit.red = true_red_bit_depth; |
sig_bit.green = true_green_bit_depth; |
sig_bit.blue = true_blue_bit_depth; |
/* if the image has an alpha channel then */ |
sig_bit.alpha = true_alpha_bit_depth; |
png_set_sBIT(png_ptr, info_ptr, sig_bit); |
/* Optional gamma chunk is strongly suggested if you have any guess |
* as to the correct gamma of the image. |
*/ |
png_set_gAMA(png_ptr, info_ptr, gamma); |
/* Optionally write comments into the image */ |
text_ptr[0].key = "Title"; |
text_ptr[0].text = "Mona Lisa"; |
text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr[1].key = "Author"; |
text_ptr[1].text = "Leonardo DaVinci"; |
text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr[2].key = "Description"; |
text_ptr[2].text = "<long text>"; |
text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt; |
#ifdef PNG_iTXt_SUPPORTED |
text_ptr[0].lang = NULL; |
text_ptr[1].lang = NULL; |
text_ptr[2].lang = NULL; |
#endif |
png_set_text(png_ptr, info_ptr, text_ptr, 3); |
/* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */ |
/* note that if sRGB is present the gAMA and cHRM chunks must be ignored |
* on read and must be written in accordance with the sRGB profile */ |
/* Write the file header information. REQUIRED */ |
png_write_info(png_ptr, info_ptr); |
/* If you want, you can write the info in two steps, in case you need to |
* write your private chunk ahead of PLTE: |
* |
* png_write_info_before_PLTE(write_ptr, write_info_ptr); |
* write_my_chunk(); |
* png_write_info(png_ptr, info_ptr); |
* |
* However, given the level of known- and unknown-chunk support in 1.1.0 |
* and up, this should no longer be necessary. |
*/ |
/* Once we write out the header, the compression type on the text |
* chunks gets changed to PNG_TEXT_COMPRESSION_NONE_WR or |
* PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again |
* at the end. |
*/ |
/* set up the transformations you want. Note that these are |
* all optional. Only call them if you want them. |
*/ |
/* invert monochrome pixels */ |
png_set_invert_mono(png_ptr); |
/* Shift the pixels up to a legal bit depth and fill in |
* as appropriate to correctly scale the image. |
*/ |
png_set_shift(png_ptr, &sig_bit); |
/* pack pixels into bytes */ |
png_set_packing(png_ptr); |
/* swap location of alpha bytes from ARGB to RGBA */ |
png_set_swap_alpha(png_ptr); |
/* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into |
* RGB (4 channels -> 3 channels). The second parameter is not used. |
*/ |
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); |
/* flip BGR pixels to RGB */ |
png_set_bgr(png_ptr); |
/* swap bytes of 16-bit files to most significant byte first */ |
png_set_swap(png_ptr); |
/* swap bits of 1, 2, 4 bit packed pixel formats */ |
png_set_packswap(png_ptr); |
/* turn on interlace handling if you are not using png_write_image() */ |
if (interlacing) |
number_passes = png_set_interlace_handling(png_ptr); |
else |
number_passes = 1; |
/* The easiest way to write the image (you may have a different memory |
* layout, however, so choose what fits your needs best). You need to |
* use the first method if you aren't handling interlacing yourself. |
*/ |
png_uint_32 k, height, width; |
png_byte image[height][width*bytes_per_pixel]; |
png_bytep row_pointers[height]; |
for (k = 0; k < height; k++) |
row_pointers[k] = image + k*width*bytes_per_pixel; |
/* One of the following output methods is REQUIRED */ |
#ifdef entire /* write out the entire image data in one call */ |
png_write_image(png_ptr, row_pointers); |
/* the other way to write the image - deal with interlacing */ |
#else no_entire /* write out the image data by one or more scanlines */ |
/* The number of passes is either 1 for non-interlaced images, |
* or 7 for interlaced images. |
*/ |
for (pass = 0; pass < number_passes; pass++) |
{ |
/* Write a few rows at a time. */ |
png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows); |
/* If you are only writing one row at a time, this works */ |
for (y = 0; y < height; y++) |
{ |
png_write_rows(png_ptr, &row_pointers[y], 1); |
} |
} |
#endif no_entire /* use only one output method */ |
/* You can write optional chunks like tEXt, zTXt, and tIME at the end |
* as well. Shouldn't be necessary in 1.1.0 and up as all the public |
* chunks are supported and you can use png_set_unknown_chunks() to |
* register unknown chunks into the info structure to be written out. |
*/ |
/* It is REQUIRED to call this to finish writing the rest of the file */ |
png_write_end(png_ptr, info_ptr); |
#endif hilevel |
/* If you png_malloced a palette, free it here (don't free info_ptr->palette, |
as recommended in versions 1.0.5m and earlier of this example; if |
libpng mallocs info_ptr->palette, libpng will free it). If you |
allocated it with malloc() instead of png_malloc(), use free() instead |
of png_free(). */ |
png_free(png_ptr, palette); |
palette=NULL; |
/* Similarly, if you png_malloced any data that you passed in with |
png_set_something(), such as a hist or trans array, free it here, |
when you can be sure that libpng is through with it. */ |
png_free(png_ptr, trans); |
trans=NULL; |
/* clean up after the write, and free any memory allocated */ |
png_destroy_write_struct(&png_ptr, &info_ptr); |
/* close the file */ |
fclose(fp); |
/* that's it */ |
return (OK); |
} |
#endif /* if 0 */ |
/shark/trunk/ports/png/compress.c |
---|
0,0 → 1,68 |
/* compress.c -- compress a memory buffer |
* Copyright (C) 1995-2002 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* @(#) $Id: compress.c,v 1.1 2003-03-20 13:08:10 giacomo Exp $ */ |
#include "zlib.h" |
/* =========================================================================== |
Compresses the source buffer into the destination buffer. The level |
parameter has the same meaning as in deflateInit. sourceLen is the byte |
length of the source buffer. Upon entry, destLen is the total size of the |
destination buffer, which must be at least 0.1% larger than sourceLen plus |
12 bytes. Upon exit, destLen is the actual size of the compressed buffer. |
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
memory, Z_BUF_ERROR if there was not enough room in the output buffer, |
Z_STREAM_ERROR if the level parameter is invalid. |
*/ |
int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) |
Bytef *dest; |
uLongf *destLen; |
const Bytef *source; |
uLong sourceLen; |
int level; |
{ |
z_stream stream; |
int err; |
stream.next_in = (Bytef*)source; |
stream.avail_in = (uInt)sourceLen; |
#ifdef MAXSEG_64K |
/* Check for source > 64K on 16-bit machine: */ |
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; |
#endif |
stream.next_out = dest; |
stream.avail_out = (uInt)*destLen; |
if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; |
stream.zalloc = (alloc_func)0; |
stream.zfree = (free_func)0; |
stream.opaque = (voidpf)0; |
err = deflateInit(&stream, level); |
if (err != Z_OK) return err; |
err = deflate(&stream, Z_FINISH); |
if (err != Z_STREAM_END) { |
deflateEnd(&stream); |
return err == Z_OK ? Z_BUF_ERROR : err; |
} |
*destLen = stream.total_out; |
err = deflateEnd(&stream); |
return err; |
} |
/* =========================================================================== |
*/ |
int ZEXPORT compress (dest, destLen, source, sourceLen) |
Bytef *dest; |
uLongf *destLen; |
const Bytef *source; |
uLong sourceLen; |
{ |
return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); |
} |
/shark/trunk/ports/png/pngtrans.c |
---|
0,0 → 1,640 |
/* pngtrans.c - transforms the data in a row (used by both readers and writers) |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
/* turn on BGR-to-RGB mapping */ |
void PNGAPI |
png_set_bgr(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_bgr\n"); |
png_ptr->transformations |= PNG_BGR; |
} |
#endif |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
/* turn on 16 bit byte swapping */ |
void PNGAPI |
png_set_swap(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_swap\n"); |
if (png_ptr->bit_depth == 16) |
png_ptr->transformations |= PNG_SWAP_BYTES; |
} |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) |
/* turn on pixel packing */ |
void PNGAPI |
png_set_packing(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_packing\n"); |
if (png_ptr->bit_depth < 8) |
{ |
png_ptr->transformations |= PNG_PACK; |
png_ptr->usr_bit_depth = 8; |
} |
} |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
/* turn on packed pixel swapping */ |
void PNGAPI |
png_set_packswap(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_packswap\n"); |
if (png_ptr->bit_depth < 8) |
png_ptr->transformations |= PNG_PACKSWAP; |
} |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
void PNGAPI |
png_set_shift(png_structp png_ptr, png_color_8p true_bits) |
{ |
png_debug(1, "in png_set_shift\n"); |
png_ptr->transformations |= PNG_SHIFT; |
png_ptr->shift = *true_bits; |
} |
#endif |
#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ |
defined(PNG_WRITE_INTERLACING_SUPPORTED) |
int PNGAPI |
png_set_interlace_handling(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_interlace handling\n"); |
if (png_ptr->interlaced) |
{ |
png_ptr->transformations |= PNG_INTERLACE; |
return (7); |
} |
return (1); |
} |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
/* Add a filler byte on read, or remove a filler or alpha byte on write. |
* The filler type has changed in v0.95 to allow future 2-byte fillers |
* for 48-bit input data, as well as to avoid problems with some compilers |
* that don't like bytes as parameters. |
*/ |
void PNGAPI |
png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc) |
{ |
png_debug(1, "in png_set_filler\n"); |
png_ptr->transformations |= PNG_FILLER; |
png_ptr->filler = (png_byte)filler; |
if (filler_loc == PNG_FILLER_AFTER) |
png_ptr->flags |= PNG_FLAG_FILLER_AFTER; |
else |
png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER; |
/* This should probably go in the "do_filler" routine. |
* I attempted to do that in libpng-1.0.1a but that caused problems |
* so I restored it in libpng-1.0.2a |
*/ |
if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
{ |
png_ptr->usr_channels = 4; |
} |
/* Also I added this in libpng-1.0.2a (what happens when we expand |
* a less-than-8-bit grayscale to GA? */ |
if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY && png_ptr->bit_depth >= 8) |
{ |
png_ptr->usr_channels = 2; |
} |
} |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
void PNGAPI |
png_set_swap_alpha(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_swap_alpha\n"); |
png_ptr->transformations |= PNG_SWAP_ALPHA; |
} |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
void PNGAPI |
png_set_invert_alpha(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_invert_alpha\n"); |
png_ptr->transformations |= PNG_INVERT_ALPHA; |
} |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
void PNGAPI |
png_set_invert_mono(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_invert_mono\n"); |
png_ptr->transformations |= PNG_INVERT_MONO; |
} |
/* invert monochrome grayscale data */ |
void /* PRIVATE */ |
png_do_invert(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_invert\n"); |
/* This test removed from libpng version 1.0.13 and 1.2.0: |
* if (row_info->bit_depth == 1 && |
*/ |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row == NULL || row_info == NULL) |
return; |
#endif |
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
png_bytep rp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(~(*rp)); |
rp++; |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && |
row_info->bit_depth == 8) |
{ |
png_bytep rp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
for (i = 0; i < istop; i+=2) |
{ |
*rp = (png_byte)(~(*rp)); |
rp+=2; |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && |
row_info->bit_depth == 16) |
{ |
png_bytep rp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
for (i = 0; i < istop; i+=4) |
{ |
*rp = (png_byte)(~(*rp)); |
*(rp+1) = (png_byte)(~(*(rp+1))); |
rp+=4; |
} |
} |
} |
#endif |
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) |
/* swaps byte order on 16 bit depth images */ |
void /* PRIVATE */ |
png_do_swap(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_swap\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
row_info->bit_depth == 16) |
{ |
png_bytep rp = row; |
png_uint_32 i; |
png_uint_32 istop= row_info->width * row_info->channels; |
for (i = 0; i < istop; i++, rp += 2) |
{ |
png_byte t = *rp; |
*rp = *(rp + 1); |
*(rp + 1) = t; |
} |
} |
} |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
static png_byte onebppswaptable[256] = { |
0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, |
0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, |
0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, |
0x18, 0x98, 0x58, 0xD8, 0x38, 0xB8, 0x78, 0xF8, |
0x04, 0x84, 0x44, 0xC4, 0x24, 0xA4, 0x64, 0xE4, |
0x14, 0x94, 0x54, 0xD4, 0x34, 0xB4, 0x74, 0xF4, |
0x0C, 0x8C, 0x4C, 0xCC, 0x2C, 0xAC, 0x6C, 0xEC, |
0x1C, 0x9C, 0x5C, 0xDC, 0x3C, 0xBC, 0x7C, 0xFC, |
0x02, 0x82, 0x42, 0xC2, 0x22, 0xA2, 0x62, 0xE2, |
0x12, 0x92, 0x52, 0xD2, 0x32, 0xB2, 0x72, 0xF2, |
0x0A, 0x8A, 0x4A, 0xCA, 0x2A, 0xAA, 0x6A, 0xEA, |
0x1A, 0x9A, 0x5A, 0xDA, 0x3A, 0xBA, 0x7A, 0xFA, |
0x06, 0x86, 0x46, 0xC6, 0x26, 0xA6, 0x66, 0xE6, |
0x16, 0x96, 0x56, 0xD6, 0x36, 0xB6, 0x76, 0xF6, |
0x0E, 0x8E, 0x4E, 0xCE, 0x2E, 0xAE, 0x6E, 0xEE, |
0x1E, 0x9E, 0x5E, 0xDE, 0x3E, 0xBE, 0x7E, 0xFE, |
0x01, 0x81, 0x41, 0xC1, 0x21, 0xA1, 0x61, 0xE1, |
0x11, 0x91, 0x51, 0xD1, 0x31, 0xB1, 0x71, 0xF1, |
0x09, 0x89, 0x49, 0xC9, 0x29, 0xA9, 0x69, 0xE9, |
0x19, 0x99, 0x59, 0xD9, 0x39, 0xB9, 0x79, 0xF9, |
0x05, 0x85, 0x45, 0xC5, 0x25, 0xA5, 0x65, 0xE5, |
0x15, 0x95, 0x55, 0xD5, 0x35, 0xB5, 0x75, 0xF5, |
0x0D, 0x8D, 0x4D, 0xCD, 0x2D, 0xAD, 0x6D, 0xED, |
0x1D, 0x9D, 0x5D, 0xDD, 0x3D, 0xBD, 0x7D, 0xFD, |
0x03, 0x83, 0x43, 0xC3, 0x23, 0xA3, 0x63, 0xE3, |
0x13, 0x93, 0x53, 0xD3, 0x33, 0xB3, 0x73, 0xF3, |
0x0B, 0x8B, 0x4B, 0xCB, 0x2B, 0xAB, 0x6B, 0xEB, |
0x1B, 0x9B, 0x5B, 0xDB, 0x3B, 0xBB, 0x7B, 0xFB, |
0x07, 0x87, 0x47, 0xC7, 0x27, 0xA7, 0x67, 0xE7, |
0x17, 0x97, 0x57, 0xD7, 0x37, 0xB7, 0x77, 0xF7, |
0x0F, 0x8F, 0x4F, 0xCF, 0x2F, 0xAF, 0x6F, 0xEF, |
0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF |
}; |
static png_byte twobppswaptable[256] = { |
0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0, |
0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0, |
0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4, |
0x24, 0x64, 0xA4, 0xE4, 0x34, 0x74, 0xB4, 0xF4, |
0x08, 0x48, 0x88, 0xC8, 0x18, 0x58, 0x98, 0xD8, |
0x28, 0x68, 0xA8, 0xE8, 0x38, 0x78, 0xB8, 0xF8, |
0x0C, 0x4C, 0x8C, 0xCC, 0x1C, 0x5C, 0x9C, 0xDC, |
0x2C, 0x6C, 0xAC, 0xEC, 0x3C, 0x7C, 0xBC, 0xFC, |
0x01, 0x41, 0x81, 0xC1, 0x11, 0x51, 0x91, 0xD1, |
0x21, 0x61, 0xA1, 0xE1, 0x31, 0x71, 0xB1, 0xF1, |
0x05, 0x45, 0x85, 0xC5, 0x15, 0x55, 0x95, 0xD5, |
0x25, 0x65, 0xA5, 0xE5, 0x35, 0x75, 0xB5, 0xF5, |
0x09, 0x49, 0x89, 0xC9, 0x19, 0x59, 0x99, 0xD9, |
0x29, 0x69, 0xA9, 0xE9, 0x39, 0x79, 0xB9, 0xF9, |
0x0D, 0x4D, 0x8D, 0xCD, 0x1D, 0x5D, 0x9D, 0xDD, |
0x2D, 0x6D, 0xAD, 0xED, 0x3D, 0x7D, 0xBD, 0xFD, |
0x02, 0x42, 0x82, 0xC2, 0x12, 0x52, 0x92, 0xD2, |
0x22, 0x62, 0xA2, 0xE2, 0x32, 0x72, 0xB2, 0xF2, |
0x06, 0x46, 0x86, 0xC6, 0x16, 0x56, 0x96, 0xD6, |
0x26, 0x66, 0xA6, 0xE6, 0x36, 0x76, 0xB6, 0xF6, |
0x0A, 0x4A, 0x8A, 0xCA, 0x1A, 0x5A, 0x9A, 0xDA, |
0x2A, 0x6A, 0xAA, 0xEA, 0x3A, 0x7A, 0xBA, 0xFA, |
0x0E, 0x4E, 0x8E, 0xCE, 0x1E, 0x5E, 0x9E, 0xDE, |
0x2E, 0x6E, 0xAE, 0xEE, 0x3E, 0x7E, 0xBE, 0xFE, |
0x03, 0x43, 0x83, 0xC3, 0x13, 0x53, 0x93, 0xD3, |
0x23, 0x63, 0xA3, 0xE3, 0x33, 0x73, 0xB3, 0xF3, |
0x07, 0x47, 0x87, 0xC7, 0x17, 0x57, 0x97, 0xD7, |
0x27, 0x67, 0xA7, 0xE7, 0x37, 0x77, 0xB7, 0xF7, |
0x0B, 0x4B, 0x8B, 0xCB, 0x1B, 0x5B, 0x9B, 0xDB, |
0x2B, 0x6B, 0xAB, 0xEB, 0x3B, 0x7B, 0xBB, 0xFB, |
0x0F, 0x4F, 0x8F, 0xCF, 0x1F, 0x5F, 0x9F, 0xDF, |
0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF |
}; |
static png_byte fourbppswaptable[256] = { |
0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, |
0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, |
0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, |
0x81, 0x91, 0xA1, 0xB1, 0xC1, 0xD1, 0xE1, 0xF1, |
0x02, 0x12, 0x22, 0x32, 0x42, 0x52, 0x62, 0x72, |
0x82, 0x92, 0xA2, 0xB2, 0xC2, 0xD2, 0xE2, 0xF2, |
0x03, 0x13, 0x23, 0x33, 0x43, 0x53, 0x63, 0x73, |
0x83, 0x93, 0xA3, 0xB3, 0xC3, 0xD3, 0xE3, 0xF3, |
0x04, 0x14, 0x24, 0x34, 0x44, 0x54, 0x64, 0x74, |
0x84, 0x94, 0xA4, 0xB4, 0xC4, 0xD4, 0xE4, 0xF4, |
0x05, 0x15, 0x25, 0x35, 0x45, 0x55, 0x65, 0x75, |
0x85, 0x95, 0xA5, 0xB5, 0xC5, 0xD5, 0xE5, 0xF5, |
0x06, 0x16, 0x26, 0x36, 0x46, 0x56, 0x66, 0x76, |
0x86, 0x96, 0xA6, 0xB6, 0xC6, 0xD6, 0xE6, 0xF6, |
0x07, 0x17, 0x27, 0x37, 0x47, 0x57, 0x67, 0x77, |
0x87, 0x97, 0xA7, 0xB7, 0xC7, 0xD7, 0xE7, 0xF7, |
0x08, 0x18, 0x28, 0x38, 0x48, 0x58, 0x68, 0x78, |
0x88, 0x98, 0xA8, 0xB8, 0xC8, 0xD8, 0xE8, 0xF8, |
0x09, 0x19, 0x29, 0x39, 0x49, 0x59, 0x69, 0x79, |
0x89, 0x99, 0xA9, 0xB9, 0xC9, 0xD9, 0xE9, 0xF9, |
0x0A, 0x1A, 0x2A, 0x3A, 0x4A, 0x5A, 0x6A, 0x7A, |
0x8A, 0x9A, 0xAA, 0xBA, 0xCA, 0xDA, 0xEA, 0xFA, |
0x0B, 0x1B, 0x2B, 0x3B, 0x4B, 0x5B, 0x6B, 0x7B, |
0x8B, 0x9B, 0xAB, 0xBB, 0xCB, 0xDB, 0xEB, 0xFB, |
0x0C, 0x1C, 0x2C, 0x3C, 0x4C, 0x5C, 0x6C, 0x7C, |
0x8C, 0x9C, 0xAC, 0xBC, 0xCC, 0xDC, 0xEC, 0xFC, |
0x0D, 0x1D, 0x2D, 0x3D, 0x4D, 0x5D, 0x6D, 0x7D, |
0x8D, 0x9D, 0xAD, 0xBD, 0xCD, 0xDD, 0xED, 0xFD, |
0x0E, 0x1E, 0x2E, 0x3E, 0x4E, 0x5E, 0x6E, 0x7E, |
0x8E, 0x9E, 0xAE, 0xBE, 0xCE, 0xDE, 0xEE, 0xFE, |
0x0F, 0x1F, 0x2F, 0x3F, 0x4F, 0x5F, 0x6F, 0x7F, |
0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF |
}; |
/* swaps pixel packing order within bytes */ |
void /* PRIVATE */ |
png_do_packswap(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_packswap\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
row_info->bit_depth < 8) |
{ |
png_bytep rp, end, table; |
end = row + row_info->rowbytes; |
if (row_info->bit_depth == 1) |
table = onebppswaptable; |
else if (row_info->bit_depth == 2) |
table = twobppswaptable; |
else if (row_info->bit_depth == 4) |
table = fourbppswaptable; |
else |
return; |
for (rp = row; rp < end; rp++) |
*rp = table[*rp]; |
} |
} |
#endif /* PNG_READ_PACKSWAP_SUPPORTED or PNG_WRITE_PACKSWAP_SUPPORTED */ |
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ |
defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
/* remove filler or alpha byte(s) */ |
void /* PRIVATE */ |
png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags) |
{ |
png_debug(1, "in png_do_strip_filler\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
/* |
if (row_info->color_type == PNG_COLOR_TYPE_RGB || |
row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
*/ |
png_bytep sp=row; |
png_bytep dp=row; |
png_uint_32 row_width=row_info->width; |
png_uint_32 i; |
if (row_info->channels == 4) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This converts from RGBX or RGBA to RGB */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
dp+=3; sp+=4; |
for (i = 1; i < row_width; i++) |
{ |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
sp++; |
} |
} |
/* This converts from XRGB or ARGB to RGB */ |
else |
{ |
for (i = 0; i < row_width; i++) |
{ |
sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
} |
} |
row_info->pixel_depth = 24; |
row_info->rowbytes = row_width * 3; |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */ |
sp += 8; dp += 6; |
for (i = 1; i < row_width; i++) |
{ |
/* This could be (although png_memcpy is probably slower): |
png_memcpy(dp, sp, 6); |
sp += 8; |
dp += 6; |
*/ |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
sp += 2; |
} |
} |
else |
{ |
/* This converts from XXRRGGBB or AARRGGBB to RRGGBB */ |
for (i = 0; i < row_width; i++) |
{ |
/* This could be (although png_memcpy is probably slower): |
png_memcpy(dp, sp, 6); |
sp += 8; |
dp += 6; |
*/ |
sp+=2; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
*dp++ = *sp++; |
} |
} |
row_info->pixel_depth = 48; |
row_info->rowbytes = row_width * 6; |
} |
row_info->channels = 3; |
row_info->color_type &= ~PNG_COLOR_MASK_ALPHA; |
} |
/* |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY || |
row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
*/ |
else if (row_info->channels == 2) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This converts from GX or GA to G */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
for (i = 0; i < row_width; i++) |
{ |
*dp++ = *sp++; |
sp++; |
} |
} |
/* This converts from XG or AG to G */ |
else |
{ |
for (i = 0; i < row_width; i++) |
{ |
sp++; |
*dp++ = *sp++; |
} |
} |
row_info->pixel_depth = 8; |
row_info->rowbytes = row_width; |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This converts from GGXX or GGAA to GG */ |
sp += 4; dp += 2; |
for (i = 1; i < row_width; i++) |
{ |
*dp++ = *sp++; |
*dp++ = *sp++; |
sp += 2; |
} |
} |
else |
{ |
/* This converts from XXGG or AAGG to GG */ |
for (i = 0; i < row_width; i++) |
{ |
sp += 2; |
*dp++ = *sp++; |
*dp++ = *sp++; |
} |
} |
row_info->pixel_depth = 16; |
row_info->rowbytes = row_width * 2; |
} |
row_info->channels = 1; |
row_info->color_type &= ~PNG_COLOR_MASK_ALPHA; |
} |
} |
} |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
/* swaps red and blue bytes within a pixel */ |
void /* PRIVATE */ |
png_do_bgr(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_bgr\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
png_uint_32 row_width = row_info->width; |
if (row_info->bit_depth == 8) |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
{ |
png_bytep rp; |
png_uint_32 i; |
for (i = 0, rp = row; i < row_width; i++, rp += 3) |
{ |
png_byte save = *rp; |
*rp = *(rp + 2); |
*(rp + 2) = save; |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
png_bytep rp; |
png_uint_32 i; |
for (i = 0, rp = row; i < row_width; i++, rp += 4) |
{ |
png_byte save = *rp; |
*rp = *(rp + 2); |
*(rp + 2) = save; |
} |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
{ |
png_bytep rp; |
png_uint_32 i; |
for (i = 0, rp = row; i < row_width; i++, rp += 6) |
{ |
png_byte save = *rp; |
*rp = *(rp + 4); |
*(rp + 4) = save; |
save = *(rp + 1); |
*(rp + 1) = *(rp + 5); |
*(rp + 5) = save; |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
png_bytep rp; |
png_uint_32 i; |
for (i = 0, rp = row; i < row_width; i++, rp += 8) |
{ |
png_byte save = *rp; |
*rp = *(rp + 4); |
*(rp + 4) = save; |
save = *(rp + 1); |
*(rp + 1) = *(rp + 5); |
*(rp + 5) = save; |
} |
} |
} |
} |
} |
#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
void PNGAPI |
png_set_user_transform_info(png_structp png_ptr, png_voidp |
user_transform_ptr, int user_transform_depth, int user_transform_channels) |
{ |
png_debug(1, "in png_set_user_transform_info\n"); |
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
png_ptr->user_transform_ptr = user_transform_ptr; |
png_ptr->user_transform_depth = (png_byte)user_transform_depth; |
png_ptr->user_transform_channels = (png_byte)user_transform_channels; |
#else |
if(user_transform_ptr || user_transform_depth || user_transform_channels) |
png_warning(png_ptr, |
"This version of libpng does not support user transform info"); |
#endif |
} |
#endif |
/* This function returns a pointer to the user_transform_ptr associated with |
* the user transform functions. The application should free any memory |
* associated with this pointer before png_write_destroy and png_read_destroy |
* are called. |
*/ |
png_voidp PNGAPI |
png_get_user_transform_ptr(png_structp png_ptr) |
{ |
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
return ((png_voidp)png_ptr->user_transform_ptr); |
#else |
if(png_ptr) |
return (NULL); |
return (NULL); |
#endif |
} |
/shark/trunk/ports/png/infblock.h |
---|
0,0 → 1,39 |
/* infblock.h -- header to use infblock.c |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* WARNING: this file should *not* be used by applications. It is |
part of the implementation of the compression library and is |
subject to change. Applications should only use zlib.h. |
*/ |
struct inflate_blocks_state; |
typedef struct inflate_blocks_state FAR inflate_blocks_statef; |
extern inflate_blocks_statef * inflate_blocks_new OF(( |
z_streamp z, |
check_func c, /* check function */ |
uInt w)); /* window size */ |
extern int inflate_blocks OF(( |
inflate_blocks_statef *, |
z_streamp , |
int)); /* initial return code */ |
extern void inflate_blocks_reset OF(( |
inflate_blocks_statef *, |
z_streamp , |
uLongf *)); /* check value on output */ |
extern int inflate_blocks_free OF(( |
inflate_blocks_statef *, |
z_streamp)); |
extern void inflate_set_dictionary OF(( |
inflate_blocks_statef *s, |
const Bytef *d, /* dictionary */ |
uInt n)); /* dictionary length */ |
extern int inflate_blocks_sync_point OF(( |
inflate_blocks_statef *s)); |
/shark/trunk/ports/png/pngrio.c |
---|
0,0 → 1,161 |
/* pngrio.c - functions for data input |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file provides a location for all input. Users who need |
* special handling are expected to write a function that has the same |
* arguments as this and performs a similar function, but that possibly |
* has a different input method. Note that you shouldn't change this |
* function, but rather write a replacement function and then make |
* libpng use it at run time with png_set_read_fn(...). |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
/* Read the data from whatever input you are using. The default routine |
reads from a file pointer. Note that this routine sometimes gets called |
with very small lengths, so you should implement some kind of simple |
buffering if you are using unbuffered reads. This should never be asked |
to read more then 64K on a 16 bit machine. */ |
void /* PRIVATE */ |
png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_debug1(4,"reading %d bytes\n", (int)length); |
if (png_ptr->read_data_fn != NULL) |
(*(png_ptr->read_data_fn))(png_ptr, data, length); |
else |
png_error(png_ptr, "Call to NULL read function"); |
} |
#if !defined(PNG_NO_STDIO) |
/* This is the function that does the actual reading of data. If you are |
not reading from a standard C stream, you should create a replacement |
read_data function and use it at run time with png_set_read_fn(), rather |
than changing the library. */ |
#ifndef USE_FAR_KEYWORD |
void PNGAPI |
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_size_t check; |
/* fread() returns 0 on error, so it is OK to store this in a png_size_t |
* instead of an int, which is what fread() actually returns. |
*/ |
#if defined(_WIN32_WCE) |
if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) |
check = 0; |
#else |
check = (png_size_t)fread(data, (png_size_t)1, length, |
(png_FILE_p)png_ptr->io_ptr); |
#endif |
if (check != length) |
png_error(png_ptr, "Read Error"); |
} |
#else |
/* this is the model-independent version. Since the standard I/O library |
can't handle far buffers in the medium and small models, we have to copy |
the data. |
*/ |
#define NEAR_BUF_SIZE 1024 |
#define MIN(a,b) (a <= b ? a : b) |
static void /* PRIVATE */ |
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
int check; |
png_byte *n_data; |
png_FILE_p io_ptr; |
/* Check if data really is near. If so, use usual code. */ |
n_data = (png_byte *)CVT_PTR_NOCHECK(data); |
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
if ((png_bytep)n_data == data) |
{ |
#if defined(_WIN32_WCE) |
if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) |
check = 0; |
#else |
check = fread(n_data, 1, length, io_ptr); |
#endif |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t read, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
read = MIN(NEAR_BUF_SIZE, remaining); |
#if defined(_WIN32_WCE) |
if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) ) |
err = 0; |
#else |
err = fread(buf, (png_size_t)1, read, io_ptr); |
#endif |
png_memcpy(data, buf, read); /* copy far buffer to near buffer */ |
if(err != read) |
break; |
else |
check += err; |
data += read; |
remaining -= read; |
} |
while (remaining != 0); |
} |
if ((png_uint_32)check != (png_uint_32)length) |
png_error(png_ptr, "read Error"); |
} |
#endif |
#endif |
/* This function allows the application to supply a new input function |
for libpng if standard C streams aren't being used. |
This function takes as its arguments: |
png_ptr - pointer to a png input data structure |
io_ptr - pointer to user supplied structure containing info about |
the input functions. May be NULL. |
read_data_fn - pointer to a new input function that takes as its |
arguments a pointer to a png_struct, a pointer to |
a location where input data can be stored, and a 32-bit |
unsigned int that is the number of bytes to be read. |
To exit and output any fatal error messages the new write |
function should call png_error(png_ptr, "Error msg"). */ |
void PNGAPI |
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, |
png_rw_ptr read_data_fn) |
{ |
png_ptr->io_ptr = io_ptr; |
#if !defined(PNG_NO_STDIO) |
if (read_data_fn != NULL) |
png_ptr->read_data_fn = read_data_fn; |
else |
png_ptr->read_data_fn = png_default_read_data; |
#else |
png_ptr->read_data_fn = read_data_fn; |
#endif |
/* It is an error to write to a read device */ |
if (png_ptr->write_data_fn != NULL) |
{ |
png_ptr->write_data_fn = NULL; |
png_warning(png_ptr, |
"It's an error to set both read_data_fn and write_data_fn in the "); |
png_warning(png_ptr, |
"same structure. Resetting write_data_fn to NULL."); |
} |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
png_ptr->output_flush_fn = NULL; |
#endif |
} |
/shark/trunk/ports/png/inffast.h |
---|
0,0 → 1,17 |
/* inffast.h -- header to use inffast.c |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* WARNING: this file should *not* be used by applications. It is |
part of the implementation of the compression library and is |
subject to change. Applications should only use zlib.h. |
*/ |
extern int inflate_fast OF(( |
uInt, |
uInt, |
inflate_huft *, |
inflate_huft *, |
inflate_blocks_statef *, |
z_streamp )); |
/shark/trunk/ports/png/pngwrite.c |
---|
0,0 → 1,1450 |
/* pngwrite.c - general routines to write a PNG file |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
/* get internal access to png.h */ |
#define PNG_INTERNAL |
#include "png.h" |
#ifdef PNG_WRITE_SUPPORTED |
/* Writes all the PNG information. This is the suggested way to use the |
* library. If you have a new chunk to add, make a function to write it, |
* and put it in the correct location here. If you want the chunk written |
* after the image data, put it in png_write_end(). I strongly encourage |
* you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing |
* the chunk, as that will keep the code from breaking if you want to just |
* write a plain PNG file. If you have long comments, I suggest writing |
* them in png_write_end(), and compressing them. |
*/ |
void PNGAPI |
png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_write_info_before_PLTE\n"); |
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) |
{ |
png_write_sig(png_ptr); /* write PNG signature */ |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted)) |
{ |
png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n"); |
png_ptr->mng_features_permitted=0; |
} |
#endif |
/* write IHDR information. */ |
png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, |
info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, |
info_ptr->filter_type, |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
info_ptr->interlace_type); |
#else |
0); |
#endif |
/* the rest of these check to see if the valid field has the appropriate |
flag set, and if it does, writes the chunk. */ |
#if defined(PNG_WRITE_gAMA_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_gAMA) |
{ |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
png_write_gAMA(png_ptr, info_ptr->gamma); |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma); |
# endif |
#endif |
} |
#endif |
#if defined(PNG_WRITE_sRGB_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sRGB) |
png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent); |
#endif |
#if defined(PNG_WRITE_iCCP_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_iCCP) |
png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE, |
info_ptr->iccp_profile, (int)info_ptr->iccp_proflen); |
#endif |
#if defined(PNG_WRITE_sBIT_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sBIT) |
png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); |
#endif |
#if defined(PNG_WRITE_cHRM_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_cHRM) |
{ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_write_cHRM(png_ptr, |
info_ptr->x_white, info_ptr->y_white, |
info_ptr->x_red, info_ptr->y_red, |
info_ptr->x_green, info_ptr->y_green, |
info_ptr->x_blue, info_ptr->y_blue); |
#else |
# ifdef PNG_FIXED_POINT_SUPPORTED |
png_write_cHRM_fixed(png_ptr, |
info_ptr->int_x_white, info_ptr->int_y_white, |
info_ptr->int_x_red, info_ptr->int_y_red, |
info_ptr->int_x_green, info_ptr->int_y_green, |
info_ptr->int_x_blue, info_ptr->int_y_blue); |
# endif |
#endif |
} |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks\n"); |
for (up = info_ptr->unknown_chunks; |
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
up++) |
{ |
int keep=png_handle_as_unknown(png_ptr, up->name); |
if (keep != HANDLE_CHUNK_NEVER && |
up->location && (!(up->location & PNG_HAVE_PLTE)) && |
((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS || |
(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
{ |
png_write_chunk(png_ptr, up->name, up->data, up->size); |
} |
} |
} |
#endif |
png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE; |
} |
} |
void PNGAPI |
png_write_info(png_structp png_ptr, png_infop info_ptr) |
{ |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
int i; |
#endif |
png_debug(1, "in png_write_info\n"); |
png_write_info_before_PLTE(png_ptr, info_ptr); |
if (info_ptr->valid & PNG_INFO_PLTE) |
png_write_PLTE(png_ptr, info_ptr->palette, |
(png_uint_32)info_ptr->num_palette); |
else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
png_error(png_ptr, "Valid palette required for paletted images\n"); |
#if defined(PNG_WRITE_tRNS_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_tRNS) |
{ |
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
/* invert the alpha channel (in tRNS) */ |
if ((png_ptr->transformations & PNG_INVERT_ALPHA) && |
info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
int j; |
for (j=0; j<(int)info_ptr->num_trans; j++) |
info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]); |
} |
#endif |
png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values), |
info_ptr->num_trans, info_ptr->color_type); |
} |
#endif |
#if defined(PNG_WRITE_bKGD_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_bKGD) |
png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type); |
#endif |
#if defined(PNG_WRITE_hIST_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_hIST) |
png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette); |
#endif |
#if defined(PNG_WRITE_oFFs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_oFFs) |
png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset, |
info_ptr->offset_unit_type); |
#endif |
#if defined(PNG_WRITE_pCAL_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pCAL) |
png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0, |
info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams, |
info_ptr->pcal_units, info_ptr->pcal_params); |
#endif |
#if defined(PNG_WRITE_sCAL_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sCAL) |
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) |
png_write_sCAL(png_ptr, (int)info_ptr->scal_unit, |
info_ptr->scal_pixel_width, info_ptr->scal_pixel_height); |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit, |
info_ptr->scal_s_width, info_ptr->scal_s_height); |
#else |
png_warning(png_ptr, |
"png_write_sCAL not supported; sCAL chunk not written.\n"); |
#endif |
#endif |
#endif |
#if defined(PNG_WRITE_pHYs_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_pHYs) |
png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit, |
info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type); |
#endif |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_tIME) |
{ |
png_write_tIME(png_ptr, &(info_ptr->mod_time)); |
png_ptr->mode |= PNG_WROTE_tIME; |
} |
#endif |
#if defined(PNG_WRITE_sPLT_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sPLT) |
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) |
png_write_sPLT(png_ptr, info_ptr->splt_palettes + i); |
#endif |
#if defined(PNG_WRITE_TEXT_SUPPORTED) |
/* Check to see if we need to write text chunks */ |
for (i = 0; i < info_ptr->num_text; i++) |
{ |
png_debug2(2, "Writing header text chunk %d, type %d\n", i, |
info_ptr->text[i].compression); |
/* an internationalized chunk? */ |
if (info_ptr->text[i].compression > 0) |
{ |
#if defined(PNG_WRITE_iTXt_SUPPORTED) |
/* write international chunk */ |
png_write_iTXt(png_ptr, |
info_ptr->text[i].compression, |
info_ptr->text[i].key, |
info_ptr->text[i].lang, |
info_ptr->text[i].lang_key, |
info_ptr->text[i].text); |
#else |
png_warning(png_ptr, "Unable to write international text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
} |
/* If we want a compressed text chunk */ |
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt) |
{ |
#if defined(PNG_WRITE_zTXt_SUPPORTED) |
/* write compressed chunk */ |
png_write_zTXt(png_ptr, info_ptr->text[i].key, |
info_ptr->text[i].text, 0, |
info_ptr->text[i].compression); |
#else |
png_warning(png_ptr, "Unable to write compressed text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; |
} |
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) |
{ |
#if defined(PNG_WRITE_tEXt_SUPPORTED) |
/* write uncompressed chunk */ |
png_write_tEXt(png_ptr, info_ptr->text[i].key, |
info_ptr->text[i].text, |
0); |
#else |
png_warning(png_ptr, "Unable to write uncompressed text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
} |
} |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks\n"); |
for (up = info_ptr->unknown_chunks; |
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
up++) |
{ |
int keep=png_handle_as_unknown(png_ptr, up->name); |
if (keep != HANDLE_CHUNK_NEVER && |
up->location && (up->location & PNG_HAVE_PLTE) && |
!(up->location & PNG_HAVE_IDAT) && |
((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS || |
(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
{ |
png_write_chunk(png_ptr, up->name, up->data, up->size); |
} |
} |
} |
#endif |
} |
/* Writes the end of the PNG file. If you don't want to write comments or |
* time information, you can pass NULL for info. If you already wrote these |
* in png_write_info(), do not write them again here. If you have long |
* comments, I suggest writing them here, and compressing them. |
*/ |
void PNGAPI |
png_write_end(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_write_end\n"); |
if (!(png_ptr->mode & PNG_HAVE_IDAT)) |
png_error(png_ptr, "No IDATs written into file"); |
/* see if user wants us to write information chunks */ |
if (info_ptr != NULL) |
{ |
#if defined(PNG_WRITE_TEXT_SUPPORTED) |
int i; /* local index variable */ |
#endif |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
/* check to see if user has supplied a time chunk */ |
if ((info_ptr->valid & PNG_INFO_tIME) && |
!(png_ptr->mode & PNG_WROTE_tIME)) |
png_write_tIME(png_ptr, &(info_ptr->mod_time)); |
#endif |
#if defined(PNG_WRITE_TEXT_SUPPORTED) |
/* loop through comment chunks */ |
for (i = 0; i < info_ptr->num_text; i++) |
{ |
png_debug2(2, "Writing trailer text chunk %d, type %d\n", i, |
info_ptr->text[i].compression); |
/* an internationalized chunk? */ |
if (info_ptr->text[i].compression > 0) |
{ |
#if defined(PNG_WRITE_iTXt_SUPPORTED) |
/* write international chunk */ |
png_write_iTXt(png_ptr, |
info_ptr->text[i].compression, |
info_ptr->text[i].key, |
info_ptr->text[i].lang, |
info_ptr->text[i].lang_key, |
info_ptr->text[i].text); |
#else |
png_warning(png_ptr, "Unable to write international text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
} |
else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt) |
{ |
#if defined(PNG_WRITE_zTXt_SUPPORTED) |
/* write compressed chunk */ |
png_write_zTXt(png_ptr, info_ptr->text[i].key, |
info_ptr->text[i].text, 0, |
info_ptr->text[i].compression); |
#else |
png_warning(png_ptr, "Unable to write compressed text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR; |
} |
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) |
{ |
#if defined(PNG_WRITE_tEXt_SUPPORTED) |
/* write uncompressed chunk */ |
png_write_tEXt(png_ptr, info_ptr->text[i].key, |
info_ptr->text[i].text, 0); |
#else |
png_warning(png_ptr, "Unable to write uncompressed text\n"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
} |
} |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks\n"); |
for (up = info_ptr->unknown_chunks; |
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; |
up++) |
{ |
int keep=png_handle_as_unknown(png_ptr, up->name); |
if (keep != HANDLE_CHUNK_NEVER && |
up->location && (up->location & PNG_AFTER_IDAT) && |
((up->name[3] & 0x20) || keep == HANDLE_CHUNK_ALWAYS || |
(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
{ |
png_write_chunk(png_ptr, up->name, up->data, up->size); |
} |
} |
} |
#endif |
} |
png_ptr->mode |= PNG_AFTER_IDAT; |
/* write end of PNG file */ |
png_write_IEND(png_ptr); |
#if 0 |
/* This flush, added in libpng-1.0.8, causes some applications to crash |
because they do not set png_ptr->output_flush_fn */ |
png_flush(png_ptr); |
#endif |
} |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
#if !defined(_WIN32_WCE) |
/* "time.h" functions are not supported on WindowsCE */ |
void PNGAPI |
png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime) |
{ |
png_debug(1, "in png_convert_from_struct_tm\n"); |
ptime->year = (png_uint_16)(1900 + ttime->tm_year); |
ptime->month = (png_byte)(ttime->tm_mon + 1); |
ptime->day = (png_byte)ttime->tm_mday; |
ptime->hour = (png_byte)ttime->tm_hour; |
ptime->minute = (png_byte)ttime->tm_min; |
ptime->second = (png_byte)ttime->tm_sec; |
} |
void PNGAPI |
png_convert_from_time_t(png_timep ptime, time_t ttime) |
{ |
struct tm *tbuf; |
png_debug(1, "in png_convert_from_time_t\n"); |
tbuf = gmtime(&ttime); |
png_convert_from_struct_tm(ptime, tbuf); |
} |
#endif |
#endif |
/* Initialize png_ptr structure, and allocate any memory needed */ |
png_structp PNGAPI |
png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn, |
warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); |
} |
/* Alternate initialize png_ptr structure, and allocate any memory needed */ |
png_structp PNGAPI |
png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, |
png_malloc_ptr malloc_fn, png_free_ptr free_fn) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_structp png_ptr; |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
jmp_buf jmpbuf; |
#endif |
#endif |
int i; |
png_debug(1, "in png_create_write_struct\n"); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, |
(png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); |
#else |
png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
#endif /* PNG_USER_MEM_SUPPORTED */ |
if (png_ptr == NULL) |
return (NULL); |
#if !defined(PNG_1_0_X) |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ |
#endif |
#endif /* PNG_1_0_X */ |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
#else |
if (setjmp(png_ptr->jmpbuf)) |
#endif |
{ |
png_free(png_ptr, png_ptr->zbuf); |
png_ptr->zbuf=NULL; |
png_destroy_struct(png_ptr); |
return (NULL); |
} |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf)); |
#endif |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); |
#endif /* PNG_USER_MEM_SUPPORTED */ |
png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); |
i=0; |
do |
{ |
if(user_png_ver[i] != png_libpng_ver[i]) |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
} while (png_libpng_ver[i++]); |
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) |
{ |
/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so |
* we must recompile any applications that use any older library version. |
* For versions after libpng 1.0, we will be compatible, so we need |
* only check the first digit. |
*/ |
if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || |
(user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || |
(user_png_ver[0] == '0' && user_png_ver[2] < '9')) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char msg[80]; |
if (user_png_ver) |
{ |
sprintf(msg, "Application was compiled with png.h from libpng-%.20s", |
user_png_ver); |
png_warning(png_ptr, msg); |
} |
sprintf(msg, "Application is running with png.c from libpng-%.20s", |
png_libpng_ver); |
png_warning(png_ptr, msg); |
#endif |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"Incompatible libpng version in application and library"); |
} |
} |
/* initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)png_ptr->zbuf_size); |
png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, |
png_flush_ptr_NULL); |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, |
1, png_doublep_NULL, png_doublep_NULL); |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* Applications that neglect to set up their own setjmp() and then encounter |
a png_error() will longjmp here. Since the jmpbuf is then meaningless we |
abort instead of returning. */ |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
PNG_ABORT(); |
png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf)); |
#else |
if (setjmp(png_ptr->jmpbuf)) |
PNG_ABORT(); |
#endif |
#endif |
return (png_ptr); |
} |
/* Initialize png_ptr structure, and allocate any memory needed */ |
#undef png_write_init |
void PNGAPI |
png_write_init(png_structp png_ptr) |
{ |
/* We only come here via pre-1.0.7-compiled applications */ |
png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0); |
} |
void PNGAPI |
png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver, |
png_size_t png_struct_size, png_size_t png_info_size) |
{ |
/* We only come here via pre-1.0.12-compiled applications */ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
if(sizeof(png_struct) > png_struct_size || sizeof(png_info) > png_info_size) |
{ |
char msg[80]; |
png_ptr->warning_fn=NULL; |
if (user_png_ver) |
{ |
sprintf(msg, "Application was compiled with png.h from libpng-%.20s", |
user_png_ver); |
png_warning(png_ptr, msg); |
} |
sprintf(msg, "Application is running with png.c from libpng-%.20s", |
png_libpng_ver); |
png_warning(png_ptr, msg); |
} |
#endif |
if(sizeof(png_struct) > png_struct_size) |
{ |
png_ptr->error_fn=NULL; |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"The png struct allocated by the application for writing is too small."); |
} |
if(sizeof(png_info) > png_info_size) |
{ |
png_ptr->error_fn=NULL; |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags=0; |
#endif |
png_error(png_ptr, |
"The info struct allocated by the application for writing is too small."); |
} |
png_write_init_3(&png_ptr, user_png_ver, png_struct_size); |
} |
void PNGAPI |
png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, |
png_size_t png_struct_size) |
{ |
png_structp png_ptr=*ptr_ptr; |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf tmp_jmp; /* to save current jump buffer */ |
#endif |
int i = 0; |
do |
{ |
if (user_png_ver[i] != png_libpng_ver[i]) |
{ |
#ifdef PNG_LEGACY_SUPPORTED |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
#else |
png_ptr->warning_fn=NULL; |
png_warning(png_ptr, |
"Application uses deprecated png_write_init() and should be recompiled."); |
break; |
#endif |
} |
} while (png_libpng_ver[i++]); |
png_debug(1, "in png_write_init_3\n"); |
#ifdef PNG_SETJMP_SUPPORTED |
/* save jump buffer and error functions */ |
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf)); |
#endif |
if (sizeof(png_struct) > png_struct_size) |
{ |
png_destroy_struct(png_ptr); |
png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
*ptr_ptr = png_ptr; |
} |
/* reset all variables to 0 */ |
png_memset(png_ptr, 0, sizeof (png_struct)); |
#if !defined(PNG_1_0_X) |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
png_init_mmx_flags(png_ptr); /* 1.2.0 addition */ |
#endif |
#endif /* PNG_1_0_X */ |
#ifdef PNG_SETJMP_SUPPORTED |
/* restore jump buffer */ |
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf)); |
#endif |
png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, |
png_flush_ptr_NULL); |
/* initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)png_ptr->zbuf_size); |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, |
1, png_doublep_NULL, png_doublep_NULL); |
#endif |
} |
/* Write a few rows of image data. If the image is interlaced, |
* either you will have to write the 7 sub images, or, if you |
* have called png_set_interlace_handling(), you will have to |
* "write" the image seven times. |
*/ |
void PNGAPI |
png_write_rows(png_structp png_ptr, png_bytepp row, |
png_uint_32 num_rows) |
{ |
png_uint_32 i; /* row counter */ |
png_bytepp rp; /* row pointer */ |
png_debug(1, "in png_write_rows\n"); |
/* loop through the rows */ |
for (i = 0, rp = row; i < num_rows; i++, rp++) |
{ |
png_write_row(png_ptr, *rp); |
} |
} |
/* Write the image. You only need to call this function once, even |
* if you are writing an interlaced image. |
*/ |
void PNGAPI |
png_write_image(png_structp png_ptr, png_bytepp image) |
{ |
png_uint_32 i; /* row index */ |
int pass, num_pass; /* pass variables */ |
png_bytepp rp; /* points to current row */ |
png_debug(1, "in png_write_image\n"); |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* intialize interlace handling. If image is not interlaced, |
this will set pass to 1 */ |
num_pass = png_set_interlace_handling(png_ptr); |
#else |
num_pass = 1; |
#endif |
/* loop through passes */ |
for (pass = 0; pass < num_pass; pass++) |
{ |
/* loop through image */ |
for (i = 0, rp = image; i < png_ptr->height; i++, rp++) |
{ |
png_write_row(png_ptr, *rp); |
} |
} |
} |
/* called by user to write a row of image data */ |
void PNGAPI |
png_write_row(png_structp png_ptr, png_bytep row) |
{ |
png_debug2(1, "in png_write_row (row %ld, pass %d)\n", |
png_ptr->row_number, png_ptr->pass); |
/* initialize transformations and other stuff if first time */ |
if (png_ptr->row_number == 0 && png_ptr->pass == 0) |
{ |
/* make sure we wrote the header info */ |
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) |
png_error(png_ptr, |
"png_write_info was never called before png_write_row."); |
/* check for transforms that have been set but were defined out */ |
#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED) |
if (png_ptr->transformations & PNG_FILLER) |
png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED) |
if (png_ptr->transformations & PNG_PACK) |
png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED) |
if (png_ptr->transformations & PNG_SHIFT) |
png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED) |
if (png_ptr->transformations & PNG_BGR) |
png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined."); |
#endif |
#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined."); |
#endif |
png_write_start_row(png_ptr); |
} |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* if interlaced and not interested in row, return */ |
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) |
{ |
switch (png_ptr->pass) |
{ |
case 0: |
if (png_ptr->row_number & 0x07) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 1: |
if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 2: |
if ((png_ptr->row_number & 0x07) != 4) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 3: |
if ((png_ptr->row_number & 0x03) || png_ptr->width < 3) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 4: |
if ((png_ptr->row_number & 0x03) != 2) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 5: |
if ((png_ptr->row_number & 0x01) || png_ptr->width < 2) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
case 6: |
if (!(png_ptr->row_number & 0x01)) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
break; |
} |
} |
#endif |
/* set up row info for transformations */ |
png_ptr->row_info.color_type = png_ptr->color_type; |
png_ptr->row_info.width = png_ptr->usr_width; |
png_ptr->row_info.channels = png_ptr->usr_channels; |
png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth; |
png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * |
png_ptr->row_info.channels); |
png_ptr->row_info.rowbytes = ((png_ptr->row_info.width * |
(png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3); |
png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type); |
png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width); |
png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels); |
png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth); |
png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth); |
png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes); |
/* Copy user's row into buffer, leaving room for filter byte. */ |
png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row, |
png_ptr->row_info.rowbytes); |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* handle interlacing */ |
if (png_ptr->interlaced && png_ptr->pass < 6 && |
(png_ptr->transformations & PNG_INTERLACE)) |
{ |
png_do_write_interlace(&(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->pass); |
/* this should always get caught above, but still ... */ |
if (!(png_ptr->row_info.width)) |
{ |
png_write_finish_row(png_ptr); |
return; |
} |
} |
#endif |
/* handle other transformations */ |
if (png_ptr->transformations) |
png_do_write_transformations(png_ptr); |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
/* Write filter_method 64 (intrapixel differencing) only if |
* 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and |
* 2. Libpng did not write a PNG signature (this filter_method is only |
* used in PNG datastreams that are embedded in MNG datastreams) and |
* 3. The application called png_permit_mng_features with a mask that |
* included PNG_FLAG_MNG_FILTER_64 and |
* 4. The filter_method is 64 and |
* 5. The color_type is RGB or RGBA |
*/ |
if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
(png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) |
{ |
/* Intrapixel differencing */ |
png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); |
} |
#endif |
/* Find a filter if necessary, filter the row and write it out. */ |
png_write_find_filter(png_ptr, &(png_ptr->row_info)); |
if (png_ptr->write_row_fn != NULL) |
(*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass); |
} |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
/* Set the automatic flush interval or 0 to turn flushing off */ |
void PNGAPI |
png_set_flush(png_structp png_ptr, int nrows) |
{ |
png_debug(1, "in png_set_flush\n"); |
png_ptr->flush_dist = (nrows < 0 ? 0 : nrows); |
} |
/* flush the current output buffers now */ |
void PNGAPI |
png_write_flush(png_structp png_ptr) |
{ |
int wrote_IDAT; |
png_debug(1, "in png_write_flush\n"); |
/* We have already written out all of the data */ |
if (png_ptr->row_number >= png_ptr->num_rows) |
return; |
do |
{ |
int ret; |
/* compress the data */ |
ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH); |
wrote_IDAT = 0; |
/* check for compression errors */ |
if (ret != Z_OK) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
if (!(png_ptr->zstream.avail_out)) |
{ |
/* write the IDAT and reset the zlib output buffer */ |
png_write_IDAT(png_ptr, png_ptr->zbuf, |
png_ptr->zbuf_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
wrote_IDAT = 1; |
} |
} while(wrote_IDAT == 1); |
/* If there is any data left to be output, write it into a new IDAT */ |
if (png_ptr->zbuf_size != png_ptr->zstream.avail_out) |
{ |
/* write the IDAT and reset the zlib output buffer */ |
png_write_IDAT(png_ptr, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
png_ptr->flush_rows = 0; |
png_flush(png_ptr); |
} |
#endif /* PNG_WRITE_FLUSH_SUPPORTED */ |
/* free all memory used by the write */ |
void PNGAPI |
png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) |
{ |
png_structp png_ptr = NULL; |
png_infop info_ptr = NULL; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn = NULL; |
png_voidp mem_ptr = NULL; |
#endif |
png_debug(1, "in png_destroy_write_struct\n"); |
if (png_ptr_ptr != NULL) |
{ |
png_ptr = *png_ptr_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
mem_ptr = png_ptr->mem_ptr; |
#endif |
} |
if (info_ptr_ptr != NULL) |
info_ptr = *info_ptr_ptr; |
if (info_ptr != NULL) |
{ |
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
if (png_ptr->num_chunk_list) |
{ |
png_free(png_ptr, png_ptr->chunk_list); |
png_ptr->chunk_list=NULL; |
png_ptr->num_chunk_list=0; |
} |
#endif |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)info_ptr); |
#endif |
*info_ptr_ptr = NULL; |
} |
if (png_ptr != NULL) |
{ |
png_write_destroy(png_ptr); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, |
(png_voidp)mem_ptr); |
#else |
png_destroy_struct((png_voidp)png_ptr); |
#endif |
*png_ptr_ptr = NULL; |
} |
} |
/* Free any memory used in png_ptr struct (old method) */ |
void /* PRIVATE */ |
png_write_destroy(png_structp png_ptr) |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf tmp_jmp; /* save jump buffer */ |
#endif |
png_error_ptr error_fn; |
png_error_ptr warning_fn; |
png_voidp error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_free_ptr free_fn; |
#endif |
png_debug(1, "in png_write_destroy\n"); |
/* free any memory zlib uses */ |
deflateEnd(&png_ptr->zstream); |
/* free our memory. png_free checks NULL for us. */ |
png_free(png_ptr, png_ptr->zbuf); |
png_free(png_ptr, png_ptr->row_buf); |
png_free(png_ptr, png_ptr->prev_row); |
png_free(png_ptr, png_ptr->sub_row); |
png_free(png_ptr, png_ptr->up_row); |
png_free(png_ptr, png_ptr->avg_row); |
png_free(png_ptr, png_ptr->paeth_row); |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
png_free(png_ptr, png_ptr->time_buffer); |
#endif |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
png_free(png_ptr, png_ptr->prev_filters); |
png_free(png_ptr, png_ptr->filter_weights); |
png_free(png_ptr, png_ptr->inv_filter_weights); |
png_free(png_ptr, png_ptr->filter_costs); |
png_free(png_ptr, png_ptr->inv_filter_costs); |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* reset structure */ |
png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf)); |
#endif |
error_fn = png_ptr->error_fn; |
warning_fn = png_ptr->warning_fn; |
error_ptr = png_ptr->error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
free_fn = png_ptr->free_fn; |
#endif |
png_memset(png_ptr, 0, sizeof (png_struct)); |
png_ptr->error_fn = error_fn; |
png_ptr->warning_fn = warning_fn; |
png_ptr->error_ptr = error_ptr; |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr->free_fn = free_fn; |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf)); |
#endif |
} |
/* Allow the application to select one or more row filters to use. */ |
void PNGAPI |
png_set_filter(png_structp png_ptr, int method, int filters) |
{ |
png_debug(1, "in png_set_filter\n"); |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
(method == PNG_INTRAPIXEL_DIFFERENCING)) |
method = PNG_FILTER_TYPE_BASE; |
#endif |
if (method == PNG_FILTER_TYPE_BASE) |
{ |
switch (filters & (PNG_ALL_FILTERS | 0x07)) |
{ |
case 5: |
case 6: |
case 7: png_warning(png_ptr, "Unknown row filter for method 0"); |
case PNG_FILTER_VALUE_NONE: png_ptr->do_filter=PNG_FILTER_NONE; break; |
case PNG_FILTER_VALUE_SUB: png_ptr->do_filter=PNG_FILTER_SUB; break; |
case PNG_FILTER_VALUE_UP: png_ptr->do_filter=PNG_FILTER_UP; break; |
case PNG_FILTER_VALUE_AVG: png_ptr->do_filter=PNG_FILTER_AVG; break; |
case PNG_FILTER_VALUE_PAETH: png_ptr->do_filter=PNG_FILTER_PAETH;break; |
default: png_ptr->do_filter = (png_byte)filters; break; |
} |
/* If we have allocated the row_buf, this means we have already started |
* with the image and we should have allocated all of the filter buffers |
* that have been selected. If prev_row isn't already allocated, then |
* it is too late to start using the filters that need it, since we |
* will be missing the data in the previous row. If an application |
* wants to start and stop using particular filters during compression, |
* it should start out with all of the filters, and then add and |
* remove them after the start of compression. |
*/ |
if (png_ptr->row_buf != NULL) |
{ |
if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL) |
{ |
png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; |
} |
if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL) |
{ |
if (png_ptr->prev_row == NULL) |
{ |
png_warning(png_ptr, "Can't add Up filter after starting"); |
png_ptr->do_filter &= ~PNG_FILTER_UP; |
} |
else |
{ |
png_ptr->up_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; |
} |
} |
if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL) |
{ |
if (png_ptr->prev_row == NULL) |
{ |
png_warning(png_ptr, "Can't add Average filter after starting"); |
png_ptr->do_filter &= ~PNG_FILTER_AVG; |
} |
else |
{ |
png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; |
} |
} |
if ((png_ptr->do_filter & PNG_FILTER_PAETH) && |
png_ptr->paeth_row == NULL) |
{ |
if (png_ptr->prev_row == NULL) |
{ |
png_warning(png_ptr, "Can't add Paeth filter after starting"); |
png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH); |
} |
else |
{ |
png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; |
} |
} |
if (png_ptr->do_filter == PNG_NO_FILTERS) |
png_ptr->do_filter = PNG_FILTER_NONE; |
} |
} |
else |
png_error(png_ptr, "Unknown custom filter method"); |
} |
/* This allows us to influence the way in which libpng chooses the "best" |
* filter for the current scanline. While the "minimum-sum-of-absolute- |
* differences metric is relatively fast and effective, there is some |
* question as to whether it can be improved upon by trying to keep the |
* filtered data going to zlib more consistent, hopefully resulting in |
* better compression. |
*/ |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */ |
void PNGAPI |
png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, |
int num_weights, png_doublep filter_weights, |
png_doublep filter_costs) |
{ |
int i; |
png_debug(1, "in png_set_filter_heuristics\n"); |
if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST) |
{ |
png_warning(png_ptr, "Unknown filter heuristic method"); |
return; |
} |
if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT) |
{ |
heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED; |
} |
if (num_weights < 0 || filter_weights == NULL || |
heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED) |
{ |
num_weights = 0; |
} |
png_ptr->num_prev_filters = (png_byte)num_weights; |
png_ptr->heuristic_method = (png_byte)heuristic_method; |
if (num_weights > 0) |
{ |
if (png_ptr->prev_filters == NULL) |
{ |
png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(sizeof(png_byte) * num_weights)); |
/* To make sure that the weighting starts out fairly */ |
for (i = 0; i < num_weights; i++) |
{ |
png_ptr->prev_filters[i] = 255; |
} |
} |
if (png_ptr->filter_weights == NULL) |
{ |
png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(sizeof(png_uint_16) * num_weights)); |
png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(sizeof(png_uint_16) * num_weights)); |
for (i = 0; i < num_weights; i++) |
{ |
png_ptr->inv_filter_weights[i] = |
png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; |
} |
} |
for (i = 0; i < num_weights; i++) |
{ |
if (filter_weights[i] < 0.0) |
{ |
png_ptr->inv_filter_weights[i] = |
png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; |
} |
else |
{ |
png_ptr->inv_filter_weights[i] = |
(png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5); |
png_ptr->filter_weights[i] = |
(png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5); |
} |
} |
} |
/* If, in the future, there are other filter methods, this would |
* need to be based on png_ptr->filter. |
*/ |
if (png_ptr->filter_costs == NULL) |
{ |
png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); |
png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); |
for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) |
{ |
png_ptr->inv_filter_costs[i] = |
png_ptr->filter_costs[i] = PNG_COST_FACTOR; |
} |
} |
/* Here is where we set the relative costs of the different filters. We |
* should take the desired compression level into account when setting |
* the costs, so that Paeth, for instance, has a high relative cost at low |
* compression levels, while it has a lower relative cost at higher |
* compression settings. The filter types are in order of increasing |
* relative cost, so it would be possible to do this with an algorithm. |
*/ |
for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) |
{ |
if (filter_costs == NULL || filter_costs[i] < 0.0) |
{ |
png_ptr->inv_filter_costs[i] = |
png_ptr->filter_costs[i] = PNG_COST_FACTOR; |
} |
else if (filter_costs[i] >= 1.0) |
{ |
png_ptr->inv_filter_costs[i] = |
(png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5); |
png_ptr->filter_costs[i] = |
(png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5); |
} |
} |
} |
#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ |
void PNGAPI |
png_set_compression_level(png_structp png_ptr, int level) |
{ |
png_debug(1, "in png_set_compression_level\n"); |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_LEVEL; |
png_ptr->zlib_level = level; |
} |
void PNGAPI |
png_set_compression_mem_level(png_structp png_ptr, int mem_level) |
{ |
png_debug(1, "in png_set_compression_mem_level\n"); |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL; |
png_ptr->zlib_mem_level = mem_level; |
} |
void PNGAPI |
png_set_compression_strategy(png_structp png_ptr, int strategy) |
{ |
png_debug(1, "in png_set_compression_strategy\n"); |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY; |
png_ptr->zlib_strategy = strategy; |
} |
void PNGAPI |
png_set_compression_window_bits(png_structp png_ptr, int window_bits) |
{ |
if (window_bits > 15) |
png_warning(png_ptr, "Only compression windows <= 32k supported by PNG"); |
else if (window_bits < 8) |
png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); |
#ifndef WBITS_8_OK |
/* avoid libpng bug with 256-byte windows */ |
if (window_bits == 8) |
{ |
png_warning(png_ptr, "Compression window is being reset to 512"); |
window_bits=9; |
} |
#endif |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS; |
png_ptr->zlib_window_bits = window_bits; |
} |
void PNGAPI |
png_set_compression_method(png_structp png_ptr, int method) |
{ |
png_debug(1, "in png_set_compression_method\n"); |
if (method != 8) |
png_warning(png_ptr, "Only compression method 8 is supported by PNG"); |
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_METHOD; |
png_ptr->zlib_method = method; |
} |
void PNGAPI |
png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn) |
{ |
png_ptr->write_row_fn = write_row_fn; |
} |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
void PNGAPI |
png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr |
write_user_transform_fn) |
{ |
png_debug(1, "in png_set_write_user_transform_fn\n"); |
png_ptr->transformations |= PNG_USER_TRANSFORM; |
png_ptr->write_user_transform_fn = write_user_transform_fn; |
} |
#endif |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
void PNGAPI |
png_write_png(png_structp png_ptr, png_infop info_ptr, |
int transforms, voidp params) |
{ |
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
/* invert the alpha channel from opacity to transparency */ |
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) |
png_set_invert_alpha(png_ptr); |
#endif |
/* Write the file header information. */ |
png_write_info(png_ptr, info_ptr); |
/* ------ these transformations don't touch the info structure ------- */ |
#if defined(PNG_WRITE_INVERT_SUPPORTED) |
/* invert monochrome pixels */ |
if (transforms & PNG_TRANSFORM_INVERT_MONO) |
png_set_invert_mono(png_ptr); |
#endif |
#if defined(PNG_WRITE_SHIFT_SUPPORTED) |
/* Shift the pixels up to a legal bit depth and fill in |
* as appropriate to correctly scale the image. |
*/ |
if ((transforms & PNG_TRANSFORM_SHIFT) |
&& (info_ptr->valid & PNG_INFO_sBIT)) |
png_set_shift(png_ptr, &info_ptr->sig_bit); |
#endif |
#if defined(PNG_WRITE_PACK_SUPPORTED) |
/* pack pixels into bytes */ |
if (transforms & PNG_TRANSFORM_PACKING) |
png_set_packing(png_ptr); |
#endif |
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
/* swap location of alpha bytes from ARGB to RGBA */ |
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) |
png_set_swap_alpha(png_ptr); |
#endif |
#if defined(PNG_WRITE_FILLER_SUPPORTED) |
/* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into |
* RGB (4 channels -> 3 channels). The second parameter is not used. |
*/ |
if (transforms & PNG_TRANSFORM_STRIP_FILLER) |
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); |
#endif |
#if defined(PNG_WRITE_BGR_SUPPORTED) |
/* flip BGR pixels to RGB */ |
if (transforms & PNG_TRANSFORM_BGR) |
png_set_bgr(png_ptr); |
#endif |
#if defined(PNG_WRITE_SWAP_SUPPORTED) |
/* swap bytes of 16-bit files to most significant byte first */ |
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) |
png_set_swap(png_ptr); |
#endif |
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
/* swap bits of 1, 2, 4 bit packed pixel formats */ |
if (transforms & PNG_TRANSFORM_PACKSWAP) |
png_set_packswap(png_ptr); |
#endif |
/* ----------------------- end of transformations ------------------- */ |
/* write the bits */ |
if (info_ptr->valid & PNG_INFO_IDAT) |
png_write_image(png_ptr, info_ptr->row_pointers); |
/* It is REQUIRED to call this to finish writing the rest of the file */ |
png_write_end(png_ptr, info_ptr); |
if(transforms == 0 || params == NULL) |
/* quiet compiler warnings */ return; |
} |
#endif |
#endif /* PNG_WRITE_SUPPORTED */ |
/shark/trunk/ports/png/pngconf.h |
---|
0,0 → 1,1348 |
/* pngconf.h - machine configurable file for libpng |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
/* Any machine specific code is near the front of this file, so if you |
* are configuring libpng for a machine, you may want to read the section |
* starting here down to where it starts to typedef png_color, png_text, |
* and png_info. |
*/ |
#ifndef PNGCONF_H |
#define PNGCONF_H |
/* This is the size of the compression buffer, and thus the size of |
* an IDAT chunk. Make this whatever size you feel is best for your |
* machine. One of these will be allocated per png_struct. When this |
* is full, it writes the data to the disk, and does some other |
* calculations. Making this an extremely small size will slow |
* the library down, but you may want to experiment to determine |
* where it becomes significant, if you are concerned with memory |
* usage. Note that zlib allocates at least 32Kb also. For readers, |
* this describes the size of the buffer available to read the data in. |
* Unless this gets smaller than the size of a row (compressed), |
* it should not make much difference how big this is. |
*/ |
#ifndef PNG_ZBUF_SIZE |
# define PNG_ZBUF_SIZE 8192 |
#endif |
/* Enable if you want a write-only libpng */ |
#ifndef PNG_NO_READ_SUPPORTED |
# define PNG_READ_SUPPORTED |
#endif |
/* Enable if you want a read-only libpng */ |
#ifndef PNG_NO_WRITE_SUPPORTED |
# define PNG_WRITE_SUPPORTED |
#endif |
/* Enabled by default in 1.2.0. You can disable this if you don't need to |
support PNGs that are embedded in MNG datastreams */ |
#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES) |
# ifndef PNG_MNG_FEATURES_SUPPORTED |
# define PNG_MNG_FEATURES_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_FLOATING_POINT_SUPPORTED |
# ifndef PNG_FLOATING_POINT_SUPPORTED |
# define PNG_FLOATING_POINT_SUPPORTED |
# endif |
#endif |
/* If you are running on a machine where you cannot allocate more |
* than 64K of memory at once, uncomment this. While libpng will not |
* normally need that much memory in a chunk (unless you load up a very |
* large file), zlib needs to know how big of a chunk it can use, and |
* libpng thus makes sure to check any memory allocation to verify it |
* will fit into memory. |
#define PNG_MAX_MALLOC_64K |
*/ |
#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) |
# define PNG_MAX_MALLOC_64K |
#endif |
/* Special munging to support doing things the 'cygwin' way: |
* 'Normal' png-on-win32 defines/defaults: |
* PNG_BUILD_DLL -- building dll |
* PNG_USE_DLL -- building an application, linking to dll |
* (no define) -- building static library, or building an |
* application and linking to the static lib |
* 'Cygwin' defines/defaults: |
* PNG_BUILD_DLL -- (ignored) building the dll |
* (no define) -- (ignored) building an application, linking to the dll |
* PNG_STATIC -- (ignored) building the static lib, or building an |
* application that links to the static lib. |
* ALL_STATIC -- (ignored) building various static libs, or building an |
* application that links to the static libs. |
* Thus, |
* a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and |
* this bit of #ifdefs will define the 'correct' config variables based on |
* that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but |
* unnecessary. |
* |
* Also, the precedence order is: |
* ALL_STATIC (since we can't #undef something outside our namespace) |
* PNG_BUILD_DLL |
* PNG_STATIC |
* (nothing) == PNG_USE_DLL |
* |
* CYGWIN (2002-01-20): The preceding is now obsolete. With the advent |
* of auto-import in binutils, we no longer need to worry about |
* __declspec(dllexport) / __declspec(dllimport) and friends. Therefore, |
* we don't need to worry about PNG_STATIC or ALL_STATIC when it comes |
* to __declspec() stuff. However, we DO need to worry about |
* PNG_BUILD_DLL and PNG_STATIC because those change some defaults |
* such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed. |
*/ |
#if defined(__CYGWIN__) |
# if defined(ALL_STATIC) |
# if defined(PNG_BUILD_DLL) |
# undef PNG_BUILD_DLL |
# endif |
# if defined(PNG_USE_DLL) |
# undef PNG_USE_DLL |
# endif |
# if defined(PNG_DLL) |
# undef PNG_DLL |
# endif |
# if !defined(PNG_STATIC) |
# define PNG_STATIC |
# endif |
# else |
# if defined (PNG_BUILD_DLL) |
# if defined(PNG_STATIC) |
# undef PNG_STATIC |
# endif |
# if defined(PNG_USE_DLL) |
# undef PNG_USE_DLL |
# endif |
# if !defined(PNG_DLL) |
# define PNG_DLL |
# endif |
# else |
# if defined(PNG_STATIC) |
# if defined(PNG_USE_DLL) |
# undef PNG_USE_DLL |
# endif |
# if defined(PNG_DLL) |
# undef PNG_DLL |
# endif |
# else |
# if !defined(PNG_USE_DLL) |
# define PNG_USE_DLL |
# endif |
# if !defined(PNG_DLL) |
# define PNG_DLL |
# endif |
# endif |
# endif |
# endif |
#endif |
/* This protects us against compilers that run on a windowing system |
* and thus don't have or would rather us not use the stdio types: |
* stdin, stdout, and stderr. The only one currently used is stderr |
* in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will |
* prevent these from being compiled and used. #defining PNG_NO_STDIO |
* will also prevent these, plus will prevent the entire set of stdio |
* macros and functions (FILE *, printf, etc.) from being compiled and used, |
* unless (PNG_DEBUG > 0) has been #defined. |
* |
* #define PNG_NO_CONSOLE_IO |
* #define PNG_NO_STDIO |
*/ |
#if defined(_WIN32_WCE) |
# include <windows.h> |
/* Console I/O functions are not supported on WindowsCE */ |
# define PNG_NO_CONSOLE_IO |
# ifdef PNG_DEBUG |
# undef PNG_DEBUG |
# endif |
#endif |
#ifdef PNG_BUILD_DLL |
# ifndef PNG_CONSOLE_IO_SUPPORTED |
# ifndef PNG_NO_CONSOLE_IO |
# define PNG_NO_CONSOLE_IO |
# endif |
# endif |
#endif |
# ifdef PNG_NO_STDIO |
# ifndef PNG_NO_CONSOLE_IO |
# define PNG_NO_CONSOLE_IO |
# endif |
# ifdef PNG_DEBUG |
# if (PNG_DEBUG > 0) |
# include <stdio.h> |
# endif |
# endif |
# else |
# if !defined(_WIN32_WCE) |
/* "stdio.h" functions are not supported on WindowsCE */ |
# include <stdio.h> |
# endif |
# endif |
/* This macro protects us against machines that don't have function |
* prototypes (ie K&R style headers). If your compiler does not handle |
* function prototypes, define this macro and use the included ansi2knr. |
* I've always been able to use _NO_PROTO as the indicator, but you may |
* need to drag the empty declaration out in front of here, or change the |
* ifdef to suit your own needs. |
*/ |
#ifndef PNGARG |
#ifdef OF /* zlib prototype munger */ |
# define PNGARG(arglist) OF(arglist) |
#else |
#ifdef _NO_PROTO |
# define PNGARG(arglist) () |
# ifndef PNG_TYPECAST_NULL |
# define PNG_TYPECAST_NULL |
# endif |
#else |
# define PNGARG(arglist) arglist |
#endif /* _NO_PROTO */ |
#endif /* OF */ |
#endif /* PNGARG */ |
/* Try to determine if we are compiling on a Mac. Note that testing for |
* just __MWERKS__ is not good enough, because the Codewarrior is now used |
* on non-Mac platforms. |
*/ |
#ifndef MACOS |
# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ |
defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) |
# define MACOS |
# endif |
#endif |
/* enough people need this for various reasons to include it here */ |
#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE) |
# include <sys/types.h> |
#endif |
#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED) |
//# define PNG_SETJMP_SUPPORTED |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* This is an attempt to force a single setjmp behaviour on Linux. If |
* the X config stuff didn't define _BSD_SOURCE we wouldn't need this. |
*/ |
# ifdef __linux__ |
# ifdef _BSD_SOURCE |
# define PNG_SAVE_BSD_SOURCE |
# undef _BSD_SOURCE |
# endif |
# ifdef _SETJMP_H |
__png.h__ already includes setjmp.h; |
__dont__ include it again.; |
# endif |
# endif /* __linux__ */ |
/* include setjmp.h for error handling */ |
//# include <setjmp.h> |
# ifdef __linux__ |
# ifdef PNG_SAVE_BSD_SOURCE |
# define _BSD_SOURCE |
# undef PNG_SAVE_BSD_SOURCE |
# endif |
# endif /* __linux__ */ |
#endif /* PNG_SETJMP_SUPPORTED */ |
#ifdef BSD |
# include <strings.h> |
#else |
# include <string.h> |
#endif |
/* Other defines for things like memory and the like can go here. */ |
#ifdef PNG_INTERNAL |
#include <stdlib.h> |
/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which |
* aren't usually used outside the library (as far as I know), so it is |
* debatable if they should be exported at all. In the future, when it is |
* possible to have run-time registry of chunk-handling functions, some of |
* these will be made available again. |
#define PNG_EXTERN extern |
*/ |
#define PNG_EXTERN |
/* Other defines specific to compilers can go here. Try to keep |
* them inside an appropriate ifdef/endif pair for portability. |
*/ |
#if defined(PNG_FLOATING_POINT_SUPPORTED) |
# if defined(MACOS) |
/* We need to check that <math.h> hasn't already been included earlier |
* as it seems it doesn't agree with <fp.h>, yet we should really use |
* <fp.h> if possible. |
*/ |
# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) |
# include <fp.h> |
# endif |
# else |
# include <math.h> |
# endif |
# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) |
/* Amiga SAS/C: We must include builtin FPU functions when compiling using |
* MATH=68881 |
*/ |
# include <m68881.h> |
# endif |
#endif |
/* Codewarrior on NT has linking problems without this. */ |
#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__) |
# define PNG_ALWAYS_EXTERN |
#endif |
/* For some reason, Borland C++ defines memcmp, etc. in mem.h, not |
* stdlib.h like it should (I think). Or perhaps this is a C++ |
* "feature"? |
*/ |
#ifdef __TURBOC__ |
# include <mem.h> |
# include "alloc.h" |
#endif |
#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \ |
defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__)) |
# include <malloc.h> |
#endif |
/* This controls how fine the dithering gets. As this allocates |
* a largish chunk of memory (32K), those who are not as concerned |
* with dithering quality can decrease some or all of these. |
*/ |
#ifndef PNG_DITHER_RED_BITS |
# define PNG_DITHER_RED_BITS 5 |
#endif |
#ifndef PNG_DITHER_GREEN_BITS |
# define PNG_DITHER_GREEN_BITS 5 |
#endif |
#ifndef PNG_DITHER_BLUE_BITS |
# define PNG_DITHER_BLUE_BITS 5 |
#endif |
/* This controls how fine the gamma correction becomes when you |
* are only interested in 8 bits anyway. Increasing this value |
* results in more memory being used, and more pow() functions |
* being called to fill in the gamma tables. Don't set this value |
* less then 8, and even that may not work (I haven't tested it). |
*/ |
#ifndef PNG_MAX_GAMMA_8 |
# define PNG_MAX_GAMMA_8 11 |
#endif |
/* This controls how much a difference in gamma we can tolerate before |
* we actually start doing gamma conversion. |
*/ |
#ifndef PNG_GAMMA_THRESHOLD |
# define PNG_GAMMA_THRESHOLD 0.05 |
#endif |
#endif /* PNG_INTERNAL */ |
/* The following uses const char * instead of char * for error |
* and warning message functions, so some compilers won't complain. |
* If you do not want to use const, define PNG_NO_CONST here. |
*/ |
#ifndef PNG_NO_CONST |
# define PNG_CONST const |
#else |
# define PNG_CONST |
#endif |
/* The following defines give you the ability to remove code from the |
* library that you will not be using. I wish I could figure out how to |
* automate this, but I can't do that without making it seriously hard |
* on the users. So if you are not using an ability, change the #define |
* to and #undef, and that part of the library will not be compiled. If |
* your linker can't find a function, you may want to make sure the |
* ability is defined here. Some of these depend upon some others being |
* defined. I haven't figured out all the interactions here, so you may |
* have to experiment awhile to get everything to compile. If you are |
* creating or using a shared library, you probably shouldn't touch this, |
* as it will affect the size of the structures, and this will cause bad |
* things to happen if the library and/or application ever change. |
*/ |
/* Any features you will not be using can be undef'ed here */ |
/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user |
* to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS |
* on the compile line, then pick and choose which ones to define without |
* having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED |
* if you only want to have a png-compliant reader/writer but don't need |
* any of the extra transformations. This saves about 80 kbytes in a |
* typical installation of the library. (PNG_NO_* form added in version |
* 1.0.1c, for consistency) |
*/ |
/* The size of the png_text structure changed in libpng-1.0.6 when |
* iTXt is supported. It is turned off by default, to support old apps |
* that malloc the png_text structure instead of calling png_set_text() |
* and letting libpng malloc it. It will be turned on by default in |
* libpng-1.3.0. |
*/ |
#ifndef PNG_iTXt_SUPPORTED |
# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt) |
# define PNG_NO_READ_iTXt |
# endif |
# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt) |
# define PNG_NO_WRITE_iTXt |
# endif |
#endif |
/* The following support, added after version 1.0.0, can be turned off here en |
* masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility |
* with old applications that require the length of png_struct and png_info |
* to remain unchanged. |
*/ |
#ifdef PNG_LEGACY_SUPPORTED |
# define PNG_NO_FREE_ME |
# define PNG_NO_READ_UNKNOWN_CHUNKS |
# define PNG_NO_WRITE_UNKNOWN_CHUNKS |
# define PNG_NO_READ_USER_CHUNKS |
# define PNG_NO_READ_iCCP |
# define PNG_NO_WRITE_iCCP |
# define PNG_NO_READ_iTXt |
# define PNG_NO_WRITE_iTXt |
# define PNG_NO_READ_sCAL |
# define PNG_NO_WRITE_sCAL |
# define PNG_NO_READ_sPLT |
# define PNG_NO_WRITE_sPLT |
# define PNG_NO_INFO_IMAGE |
# define PNG_NO_READ_RGB_TO_GRAY |
# define PNG_NO_READ_USER_TRANSFORM |
# define PNG_NO_WRITE_USER_TRANSFORM |
# define PNG_NO_USER_MEM |
# define PNG_NO_READ_EMPTY_PLTE |
# define PNG_NO_MNG_FEATURES |
# define PNG_NO_FIXED_POINT_SUPPORTED |
#endif |
/* Ignore attempt to turn off both floating and fixed point support */ |
#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \ |
!defined(PNG_NO_FIXED_POINT_SUPPORTED) |
# define PNG_FIXED_POINT_SUPPORTED |
#endif |
#ifndef PNG_NO_FREE_ME |
# define PNG_FREE_ME_SUPPORTED |
#endif |
#if defined(PNG_READ_SUPPORTED) |
#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \ |
!defined(PNG_NO_READ_TRANSFORMS) |
# define PNG_READ_TRANSFORMS_SUPPORTED |
#endif |
#ifdef PNG_READ_TRANSFORMS_SUPPORTED |
# ifndef PNG_NO_READ_EXPAND |
# define PNG_READ_EXPAND_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_SHIFT |
# define PNG_READ_SHIFT_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_PACK |
# define PNG_READ_PACK_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_BGR |
# define PNG_READ_BGR_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_SWAP |
# define PNG_READ_SWAP_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_PACKSWAP |
# define PNG_READ_PACKSWAP_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_INVERT |
# define PNG_READ_INVERT_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_DITHER |
# define PNG_READ_DITHER_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_BACKGROUND |
# define PNG_READ_BACKGROUND_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_16_TO_8 |
# define PNG_READ_16_TO_8_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_FILLER |
# define PNG_READ_FILLER_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_GAMMA |
# define PNG_READ_GAMMA_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_GRAY_TO_RGB |
# define PNG_READ_GRAY_TO_RGB_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_SWAP_ALPHA |
# define PNG_READ_SWAP_ALPHA_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_INVERT_ALPHA |
# define PNG_READ_INVERT_ALPHA_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_STRIP_ALPHA |
# define PNG_READ_STRIP_ALPHA_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_USER_TRANSFORM |
# define PNG_READ_USER_TRANSFORM_SUPPORTED |
# endif |
# ifndef PNG_NO_READ_RGB_TO_GRAY |
# define PNG_READ_RGB_TO_GRAY_SUPPORTED |
# endif |
#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ |
#if !defined(PNG_NO_PROGRESSIVE_READ) && \ |
!defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED) /* if you don't do progressive */ |
# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */ |
#endif /* about interlacing capability! You'll */ |
/* still have interlacing unless you change the following line: */ |
#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */ |
#ifndef PNG_NO_READ_COMPOSITE_NODIV |
# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */ |
# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */ |
# endif |
#endif |
/* Deprecated, will be removed from version 2.0.0. |
Use PNG_MNG_FEATURES_SUPPORTED instead. */ |
#ifndef PNG_NO_READ_EMPTY_PLTE |
# define PNG_READ_EMPTY_PLTE_SUPPORTED |
#endif |
#endif /* PNG_READ_SUPPORTED */ |
#if defined(PNG_WRITE_SUPPORTED) |
# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \ |
!defined(PNG_NO_WRITE_TRANSFORMS) |
# define PNG_WRITE_TRANSFORMS_SUPPORTED |
#endif |
#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED |
# ifndef PNG_NO_WRITE_SHIFT |
# define PNG_WRITE_SHIFT_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_PACK |
# define PNG_WRITE_PACK_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_BGR |
# define PNG_WRITE_BGR_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_SWAP |
# define PNG_WRITE_SWAP_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_PACKSWAP |
# define PNG_WRITE_PACKSWAP_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_INVERT |
# define PNG_WRITE_INVERT_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_FILLER |
# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */ |
# endif |
# ifndef PNG_NO_WRITE_SWAP_ALPHA |
# define PNG_WRITE_SWAP_ALPHA_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_INVERT_ALPHA |
# define PNG_WRITE_INVERT_ALPHA_SUPPORTED |
# endif |
# ifndef PNG_NO_WRITE_USER_TRANSFORM |
# define PNG_WRITE_USER_TRANSFORM_SUPPORTED |
# endif |
#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
# ifndef PNG_NO_USER_TRANSFORM_PTR |
# define PNG_USER_TRANSFORM_PTR_SUPPORTED |
# endif |
#endif |
#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant |
encoders, but can cause trouble |
if left undefined */ |
#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \ |
defined(PNG_FLOATING_POINT_SUPPORTED) |
# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
#endif |
#ifndef PNG_1_0_X |
#ifndef PNG_NO_ERROR_NUMBERS |
#define PNG_ERROR_NUMBERS_SUPPORTED |
#endif |
#endif /* PNG_1_0_X */ |
#ifndef PNG_NO_WRITE_FLUSH |
# define PNG_WRITE_FLUSH_SUPPORTED |
#endif |
/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */ |
#ifndef PNG_NO_WRITE_EMPTY_PLTE |
# define PNG_WRITE_EMPTY_PLTE_SUPPORTED |
#endif |
#endif /* PNG_WRITE_SUPPORTED */ |
#ifndef PNG_NO_STDIO |
# define PNG_TIME_RFC1123_SUPPORTED |
#endif |
/* This adds extra functions in pngget.c for accessing data from the |
* info pointer (added in version 0.99) |
* png_get_image_width() |
* png_get_image_height() |
* png_get_bit_depth() |
* png_get_color_type() |
* png_get_compression_type() |
* png_get_filter_type() |
* png_get_interlace_type() |
* png_get_pixel_aspect_ratio() |
* png_get_pixels_per_meter() |
* png_get_x_offset_pixels() |
* png_get_y_offset_pixels() |
* png_get_x_offset_microns() |
* png_get_y_offset_microns() |
*/ |
#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED) |
# define PNG_EASY_ACCESS_SUPPORTED |
#endif |
/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 |
even when PNG_USE_PNGVCRD or PNG_USE_PNGGCCRD is not defined */ |
#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE) |
# ifndef PNG_ASSEMBLER_CODE_SUPPORTED |
# define PNG_ASSEMBLER_CODE_SUPPORTED |
# endif |
# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) |
# define PNG_MMX_CODE_SUPPORTED |
# endif |
#endif |
/* If you are sure that you don't need thread safety and you are compiling |
with PNG_USE_PNGCCRD for an MMX application, you can define this for |
faster execution. See pnggccrd.c. |
#define PNG_THREAD_UNSAFE_OK |
*/ |
#if !defined(PNG_1_0_X) |
#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED) |
# define PNG_USER_MEM_SUPPORTED |
#endif |
#endif /* PNG_1_0_X */ |
/* These are currently experimental features, define them if you want */ |
/* very little testing */ |
/* |
#ifdef PNG_READ_SUPPORTED |
# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED |
# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED |
# endif |
#endif |
*/ |
/* This is only for PowerPC big-endian and 680x0 systems */ |
/* some testing */ |
/* |
#ifdef PNG_READ_SUPPORTED |
# ifndef PNG_PNG_READ_BIG_ENDIAN_SUPPORTED |
# define PNG_READ_BIG_ENDIAN_SUPPORTED |
# endif |
#endif |
*/ |
/* Buggy compilers (e.g., gcc 2.7.2.2) need this */ |
/* |
#define PNG_NO_POINTER_INDEXING |
*/ |
/* These functions are turned off by default, as they will be phased out. */ |
/* |
#define PNG_USELESS_TESTS_SUPPORTED |
#define PNG_CORRECT_PALETTE_SUPPORTED |
*/ |
/* Any chunks you are not interested in, you can undef here. The |
* ones that allocate memory may be expecially important (hIST, |
* tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info |
* a bit smaller. |
*/ |
#if defined(PNG_READ_SUPPORTED) && \ |
!defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ |
!defined(PNG_NO_READ_ANCILLARY_CHUNKS) |
# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED |
#endif |
#if defined(PNG_WRITE_SUPPORTED) && \ |
!defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ |
!defined(PNG_NO_WRITE_ANCILLARY_CHUNKS) |
# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED |
#endif |
#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED |
#ifdef PNG_NO_READ_TEXT |
# define PNG_NO_READ_iTXt |
# define PNG_NO_READ_tEXt |
# define PNG_NO_READ_zTXt |
#endif |
#ifndef PNG_NO_READ_bKGD |
# define PNG_READ_bKGD_SUPPORTED |
# define PNG_bKGD_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_cHRM |
# define PNG_READ_cHRM_SUPPORTED |
# define PNG_cHRM_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_gAMA |
# define PNG_READ_gAMA_SUPPORTED |
# define PNG_gAMA_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_hIST |
# define PNG_READ_hIST_SUPPORTED |
# define PNG_hIST_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_iCCP |
# define PNG_READ_iCCP_SUPPORTED |
# define PNG_iCCP_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_iTXt |
# ifndef PNG_READ_iTXt_SUPPORTED |
# define PNG_READ_iTXt_SUPPORTED |
# endif |
# ifndef PNG_iTXt_SUPPORTED |
# define PNG_iTXt_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_READ_oFFs |
# define PNG_READ_oFFs_SUPPORTED |
# define PNG_oFFs_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_pCAL |
# define PNG_READ_pCAL_SUPPORTED |
# define PNG_pCAL_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_sCAL |
# define PNG_READ_sCAL_SUPPORTED |
# define PNG_sCAL_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_pHYs |
# define PNG_READ_pHYs_SUPPORTED |
# define PNG_pHYs_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_sBIT |
# define PNG_READ_sBIT_SUPPORTED |
# define PNG_sBIT_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_sPLT |
# define PNG_READ_sPLT_SUPPORTED |
# define PNG_sPLT_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_sRGB |
# define PNG_READ_sRGB_SUPPORTED |
# define PNG_sRGB_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_tEXt |
# define PNG_READ_tEXt_SUPPORTED |
# define PNG_tEXt_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_tIME |
# define PNG_READ_tIME_SUPPORTED |
# define PNG_tIME_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_tRNS |
# define PNG_READ_tRNS_SUPPORTED |
# define PNG_tRNS_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_zTXt |
# define PNG_READ_zTXt_SUPPORTED |
# define PNG_zTXt_SUPPORTED |
#endif |
#ifndef PNG_NO_READ_UNKNOWN_CHUNKS |
# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED |
# define PNG_UNKNOWN_CHUNKS_SUPPORTED |
# endif |
# ifndef PNG_NO_HANDLE_AS_UNKNOWN |
# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
# endif |
#endif |
#if !defined(PNG_NO_READ_USER_CHUNKS) && \ |
defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
# define PNG_READ_USER_CHUNKS_SUPPORTED |
# define PNG_USER_CHUNKS_SUPPORTED |
# ifdef PNG_NO_READ_UNKNOWN_CHUNKS |
# undef PNG_NO_READ_UNKNOWN_CHUNKS |
# endif |
# ifdef PNG_NO_HANDLE_AS_UNKNOWN |
# undef PNG_NO_HANDLE_AS_UNKNOWN |
# endif |
#endif |
#ifndef PNG_NO_READ_OPT_PLTE |
# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */ |
#endif /* optional PLTE chunk in RGB and RGBA images */ |
#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \ |
defined(PNG_READ_zTXt_SUPPORTED) |
# define PNG_READ_TEXT_SUPPORTED |
# define PNG_TEXT_SUPPORTED |
#endif |
#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */ |
#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED |
#ifdef PNG_NO_WRITE_TEXT |
# define PNG_NO_WRITE_iTXt |
# define PNG_NO_WRITE_tEXt |
# define PNG_NO_WRITE_zTXt |
#endif |
#ifndef PNG_NO_WRITE_bKGD |
# define PNG_WRITE_bKGD_SUPPORTED |
# ifndef PNG_bKGD_SUPPORTED |
# define PNG_bKGD_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_cHRM |
# define PNG_WRITE_cHRM_SUPPORTED |
# ifndef PNG_cHRM_SUPPORTED |
# define PNG_cHRM_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_gAMA |
# define PNG_WRITE_gAMA_SUPPORTED |
# ifndef PNG_gAMA_SUPPORTED |
# define PNG_gAMA_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_hIST |
# define PNG_WRITE_hIST_SUPPORTED |
# ifndef PNG_hIST_SUPPORTED |
# define PNG_hIST_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_iCCP |
# define PNG_WRITE_iCCP_SUPPORTED |
# ifndef PNG_iCCP_SUPPORTED |
# define PNG_iCCP_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_iTXt |
# ifndef PNG_WRITE_iTXt_SUPPORTED |
# define PNG_WRITE_iTXt_SUPPORTED |
# endif |
# ifndef PNG_iTXt_SUPPORTED |
# define PNG_iTXt_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_oFFs |
# define PNG_WRITE_oFFs_SUPPORTED |
# ifndef PNG_oFFs_SUPPORTED |
# define PNG_oFFs_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_pCAL |
# define PNG_WRITE_pCAL_SUPPORTED |
# ifndef PNG_pCAL_SUPPORTED |
# define PNG_pCAL_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_sCAL |
# define PNG_WRITE_sCAL_SUPPORTED |
# ifndef PNG_sCAL_SUPPORTED |
# define PNG_sCAL_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_pHYs |
# define PNG_WRITE_pHYs_SUPPORTED |
# ifndef PNG_pHYs_SUPPORTED |
# define PNG_pHYs_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_sBIT |
# define PNG_WRITE_sBIT_SUPPORTED |
# ifndef PNG_sBIT_SUPPORTED |
# define PNG_sBIT_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_sPLT |
# define PNG_WRITE_sPLT_SUPPORTED |
# ifndef PNG_sPLT_SUPPORTED |
# define PNG_sPLT_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_sRGB |
# define PNG_WRITE_sRGB_SUPPORTED |
# ifndef PNG_sRGB_SUPPORTED |
# define PNG_sRGB_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_tEXt |
# define PNG_WRITE_tEXt_SUPPORTED |
# ifndef PNG_tEXt_SUPPORTED |
# define PNG_tEXt_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_tIME |
//# define PNG_WRITE_tIME_SUPPORTED |
# ifndef PNG_tIME_SUPPORTED |
//# define PNG_tIME_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_tRNS |
# define PNG_WRITE_tRNS_SUPPORTED |
# ifndef PNG_tRNS_SUPPORTED |
# define PNG_tRNS_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_zTXt |
# define PNG_WRITE_zTXt_SUPPORTED |
# ifndef PNG_zTXt_SUPPORTED |
# define PNG_zTXt_SUPPORTED |
# endif |
#endif |
#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS |
# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED |
# define PNG_UNKNOWN_CHUNKS_SUPPORTED |
# endif |
# ifndef PNG_NO_HANDLE_AS_UNKNOWN |
# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
# endif |
# endif |
#endif |
#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ |
defined(PNG_WRITE_zTXt_SUPPORTED) |
# define PNG_WRITE_TEXT_SUPPORTED |
# ifndef PNG_TEXT_SUPPORTED |
# define PNG_TEXT_SUPPORTED |
# endif |
#endif |
#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */ |
/* Turn this off to disable png_read_png() and |
* png_write_png() and leave the row_pointers member |
* out of the info structure. |
*/ |
#ifndef PNG_NO_INFO_IMAGE |
# define PNG_INFO_IMAGE_SUPPORTED |
#endif |
/* need the time information for reading tIME chunks */ |
#if defined(PNG_tIME_SUPPORTED) |
# if !defined(_WIN32_WCE) |
/* "time.h" functions are not supported on WindowsCE */ |
# include <time.h> |
# endif |
#endif |
/* Some typedefs to get us started. These should be safe on most of the |
* common platforms. The typedefs should be at least as large as the |
* numbers suggest (a png_uint_32 must be at least 32 bits long), but they |
* don't have to be exactly that size. Some compilers dislike passing |
* unsigned shorts as function parameters, so you may be better off using |
* unsigned int for png_uint_16. Likewise, for 64-bit systems, you may |
* want to have unsigned int for png_uint_32 instead of unsigned long. |
*/ |
typedef unsigned long png_uint_32; |
typedef long png_int_32; |
typedef unsigned short png_uint_16; |
typedef short png_int_16; |
typedef unsigned char png_byte; |
/* This is usually size_t. It is typedef'ed just in case you need it to |
change (I'm not sure if you will or not, so I thought I'd be safe) */ |
typedef size_t png_size_t; |
/* The following is needed for medium model support. It cannot be in the |
* PNG_INTERNAL section. Needs modification for other compilers besides |
* MSC. Model independent support declares all arrays and pointers to be |
* large using the far keyword. The zlib version used must also support |
* model independent data. As of version zlib 1.0.4, the necessary changes |
* have been made in zlib. The USE_FAR_KEYWORD define triggers other |
* changes that are needed. (Tim Wegner) |
*/ |
/* Separate compiler dependencies (problem here is that zlib.h always |
defines FAR. (SJT) */ |
#ifdef __BORLANDC__ |
# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) |
# define LDATA 1 |
# else |
# define LDATA 0 |
# endif |
/* GRR: why is Cygwin in here? Cygwin is not Borland C... */ |
# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) |
# define PNG_MAX_MALLOC_64K |
# if (LDATA != 1) |
# ifndef FAR |
# define FAR __far |
# endif |
# define USE_FAR_KEYWORD |
# endif /* LDATA != 1 */ |
/* Possibly useful for moving data out of default segment. |
* Uncomment it if you want. Could also define FARDATA as |
* const if your compiler supports it. (SJT) |
# define FARDATA FAR |
*/ |
# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ |
#endif /* __BORLANDC__ */ |
/* Suggest testing for specific compiler first before testing for |
* FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, |
* making reliance oncertain keywords suspect. (SJT) |
*/ |
/* MSC Medium model */ |
#if defined(FAR) |
# if defined(M_I86MM) |
# define USE_FAR_KEYWORD |
# define FARDATA FAR |
# include <dos.h> |
# endif |
#endif |
/* SJT: default case */ |
#ifndef FAR |
# define FAR |
#endif |
/* At this point FAR is always defined */ |
#ifndef FARDATA |
# define FARDATA |
#endif |
/* Typedef for floating-point numbers that are converted |
to fixed-point with a multiple of 100,000, e.g., int_gamma */ |
typedef png_int_32 png_fixed_point; |
/* Add typedefs for pointers */ |
typedef void FAR * png_voidp; |
typedef png_byte FAR * png_bytep; |
typedef png_uint_32 FAR * png_uint_32p; |
typedef png_int_32 FAR * png_int_32p; |
typedef png_uint_16 FAR * png_uint_16p; |
typedef png_int_16 FAR * png_int_16p; |
typedef PNG_CONST char FAR * png_const_charp; |
typedef char FAR * png_charp; |
typedef png_fixed_point FAR * png_fixed_point_p; |
#ifndef PNG_NO_STDIO |
#if defined(_WIN32_WCE) |
typedef HANDLE png_FILE_p; |
#else |
typedef FILE * png_FILE_p; |
#endif |
#endif |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
typedef double FAR * png_doublep; |
#endif |
/* Pointers to pointers; i.e. arrays */ |
typedef png_byte FAR * FAR * png_bytepp; |
typedef png_uint_32 FAR * FAR * png_uint_32pp; |
typedef png_int_32 FAR * FAR * png_int_32pp; |
typedef png_uint_16 FAR * FAR * png_uint_16pp; |
typedef png_int_16 FAR * FAR * png_int_16pp; |
typedef PNG_CONST char FAR * FAR * png_const_charpp; |
typedef char FAR * FAR * png_charpp; |
typedef png_fixed_point FAR * FAR * png_fixed_point_pp; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
typedef double FAR * FAR * png_doublepp; |
#endif |
/* Pointers to pointers to pointers; i.e., pointer to array */ |
typedef char FAR * FAR * FAR * png_charppp; |
/* libpng typedefs for types in zlib. If zlib changes |
* or another compression library is used, then change these. |
* Eliminates need to change all the source files. |
*/ |
typedef charf * png_zcharp; |
typedef charf * FAR * png_zcharpp; |
typedef z_stream FAR * png_zstreamp; |
/* |
* Define PNG_BUILD_DLL if the module being built is a Windows |
* LIBPNG DLL. |
* |
* Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL. |
* It is equivalent to Microsoft predefined macro _DLL that is |
* automatically defined when you compile using the share |
* version of the CRT (C Run-Time library) |
* |
* The cygwin mods make this behavior a little different: |
* Define PNG_BUILD_DLL if you are building a dll for use with cygwin |
* Define PNG_STATIC if you are building a static library for use with cygwin, |
* -or- if you are building an application that you want to link to the |
* static library. |
* PNG_USE_DLL is defined by default (no user action needed) unless one of |
* the other flags is defined. |
*/ |
#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL)) |
# define PNG_DLL |
#endif |
/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib. |
* When building a static lib, default to no GLOBAL ARRAYS, but allow |
* command-line override |
*/ |
#if defined(__CYGWIN__) |
# if !defined(PNG_STATIC) |
# if defined(PNG_USE_GLOBAL_ARRAYS) |
# undef PNG_USE_GLOBAL_ARRAYS |
# endif |
# if !defined(PNG_USE_LOCAL_ARRAYS) |
# define PNG_USE_LOCAL_ARRAYS |
# endif |
# else |
# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS) |
# if defined(PNG_USE_GLOBAL_ARRAYS) |
# undef PNG_USE_GLOBAL_ARRAYS |
# endif |
# endif |
# endif |
# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) |
# define PNG_USE_LOCAL_ARRAYS |
# endif |
#endif |
/* Do not use global arrays (helps with building DLL's) |
* They are no longer used in libpng itself, since version 1.0.5c, |
* but might be required for some pre-1.0.5c applications. |
*/ |
#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) |
# if defined(PNG_NO_GLOBAL_ARRAYS) || (defined(__GNUC__) && defined(PNG_DLL)) |
# define PNG_USE_LOCAL_ARRAYS |
# else |
# define PNG_USE_GLOBAL_ARRAYS |
# endif |
#endif |
#if defined(__CYGWIN__) |
# undef PNGAPI |
# define PNGAPI __cdecl |
# undef PNG_IMPEXP |
# define PNG_IMPEXP |
#endif |
/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall", |
* you may get warnings regarding the linkage of png_zalloc and png_zfree. |
* Don't ignore those warnings; you must also reset the default calling |
* convention in your compiler to match your PNGAPI, and you must build |
* zlib and your applications the same way you build libpng. |
*/ |
#ifndef PNGAPI |
#if defined(__MINGW32__) && !defined(PNG_MODULEDEF) |
# ifndef PNG_NO_MODULEDEF |
# define PNG_NO_MODULEDEF |
# endif |
#endif |
#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF) |
# define PNG_IMPEXP |
#endif |
#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \ |
(( defined(_Windows) || defined(_WINDOWS) || \ |
defined(WIN32) || defined(_WIN32) || defined(__WIN32__) )) |
# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) |
# define PNGAPI __cdecl |
# else |
# define PNGAPI _cdecl |
# endif |
# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \ |
0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */) |
# define PNG_IMPEXP |
# endif |
# if !defined(PNG_IMPEXP) |
# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol |
# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol |
/* Borland/Microsoft */ |
# if defined(_MSC_VER) || defined(__BORLANDC__) |
# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500) |
# define PNG_EXPORT PNG_EXPORT_TYPE1 |
# else |
# define PNG_EXPORT PNG_EXPORT_TYPE2 |
# if defined(PNG_BUILD_DLL) |
# define PNG_IMPEXP __export |
# else |
# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in |
VC++ */ |
# endif /* Exists in Borland C++ for |
C++ classes (== huge) */ |
# endif |
# endif |
# if !defined(PNG_IMPEXP) |
# if defined(PNG_BUILD_DLL) |
# define PNG_IMPEXP __declspec(dllexport) |
# else |
# define PNG_IMPEXP __declspec(dllimport) |
# endif |
# endif |
# endif /* PNG_IMPEXP */ |
#else /* !(DLL || non-cygwin WINDOWS) */ |
# if (defined(__IBMC__) || defined(IBMCPP__)) && defined(__OS2__) |
# define PNGAPI _System |
# define PNG_IMPEXP |
# else |
# if 0 /* ... other platforms, with other meanings */ |
# else |
# define PNGAPI |
# define PNG_IMPEXP |
# endif |
# endif |
#endif |
#endif |
#ifndef PNGAPI |
# define PNGAPI |
#endif |
#ifndef PNG_IMPEXP |
# define PNG_IMPEXP |
#endif |
#ifndef PNG_EXPORT |
# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol |
#endif |
#ifdef PNG_USE_GLOBAL_ARRAYS |
# ifndef PNG_EXPORT_VAR |
# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type |
# endif |
#endif |
/* User may want to use these so they are not in PNG_INTERNAL. Any library |
* functions that are passed far data must be model independent. |
*/ |
#ifndef PNG_ABORT |
# define PNG_ABORT() abort() |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) |
#else |
# define png_jmpbuf(png_ptr) \ |
(LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED) |
#endif |
#if defined(USE_FAR_KEYWORD) /* memory model independent fns */ |
/* use this to make far-to-near assignments */ |
# define CHECK 1 |
# define NOCHECK 0 |
# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) |
# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) |
# define png_strcpy _fstrcpy |
# define png_strlen _fstrlen |
# define png_memcmp _fmemcmp /* SJT: added */ |
# define png_memcpy _fmemcpy |
# define png_memset _fmemset |
#else /* use the usual functions */ |
# define CVT_PTR(ptr) (ptr) |
# define CVT_PTR_NOCHECK(ptr) (ptr) |
# define png_strcpy strcpy |
# define png_strlen strlen |
# define png_memcmp memcmp /* SJT: added */ |
# define png_memcpy memcpy |
# define png_memset memset |
#endif |
/* End of memory model independent support */ |
/* Just a little check that someone hasn't tried to define something |
* contradictory. |
*/ |
#if (PNG_ZBUF_SIZE > 65536) && defined(PNG_MAX_MALLOC_64K) |
# undef PNG_ZBUF_SIZE |
# define PNG_ZBUF_SIZE 65536 |
#endif |
#ifdef PNG_READ_SUPPORTED |
/* Prior to libpng-1.0.9, this block was in pngasmrd.h */ |
#if defined(PNG_INTERNAL) |
/* These are the default thresholds before the MMX code kicks in; if either |
* rowbytes or bitdepth is below the threshold, plain C code is used. These |
* can be overridden at runtime via the png_set_mmx_thresholds() call in |
* libpng 1.2.0 and later. The values below were chosen by Intel. |
*/ |
#ifndef PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT |
# define PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT 128 /* >= */ |
#endif |
#ifndef PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT |
# define PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT 9 /* >= */ |
#endif |
/* Set this in the makefile for VC++ on Pentium, not here. */ |
/* Platform must be Pentium. Makefile must assemble and load pngvcrd.c . |
* MMX will be detected at run time and used if present. |
*/ |
#ifdef PNG_USE_PNGVCRD |
# define PNG_HAVE_ASSEMBLER_COMBINE_ROW |
# define PNG_HAVE_ASSEMBLER_READ_INTERLACE |
# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
#endif |
/* Set this in the makefile for gcc/as on Pentium, not here. */ |
/* Platform must be Pentium. Makefile must assemble and load pnggccrd.c . |
* MMX will be detected at run time and used if present. |
*/ |
#ifdef PNG_USE_PNGGCCRD |
# define PNG_HAVE_ASSEMBLER_COMBINE_ROW |
# define PNG_HAVE_ASSEMBLER_READ_INTERLACE |
# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
#endif |
/* - see pnggccrd.c for info about what is currently enabled */ |
#endif /* PNG_INTERNAL */ |
#endif /* PNG_READ_SUPPORTED */ |
#endif /* PNGCONF_H */ |
/shark/trunk/ports/png/pngpread.c |
---|
0,0 → 1,1543 |
/* pngpread.c - read a png file in push mode |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
/* push model modes */ |
#define PNG_READ_SIG_MODE 0 |
#define PNG_READ_CHUNK_MODE 1 |
#define PNG_READ_IDAT_MODE 2 |
#define PNG_SKIP_MODE 3 |
#define PNG_READ_tEXt_MODE 4 |
#define PNG_READ_zTXt_MODE 5 |
#define PNG_READ_DONE_MODE 6 |
#define PNG_READ_iTXt_MODE 7 |
#define PNG_ERROR_MODE 8 |
void PNGAPI |
png_process_data(png_structp png_ptr, png_infop info_ptr, |
png_bytep buffer, png_size_t buffer_size) |
{ |
png_push_restore_buffer(png_ptr, buffer, buffer_size); |
while (png_ptr->buffer_size) |
{ |
png_process_some_data(png_ptr, info_ptr); |
} |
} |
/* What we do with the incoming data depends on what we were previously |
* doing before we ran out of data... |
*/ |
void /* PRIVATE */ |
png_process_some_data(png_structp png_ptr, png_infop info_ptr) |
{ |
switch (png_ptr->process_mode) |
{ |
case PNG_READ_SIG_MODE: |
{ |
png_push_read_sig(png_ptr, info_ptr); |
break; |
} |
case PNG_READ_CHUNK_MODE: |
{ |
png_push_read_chunk(png_ptr, info_ptr); |
break; |
} |
case PNG_READ_IDAT_MODE: |
{ |
png_push_read_IDAT(png_ptr); |
break; |
} |
#if defined(PNG_READ_tEXt_SUPPORTED) |
case PNG_READ_tEXt_MODE: |
{ |
png_push_read_tEXt(png_ptr, info_ptr); |
break; |
} |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
case PNG_READ_zTXt_MODE: |
{ |
png_push_read_zTXt(png_ptr, info_ptr); |
break; |
} |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
case PNG_READ_iTXt_MODE: |
{ |
png_push_read_iTXt(png_ptr, info_ptr); |
break; |
} |
#endif |
case PNG_SKIP_MODE: |
{ |
png_push_crc_finish(png_ptr); |
break; |
} |
default: |
{ |
png_ptr->buffer_size = 0; |
break; |
} |
} |
} |
/* Read any remaining signature bytes from the stream and compare them with |
* the correct PNG signature. It is possible that this routine is called |
* with bytes already read from the signature, either because they have been |
* checked by the calling application, or because of multiple calls to this |
* routine. |
*/ |
void /* PRIVATE */ |
png_push_read_sig(png_structp png_ptr, png_infop info_ptr) |
{ |
png_size_t num_checked = png_ptr->sig_bytes, |
num_to_check = 8 - num_checked; |
if (png_ptr->buffer_size < num_to_check) |
{ |
num_to_check = png_ptr->buffer_size; |
} |
png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]), |
num_to_check); |
png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes+num_to_check); |
if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) |
{ |
if (num_checked < 4 && |
png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) |
png_error(png_ptr, "Not a PNG file"); |
else |
png_error(png_ptr, "PNG file corrupted by ASCII conversion"); |
} |
else |
{ |
if (png_ptr->sig_bytes >= 8) |
{ |
png_ptr->process_mode = PNG_READ_CHUNK_MODE; |
} |
} |
} |
void /* PRIVATE */ |
png_push_read_chunk(png_structp png_ptr, png_infop info_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#if defined(PNG_READ_bKGD_SUPPORTED) |
PNG_bKGD; |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
PNG_cHRM; |
#endif |
#if defined(PNG_READ_gAMA_SUPPORTED) |
PNG_gAMA; |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
PNG_hIST; |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
PNG_iCCP; |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
PNG_iTXt; |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
PNG_oFFs; |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
PNG_pCAL; |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
PNG_pHYs; |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
PNG_sBIT; |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
PNG_sCAL; |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
PNG_sRGB; |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
PNG_sPLT; |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
PNG_tEXt; |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
PNG_tIME; |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
PNG_tRNS; |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
PNG_zTXt; |
#endif |
#endif /* PNG_USE_LOCAL_ARRAYS */ |
/* First we make sure we have enough data for the 4 byte chunk name |
* and the 4 byte chunk length before proceeding with decoding the |
* chunk data. To fully decode each of these chunks, we also make |
* sure we have enough data in the buffer for the 4 byte CRC at the |
* end of every chunk (except IDAT, which is handled separately). |
*/ |
if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) |
{ |
png_byte chunk_length[4]; |
if (png_ptr->buffer_size < 8) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_fill_buffer(png_ptr, chunk_length, 4); |
png_ptr->push_length = png_get_uint_32(chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; |
} |
if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length); |
} |
else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length); |
} |
else if (!png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) |
{ |
/* If we reach an IDAT chunk, this means we have read all of the |
* header chunks, and we can start reading the image (or if this |
* is called after the image has been read - we have an error). |
*/ |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before IDAT"); |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
png_error(png_ptr, "Missing PLTE before IDAT"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
if (png_ptr->push_length == 0) |
return; |
if (png_ptr->mode & PNG_AFTER_IDAT) |
png_error(png_ptr, "Too many IDAT's found"); |
} |
png_ptr->idat_size = png_ptr->push_length; |
png_ptr->mode |= PNG_HAVE_IDAT; |
png_ptr->process_mode = PNG_READ_IDAT_MODE; |
png_push_have_info(png_ptr, info_ptr); |
png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; |
png_ptr->zstream.next_out = png_ptr->row_buf; |
return; |
} |
else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length); |
png_ptr->process_mode = PNG_READ_DONE_MODE; |
png_push_have_end(png_ptr, info_ptr); |
} |
#if defined(PNG_READ_gAMA_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_iCCP_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_sPLT_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_tRNS_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_bKGD_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); |
} |
#endif |
else |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); |
} |
png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; |
} |
void /* PRIVATE */ |
png_push_crc_skip(png_structp png_ptr, png_uint_32 skip) |
{ |
png_ptr->process_mode = PNG_SKIP_MODE; |
png_ptr->skip_length = skip; |
} |
void /* PRIVATE */ |
png_push_crc_finish(png_structp png_ptr) |
{ |
if (png_ptr->skip_length && png_ptr->save_buffer_size) |
{ |
png_size_t save_size; |
if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size) |
save_size = (png_size_t)png_ptr->skip_length; |
else |
save_size = png_ptr->save_buffer_size; |
png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); |
png_ptr->skip_length -= save_size; |
png_ptr->buffer_size -= save_size; |
png_ptr->save_buffer_size -= save_size; |
png_ptr->save_buffer_ptr += save_size; |
} |
if (png_ptr->skip_length && png_ptr->current_buffer_size) |
{ |
png_size_t save_size; |
if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size) |
save_size = (png_size_t)png_ptr->skip_length; |
else |
save_size = png_ptr->current_buffer_size; |
png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); |
png_ptr->skip_length -= save_size; |
png_ptr->buffer_size -= save_size; |
png_ptr->current_buffer_size -= save_size; |
png_ptr->current_buffer_ptr += save_size; |
} |
if (!png_ptr->skip_length) |
{ |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_crc_finish(png_ptr, 0); |
png_ptr->process_mode = PNG_READ_CHUNK_MODE; |
} |
} |
void PNGAPI |
png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length) |
{ |
png_bytep ptr; |
ptr = buffer; |
if (png_ptr->save_buffer_size) |
{ |
png_size_t save_size; |
if (length < png_ptr->save_buffer_size) |
save_size = length; |
else |
save_size = png_ptr->save_buffer_size; |
png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size); |
length -= save_size; |
ptr += save_size; |
png_ptr->buffer_size -= save_size; |
png_ptr->save_buffer_size -= save_size; |
png_ptr->save_buffer_ptr += save_size; |
} |
if (length && png_ptr->current_buffer_size) |
{ |
png_size_t save_size; |
if (length < png_ptr->current_buffer_size) |
save_size = length; |
else |
save_size = png_ptr->current_buffer_size; |
png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size); |
png_ptr->buffer_size -= save_size; |
png_ptr->current_buffer_size -= save_size; |
png_ptr->current_buffer_ptr += save_size; |
} |
} |
void /* PRIVATE */ |
png_push_save_buffer(png_structp png_ptr) |
{ |
if (png_ptr->save_buffer_size) |
{ |
if (png_ptr->save_buffer_ptr != png_ptr->save_buffer) |
{ |
png_size_t i,istop; |
png_bytep sp; |
png_bytep dp; |
istop = png_ptr->save_buffer_size; |
for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer; |
i < istop; i++, sp++, dp++) |
{ |
*dp = *sp; |
} |
} |
} |
if (png_ptr->save_buffer_size + png_ptr->current_buffer_size > |
png_ptr->save_buffer_max) |
{ |
png_size_t new_max; |
png_bytep old_buffer; |
new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256; |
old_buffer = png_ptr->save_buffer; |
png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)new_max); |
png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); |
png_free(png_ptr, old_buffer); |
png_ptr->save_buffer_max = new_max; |
} |
if (png_ptr->current_buffer_size) |
{ |
png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size, |
png_ptr->current_buffer_ptr, png_ptr->current_buffer_size); |
png_ptr->save_buffer_size += png_ptr->current_buffer_size; |
png_ptr->current_buffer_size = 0; |
} |
png_ptr->save_buffer_ptr = png_ptr->save_buffer; |
png_ptr->buffer_size = 0; |
} |
void /* PRIVATE */ |
png_push_restore_buffer(png_structp png_ptr, png_bytep buffer, |
png_size_t buffer_length) |
{ |
png_ptr->current_buffer = buffer; |
png_ptr->current_buffer_size = buffer_length; |
png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size; |
png_ptr->current_buffer_ptr = png_ptr->current_buffer; |
} |
void /* PRIVATE */ |
png_push_read_IDAT(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IDAT; |
#endif |
if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER)) |
{ |
png_byte chunk_length[4]; |
if (png_ptr->buffer_size < 8) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_fill_buffer(png_ptr, chunk_length, 4); |
png_ptr->push_length = png_get_uint_32(chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; |
if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) |
{ |
png_ptr->process_mode = PNG_READ_CHUNK_MODE; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
png_error(png_ptr, "Not enough compressed data"); |
return; |
} |
png_ptr->idat_size = png_ptr->push_length; |
} |
if (png_ptr->idat_size && png_ptr->save_buffer_size) |
{ |
png_size_t save_size; |
if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size) |
{ |
save_size = (png_size_t)png_ptr->idat_size; |
/* check for overflow */ |
if((png_uint_32)save_size != png_ptr->idat_size) |
png_error(png_ptr, "save_size overflowed in pngpread"); |
} |
else |
save_size = png_ptr->save_buffer_size; |
png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size); |
png_ptr->idat_size -= save_size; |
png_ptr->buffer_size -= save_size; |
png_ptr->save_buffer_size -= save_size; |
png_ptr->save_buffer_ptr += save_size; |
} |
if (png_ptr->idat_size && png_ptr->current_buffer_size) |
{ |
png_size_t save_size; |
if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size) |
{ |
save_size = (png_size_t)png_ptr->idat_size; |
/* check for overflow */ |
if((png_uint_32)save_size != png_ptr->idat_size) |
png_error(png_ptr, "save_size overflowed in pngpread"); |
} |
else |
save_size = png_ptr->current_buffer_size; |
png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size); |
png_ptr->idat_size -= save_size; |
png_ptr->buffer_size -= save_size; |
png_ptr->current_buffer_size -= save_size; |
png_ptr->current_buffer_ptr += save_size; |
} |
if (!png_ptr->idat_size) |
{ |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_crc_finish(png_ptr, 0); |
png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; |
png_ptr->mode |= PNG_AFTER_IDAT; |
} |
} |
void /* PRIVATE */ |
png_process_IDAT_data(png_structp png_ptr, png_bytep buffer, |
png_size_t buffer_length) |
{ |
int ret; |
if ((png_ptr->flags & PNG_FLAG_ZLIB_FINISHED) && buffer_length) |
png_error(png_ptr, "Extra compression data"); |
png_ptr->zstream.next_in = buffer; |
png_ptr->zstream.avail_in = (uInt)buffer_length; |
for(;;) |
{ |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret != Z_OK) |
{ |
if (ret == Z_STREAM_END) |
{ |
if (png_ptr->zstream.avail_in) |
png_error(png_ptr, "Extra compressed data"); |
if (!(png_ptr->zstream.avail_out)) |
{ |
png_push_process_row(png_ptr); |
} |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
else if (ret == Z_BUF_ERROR) |
break; |
else |
png_error(png_ptr, "Decompression Error"); |
} |
if (!(png_ptr->zstream.avail_out)) |
{ |
if (( |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
png_ptr->interlaced && png_ptr->pass > 6) || |
(!png_ptr->interlaced && |
#endif |
png_ptr->row_number == png_ptr->num_rows-1)) |
{ |
if (png_ptr->zstream.avail_in) |
png_warning(png_ptr, "Too much data in IDAT chunks"); |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
png_push_process_row(png_ptr); |
png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; |
png_ptr->zstream.next_out = png_ptr->row_buf; |
} |
else |
break; |
} |
} |
void /* PRIVATE */ |
png_push_process_row(png_structp png_ptr) |
{ |
png_ptr->row_info.color_type = png_ptr->color_type; |
png_ptr->row_info.width = png_ptr->iwidth; |
png_ptr->row_info.channels = png_ptr->channels; |
png_ptr->row_info.bit_depth = png_ptr->bit_depth; |
png_ptr->row_info.pixel_depth = png_ptr->pixel_depth; |
png_ptr->row_info.rowbytes = ((png_ptr->row_info.width * |
(png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3); |
png_read_filter_row(png_ptr, &(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->prev_row + 1, |
(int)(png_ptr->row_buf[0])); |
png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, |
png_ptr->rowbytes + 1); |
if (png_ptr->transformations) |
png_do_read_transformations(png_ptr); |
#if defined(PNG_READ_INTERLACING_SUPPORTED) |
/* blow up interlaced rows to full size */ |
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) |
{ |
if (png_ptr->pass < 6) |
/* old interface (pre-1.0.9): |
png_do_read_interlace(&(png_ptr->row_info), |
png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); |
*/ |
png_do_read_interlace(png_ptr); |
switch (png_ptr->pass) |
{ |
case 0: |
{ |
int i; |
for (i = 0; i < 8 && png_ptr->pass == 0; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */ |
} |
if (png_ptr->pass == 2) /* pass 1 might be empty */ |
{ |
for (i = 0; i < 4 && png_ptr->pass == 2; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
if (png_ptr->pass == 4 && png_ptr->height <= 4) |
{ |
for (i = 0; i < 2 && png_ptr->pass == 4; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
if (png_ptr->pass == 6 && png_ptr->height <= 4) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
break; |
} |
case 1: |
{ |
int i; |
for (i = 0; i < 8 && png_ptr->pass == 1; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 2) /* skip top 4 generated rows */ |
{ |
for (i = 0; i < 4 && png_ptr->pass == 2; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
break; |
} |
case 2: |
{ |
int i; |
for (i = 0; i < 4 && png_ptr->pass == 2; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
for (i = 0; i < 4 && png_ptr->pass == 2; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 4) /* pass 3 might be empty */ |
{ |
for (i = 0; i < 2 && png_ptr->pass == 4; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
break; |
} |
case 3: |
{ |
int i; |
for (i = 0; i < 4 && png_ptr->pass == 3; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 4) /* skip top two generated rows */ |
{ |
for (i = 0; i < 2 && png_ptr->pass == 4; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
break; |
} |
case 4: |
{ |
int i; |
for (i = 0; i < 2 && png_ptr->pass == 4; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
for (i = 0; i < 2 && png_ptr->pass == 4; i++) |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 6) /* pass 5 might be empty */ |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
break; |
} |
case 5: |
{ |
int i; |
for (i = 0; i < 2 && png_ptr->pass == 5; i++) |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 6) /* skip top generated row */ |
{ |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
break; |
} |
case 6: |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
if (png_ptr->pass != 6) |
break; |
png_push_have_row(png_ptr, png_bytep_NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
} |
else |
#endif |
{ |
png_push_have_row(png_ptr, png_ptr->row_buf + 1); |
png_read_push_finish_row(png_ptr); |
} |
} |
void /* PRIVATE */ |
png_read_push_finish_row(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; |
/* Width of interlace block. This is not currently used - if you need |
* it, uncomment it here and in png.h |
const int FARDATA png_pass_width[] = {8, 4, 4, 2, 2, 1, 1}; |
*/ |
/* Height of interlace block. This is not currently used - if you need |
* it, uncomment it here and in png.h |
const int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; |
*/ |
#endif |
png_ptr->row_number++; |
if (png_ptr->row_number < png_ptr->num_rows) |
return; |
if (png_ptr->interlaced) |
{ |
png_ptr->row_number = 0; |
png_memset_check(png_ptr, png_ptr->prev_row, 0, |
png_ptr->rowbytes + 1); |
do |
{ |
png_ptr->pass++; |
if ((png_ptr->pass == 1 && png_ptr->width < 5) || |
(png_ptr->pass == 3 && png_ptr->width < 3) || |
(png_ptr->pass == 5 && png_ptr->width < 2)) |
png_ptr->pass++; |
if (png_ptr->pass > 7) |
png_ptr->pass--; |
if (png_ptr->pass >= 7) |
break; |
png_ptr->iwidth = (png_ptr->width + |
png_pass_inc[png_ptr->pass] - 1 - |
png_pass_start[png_ptr->pass]) / |
png_pass_inc[png_ptr->pass]; |
png_ptr->irowbytes = ((png_ptr->iwidth * |
png_ptr->pixel_depth + 7) >> 3) + 1; |
if (png_ptr->transformations & PNG_INTERLACE) |
break; |
png_ptr->num_rows = (png_ptr->height + |
png_pass_yinc[png_ptr->pass] - 1 - |
png_pass_ystart[png_ptr->pass]) / |
png_pass_yinc[png_ptr->pass]; |
} while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0); |
} |
} |
#if defined(PNG_READ_tEXt_SUPPORTED) |
void /* PRIVATE */ |
png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) |
{ |
png_error(png_ptr, "Out of place tEXt"); |
/* to quiet some compiler warnings */ |
if(info_ptr == NULL) return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
png_ptr->skip_length = 0; /* This may not be necessary */ |
if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ |
{ |
png_warning(png_ptr, "tEXt chunk too large to fit in memory"); |
png_ptr->skip_length = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_ptr->current_text = (png_charp)png_malloc(png_ptr, |
(png_uint_32)(length+1)); |
png_ptr->current_text[length] = '\0'; |
png_ptr->current_text_ptr = png_ptr->current_text; |
png_ptr->current_text_size = (png_size_t)length; |
png_ptr->current_text_left = (png_size_t)length; |
png_ptr->process_mode = PNG_READ_tEXt_MODE; |
} |
void /* PRIVATE */ |
png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->buffer_size && png_ptr->current_text_left) |
{ |
png_size_t text_size; |
if (png_ptr->buffer_size < png_ptr->current_text_left) |
text_size = png_ptr->buffer_size; |
else |
text_size = png_ptr->current_text_left; |
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); |
png_ptr->current_text_left -= text_size; |
png_ptr->current_text_ptr += text_size; |
} |
if (!(png_ptr->current_text_left)) |
{ |
png_textp text_ptr; |
png_charp text; |
png_charp key; |
int ret; |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_crc_finish(png_ptr); |
#if defined(PNG_MAX_MALLOC_64K) |
if (png_ptr->skip_length) |
return; |
#endif |
key = png_ptr->current_text; |
for (text = key; *text; text++) |
/* empty loop */ ; |
if (text != key + png_ptr->current_text_size) |
text++; |
text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text)); |
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr->key = key; |
#ifdef PNG_iTXt_SUPPORTED |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
#endif |
text_ptr->text = text; |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, key); |
png_free(png_ptr, text_ptr); |
png_ptr->current_text = NULL; |
if (ret) |
png_warning(png_ptr, "Insufficient memory to store text chunk."); |
} |
} |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
void /* PRIVATE */ |
png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) |
{ |
png_error(png_ptr, "Out of place zTXt"); |
/* to quiet some compiler warnings */ |
if(info_ptr == NULL) return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
/* We can't handle zTXt chunks > 64K, since we don't have enough space |
* to be able to store the uncompressed data. Actually, the threshold |
* is probably around 32K, but it isn't as definite as 64K is. |
*/ |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "zTXt chunk too large to fit in memory"); |
png_push_crc_skip(png_ptr, length); |
return; |
} |
#endif |
png_ptr->current_text = (png_charp)png_malloc(png_ptr, |
(png_uint_32)(length+1)); |
png_ptr->current_text[length] = '\0'; |
png_ptr->current_text_ptr = png_ptr->current_text; |
png_ptr->current_text_size = (png_size_t)length; |
png_ptr->current_text_left = (png_size_t)length; |
png_ptr->process_mode = PNG_READ_zTXt_MODE; |
} |
void /* PRIVATE */ |
png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->buffer_size && png_ptr->current_text_left) |
{ |
png_size_t text_size; |
if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left) |
text_size = png_ptr->buffer_size; |
else |
text_size = png_ptr->current_text_left; |
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); |
png_ptr->current_text_left -= text_size; |
png_ptr->current_text_ptr += text_size; |
} |
if (!(png_ptr->current_text_left)) |
{ |
png_textp text_ptr; |
png_charp text; |
png_charp key; |
int ret; |
png_size_t text_size, key_size; |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_crc_finish(png_ptr); |
key = png_ptr->current_text; |
for (text = key; *text; text++) |
/* empty loop */ ; |
/* zTXt can't have zero text */ |
if (text == key + png_ptr->current_text_size) |
{ |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
return; |
} |
text++; |
if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */ |
{ |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
return; |
} |
text++; |
png_ptr->zstream.next_in = (png_bytep )text; |
png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size - |
(text - key)); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
key_size = text - key; |
text_size = 0; |
text = NULL; |
ret = Z_STREAM_END; |
while (png_ptr->zstream.avail_in) |
{ |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret != Z_OK && ret != Z_STREAM_END) |
{ |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.avail_in = 0; |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
png_free(png_ptr, text); |
return; |
} |
if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END) |
{ |
if (text == NULL) |
{ |
text = (png_charp)png_malloc(png_ptr, |
(png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out |
+ key_size + 1)); |
png_memcpy(text + key_size, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
png_memcpy(text, key, key_size); |
text_size = key_size + png_ptr->zbuf_size - |
png_ptr->zstream.avail_out; |
*(text + text_size) = '\0'; |
} |
else |
{ |
png_charp tmp; |
tmp = text; |
text = (png_charp)png_malloc(png_ptr, text_size + |
(png_uint_32)(png_ptr->zbuf_size - png_ptr->zstream.avail_out |
+ 1)); |
png_memcpy(text, tmp, text_size); |
png_free(png_ptr, tmp); |
png_memcpy(text + text_size, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
*(text + text_size) = '\0'; |
} |
if (ret != Z_STREAM_END) |
{ |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
} |
else |
{ |
break; |
} |
if (ret == Z_STREAM_END) |
break; |
} |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.avail_in = 0; |
if (ret != Z_STREAM_END) |
{ |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
png_free(png_ptr, text); |
return; |
} |
png_ptr->current_text = NULL; |
png_free(png_ptr, key); |
key = text; |
text += key_size; |
text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text)); |
text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt; |
text_ptr->key = key; |
#ifdef PNG_iTXt_SUPPORTED |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
#endif |
text_ptr->text = text; |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, key); |
png_free(png_ptr, text_ptr); |
if (ret) |
png_warning(png_ptr, "Insufficient memory to store text chunk."); |
} |
} |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
void /* PRIVATE */ |
png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) |
{ |
png_error(png_ptr, "Out of place iTXt"); |
/* to quiet some compiler warnings */ |
if(info_ptr == NULL) return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
png_ptr->skip_length = 0; /* This may not be necessary */ |
if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ |
{ |
png_warning(png_ptr, "iTXt chunk too large to fit in memory"); |
png_ptr->skip_length = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_ptr->current_text = (png_charp)png_malloc(png_ptr, |
(png_uint_32)(length+1)); |
png_ptr->current_text[length] = '\0'; |
png_ptr->current_text_ptr = png_ptr->current_text; |
png_ptr->current_text_size = (png_size_t)length; |
png_ptr->current_text_left = (png_size_t)length; |
png_ptr->process_mode = PNG_READ_iTXt_MODE; |
} |
void /* PRIVATE */ |
png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->buffer_size && png_ptr->current_text_left) |
{ |
png_size_t text_size; |
if (png_ptr->buffer_size < png_ptr->current_text_left) |
text_size = png_ptr->buffer_size; |
else |
text_size = png_ptr->current_text_left; |
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); |
png_ptr->current_text_left -= text_size; |
png_ptr->current_text_ptr += text_size; |
} |
if (!(png_ptr->current_text_left)) |
{ |
png_textp text_ptr; |
png_charp key; |
int comp_flag; |
png_charp lang; |
png_charp lang_key; |
png_charp text; |
int ret; |
if (png_ptr->buffer_size < 4) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
png_push_crc_finish(png_ptr); |
#if defined(PNG_MAX_MALLOC_64K) |
if (png_ptr->skip_length) |
return; |
#endif |
key = png_ptr->current_text; |
for (lang = key; *lang; lang++) |
/* empty loop */ ; |
if (lang != key + png_ptr->current_text_size) |
lang++; |
comp_flag = *lang++; |
lang++; /* skip comp_type, always zero */ |
for (lang_key = lang; *lang_key; lang_key++) |
/* empty loop */ ; |
lang_key++; /* skip NUL separator */ |
for (text = lang_key; *text; text++) |
/* empty loop */ ; |
if (text != key + png_ptr->current_text_size) |
text++; |
text_ptr = (png_textp)png_malloc(png_ptr, (png_uint_32)sizeof(png_text)); |
text_ptr->compression = comp_flag + 2; |
text_ptr->key = key; |
text_ptr->lang = lang; |
text_ptr->lang_key = lang_key; |
text_ptr->text = text; |
text_ptr->text_length = 0; |
text_ptr->itxt_length = png_strlen(text); |
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_ptr->current_text = NULL; |
png_free(png_ptr, text_ptr); |
if (ret) |
png_warning(png_ptr, "Insufficient memory to store iTXt chunk."); |
} |
} |
#endif |
/* This function is called when we haven't found a handler for this |
* chunk. If there isn't a problem with the chunk itself (ie a bad chunk |
* name or a critical chunk), the chunk is (currently) silently ignored. |
*/ |
void /* PRIVATE */ |
png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 |
length) |
{ |
png_uint_32 skip=0; |
png_check_chunk_name(png_ptr, png_ptr->chunk_name); |
if (!(png_ptr->chunk_name[0] & 0x20)) |
{ |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
HANDLE_CHUNK_ALWAYS |
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
&& png_ptr->read_user_chunk_fn == NULL |
#endif |
) |
#endif |
png_chunk_error(png_ptr, "unknown critical chunk"); |
/* to quiet compiler warnings about unused info_ptr */ |
if (info_ptr == NULL) |
return; |
} |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) |
{ |
png_unknown_chunk chunk; |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "unknown chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name); |
chunk.data = (png_bytep)png_malloc(png_ptr, length); |
png_crc_read(png_ptr, chunk.data, length); |
chunk.size = length; |
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
if(png_ptr->read_user_chunk_fn != NULL) |
{ |
/* callback to user unknown chunk handler */ |
if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0) |
{ |
if (!(png_ptr->chunk_name[0] & 0x20)) |
if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
HANDLE_CHUNK_ALWAYS) |
png_chunk_error(png_ptr, "unknown critical chunk"); |
} |
png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); |
} |
else |
#endif |
png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); |
png_free(png_ptr, chunk.data); |
} |
else |
#endif |
skip=length; |
png_push_crc_skip(png_ptr, skip); |
} |
void /* PRIVATE */ |
png_push_have_info(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->info_fn != NULL) |
(*(png_ptr->info_fn))(png_ptr, info_ptr); |
} |
void /* PRIVATE */ |
png_push_have_end(png_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr->end_fn != NULL) |
(*(png_ptr->end_fn))(png_ptr, info_ptr); |
} |
void /* PRIVATE */ |
png_push_have_row(png_structp png_ptr, png_bytep row) |
{ |
if (png_ptr->row_fn != NULL) |
(*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number, |
(int)png_ptr->pass); |
} |
void PNGAPI |
png_progressive_combine_row (png_structp png_ptr, |
png_bytep old_row, png_bytep new_row) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
const int FARDATA png_pass_dsp_mask[7] = |
{0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; |
#endif |
if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */ |
png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]); |
} |
void PNGAPI |
png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr, |
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, |
png_progressive_end_ptr end_fn) |
{ |
png_ptr->info_fn = info_fn; |
png_ptr->row_fn = row_fn; |
png_ptr->end_fn = end_fn; |
png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer); |
} |
png_voidp PNGAPI |
png_get_progressive_ptr(png_structp png_ptr) |
{ |
return png_ptr->io_ptr; |
} |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
/shark/trunk/ports/png/pngset.c |
---|
0,0 → 1,1160 |
/* pngset.c - storage of image information into info struct |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* The functions here are used during reads to store data from the file |
* into the info struct, and during writes to store application data |
* into the info struct for writing into the file. This abstracts the |
* info struct and allows us to change the structure in the future. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#if defined(PNG_bKGD_SUPPORTED) |
void PNGAPI |
png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background) |
{ |
png_debug1(1, "in %s storage function\n", "bKGD"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_memcpy(&(info_ptr->background), background, sizeof(png_color_16)); |
info_ptr->valid |= PNG_INFO_bKGD; |
} |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_cHRM(png_structp png_ptr, png_infop info_ptr, |
double white_x, double white_y, double red_x, double red_y, |
double green_x, double green_y, double blue_x, double blue_y) |
{ |
png_debug1(1, "in %s storage function\n", "cHRM"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (white_x < 0.0 || white_y < 0.0 || |
red_x < 0.0 || red_y < 0.0 || |
green_x < 0.0 || green_y < 0.0 || |
blue_x < 0.0 || blue_y < 0.0) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set negative chromaticity value"); |
return; |
} |
if (white_x > 21474.83 || white_y > 21474.83 || |
red_x > 21474.83 || red_y > 21474.83 || |
green_x > 21474.83 || green_y > 21474.83 || |
blue_x > 21474.83 || blue_y > 21474.83) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set chromaticity value exceeding 21474.83"); |
return; |
} |
info_ptr->x_white = (float)white_x; |
info_ptr->y_white = (float)white_y; |
info_ptr->x_red = (float)red_x; |
info_ptr->y_red = (float)red_y; |
info_ptr->x_green = (float)green_x; |
info_ptr->y_green = (float)green_y; |
info_ptr->x_blue = (float)blue_x; |
info_ptr->y_blue = (float)blue_y; |
#ifdef PNG_FIXED_POINT_SUPPORTED |
info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5); |
info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5); |
info_ptr->int_x_red = (png_fixed_point)( red_x*100000.+0.5); |
info_ptr->int_y_red = (png_fixed_point)( red_y*100000.+0.5); |
info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5); |
info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5); |
info_ptr->int_x_blue = (png_fixed_point)( blue_x*100000.+0.5); |
info_ptr->int_y_blue = (png_fixed_point)( blue_y*100000.+0.5); |
#endif |
info_ptr->valid |= PNG_INFO_cHRM; |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void PNGAPI |
png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, |
png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, |
png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, |
png_fixed_point blue_x, png_fixed_point blue_y) |
{ |
png_debug1(1, "in %s storage function\n", "cHRM"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (white_x < 0 || white_y < 0 || |
red_x < 0 || red_y < 0 || |
green_x < 0 || green_y < 0 || |
blue_x < 0 || blue_y < 0) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set negative chromaticity value"); |
return; |
} |
if (white_x > (double) PNG_MAX_UINT || white_y > (double) PNG_MAX_UINT || |
red_x > (double) PNG_MAX_UINT || red_y > (double) PNG_MAX_UINT || |
green_x > (double) PNG_MAX_UINT || green_y > (double) PNG_MAX_UINT || |
blue_x > (double) PNG_MAX_UINT || blue_y > (double) PNG_MAX_UINT) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set chromaticity value exceeding 21474.83"); |
return; |
} |
info_ptr->int_x_white = white_x; |
info_ptr->int_y_white = white_y; |
info_ptr->int_x_red = red_x; |
info_ptr->int_y_red = red_y; |
info_ptr->int_x_green = green_x; |
info_ptr->int_y_green = green_y; |
info_ptr->int_x_blue = blue_x; |
info_ptr->int_y_blue = blue_y; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
info_ptr->x_white = (float)(white_x/100000.); |
info_ptr->y_white = (float)(white_y/100000.); |
info_ptr->x_red = (float)( red_x/100000.); |
info_ptr->y_red = (float)( red_y/100000.); |
info_ptr->x_green = (float)(green_x/100000.); |
info_ptr->y_green = (float)(green_y/100000.); |
info_ptr->x_blue = (float)( blue_x/100000.); |
info_ptr->y_blue = (float)( blue_y/100000.); |
#endif |
info_ptr->valid |= PNG_INFO_cHRM; |
} |
#endif |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma) |
{ |
double gamma; |
png_debug1(1, "in %s storage function\n", "gAMA"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* Check for overflow */ |
if (file_gamma > 21474.83) |
{ |
png_warning(png_ptr, "Limiting gamma to 21474.83"); |
gamma=21474.83; |
} |
else |
gamma=file_gamma; |
info_ptr->gamma = (float)gamma; |
#ifdef PNG_FIXED_POINT_SUPPORTED |
info_ptr->int_gamma = (int)(gamma*100000.+.5); |
#endif |
info_ptr->valid |= PNG_INFO_gAMA; |
if(gamma == 0.0) |
png_warning(png_ptr, "Setting gamma=0"); |
} |
#endif |
void PNGAPI |
png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point |
int_gamma) |
{ |
png_fixed_point gamma; |
png_debug1(1, "in %s storage function\n", "gAMA"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (int_gamma > (png_fixed_point) PNG_MAX_UINT) |
{ |
png_warning(png_ptr, "Limiting gamma to 21474.83"); |
gamma=PNG_MAX_UINT; |
} |
else |
{ |
if (int_gamma < 0) |
{ |
png_warning(png_ptr, "Setting negative gamma to zero"); |
gamma=0; |
} |
else |
gamma=int_gamma; |
} |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
info_ptr->gamma = (float)(gamma/100000.); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
info_ptr->int_gamma = gamma; |
#endif |
info_ptr->valid |= PNG_INFO_gAMA; |
if(gamma == 0) |
png_warning(png_ptr, "Setting gamma=0"); |
} |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
void PNGAPI |
png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist) |
{ |
int i; |
png_debug1(1, "in %s storage function\n", "hIST"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (info_ptr->num_palette == 0) |
{ |
png_warning(png_ptr, |
"Palette size 0, hIST allocation skipped."); |
return; |
} |
#ifdef PNG_FREE_ME_SUPPORTED |
png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0); |
#endif |
/* Changed from info->num_palette to 256 in version 1.2.1 */ |
png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr, |
(png_uint_32)(256 * sizeof (png_uint_16))); |
if (png_ptr->hist == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for hIST chunk data."); |
return; |
} |
for (i = 0; i < info_ptr->num_palette; i++) |
png_ptr->hist[i] = hist[i]; |
info_ptr->hist = png_ptr->hist; |
info_ptr->valid |= PNG_INFO_hIST; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_HIST; |
#else |
png_ptr->flags |= PNG_FLAG_FREE_HIST; |
#endif |
} |
#endif |
void PNGAPI |
png_set_IHDR(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 width, png_uint_32 height, int bit_depth, |
int color_type, int interlace_type, int compression_type, |
int filter_type) |
{ |
int rowbytes_per_pixel; |
png_debug1(1, "in %s storage function\n", "IHDR"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* check for width and height valid values */ |
if (width == 0 || height == 0) |
png_error(png_ptr, "Image width or height is zero in IHDR"); |
if (width > PNG_MAX_UINT || height > PNG_MAX_UINT) |
png_error(png_ptr, "Invalid image size in IHDR"); |
/* check other values */ |
if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && |
bit_depth != 8 && bit_depth != 16) |
png_error(png_ptr, "Invalid bit depth in IHDR"); |
if (color_type < 0 || color_type == 1 || |
color_type == 5 || color_type > 6) |
png_error(png_ptr, "Invalid color type in IHDR"); |
if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) || |
((color_type == PNG_COLOR_TYPE_RGB || |
color_type == PNG_COLOR_TYPE_GRAY_ALPHA || |
color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8)) |
png_error(png_ptr, "Invalid color type/bit depth combination in IHDR"); |
if (interlace_type >= PNG_INTERLACE_LAST) |
png_error(png_ptr, "Unknown interlace method in IHDR"); |
if (compression_type != PNG_COMPRESSION_TYPE_BASE) |
png_error(png_ptr, "Unknown compression method in IHDR"); |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
/* Accept filter_method 64 (intrapixel differencing) only if |
* 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and |
* 2. Libpng did not read a PNG signature (this filter_method is only |
* used in PNG datastreams that are embedded in MNG datastreams) and |
* 3. The application called png_permit_mng_features with a mask that |
* included PNG_FLAG_MNG_FILTER_64 and |
* 4. The filter_method is 64 and |
* 5. The color_type is RGB or RGBA |
*/ |
if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&png_ptr->mng_features_permitted) |
png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n"); |
if(filter_type != PNG_FILTER_TYPE_BASE) |
{ |
if(!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
(filter_type == PNG_INTRAPIXEL_DIFFERENCING) && |
((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && |
(color_type == PNG_COLOR_TYPE_RGB || |
color_type == PNG_COLOR_TYPE_RGB_ALPHA))) |
png_error(png_ptr, "Unknown filter method in IHDR"); |
if(png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) |
png_warning(png_ptr, "Invalid filter method in IHDR"); |
} |
#else |
if(filter_type != PNG_FILTER_TYPE_BASE) |
png_error(png_ptr, "Unknown filter method in IHDR"); |
#endif |
info_ptr->width = width; |
info_ptr->height = height; |
info_ptr->bit_depth = (png_byte)bit_depth; |
info_ptr->color_type =(png_byte) color_type; |
info_ptr->compression_type = (png_byte)compression_type; |
info_ptr->filter_type = (png_byte)filter_type; |
info_ptr->interlace_type = (png_byte)interlace_type; |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
info_ptr->channels = 1; |
else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) |
info_ptr->channels = 3; |
else |
info_ptr->channels = 1; |
if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) |
info_ptr->channels++; |
info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth); |
/* check for overflow */ |
rowbytes_per_pixel = (info_ptr->pixel_depth + 7) >> 3; |
if ( width > PNG_MAX_UINT/rowbytes_per_pixel - 64) |
{ |
png_warning(png_ptr, |
"Width too large to process image data; rowbytes will overflow."); |
info_ptr->rowbytes = (png_size_t)0; |
} |
else |
info_ptr->rowbytes = (info_ptr->width * info_ptr->pixel_depth + 7) >> 3; |
} |
#if defined(PNG_oFFs_SUPPORTED) |
void PNGAPI |
png_set_oFFs(png_structp png_ptr, png_infop info_ptr, |
png_int_32 offset_x, png_int_32 offset_y, int unit_type) |
{ |
png_debug1(1, "in %s storage function\n", "oFFs"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->x_offset = offset_x; |
info_ptr->y_offset = offset_y; |
info_ptr->offset_unit_type = (png_byte)unit_type; |
info_ptr->valid |= PNG_INFO_oFFs; |
} |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
void PNGAPI |
png_set_pCAL(png_structp png_ptr, png_infop info_ptr, |
png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, |
png_charp units, png_charpp params) |
{ |
png_uint_32 length; |
int i; |
png_debug1(1, "in %s storage function\n", "pCAL"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
length = png_strlen(purpose) + 1; |
png_debug1(3, "allocating purpose for info (%lu bytes)\n", length); |
info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length); |
if (info_ptr->pcal_purpose == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for pCAL purpose."); |
return; |
} |
png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length); |
png_debug(3, "storing X0, X1, type, and nparams in info\n"); |
info_ptr->pcal_X0 = X0; |
info_ptr->pcal_X1 = X1; |
info_ptr->pcal_type = (png_byte)type; |
info_ptr->pcal_nparams = (png_byte)nparams; |
length = png_strlen(units) + 1; |
png_debug1(3, "allocating units for info (%lu bytes)\n", length); |
info_ptr->pcal_units = (png_charp)png_malloc_warn(png_ptr, length); |
if (info_ptr->pcal_units == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for pCAL units."); |
return; |
} |
png_memcpy(info_ptr->pcal_units, units, (png_size_t)length); |
info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr, |
(png_uint_32)((nparams + 1) * sizeof(png_charp))); |
if (info_ptr->pcal_params == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for pCAL params."); |
return; |
} |
info_ptr->pcal_params[nparams] = NULL; |
for (i = 0; i < nparams; i++) |
{ |
length = png_strlen(params[i]) + 1; |
png_debug2(3, "allocating parameter %d for info (%lu bytes)\n", i, length); |
info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length); |
if (info_ptr->pcal_params[i] == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for pCAL parameter."); |
return; |
} |
png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length); |
} |
info_ptr->valid |= PNG_INFO_pCAL; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_PCAL; |
#endif |
} |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_sCAL(png_structp png_ptr, png_infop info_ptr, |
int unit, double width, double height) |
{ |
png_debug1(1, "in %s storage function\n", "sCAL"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->scal_unit = (png_byte)unit; |
info_ptr->scal_pixel_width = width; |
info_ptr->scal_pixel_height = height; |
info_ptr->valid |= PNG_INFO_sCAL; |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void PNGAPI |
png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr, |
int unit, png_charp swidth, png_charp sheight) |
{ |
png_uint_32 length; |
png_debug1(1, "in %s storage function\n", "sCAL"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->scal_unit = (png_byte)unit; |
length = png_strlen(swidth) + 1; |
png_debug1(3, "allocating unit for info (%d bytes)\n", length); |
info_ptr->scal_s_width = (png_charp)png_malloc(png_ptr, length); |
png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length); |
length = png_strlen(sheight) + 1; |
png_debug1(3, "allocating unit for info (%d bytes)\n", length); |
info_ptr->scal_s_height = (png_charp)png_malloc(png_ptr, length); |
png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length); |
info_ptr->valid |= PNG_INFO_sCAL; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_SCAL; |
#endif |
} |
#endif |
#endif |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
void PNGAPI |
png_set_pHYs(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 res_x, png_uint_32 res_y, int unit_type) |
{ |
png_debug1(1, "in %s storage function\n", "pHYs"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->x_pixels_per_unit = res_x; |
info_ptr->y_pixels_per_unit = res_y; |
info_ptr->phys_unit_type = (png_byte)unit_type; |
info_ptr->valid |= PNG_INFO_pHYs; |
} |
#endif |
void PNGAPI |
png_set_PLTE(png_structp png_ptr, png_infop info_ptr, |
png_colorp palette, int num_palette) |
{ |
png_debug1(1, "in %s storage function\n", "PLTE"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* |
* It may not actually be necessary to set png_ptr->palette here; |
* we do it for backward compatibility with the way the png_handle_tRNS |
* function used to do the allocation. |
*/ |
#ifdef PNG_FREE_ME_SUPPORTED |
png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0); |
#endif |
/* Changed in libpng-1.2.1 to allocate 256 instead of num_palette entries, |
in case of an invalid PNG file that has too-large sample values. */ |
png_ptr->palette = (png_colorp)png_zalloc(png_ptr, (uInt)256, |
sizeof (png_color)); |
if (png_ptr->palette == NULL) |
png_error(png_ptr, "Unable to malloc palette"); |
png_memcpy(png_ptr->palette, palette, num_palette * sizeof (png_color)); |
info_ptr->palette = png_ptr->palette; |
info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_PLTE; |
#else |
png_ptr->flags |= PNG_FLAG_FREE_PLTE; |
#endif |
info_ptr->valid |= PNG_INFO_PLTE; |
} |
#if defined(PNG_sBIT_SUPPORTED) |
void PNGAPI |
png_set_sBIT(png_structp png_ptr, png_infop info_ptr, |
png_color_8p sig_bit) |
{ |
png_debug1(1, "in %s storage function\n", "sBIT"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_memcpy(&(info_ptr->sig_bit), sig_bit, sizeof (png_color_8)); |
info_ptr->valid |= PNG_INFO_sBIT; |
} |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
void PNGAPI |
png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int intent) |
{ |
png_debug1(1, "in %s storage function\n", "sRGB"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->srgb_intent = (png_byte)intent; |
info_ptr->valid |= PNG_INFO_sRGB; |
} |
void PNGAPI |
png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr, |
int intent) |
{ |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float file_gamma; |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_fixed_point int_file_gamma; |
#endif |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, |
int_green_y, int_blue_x, int_blue_y; |
#endif |
#endif |
png_debug1(1, "in %s storage function\n", "sRGB_gAMA_and_cHRM"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_set_sRGB(png_ptr, info_ptr, intent); |
#if defined(PNG_gAMA_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
file_gamma = (float).45455; |
png_set_gAMA(png_ptr, info_ptr, file_gamma); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
int_file_gamma = 45455L; |
png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma); |
#endif |
#endif |
#if defined(PNG_cHRM_SUPPORTED) |
#ifdef PNG_FIXED_POINT_SUPPORTED |
int_white_x = 31270L; |
int_white_y = 32900L; |
int_red_x = 64000L; |
int_red_y = 33000L; |
int_green_x = 30000L; |
int_green_y = 60000L; |
int_blue_x = 15000L; |
int_blue_y = 6000L; |
png_set_cHRM_fixed(png_ptr, info_ptr, |
int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_green_y, |
int_blue_x, int_blue_y); |
#endif |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
white_x = (float).3127; |
white_y = (float).3290; |
red_x = (float).64; |
red_y = (float).33; |
green_x = (float).30; |
green_y = (float).60; |
blue_x = (float).15; |
blue_y = (float).06; |
png_set_cHRM(png_ptr, info_ptr, |
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); |
#endif |
#endif |
} |
#endif |
#if defined(PNG_iCCP_SUPPORTED) |
void PNGAPI |
png_set_iCCP(png_structp png_ptr, png_infop info_ptr, |
png_charp name, int compression_type, |
png_charp profile, png_uint_32 proflen) |
{ |
png_charp new_iccp_name; |
png_charp new_iccp_profile; |
png_debug1(1, "in %s storage function\n", "iCCP"); |
if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL) |
return; |
new_iccp_name = (png_charp)png_malloc(png_ptr, png_strlen(name)+1); |
png_strcpy(new_iccp_name, name); |
new_iccp_profile = (png_charp)png_malloc(png_ptr, proflen); |
png_memcpy(new_iccp_profile, profile, (png_size_t)proflen); |
png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0); |
info_ptr->iccp_proflen = proflen; |
info_ptr->iccp_name = new_iccp_name; |
info_ptr->iccp_profile = new_iccp_profile; |
/* Compression is always zero but is here so the API and info structure |
* does not have to change if we introduce multiple compression types */ |
info_ptr->iccp_compression = (png_byte)compression_type; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_ICCP; |
#endif |
info_ptr->valid |= PNG_INFO_iCCP; |
} |
#endif |
#if defined(PNG_TEXT_SUPPORTED) |
void PNGAPI |
png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, |
int num_text) |
{ |
int ret; |
ret=png_set_text_2(png_ptr, info_ptr, text_ptr, num_text); |
if (ret) |
png_error(png_ptr, "Insufficient memory to store text"); |
} |
int /* PRIVATE */ |
png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, |
int num_text) |
{ |
int i; |
png_debug1(1, "in %s storage function\n", (png_ptr->chunk_name[0] == '\0' ? |
"text" : (png_const_charp)png_ptr->chunk_name)); |
if (png_ptr == NULL || info_ptr == NULL || num_text == 0) |
return(0); |
/* Make sure we have enough space in the "text" array in info_struct |
* to hold all of the incoming text_ptr objects. |
*/ |
if (info_ptr->num_text + num_text > info_ptr->max_text) |
{ |
if (info_ptr->text != NULL) |
{ |
png_textp old_text; |
int old_max; |
old_max = info_ptr->max_text; |
info_ptr->max_text = info_ptr->num_text + num_text + 8; |
old_text = info_ptr->text; |
info_ptr->text = (png_textp)png_malloc_warn(png_ptr, |
(png_uint_32)(info_ptr->max_text * sizeof (png_text))); |
if (info_ptr->text == NULL) |
{ |
png_free(png_ptr, old_text); |
return(1); |
} |
png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max * |
sizeof(png_text))); |
png_free(png_ptr, old_text); |
} |
else |
{ |
info_ptr->max_text = num_text + 8; |
info_ptr->num_text = 0; |
info_ptr->text = (png_textp)png_malloc_warn(png_ptr, |
(png_uint_32)(info_ptr->max_text * sizeof (png_text))); |
if (info_ptr->text == NULL) |
return(1); |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_TEXT; |
#endif |
} |
png_debug1(3, "allocated %d entries for info_ptr->text\n", |
info_ptr->max_text); |
} |
for (i = 0; i < num_text; i++) |
{ |
png_size_t text_length,key_len; |
png_size_t lang_len,lang_key_len; |
png_textp textp = &(info_ptr->text[info_ptr->num_text]); |
if (text_ptr[i].key == NULL) |
continue; |
key_len = png_strlen(text_ptr[i].key); |
if(text_ptr[i].compression <= 0) |
{ |
lang_len = 0; |
lang_key_len = 0; |
} |
else |
#ifdef PNG_iTXt_SUPPORTED |
{ |
/* set iTXt data */ |
if (text_ptr[i].lang != NULL) |
lang_len = png_strlen(text_ptr[i].lang); |
else |
lang_len = 0; |
if (text_ptr[i].lang_key != NULL) |
lang_key_len = png_strlen(text_ptr[i].lang_key); |
else |
lang_key_len = 0; |
} |
#else |
{ |
png_warning(png_ptr, "iTXt chunk not supported."); |
continue; |
} |
#endif |
if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0') |
{ |
text_length = 0; |
#ifdef PNG_iTXt_SUPPORTED |
if(text_ptr[i].compression > 0) |
textp->compression = PNG_ITXT_COMPRESSION_NONE; |
else |
#endif |
textp->compression = PNG_TEXT_COMPRESSION_NONE; |
} |
else |
{ |
text_length = png_strlen(text_ptr[i].text); |
textp->compression = text_ptr[i].compression; |
} |
textp->key = (png_charp)png_malloc_warn(png_ptr, |
(png_uint_32)(key_len + text_length + lang_len + lang_key_len + 4)); |
if (textp->key == NULL) |
return(1); |
png_debug2(2, "Allocated %lu bytes at %x in png_set_text\n", |
(png_uint_32)(key_len + lang_len + lang_key_len + text_length + 4), |
(int)textp->key); |
png_memcpy(textp->key, text_ptr[i].key, |
(png_size_t)(key_len)); |
*(textp->key+key_len) = '\0'; |
#ifdef PNG_iTXt_SUPPORTED |
if (text_ptr[i].compression > 0) |
{ |
textp->lang=textp->key + key_len + 1; |
png_memcpy(textp->lang, text_ptr[i].lang, lang_len); |
*(textp->lang+lang_len) = '\0'; |
textp->lang_key=textp->lang + lang_len + 1; |
png_memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len); |
*(textp->lang_key+lang_key_len) = '\0'; |
textp->text=textp->lang_key + lang_key_len + 1; |
} |
else |
#endif |
{ |
#ifdef PNG_iTXt_SUPPORTED |
textp->lang=NULL; |
textp->lang_key=NULL; |
#endif |
textp->text=textp->key + key_len + 1; |
} |
if(text_length) |
png_memcpy(textp->text, text_ptr[i].text, |
(png_size_t)(text_length)); |
*(textp->text+text_length) = '\0'; |
#ifdef PNG_iTXt_SUPPORTED |
if(textp->compression > 0) |
{ |
textp->text_length = 0; |
textp->itxt_length = text_length; |
} |
else |
#endif |
{ |
textp->text_length = text_length; |
#ifdef PNG_iTXt_SUPPORTED |
textp->itxt_length = 0; |
#endif |
} |
info_ptr->text[info_ptr->num_text]= *textp; |
info_ptr->num_text++; |
png_debug1(3, "transferred text chunk %d\n", info_ptr->num_text); |
} |
return(0); |
} |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
void PNGAPI |
png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time) |
{ |
png_debug1(1, "in %s storage function\n", "tIME"); |
if (png_ptr == NULL || info_ptr == NULL || |
(png_ptr->mode & PNG_WROTE_tIME)) |
return; |
png_memcpy(&(info_ptr->mod_time), mod_time, sizeof (png_time)); |
info_ptr->valid |= PNG_INFO_tIME; |
} |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
void PNGAPI |
png_set_tRNS(png_structp png_ptr, png_infop info_ptr, |
png_bytep trans, int num_trans, png_color_16p trans_values) |
{ |
png_debug1(1, "in %s storage function\n", "tRNS"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (trans != NULL) |
{ |
/* |
* It may not actually be necessary to set png_ptr->trans here; |
* we do it for backward compatibility with the way the png_handle_tRNS |
* function used to do the allocation. |
*/ |
#ifdef PNG_FREE_ME_SUPPORTED |
png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0); |
#endif |
/* Changed from num_trans to 256 in version 1.2.1 */ |
png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)256); |
png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans); |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_TRNS; |
#else |
png_ptr->flags |= PNG_FLAG_FREE_TRNS; |
#endif |
} |
if (trans_values != NULL) |
{ |
png_memcpy(&(info_ptr->trans_values), trans_values, |
sizeof(png_color_16)); |
if (num_trans == 0) |
num_trans = 1; |
} |
info_ptr->num_trans = (png_uint_16)num_trans; |
info_ptr->valid |= PNG_INFO_tRNS; |
} |
#endif |
#if defined(PNG_sPLT_SUPPORTED) |
void PNGAPI |
png_set_sPLT(png_structp png_ptr, |
png_infop info_ptr, png_sPLT_tp entries, int nentries) |
{ |
png_sPLT_tp np; |
int i; |
np = (png_sPLT_tp)png_malloc_warn(png_ptr, |
(info_ptr->splt_palettes_num + nentries) * sizeof(png_sPLT_t)); |
if (np == NULL) |
{ |
png_warning(png_ptr, "No memory for sPLT palettes."); |
return; |
} |
png_memcpy(np, info_ptr->splt_palettes, |
info_ptr->splt_palettes_num * sizeof(png_sPLT_t)); |
png_free(png_ptr, info_ptr->splt_palettes); |
info_ptr->splt_palettes=NULL; |
for (i = 0; i < nentries; i++) |
{ |
png_sPLT_tp to = np + info_ptr->splt_palettes_num + i; |
png_sPLT_tp from = entries + i; |
to->name = (png_charp)png_malloc(png_ptr, |
png_strlen(from->name) + 1); |
png_strcpy(to->name, from->name); |
to->entries = (png_sPLT_entryp)png_malloc(png_ptr, |
from->nentries * sizeof(png_sPLT_t)); |
png_memcpy(to->entries, from->entries, |
from->nentries * sizeof(png_sPLT_t)); |
to->nentries = from->nentries; |
to->depth = from->depth; |
} |
info_ptr->splt_palettes = np; |
info_ptr->splt_palettes_num += nentries; |
info_ptr->valid |= PNG_INFO_sPLT; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_SPLT; |
#endif |
} |
#endif /* PNG_sPLT_SUPPORTED */ |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
void PNGAPI |
png_set_unknown_chunks(png_structp png_ptr, |
png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns) |
{ |
png_unknown_chunkp np; |
int i; |
if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0) |
return; |
np = (png_unknown_chunkp)png_malloc_warn(png_ptr, |
(info_ptr->unknown_chunks_num + num_unknowns) * |
sizeof(png_unknown_chunk)); |
if (np == NULL) |
{ |
png_warning(png_ptr, "Out of memory while processing unknown chunk."); |
return; |
} |
png_memcpy(np, info_ptr->unknown_chunks, |
info_ptr->unknown_chunks_num * sizeof(png_unknown_chunk)); |
png_free(png_ptr, info_ptr->unknown_chunks); |
info_ptr->unknown_chunks=NULL; |
for (i = 0; i < num_unknowns; i++) |
{ |
png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i; |
png_unknown_chunkp from = unknowns + i; |
png_strcpy((png_charp)to->name, (png_charp)from->name); |
to->data = (png_bytep)png_malloc(png_ptr, from->size); |
if (to->data == NULL) |
png_warning(png_ptr, "Out of memory while processing unknown chunk."); |
else |
{ |
png_memcpy(to->data, from->data, from->size); |
to->size = from->size; |
/* note our location in the read or write sequence */ |
to->location = (png_byte)(png_ptr->mode & 0xff); |
} |
} |
info_ptr->unknown_chunks = np; |
info_ptr->unknown_chunks_num += num_unknowns; |
#ifdef PNG_FREE_ME_SUPPORTED |
info_ptr->free_me |= PNG_FREE_UNKN; |
#endif |
} |
void PNGAPI |
png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr, |
int chunk, int location) |
{ |
if(png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk < |
(int)info_ptr->unknown_chunks_num) |
info_ptr->unknown_chunks[chunk].location = (png_byte)location; |
} |
#endif |
#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ |
defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) |
void PNGAPI |
png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted) |
{ |
/* This function is deprecated in favor of png_permit_mng_features() |
and will be removed from libpng-2.0.0 */ |
png_debug(1, "in png_permit_empty_plte, DEPRECATED.\n"); |
if (png_ptr == NULL) |
return; |
png_ptr->mng_features_permitted = (png_byte) |
((png_ptr->mng_features_permitted & (~(PNG_FLAG_MNG_EMPTY_PLTE))) | |
((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE))); |
} |
#endif |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
png_uint_32 PNGAPI |
png_permit_mng_features (png_structp png_ptr, png_uint_32 mng_features) |
{ |
png_debug(1, "in png_permit_mng_features\n"); |
if (png_ptr == NULL) |
return (png_uint_32)0; |
png_ptr->mng_features_permitted = |
(png_byte)(mng_features & PNG_ALL_MNG_FEATURES); |
return (png_uint_32)png_ptr->mng_features_permitted; |
} |
#endif |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
void PNGAPI |
png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep |
chunk_list, int num_chunks) |
{ |
png_bytep new_list, p; |
int i, old_num_chunks; |
if (num_chunks == 0) |
{ |
if(keep == HANDLE_CHUNK_ALWAYS || keep == HANDLE_CHUNK_IF_SAFE) |
png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS; |
else |
png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS; |
if(keep == HANDLE_CHUNK_ALWAYS) |
png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS; |
else |
png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS; |
return; |
} |
if (chunk_list == NULL) |
return; |
old_num_chunks=png_ptr->num_chunk_list; |
new_list=(png_bytep)png_malloc(png_ptr, |
(png_uint_32)(5*(num_chunks+old_num_chunks))); |
if(png_ptr->chunk_list != NULL) |
{ |
png_memcpy(new_list, png_ptr->chunk_list, |
(png_size_t)(5*old_num_chunks)); |
png_free(png_ptr, png_ptr->chunk_list); |
png_ptr->chunk_list=NULL; |
} |
png_memcpy(new_list+5*old_num_chunks, chunk_list, |
(png_size_t)(5*num_chunks)); |
for (p=new_list+5*old_num_chunks+4, i=0; i<num_chunks; i++, p+=5) |
*p=(png_byte)keep; |
png_ptr->num_chunk_list=old_num_chunks+num_chunks; |
png_ptr->chunk_list=new_list; |
#ifdef PNG_FREE_ME_SUPPORTED |
png_ptr->free_me |= PNG_FREE_LIST; |
#endif |
} |
#endif |
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
void PNGAPI |
png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr, |
png_user_chunk_ptr read_user_chunk_fn) |
{ |
png_debug(1, "in png_set_read_user_chunk_fn\n"); |
png_ptr->read_user_chunk_fn = read_user_chunk_fn; |
png_ptr->user_chunk_ptr = user_chunk_ptr; |
} |
#endif |
#if defined(PNG_INFO_IMAGE_SUPPORTED) |
void PNGAPI |
png_set_rows(png_structp png_ptr, png_infop info_ptr, png_bytepp row_pointers) |
{ |
png_debug1(1, "in %s storage function\n", "rows"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if(info_ptr->row_pointers && (info_ptr->row_pointers != row_pointers)) |
png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); |
info_ptr->row_pointers = row_pointers; |
if(row_pointers) |
info_ptr->valid |= PNG_INFO_IDAT; |
} |
#endif |
void PNGAPI |
png_set_compression_buffer_size(png_structp png_ptr, png_uint_32 size) |
{ |
if(png_ptr->zbuf) |
png_free(png_ptr, png_ptr->zbuf); |
png_ptr->zbuf_size = (png_size_t)size; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
void PNGAPI |
png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask) |
{ |
if (png_ptr && info_ptr) |
info_ptr->valid &= ~(mask); |
} |
#ifndef PNG_1_0_X |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
/* this function was added to libpng 1.2.0 and should always exist by default */ |
void PNGAPI |
png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags) |
{ |
png_uint_32 settable_asm_flags; |
png_uint_32 settable_mmx_flags; |
settable_mmx_flags = |
#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
PNG_ASM_FLAG_MMX_READ_COMBINE_ROW | |
#endif |
#ifdef PNG_HAVE_ASSEMBLER_READ_INTERLACE |
PNG_ASM_FLAG_MMX_READ_INTERLACE | |
#endif |
#ifdef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
PNG_ASM_FLAG_MMX_READ_FILTER_SUB | |
PNG_ASM_FLAG_MMX_READ_FILTER_UP | |
PNG_ASM_FLAG_MMX_READ_FILTER_AVG | |
PNG_ASM_FLAG_MMX_READ_FILTER_PAETH | |
#endif |
0; |
/* could be some non-MMX ones in the future, but not currently: */ |
settable_asm_flags = settable_mmx_flags; |
if (!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED) || |
!(png_ptr->asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU)) |
{ |
/* clear all MMX flags if MMX isn't supported */ |
settable_asm_flags &= ~settable_mmx_flags; |
png_ptr->asm_flags &= ~settable_mmx_flags; |
} |
/* we're replacing the settable bits with those passed in by the user, |
* so first zero them out of the master copy, then logical-OR in the |
* allowed subset that was requested */ |
png_ptr->asm_flags &= ~settable_asm_flags; /* zero them */ |
png_ptr->asm_flags |= (asm_flags & settable_asm_flags); /* set them */ |
} |
#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ |
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED |
/* this function was added to libpng 1.2.0 */ |
void PNGAPI |
png_set_mmx_thresholds (png_structp png_ptr, |
png_byte mmx_bitdepth_threshold, |
png_uint_32 mmx_rowbytes_threshold) |
{ |
png_ptr->mmx_bitdepth_threshold = mmx_bitdepth_threshold; |
png_ptr->mmx_rowbytes_threshold = mmx_rowbytes_threshold; |
} |
#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ |
#endif /* ?PNG_1_0_X */ |
/shark/trunk/ports/png/pngwio.c |
---|
0,0 → 1,228 |
/* pngwio.c - functions for data output |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file provides a location for all output. Users who need |
* special handling are expected to write functions that have the same |
* arguments as these and perform similar functions, but that possibly |
* use different output methods. Note that you shouldn't change these |
* functions, but rather write replacement functions and then change |
* them at run time with png_set_write_fn(...). |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#ifdef PNG_WRITE_SUPPORTED |
/* Write the data to whatever output you are using. The default routine |
writes to a file pointer. Note that this routine sometimes gets called |
with very small lengths, so you should implement some kind of simple |
buffering if you are using unbuffered writes. This should never be asked |
to write more than 64K on a 16 bit machine. */ |
void /* PRIVATE */ |
png_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
if (png_ptr->write_data_fn != NULL ) |
(*(png_ptr->write_data_fn))(png_ptr, data, length); |
else |
png_error(png_ptr, "Call to NULL write function"); |
} |
#if !defined(PNG_NO_STDIO) |
/* This is the function that does the actual writing of data. If you are |
not writing to a standard C stream, you should create a replacement |
write_data function and use it at run time with png_set_write_fn(), rather |
than changing the library. */ |
#ifndef USE_FAR_KEYWORD |
void PNGAPI |
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_uint_32 check; |
#if defined(_WIN32_WCE) |
if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) |
check = 0; |
#else |
check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr)); |
#endif |
if (check != length) |
png_error(png_ptr, "Write Error"); |
} |
#else |
/* this is the model-independent version. Since the standard I/O library |
can't handle far buffers in the medium and small models, we have to copy |
the data. |
*/ |
#define NEAR_BUF_SIZE 1024 |
#define MIN(a,b) (a <= b ? a : b) |
void PNGAPI |
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_uint_32 check; |
png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ |
png_FILE_p io_ptr; |
/* Check if data really is near. If so, use usual code. */ |
near_data = (png_byte *)CVT_PTR_NOCHECK(data); |
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
if ((png_bytep)near_data == data) |
{ |
#if defined(_WIN32_WCE) |
if ( !WriteFile(io_ptr, near_data, length, &check, NULL) ) |
check = 0; |
#else |
check = fwrite(near_data, 1, length, io_ptr); |
#endif |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t written, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
written = MIN(NEAR_BUF_SIZE, remaining); |
png_memcpy(buf, data, written); /* copy far buffer to near buffer */ |
#if defined(_WIN32_WCE) |
if ( !WriteFile(io_ptr, buf, written, &err, NULL) ) |
err = 0; |
#else |
err = fwrite(buf, 1, written, io_ptr); |
#endif |
if (err != written) |
break; |
else |
check += err; |
data += written; |
remaining -= written; |
} |
while (remaining != 0); |
} |
if (check != length) |
png_error(png_ptr, "Write Error"); |
} |
#endif |
#endif |
/* This function is called to output any data pending writing (normally |
to disk). After png_flush is called, there should be no data pending |
writing in any buffers. */ |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
void /* PRIVATE */ |
png_flush(png_structp png_ptr) |
{ |
if (png_ptr->output_flush_fn != NULL) |
(*(png_ptr->output_flush_fn))(png_ptr); |
} |
#if !defined(PNG_NO_STDIO) |
void PNGAPI |
png_default_flush(png_structp png_ptr) |
{ |
#if !defined(_WIN32_WCE) |
png_FILE_p io_ptr; |
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); |
if (io_ptr != NULL) |
fflush(io_ptr); |
#endif |
} |
#endif |
#endif |
/* This function allows the application to supply new output functions for |
libpng if standard C streams aren't being used. |
This function takes as its arguments: |
png_ptr - pointer to a png output data structure |
io_ptr - pointer to user supplied structure containing info about |
the output functions. May be NULL. |
write_data_fn - pointer to a new output function that takes as its |
arguments a pointer to a png_struct, a pointer to |
data to be written, and a 32-bit unsigned int that is |
the number of bytes to be written. The new write |
function should call png_error(png_ptr, "Error msg") |
to exit and output any fatal error messages. |
flush_data_fn - pointer to a new flush function that takes as its |
arguments a pointer to a png_struct. After a call to |
the flush function, there should be no data in any buffers |
or pending transmission. If the output method doesn't do |
any buffering of ouput, a function prototype must still be |
supplied although it doesn't have to do anything. If |
PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile |
time, output_flush_fn will be ignored, although it must be |
supplied for compatibility. */ |
void PNGAPI |
png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, |
png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn) |
{ |
png_ptr->io_ptr = io_ptr; |
#if !defined(PNG_NO_STDIO) |
if (write_data_fn != NULL) |
png_ptr->write_data_fn = write_data_fn; |
else |
png_ptr->write_data_fn = png_default_write_data; |
#else |
png_ptr->write_data_fn = write_data_fn; |
#endif |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
#if !defined(PNG_NO_STDIO) |
if (output_flush_fn != NULL) |
png_ptr->output_flush_fn = output_flush_fn; |
else |
png_ptr->output_flush_fn = png_default_flush; |
#else |
png_ptr->output_flush_fn = output_flush_fn; |
#endif |
#endif /* PNG_WRITE_FLUSH_SUPPORTED */ |
/* It is an error to read while writing a png file */ |
if (png_ptr->read_data_fn != NULL) |
{ |
png_ptr->read_data_fn = NULL; |
png_warning(png_ptr, |
"Attempted to set both read_data_fn and write_data_fn in"); |
png_warning(png_ptr, |
"the same structure. Resetting read_data_fn to NULL."); |
} |
} |
#if defined(USE_FAR_KEYWORD) |
#if defined(_MSC_VER) |
void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check) |
{ |
void *near_ptr; |
void FAR *far_ptr; |
FP_OFF(near_ptr) = FP_OFF(ptr); |
far_ptr = (void FAR *)near_ptr; |
if(check != 0) |
if(FP_SEG(ptr) != FP_SEG(far_ptr)) |
png_error(png_ptr,"segment lost in conversion"); |
return(near_ptr); |
} |
# else |
void *png_far_to_near(png_structp png_ptr,png_voidp ptr, int check) |
{ |
void *near_ptr; |
void FAR *far_ptr; |
near_ptr = (void FAR *)ptr; |
far_ptr = (void FAR *)near_ptr; |
if(check != 0) |
if(far_ptr != ptr) |
png_error(png_ptr,"segment lost in conversion"); |
return(near_ptr); |
} |
# endif |
# endif |
#endif /* PNG_WRITE_SUPPORTED */ |
/shark/trunk/ports/png/pngrutil.c |
---|
0,0 → 1,3101 |
/* pngrutil.c - utilities to read a PNG file |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file contains routines that are only called from within |
* libpng itself during the course of reading an image. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#if defined(_WIN32_WCE) |
/* strtod() function is not supported on WindowsCE */ |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
__inline double strtod(const char *nptr, char **endptr) |
{ |
double result = 0; |
int len; |
wchar_t *str, *end; |
len = MultiByteToWideChar(CP_ACP, 0, nptr, -1, NULL, 0); |
str = (wchar_t *)malloc(len * sizeof(wchar_t)); |
if ( NULL != str ) |
{ |
MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len); |
result = wcstod(str, &end); |
len = WideCharToMultiByte(CP_ACP, 0, end, -1, NULL, 0, NULL, NULL); |
*endptr = (char *)nptr + (png_strlen(nptr) - len + 1); |
free(str); |
} |
return result; |
} |
# endif |
#endif |
#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED |
/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */ |
png_uint_32 /* PRIVATE */ |
png_get_uint_32(png_bytep buf) |
{ |
png_uint_32 i = ((png_uint_32)(*buf) << 24) + |
((png_uint_32)(*(buf + 1)) << 16) + |
((png_uint_32)(*(buf + 2)) << 8) + |
(png_uint_32)(*(buf + 3)); |
return (i); |
} |
#if defined(PNG_READ_pCAL_SUPPORTED) || defined(PNG_READ_oFFs_SUPPORTED) |
/* Grab a signed 32-bit integer from a buffer in big-endian format. The |
* data is stored in the PNG file in two's complement format, and it is |
* assumed that the machine format for signed integers is the same. */ |
png_int_32 /* PRIVATE */ |
png_get_int_32(png_bytep buf) |
{ |
png_int_32 i = ((png_int_32)(*buf) << 24) + |
((png_int_32)(*(buf + 1)) << 16) + |
((png_int_32)(*(buf + 2)) << 8) + |
(png_int_32)(*(buf + 3)); |
return (i); |
} |
#endif /* PNG_READ_pCAL_SUPPORTED */ |
/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */ |
png_uint_16 /* PRIVATE */ |
png_get_uint_16(png_bytep buf) |
{ |
png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) + |
(png_uint_16)(*(buf + 1))); |
return (i); |
} |
#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */ |
/* Read data, and (optionally) run it through the CRC. */ |
void /* PRIVATE */ |
png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length) |
{ |
png_read_data(png_ptr, buf, length); |
png_calculate_crc(png_ptr, buf, length); |
} |
/* Optionally skip data and then check the CRC. Depending on whether we |
are reading a ancillary or critical chunk, and how the program has set |
things up, we may calculate the CRC on the data and print a message. |
Returns '1' if there was a CRC error, '0' otherwise. */ |
int /* PRIVATE */ |
png_crc_finish(png_structp png_ptr, png_uint_32 skip) |
{ |
png_size_t i; |
png_size_t istop = png_ptr->zbuf_size; |
for (i = (png_size_t)skip; i > istop; i -= istop) |
{ |
png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
} |
if (i) |
{ |
png_crc_read(png_ptr, png_ptr->zbuf, i); |
} |
if (png_crc_error(png_ptr)) |
{ |
if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */ |
!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) || |
(!(png_ptr->chunk_name[0] & 0x20) && /* Critical */ |
(png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))) |
{ |
png_chunk_warning(png_ptr, "CRC error"); |
} |
else |
{ |
png_chunk_error(png_ptr, "CRC error"); |
} |
return (1); |
} |
return (0); |
} |
/* Compare the CRC stored in the PNG file with that calculated by libpng from |
the data it has read thus far. */ |
int /* PRIVATE */ |
png_crc_error(png_structp png_ptr) |
{ |
png_byte crc_bytes[4]; |
png_uint_32 crc; |
int need_crc = 1; |
if (png_ptr->chunk_name[0] & 0x20) /* ancillary */ |
{ |
if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) == |
(PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
need_crc = 0; |
} |
else /* critical */ |
{ |
if (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) |
need_crc = 0; |
} |
png_read_data(png_ptr, crc_bytes, 4); |
if (need_crc) |
{ |
crc = png_get_uint_32(crc_bytes); |
return ((int)(crc != png_ptr->crc)); |
} |
else |
return (0); |
} |
#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \ |
defined(PNG_READ_iCCP_SUPPORTED) |
/* |
* Decompress trailing data in a chunk. The assumption is that chunkdata |
* points at an allocated area holding the contents of a chunk with a |
* trailing compressed part. What we get back is an allocated area |
* holding the original prefix part and an uncompressed version of the |
* trailing part (the malloc area passed in is freed). |
*/ |
png_charp /* PRIVATE */ |
png_decompress_chunk(png_structp png_ptr, int comp_type, |
png_charp chunkdata, png_size_t chunklength, |
png_size_t prefix_size, png_size_t *newlength) |
{ |
static char msg[] = "Error decoding compressed text"; |
png_charp text = NULL; |
png_size_t text_size; |
if (comp_type == PNG_COMPRESSION_TYPE_BASE) |
{ |
int ret = Z_OK; |
png_ptr->zstream.next_in = (png_bytep)(chunkdata + prefix_size); |
png_ptr->zstream.avail_in = (uInt)(chunklength - prefix_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
text_size = 0; |
text = NULL; |
while (png_ptr->zstream.avail_in) |
{ |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret != Z_OK && ret != Z_STREAM_END) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_warning(png_ptr, png_ptr->zstream.msg); |
else |
png_warning(png_ptr, msg); |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.avail_in = 0; |
if (text == NULL) |
{ |
text_size = prefix_size + sizeof(msg) + 1; |
text = (png_charp)png_malloc_warn(png_ptr, text_size); |
if (text == NULL) |
{ |
png_free(png_ptr,chunkdata); |
png_error(png_ptr,"Not enough memory to decompress chunk"); |
} |
png_memcpy(text, chunkdata, prefix_size); |
} |
text[text_size - 1] = 0x00; |
/* Copy what we can of the error message into the text chunk */ |
text_size = (png_size_t)(chunklength - (text - chunkdata) - 1); |
text_size = sizeof(msg) > text_size ? text_size : sizeof(msg); |
png_memcpy(text + prefix_size, msg, text_size + 1); |
break; |
} |
if (!png_ptr->zstream.avail_out || ret == Z_STREAM_END) |
{ |
if (text == NULL) |
{ |
text_size = prefix_size + |
png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
text = (png_charp)png_malloc_warn(png_ptr, text_size + 1); |
if (text == NULL) |
{ |
png_free(png_ptr,chunkdata); |
png_error(png_ptr,"Not enough memory to decompress chunk."); |
} |
png_memcpy(text + prefix_size, png_ptr->zbuf, |
text_size - prefix_size); |
png_memcpy(text, chunkdata, prefix_size); |
*(text + text_size) = 0x00; |
} |
else |
{ |
png_charp tmp; |
tmp = text; |
text = (png_charp)png_malloc_warn(png_ptr, |
(png_uint_32)(text_size + |
png_ptr->zbuf_size - png_ptr->zstream.avail_out + 1)); |
if (text == NULL) |
{ |
png_free(png_ptr, tmp); |
png_free(png_ptr, chunkdata); |
png_error(png_ptr,"Not enough memory to decompress chunk.."); |
} |
png_memcpy(text, tmp, text_size); |
png_free(png_ptr, tmp); |
png_memcpy(text + text_size, png_ptr->zbuf, |
(png_ptr->zbuf_size - png_ptr->zstream.avail_out)); |
text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
*(text + text_size) = 0x00; |
} |
if (ret == Z_STREAM_END) |
break; |
else |
{ |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
} |
} |
if (ret != Z_STREAM_END) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char umsg[50]; |
if (ret == Z_BUF_ERROR) |
sprintf(umsg,"Buffer error in compressed datastream in %s chunk", |
png_ptr->chunk_name); |
else if (ret == Z_DATA_ERROR) |
sprintf(umsg,"Data error in compressed datastream in %s chunk", |
png_ptr->chunk_name); |
else |
sprintf(umsg,"Incomplete compressed datastream in %s chunk", |
png_ptr->chunk_name); |
png_warning(png_ptr, umsg); |
#else |
png_warning(png_ptr, |
"Incomplete compressed datastream in chunk other than IDAT"); |
#endif |
text_size=prefix_size; |
if (text == NULL) |
{ |
text = (png_charp)png_malloc_warn(png_ptr, text_size+1); |
if (text == NULL) |
{ |
png_free(png_ptr, chunkdata); |
png_error(png_ptr,"Not enough memory for text."); |
} |
png_memcpy(text, chunkdata, prefix_size); |
} |
*(text + text_size) = 0x00; |
} |
inflateReset(&png_ptr->zstream); |
png_ptr->zstream.avail_in = 0; |
png_free(png_ptr, chunkdata); |
chunkdata = text; |
*newlength=text_size; |
} |
else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */ |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char umsg[50]; |
sprintf(umsg, "Unknown zTXt compression type %d", comp_type); |
png_warning(png_ptr, umsg); |
#else |
png_warning(png_ptr, "Unknown zTXt compression type"); |
#endif |
*(chunkdata + prefix_size) = 0x00; |
*newlength=prefix_size; |
} |
return chunkdata; |
} |
#endif |
/* read and check the IDHR chunk */ |
void /* PRIVATE */ |
png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[13]; |
png_uint_32 width, height; |
int bit_depth, color_type, compression_type, filter_type; |
int interlace_type; |
png_debug(1, "in png_handle_IHDR\n"); |
if (png_ptr->mode & PNG_HAVE_IHDR) |
png_error(png_ptr, "Out of place IHDR"); |
/* check the length */ |
if (length != 13) |
png_error(png_ptr, "Invalid IHDR chunk"); |
png_ptr->mode |= PNG_HAVE_IHDR; |
png_crc_read(png_ptr, buf, 13); |
png_crc_finish(png_ptr, 0); |
width = png_get_uint_32(buf); |
height = png_get_uint_32(buf + 4); |
bit_depth = buf[8]; |
color_type = buf[9]; |
compression_type = buf[10]; |
filter_type = buf[11]; |
interlace_type = buf[12]; |
/* set internal variables */ |
png_ptr->width = width; |
png_ptr->height = height; |
png_ptr->bit_depth = (png_byte)bit_depth; |
png_ptr->interlaced = (png_byte)interlace_type; |
png_ptr->color_type = (png_byte)color_type; |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
png_ptr->filter_type = (png_byte)filter_type; |
#endif |
/* find number of channels */ |
switch (png_ptr->color_type) |
{ |
case PNG_COLOR_TYPE_GRAY: |
case PNG_COLOR_TYPE_PALETTE: |
png_ptr->channels = 1; |
break; |
case PNG_COLOR_TYPE_RGB: |
png_ptr->channels = 3; |
break; |
case PNG_COLOR_TYPE_GRAY_ALPHA: |
png_ptr->channels = 2; |
break; |
case PNG_COLOR_TYPE_RGB_ALPHA: |
png_ptr->channels = 4; |
break; |
} |
/* set up other useful info */ |
png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * |
png_ptr->channels); |
png_ptr->rowbytes = ((png_ptr->width * |
(png_uint_32)png_ptr->pixel_depth + 7) >> 3); |
png_debug1(3,"bit_depth = %d\n", png_ptr->bit_depth); |
png_debug1(3,"channels = %d\n", png_ptr->channels); |
png_debug1(3,"rowbytes = %lu\n", png_ptr->rowbytes); |
png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, |
color_type, interlace_type, compression_type, filter_type); |
} |
/* read and check the palette */ |
void /* PRIVATE */ |
png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_color palette[PNG_MAX_PALETTE_LENGTH]; |
int num, i; |
#ifndef PNG_NO_POINTER_INDEXING |
png_colorp pal_ptr; |
#endif |
png_debug(1, "in png_handle_PLTE\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before PLTE"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid PLTE after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
png_error(png_ptr, "Duplicate PLTE chunk"); |
png_ptr->mode |= PNG_HAVE_PLTE; |
if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) |
{ |
png_warning(png_ptr, |
"Ignoring PLTE chunk in grayscale PNG"); |
png_crc_finish(png_ptr, length); |
return; |
} |
#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) |
if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
png_crc_finish(png_ptr, length); |
return; |
} |
#endif |
if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3) |
{ |
if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
png_warning(png_ptr, "Invalid palette chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else |
{ |
png_error(png_ptr, "Invalid palette chunk"); |
} |
} |
num = (int)length / 3; |
#ifndef PNG_NO_POINTER_INDEXING |
for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++) |
{ |
png_byte buf[3]; |
png_crc_read(png_ptr, buf, 3); |
pal_ptr->red = buf[0]; |
pal_ptr->green = buf[1]; |
pal_ptr->blue = buf[2]; |
} |
#else |
for (i = 0; i < num; i++) |
{ |
png_byte buf[3]; |
png_crc_read(png_ptr, buf, 3); |
/* don't depend upon png_color being any order */ |
palette[i].red = buf[0]; |
palette[i].green = buf[1]; |
palette[i].blue = buf[2]; |
} |
#endif |
/* If we actually NEED the PLTE chunk (ie for a paletted image), we do |
whatever the normal CRC configuration tells us. However, if we |
have an RGB image, the PLTE can be considered ancillary, so |
we will act as though it is. */ |
#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
#endif |
{ |
png_crc_finish(png_ptr, 0); |
} |
#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) |
else if (png_crc_error(png_ptr)) /* Only if we have a CRC error */ |
{ |
/* If we don't want to use the data from an ancillary chunk, |
we have two options: an error abort, or a warning and we |
ignore the data in this chunk (which should be OK, since |
it's considered ancillary for a RGB or RGBA image). */ |
if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE)) |
{ |
if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) |
{ |
png_chunk_error(png_ptr, "CRC error"); |
} |
else |
{ |
png_chunk_warning(png_ptr, "CRC error"); |
return; |
} |
} |
/* Otherwise, we (optionally) emit a warning and use the chunk. */ |
else if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) |
{ |
png_chunk_warning(png_ptr, "CRC error"); |
} |
} |
#endif |
png_set_PLTE(png_ptr, info_ptr, palette, num); |
#if defined(PNG_READ_tRNS_SUPPORTED) |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) |
{ |
if (png_ptr->num_trans > (png_uint_16)num) |
{ |
png_warning(png_ptr, "Truncating incorrect tRNS chunk length"); |
png_ptr->num_trans = (png_uint_16)num; |
} |
if (info_ptr->num_trans > (png_uint_16)num) |
{ |
png_warning(png_ptr, "Truncating incorrect info tRNS chunk length"); |
info_ptr->num_trans = (png_uint_16)num; |
} |
} |
} |
#endif |
} |
void /* PRIVATE */ |
png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_debug(1, "in png_handle_IEND\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT)) |
{ |
png_error(png_ptr, "No image in file"); |
info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */ |
} |
png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND); |
if (length != 0) |
{ |
png_warning(png_ptr, "Incorrect IEND chunk length"); |
} |
png_crc_finish(png_ptr, length); |
} |
#if defined(PNG_READ_gAMA_SUPPORTED) |
void /* PRIVATE */ |
png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_fixed_point igamma; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float file_gamma; |
#endif |
png_byte buf[4]; |
png_debug(1, "in png_handle_gAMA\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before gAMA"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid gAMA after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place gAMA chunk"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
#if defined(PNG_READ_sRGB_SUPPORTED) |
&& !(info_ptr->valid & PNG_INFO_sRGB) |
#endif |
) |
{ |
png_warning(png_ptr, "Duplicate gAMA chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 4) |
{ |
png_warning(png_ptr, "Incorrect gAMA chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 4); |
if (png_crc_finish(png_ptr, 0)) |
return; |
igamma = (png_fixed_point)png_get_uint_32(buf); |
/* check for zero gamma */ |
if (igamma == 0) |
{ |
png_warning(png_ptr, |
"Ignoring gAMA chunk with gamma=0"); |
return; |
} |
#if defined(PNG_READ_sRGB_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sRGB) |
if(igamma < 45000L || igamma > 46000L) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect gAMA value when sRGB is also present"); |
#ifndef PNG_NO_CONSOLE_IO |
cprintf("gamma = (%d/100000)\n", (int)igamma); |
#endif |
return; |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
file_gamma = (float)igamma / (float)100000.0; |
# ifdef PNG_READ_GAMMA_SUPPORTED |
png_ptr->gamma = file_gamma; |
# endif |
png_set_gAMA(png_ptr, info_ptr, file_gamma); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_set_gAMA_fixed(png_ptr, info_ptr, igamma); |
#endif |
} |
#endif |
#if defined(PNG_READ_sBIT_SUPPORTED) |
void /* PRIVATE */ |
png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_size_t truelen; |
png_byte buf[4]; |
png_debug(1, "in png_handle_sBIT\n"); |
buf[0] = buf[1] = buf[2] = buf[3] = 0; |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sBIT"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid sBIT after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
{ |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place sBIT chunk"); |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT)) |
{ |
png_warning(png_ptr, "Duplicate sBIT chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
truelen = 3; |
else |
truelen = (png_size_t)png_ptr->channels; |
if (length != truelen) |
{ |
png_warning(png_ptr, "Incorrect sBIT chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, truelen); |
if (png_crc_finish(png_ptr, 0)) |
return; |
if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) |
{ |
png_ptr->sig_bit.red = buf[0]; |
png_ptr->sig_bit.green = buf[1]; |
png_ptr->sig_bit.blue = buf[2]; |
png_ptr->sig_bit.alpha = buf[3]; |
} |
else |
{ |
png_ptr->sig_bit.gray = buf[0]; |
png_ptr->sig_bit.red = buf[0]; |
png_ptr->sig_bit.green = buf[0]; |
png_ptr->sig_bit.blue = buf[0]; |
png_ptr->sig_bit.alpha = buf[1]; |
} |
png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit)); |
} |
#endif |
#if defined(PNG_READ_cHRM_SUPPORTED) |
void /* PRIVATE */ |
png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[4]; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; |
#endif |
png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, |
int_y_green, int_x_blue, int_y_blue; |
png_uint_32 uint_x, uint_y; |
png_debug(1, "in png_handle_cHRM\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before cHRM"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid cHRM after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Missing PLTE before cHRM"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM) |
#if defined(PNG_READ_sRGB_SUPPORTED) |
&& !(info_ptr->valid & PNG_INFO_sRGB) |
#endif |
) |
{ |
png_warning(png_ptr, "Duplicate cHRM chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 32) |
{ |
png_warning(png_ptr, "Incorrect cHRM chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 4); |
uint_x = png_get_uint_32(buf); |
png_crc_read(png_ptr, buf, 4); |
uint_y = png_get_uint_32(buf); |
if (uint_x > 80000L || uint_y > 80000L || |
uint_x + uint_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid cHRM white point"); |
png_crc_finish(png_ptr, 24); |
return; |
} |
int_x_white = (png_fixed_point)uint_x; |
int_y_white = (png_fixed_point)uint_y; |
png_crc_read(png_ptr, buf, 4); |
uint_x = png_get_uint_32(buf); |
png_crc_read(png_ptr, buf, 4); |
uint_y = png_get_uint_32(buf); |
if (uint_x > 80000L || uint_y > 80000L || |
uint_x + uint_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid cHRM red point"); |
png_crc_finish(png_ptr, 16); |
return; |
} |
int_x_red = (png_fixed_point)uint_x; |
int_y_red = (png_fixed_point)uint_y; |
png_crc_read(png_ptr, buf, 4); |
uint_x = png_get_uint_32(buf); |
png_crc_read(png_ptr, buf, 4); |
uint_y = png_get_uint_32(buf); |
if (uint_x > 80000L || uint_y > 80000L || |
uint_x + uint_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid cHRM green point"); |
png_crc_finish(png_ptr, 8); |
return; |
} |
int_x_green = (png_fixed_point)uint_x; |
int_y_green = (png_fixed_point)uint_y; |
png_crc_read(png_ptr, buf, 4); |
uint_x = png_get_uint_32(buf); |
png_crc_read(png_ptr, buf, 4); |
uint_y = png_get_uint_32(buf); |
if (uint_x > 80000L || uint_y > 80000L || |
uint_x + uint_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid cHRM blue point"); |
png_crc_finish(png_ptr, 0); |
return; |
} |
int_x_blue = (png_fixed_point)uint_x; |
int_y_blue = (png_fixed_point)uint_y; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
white_x = (float)int_x_white / (float)100000.0; |
white_y = (float)int_y_white / (float)100000.0; |
red_x = (float)int_x_red / (float)100000.0; |
red_y = (float)int_y_red / (float)100000.0; |
green_x = (float)int_x_green / (float)100000.0; |
green_y = (float)int_y_green / (float)100000.0; |
blue_x = (float)int_x_blue / (float)100000.0; |
blue_y = (float)int_y_blue / (float)100000.0; |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
if (info_ptr->valid & PNG_INFO_sRGB) |
{ |
if (abs(int_x_white - 31270L) > 1000 || |
abs(int_y_white - 32900L) > 1000 || |
abs(int_x_red - 64000L) > 1000 || |
abs(int_y_red - 33000L) > 1000 || |
abs(int_x_green - 30000L) > 1000 || |
abs(int_y_green - 60000L) > 1000 || |
abs(int_x_blue - 15000L) > 1000 || |
abs(int_y_blue - 6000L) > 1000) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect cHRM value when sRGB is also present"); |
#ifndef PNG_NO_CONSOLE_IO |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
cprintf("wx=%f, wy=%f, rx=%f, ry=%f\n", |
white_x, white_y, red_x, red_y); |
cprintf("gx=%f, gy=%f, bx=%f, by=%f\n", |
green_x, green_y, blue_x, blue_y); |
#else |
cprintf("wx=%ld, wy=%ld, rx=%ld, ry=%ld\n", |
int_x_white, int_y_white, int_x_red, int_y_red); |
cprintf("gx=%ld, gy=%ld, bx=%ld, by=%ld\n", |
int_x_green, int_y_green, int_x_blue, int_y_blue); |
#endif |
#endif /* PNG_NO_CONSOLE_IO */ |
} |
png_crc_finish(png_ptr, 0); |
return; |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_set_cHRM(png_ptr, info_ptr, |
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_set_cHRM_fixed(png_ptr, info_ptr, |
int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, |
int_y_green, int_x_blue, int_y_blue); |
#endif |
if (png_crc_finish(png_ptr, 0)) |
return; |
} |
#endif |
#if defined(PNG_READ_sRGB_SUPPORTED) |
void /* PRIVATE */ |
png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
int intent; |
png_byte buf[1]; |
png_debug(1, "in png_handle_sRGB\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sRGB"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid sRGB after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place sRGB chunk"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) |
{ |
png_warning(png_ptr, "Duplicate sRGB chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 1) |
{ |
png_warning(png_ptr, "Incorrect sRGB chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 1); |
if (png_crc_finish(png_ptr, 0)) |
return; |
intent = buf[0]; |
/* check for bad intent */ |
if (intent >= PNG_sRGB_INTENT_LAST) |
{ |
png_warning(png_ptr, "Unknown sRGB intent"); |
return; |
} |
#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) |
if ((info_ptr->valid & PNG_INFO_gAMA)) |
{ |
int igamma; |
#ifdef PNG_FIXED_POINT_SUPPORTED |
igamma=(int)info_ptr->int_gamma; |
#else |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
igamma=(int)(info_ptr->gamma * 100000.); |
# endif |
#endif |
if(igamma < 45000L || igamma > 46000L) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect gAMA value when sRGB is also present"); |
#ifndef PNG_NO_CONSOLE_IO |
# ifdef PNG_FIXED_POINT_SUPPORTED |
cprintf("incorrect gamma=(%d/100000)\n",(int)png_ptr->int_gamma); |
# else |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
cprintf("incorrect gamma=%f\n",png_ptr->gamma); |
# endif |
# endif |
#endif |
} |
} |
#endif /* PNG_READ_gAMA_SUPPORTED */ |
#ifdef PNG_READ_cHRM_SUPPORTED |
#ifdef PNG_FIXED_POINT_SUPPORTED |
if (info_ptr->valid & PNG_INFO_cHRM) |
if (abs(info_ptr->int_x_white - 31270L) > 1000 || |
abs(info_ptr->int_y_white - 32900L) > 1000 || |
abs(info_ptr->int_x_red - 64000L) > 1000 || |
abs(info_ptr->int_y_red - 33000L) > 1000 || |
abs(info_ptr->int_x_green - 30000L) > 1000 || |
abs(info_ptr->int_y_green - 60000L) > 1000 || |
abs(info_ptr->int_x_blue - 15000L) > 1000 || |
abs(info_ptr->int_y_blue - 6000L) > 1000) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect cHRM value when sRGB is also present"); |
} |
#endif /* PNG_FIXED_POINT_SUPPORTED */ |
#endif /* PNG_READ_cHRM_SUPPORTED */ |
png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent); |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
#if defined(PNG_READ_iCCP_SUPPORTED) |
void /* PRIVATE */ |
png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
/* Note: this does not properly handle chunks that are > 64K under DOS */ |
{ |
png_charp chunkdata; |
png_byte compression_type; |
png_bytep pC; |
png_charp profile; |
png_uint_32 skip = 0; |
png_uint_32 profile_size = 0; |
png_uint_32 profile_length = 0; |
png_size_t slength, prefix_length, data_length; |
png_debug(1, "in png_handle_iCCP\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before iCCP"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid iCCP after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->mode & PNG_HAVE_PLTE) |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Out of place iCCP chunk"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP)) |
{ |
png_warning(png_ptr, "Duplicate iCCP chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "iCCP chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
chunkdata = (png_charp)png_malloc(png_ptr, length + 1); |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, chunkdata); |
return; |
} |
chunkdata[slength] = 0x00; |
for (profile = chunkdata; *profile; profile++) |
/* empty loop to find end of name */ ; |
++profile; |
/* there should be at least one zero (the compression type byte) |
following the separator, and we should be on it */ |
if ( profile >= chunkdata + slength) |
{ |
png_free(png_ptr, chunkdata); |
png_warning(png_ptr, "Malformed iCCP chunk"); |
return; |
} |
/* compression_type should always be zero */ |
compression_type = *profile++; |
if (compression_type) |
{ |
png_warning(png_ptr, "Ignoring nonzero compression type in iCCP chunk"); |
compression_type=0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8 |
wrote nonzero) */ |
} |
prefix_length = profile - chunkdata; |
chunkdata = png_decompress_chunk(png_ptr, compression_type, chunkdata, |
slength, prefix_length, &data_length); |
profile_length = data_length - prefix_length; |
if ( prefix_length > data_length || profile_length < 4) |
{ |
png_free(png_ptr, chunkdata); |
png_warning(png_ptr, "Profile size field missing from iCCP chunk"); |
return; |
} |
/* Check the profile_size recorded in the first 32 bits of the ICC profile */ |
pC = (png_bytep)(chunkdata+prefix_length); |
profile_size = ((*(pC ))<<24) | |
((*(pC+1))<<16) | |
((*(pC+2))<< 8) | |
((*(pC+3)) ); |
if(profile_size < profile_length) |
profile_length = profile_size; |
if(profile_size > profile_length) |
{ |
png_free(png_ptr, chunkdata); |
png_warning(png_ptr, "Ignoring truncated iCCP profile.\n"); |
return; |
} |
png_set_iCCP(png_ptr, info_ptr, chunkdata, compression_type, |
chunkdata + prefix_length, profile_length); |
png_free(png_ptr, chunkdata); |
} |
#endif /* PNG_READ_iCCP_SUPPORTED */ |
#if defined(PNG_READ_sPLT_SUPPORTED) |
void /* PRIVATE */ |
png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
/* Note: this does not properly handle chunks that are > 64K under DOS */ |
{ |
png_bytep chunkdata; |
png_bytep entry_start; |
png_sPLT_t new_palette; |
#ifdef PNG_NO_POINTER_INDEXING |
png_sPLT_entryp pp; |
#endif |
int data_length, entry_size, i; |
png_uint_32 skip = 0; |
png_size_t slength; |
png_debug(1, "in png_handle_sPLT\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sPLT"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid sPLT after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "sPLT chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
chunkdata = (png_bytep)png_malloc(png_ptr, length + 1); |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, chunkdata); |
return; |
} |
chunkdata[slength] = 0x00; |
for (entry_start = chunkdata; *entry_start; entry_start++) |
/* empty loop to find end of name */ ; |
++entry_start; |
/* a sample depth should follow the separator, and we should be on it */ |
if (entry_start > chunkdata + slength) |
{ |
png_free(png_ptr, chunkdata); |
png_warning(png_ptr, "malformed sPLT chunk"); |
return; |
} |
new_palette.depth = *entry_start++; |
entry_size = (new_palette.depth == 8 ? 6 : 10); |
data_length = (slength - (entry_start - chunkdata)); |
/* integrity-check the data length */ |
if (data_length % entry_size) |
{ |
png_free(png_ptr, chunkdata); |
png_warning(png_ptr, "sPLT chunk has bad length"); |
return; |
} |
new_palette.nentries = data_length / entry_size; |
new_palette.entries = (png_sPLT_entryp)png_malloc( |
png_ptr, new_palette.nentries * sizeof(png_sPLT_entry)); |
#ifndef PNG_NO_POINTER_INDEXING |
for (i = 0; i < new_palette.nentries; i++) |
{ |
png_sPLT_entryp pp = new_palette.entries + i; |
if (new_palette.depth == 8) |
{ |
pp->red = *entry_start++; |
pp->green = *entry_start++; |
pp->blue = *entry_start++; |
pp->alpha = *entry_start++; |
} |
else |
{ |
pp->red = png_get_uint_16(entry_start); entry_start += 2; |
pp->green = png_get_uint_16(entry_start); entry_start += 2; |
pp->blue = png_get_uint_16(entry_start); entry_start += 2; |
pp->alpha = png_get_uint_16(entry_start); entry_start += 2; |
} |
pp->frequency = png_get_uint_16(entry_start); entry_start += 2; |
} |
#else |
pp = new_palette.entries; |
for (i = 0; i < new_palette.nentries; i++) |
{ |
if (new_palette.depth == 8) |
{ |
pp[i].red = *entry_start++; |
pp[i].green = *entry_start++; |
pp[i].blue = *entry_start++; |
pp[i].alpha = *entry_start++; |
} |
else |
{ |
pp[i].red = png_get_uint_16(entry_start); entry_start += 2; |
pp[i].green = png_get_uint_16(entry_start); entry_start += 2; |
pp[i].blue = png_get_uint_16(entry_start); entry_start += 2; |
pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2; |
} |
pp->frequency = png_get_uint_16(entry_start); entry_start += 2; |
} |
#endif |
/* discard all chunk data except the name and stash that */ |
new_palette.name = (png_charp)chunkdata; |
png_set_sPLT(png_ptr, info_ptr, &new_palette, 1); |
png_free(png_ptr, chunkdata); |
png_free(png_ptr, new_palette.entries); |
} |
#endif /* PNG_READ_sPLT_SUPPORTED */ |
#if defined(PNG_READ_tRNS_SUPPORTED) |
void /* PRIVATE */ |
png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte readbuf[PNG_MAX_PALETTE_LENGTH]; |
png_debug(1, "in png_handle_tRNS\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before tRNS"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid tRNS after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS)) |
{ |
png_warning(png_ptr, "Duplicate tRNS chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (!(png_ptr->mode & PNG_HAVE_PLTE)) |
{ |
/* Should be an error, but we can cope with it */ |
png_warning(png_ptr, "Missing PLTE before tRNS"); |
} |
else if (length > (png_uint_32)png_ptr->num_palette) |
{ |
png_warning(png_ptr, "Incorrect tRNS chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length == 0) |
{ |
png_warning(png_ptr, "Zero length tRNS chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, readbuf, (png_size_t)length); |
png_ptr->num_trans = (png_uint_16)length; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
{ |
png_byte buf[6]; |
if (length != 6) |
{ |
png_warning(png_ptr, "Incorrect tRNS chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, (png_size_t)length); |
png_ptr->num_trans = 1; |
png_ptr->trans_values.red = png_get_uint_16(buf); |
png_ptr->trans_values.green = png_get_uint_16(buf + 2); |
png_ptr->trans_values.blue = png_get_uint_16(buf + 4); |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
png_byte buf[6]; |
if (length != 2) |
{ |
png_warning(png_ptr, "Incorrect tRNS chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 2); |
png_ptr->num_trans = 1; |
png_ptr->trans_values.gray = png_get_uint_16(buf); |
} |
else |
{ |
png_warning(png_ptr, "tRNS chunk not allowed with alpha channel"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_crc_finish(png_ptr, 0)) |
return; |
png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans, |
&(png_ptr->trans_values)); |
} |
#endif |
#if defined(PNG_READ_bKGD_SUPPORTED) |
void /* PRIVATE */ |
png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_size_t truelen; |
png_byte buf[6]; |
png_debug(1, "in png_handle_bKGD\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before bKGD"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid bKGD after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && |
!(png_ptr->mode & PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Missing PLTE before bKGD"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD)) |
{ |
png_warning(png_ptr, "Duplicate bKGD chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
truelen = 1; |
else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) |
truelen = 6; |
else |
truelen = 2; |
if (length != truelen) |
{ |
png_warning(png_ptr, "Incorrect bKGD chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, truelen); |
if (png_crc_finish(png_ptr, 0)) |
return; |
/* We convert the index value into RGB components so that we can allow |
* arbitrary RGB values for background when we have transparency, and |
* so it is easy to determine the RGB values of the background color |
* from the info_ptr struct. */ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_ptr->background.index = buf[0]; |
if(info_ptr->num_palette) |
{ |
if(buf[0] > info_ptr->num_palette) |
{ |
png_warning(png_ptr, "Incorrect bKGD chunk index value"); |
return; |
} |
png_ptr->background.red = |
(png_uint_16)png_ptr->palette[buf[0]].red; |
png_ptr->background.green = |
(png_uint_16)png_ptr->palette[buf[0]].green; |
png_ptr->background.blue = |
(png_uint_16)png_ptr->palette[buf[0]].blue; |
} |
} |
else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */ |
{ |
png_ptr->background.red = |
png_ptr->background.green = |
png_ptr->background.blue = |
png_ptr->background.gray = png_get_uint_16(buf); |
} |
else |
{ |
png_ptr->background.red = png_get_uint_16(buf); |
png_ptr->background.green = png_get_uint_16(buf + 2); |
png_ptr->background.blue = png_get_uint_16(buf + 4); |
} |
png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background)); |
} |
#endif |
#if defined(PNG_READ_hIST_SUPPORTED) |
void /* PRIVATE */ |
png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
int num, i; |
png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH]; |
png_debug(1, "in png_handle_hIST\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before hIST"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid hIST after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (!(png_ptr->mode & PNG_HAVE_PLTE)) |
{ |
png_warning(png_ptr, "Missing PLTE before hIST"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST)) |
{ |
png_warning(png_ptr, "Duplicate hIST chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
num = (int)length / 2 ; |
if (num != png_ptr->num_palette) |
{ |
png_warning(png_ptr, "Incorrect hIST chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
for (i = 0; i < num; i++) |
{ |
png_byte buf[2]; |
png_crc_read(png_ptr, buf, 2); |
readbuf[i] = png_get_uint_16(buf); |
} |
if (png_crc_finish(png_ptr, 0)) |
return; |
png_set_hIST(png_ptr, info_ptr, readbuf); |
} |
#endif |
#if defined(PNG_READ_pHYs_SUPPORTED) |
void /* PRIVATE */ |
png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[9]; |
png_uint_32 res_x, res_y; |
int unit_type; |
png_debug(1, "in png_handle_pHYs\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before pHYs"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid pHYs after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_warning(png_ptr, "Duplicate pHYs chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 9) |
{ |
png_warning(png_ptr, "Incorrect pHYs chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 9); |
if (png_crc_finish(png_ptr, 0)) |
return; |
res_x = png_get_uint_32(buf); |
res_y = png_get_uint_32(buf + 4); |
unit_type = buf[8]; |
png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type); |
} |
#endif |
#if defined(PNG_READ_oFFs_SUPPORTED) |
void /* PRIVATE */ |
png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[9]; |
png_int_32 offset_x, offset_y; |
int unit_type; |
png_debug(1, "in png_handle_oFFs\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before oFFs"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid oFFs after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
{ |
png_warning(png_ptr, "Duplicate oFFs chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (length != 9) |
{ |
png_warning(png_ptr, "Incorrect oFFs chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 9); |
if (png_crc_finish(png_ptr, 0)) |
return; |
offset_x = png_get_int_32(buf); |
offset_y = png_get_int_32(buf + 4); |
unit_type = buf[8]; |
png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type); |
} |
#endif |
#if defined(PNG_READ_pCAL_SUPPORTED) |
/* read the pCAL chunk (described in the PNG Extensions document) */ |
void /* PRIVATE */ |
png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_charp purpose; |
png_int_32 X0, X1; |
png_byte type, nparams; |
png_charp buf, units, endptr; |
png_charpp params; |
png_size_t slength; |
int i; |
png_debug(1, "in png_handle_pCAL\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before pCAL"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid pCAL after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)) |
{ |
png_warning(png_ptr, "Duplicate pCAL chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_debug1(2, "Allocating and reading pCAL chunk data (%lu bytes)\n", |
length + 1); |
purpose = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (purpose == NULL) |
{ |
png_warning(png_ptr, "No memory for pCAL purpose."); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)purpose, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, purpose); |
return; |
} |
purpose[slength] = 0x00; /* null terminate the last string */ |
png_debug(3, "Finding end of pCAL purpose string\n"); |
for (buf = purpose; *buf; buf++) |
/* empty loop */ ; |
endptr = purpose + slength; |
/* We need to have at least 12 bytes after the purpose string |
in order to get the parameter information. */ |
if (endptr <= buf + 12) |
{ |
png_warning(png_ptr, "Invalid pCAL data"); |
png_free(png_ptr, purpose); |
return; |
} |
png_debug(3, "Reading pCAL X0, X1, type, nparams, and units\n"); |
X0 = png_get_int_32((png_bytep)buf+1); |
X1 = png_get_int_32((png_bytep)buf+5); |
type = buf[9]; |
nparams = buf[10]; |
units = buf + 11; |
png_debug(3, "Checking pCAL equation type and number of parameters\n"); |
/* Check that we have the right number of parameters for known |
equation types. */ |
if ((type == PNG_EQUATION_LINEAR && nparams != 2) || |
(type == PNG_EQUATION_BASE_E && nparams != 3) || |
(type == PNG_EQUATION_ARBITRARY && nparams != 3) || |
(type == PNG_EQUATION_HYPERBOLIC && nparams != 4)) |
{ |
png_warning(png_ptr, "Invalid pCAL parameters for equation type"); |
png_free(png_ptr, purpose); |
return; |
} |
else if (type >= PNG_EQUATION_LAST) |
{ |
png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); |
} |
for (buf = units; *buf; buf++) |
/* Empty loop to move past the units string. */ ; |
png_debug(3, "Allocating pCAL parameters array\n"); |
params = (png_charpp)png_malloc_warn(png_ptr, (png_uint_32)(nparams |
*sizeof(png_charp))) ; |
if (params == NULL) |
{ |
png_free(png_ptr, purpose); |
png_warning(png_ptr, "No memory for pCAL params."); |
return; |
} |
/* Get pointers to the start of each parameter string. */ |
for (i = 0; i < (int)nparams; i++) |
{ |
buf++; /* Skip the null string terminator from previous parameter. */ |
png_debug1(3, "Reading pCAL parameter %d\n", i); |
for (params[i] = buf; *buf != 0x00 && buf <= endptr; buf++) |
/* Empty loop to move past each parameter string */ ; |
/* Make sure we haven't run out of data yet */ |
if (buf > endptr) |
{ |
png_warning(png_ptr, "Invalid pCAL data"); |
png_free(png_ptr, purpose); |
png_free(png_ptr, params); |
return; |
} |
} |
png_set_pCAL(png_ptr, info_ptr, purpose, X0, X1, type, nparams, |
units, params); |
png_free(png_ptr, purpose); |
png_free(png_ptr, params); |
} |
#endif |
#if defined(PNG_READ_sCAL_SUPPORTED) |
/* read the sCAL chunk */ |
void /* PRIVATE */ |
png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_charp buffer, ep; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
double width, height; |
png_charp vp; |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_charp swidth, sheight; |
#endif |
#endif |
png_size_t slength; |
png_debug(1, "in png_handle_sCAL\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before sCAL"); |
else if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
png_warning(png_ptr, "Invalid sCAL after IDAT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL)) |
{ |
png_warning(png_ptr, "Duplicate sCAL chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)\n", |
length + 1); |
buffer = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (buffer == NULL) |
{ |
png_warning(png_ptr, "Out of memory while processing sCAL chunk"); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)buffer, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, buffer); |
return; |
} |
buffer[slength] = 0x00; /* null terminate the last string */ |
ep = buffer + 1; /* skip unit byte */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
width = strtod(ep, &vp); |
if (*vp) |
{ |
png_warning(png_ptr, "malformed width string in sCAL chunk"); |
return; |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); |
if (swidth == NULL) |
{ |
png_warning(png_ptr, "Out of memory while processing sCAL chunk width"); |
return; |
} |
png_memcpy(swidth, ep, (png_size_t)png_strlen(ep)); |
#endif |
#endif |
for (ep = buffer; *ep; ep++) |
/* empty loop */ ; |
ep++; |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
height = strtod(ep, &vp); |
if (*vp) |
{ |
png_warning(png_ptr, "malformed height string in sCAL chunk"); |
return; |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); |
if (swidth == NULL) |
{ |
png_warning(png_ptr, "Out of memory while processing sCAL chunk height"); |
return; |
} |
png_memcpy(sheight, ep, (png_size_t)png_strlen(ep)); |
#endif |
#endif |
if (buffer + slength < ep |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
|| width <= 0. || height <= 0. |
#endif |
) |
{ |
png_warning(png_ptr, "Invalid sCAL data"); |
png_free(png_ptr, buffer); |
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) |
png_free(png_ptr, swidth); |
png_free(png_ptr, sheight); |
#endif |
return; |
} |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
png_set_sCAL(png_ptr, info_ptr, buffer[0], width, height); |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_set_sCAL_s(png_ptr, info_ptr, buffer[0], swidth, sheight); |
#endif |
#endif |
png_free(png_ptr, buffer); |
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) |
png_free(png_ptr, swidth); |
png_free(png_ptr, sheight); |
#endif |
} |
#endif |
#if defined(PNG_READ_tIME_SUPPORTED) |
void /* PRIVATE */ |
png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[7]; |
png_time mod_time; |
png_debug(1, "in png_handle_tIME\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Out of place tIME chunk"); |
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME)) |
{ |
png_warning(png_ptr, "Duplicate tIME chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
if (length != 7) |
{ |
png_warning(png_ptr, "Incorrect tIME chunk length"); |
png_crc_finish(png_ptr, length); |
return; |
} |
png_crc_read(png_ptr, buf, 7); |
if (png_crc_finish(png_ptr, 0)) |
return; |
mod_time.second = buf[6]; |
mod_time.minute = buf[5]; |
mod_time.hour = buf[4]; |
mod_time.day = buf[3]; |
mod_time.month = buf[2]; |
mod_time.year = png_get_uint_16(buf); |
png_set_tIME(png_ptr, info_ptr, &mod_time); |
} |
#endif |
#if defined(PNG_READ_tEXt_SUPPORTED) |
/* Note: this does not properly handle chunks that are > 64K under DOS */ |
void /* PRIVATE */ |
png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_textp text_ptr; |
png_charp key; |
png_charp text; |
png_uint_32 skip = 0; |
png_size_t slength; |
int ret; |
png_debug(1, "in png_handle_tEXt\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before tEXt"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "tEXt chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
key = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (key == NULL) |
{ |
png_warning(png_ptr, "No memory to process text chunk."); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)key, slength); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, key); |
return; |
} |
key[slength] = 0x00; |
for (text = key; *text; text++) |
/* empty loop to find end of key */ ; |
if (text != key + slength) |
text++; |
text_ptr = (png_textp)png_malloc_warn(png_ptr, (png_uint_32)sizeof(png_text)); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr, "Not enough memory to process text chunk."); |
png_free(png_ptr, key); |
return; |
} |
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr->key = key; |
#ifdef PNG_iTXt_SUPPORTED |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
text_ptr->itxt_length = 0; |
#endif |
text_ptr->text = text; |
text_ptr->text_length = png_strlen(text); |
ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, key); |
png_free(png_ptr, text_ptr); |
if (ret) |
png_warning(png_ptr, "Insufficient memory to process text chunk."); |
} |
#endif |
#if defined(PNG_READ_zTXt_SUPPORTED) |
/* note: this does not correctly handle chunks that are > 64K under DOS */ |
void /* PRIVATE */ |
png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_textp text_ptr; |
png_charp chunkdata; |
png_charp text; |
int comp_type; |
int ret; |
png_size_t slength, prefix_len, data_len; |
png_debug(1, "in png_handle_zTXt\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before zTXt"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
#ifdef PNG_MAX_MALLOC_64K |
/* We will no doubt have problems with chunks even half this size, but |
there is no hard and fast rule to tell us where to stop. */ |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr,"zTXt chunk too large to fit in memory"); |
png_crc_finish(png_ptr, length); |
return; |
} |
#endif |
chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (chunkdata == NULL) |
{ |
png_warning(png_ptr,"Out of memory processing zTXt chunk."); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, chunkdata); |
return; |
} |
chunkdata[slength] = 0x00; |
for (text = chunkdata; *text; text++) |
/* empty loop */ ; |
/* zTXt must have some text after the chunkdataword */ |
if (text == chunkdata + slength) |
{ |
comp_type = PNG_TEXT_COMPRESSION_NONE; |
png_warning(png_ptr, "Zero length zTXt chunk"); |
} |
else |
{ |
comp_type = *(++text); |
if (comp_type != PNG_TEXT_COMPRESSION_zTXt) |
{ |
png_warning(png_ptr, "Unknown compression type in zTXt chunk"); |
comp_type = PNG_TEXT_COMPRESSION_zTXt; |
} |
text++; /* skip the compression_method byte */ |
} |
prefix_len = text - chunkdata; |
chunkdata = (png_charp)png_decompress_chunk(png_ptr, comp_type, chunkdata, |
(png_size_t)length, prefix_len, &data_len); |
text_ptr = (png_textp)png_malloc_warn(png_ptr, (png_uint_32)sizeof(png_text)); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr,"Not enough memory to process zTXt chunk."); |
png_free(png_ptr, chunkdata); |
return; |
} |
text_ptr->compression = comp_type; |
text_ptr->key = chunkdata; |
#ifdef PNG_iTXt_SUPPORTED |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
text_ptr->itxt_length = 0; |
#endif |
text_ptr->text = chunkdata + prefix_len; |
text_ptr->text_length = data_len; |
ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, text_ptr); |
png_free(png_ptr, chunkdata); |
if (ret) |
png_error(png_ptr, "Insufficient memory to store zTXt chunk."); |
} |
#endif |
#if defined(PNG_READ_iTXt_SUPPORTED) |
/* note: this does not correctly handle chunks that are > 64K under DOS */ |
void /* PRIVATE */ |
png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_textp text_ptr; |
png_charp chunkdata; |
png_charp key, lang, text, lang_key; |
int comp_flag; |
int comp_type = 0; |
int ret; |
png_size_t slength, prefix_len, data_len; |
png_debug(1, "in png_handle_iTXt\n"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR)) |
png_error(png_ptr, "Missing IHDR before iTXt"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
png_ptr->mode |= PNG_AFTER_IDAT; |
#ifdef PNG_MAX_MALLOC_64K |
/* We will no doubt have problems with chunks even half this size, but |
there is no hard and fast rule to tell us where to stop. */ |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr,"iTXt chunk too large to fit in memory"); |
png_crc_finish(png_ptr, length); |
return; |
} |
#endif |
chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (chunkdata == NULL) |
{ |
png_warning(png_ptr, "No memory to process iTXt chunk."); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)chunkdata, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, chunkdata); |
return; |
} |
chunkdata[slength] = 0x00; |
for (lang = chunkdata; *lang; lang++) |
/* empty loop */ ; |
lang++; /* skip NUL separator */ |
/* iTXt must have a language tag (possibly empty), two compression bytes, |
translated keyword (possibly empty), and possibly some text after the |
keyword */ |
if (lang >= chunkdata + slength) |
{ |
comp_flag = PNG_TEXT_COMPRESSION_NONE; |
png_warning(png_ptr, "Zero length iTXt chunk"); |
} |
else |
{ |
comp_flag = *lang++; |
comp_type = *lang++; |
} |
for (lang_key = lang; *lang_key; lang_key++) |
/* empty loop */ ; |
lang_key++; /* skip NUL separator */ |
for (text = lang_key; *text; text++) |
/* empty loop */ ; |
text++; /* skip NUL separator */ |
prefix_len = text - chunkdata; |
key=chunkdata; |
if (comp_flag) |
chunkdata = png_decompress_chunk(png_ptr, comp_type, chunkdata, |
(size_t)length, prefix_len, &data_len); |
else |
data_len=png_strlen(chunkdata + prefix_len); |
text_ptr = (png_textp)png_malloc_warn(png_ptr, (png_uint_32)sizeof(png_text)); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr,"Not enough memory to process iTXt chunk."); |
png_free(png_ptr, chunkdata); |
return; |
} |
text_ptr->compression = (int)comp_flag + 1; |
text_ptr->lang_key = chunkdata+(lang_key-key); |
text_ptr->lang = chunkdata+(lang-key); |
text_ptr->itxt_length = data_len; |
text_ptr->text_length = 0; |
text_ptr->key = chunkdata; |
text_ptr->text = chunkdata + prefix_len; |
ret=png_set_text_2(png_ptr, info_ptr, text_ptr, 1); |
png_free(png_ptr, text_ptr); |
png_free(png_ptr, chunkdata); |
if (ret) |
png_error(png_ptr, "Insufficient memory to store iTXt chunk."); |
} |
#endif |
/* This function is called when we haven't found a handler for a |
chunk. If there isn't a problem with the chunk itself (ie bad |
chunk name, CRC, or a critical chunk), the chunk is silently ignored |
-- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which |
case it will be saved away to be written out later. */ |
void /* PRIVATE */ |
png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_uint_32 skip = 0; |
png_debug(1, "in png_handle_unknown\n"); |
if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IDAT; |
#endif |
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* not an IDAT */ |
png_ptr->mode |= PNG_AFTER_IDAT; |
} |
png_check_chunk_name(png_ptr, png_ptr->chunk_name); |
if (!(png_ptr->chunk_name[0] & 0x20)) |
{ |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
HANDLE_CHUNK_ALWAYS |
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
&& png_ptr->read_user_chunk_fn == NULL |
#endif |
) |
#endif |
png_chunk_error(png_ptr, "unknown critical chunk"); |
} |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) |
{ |
png_unknown_chunk chunk; |
#ifdef PNG_MAX_MALLOC_64K |
if (length > (png_uint_32)65535L) |
{ |
png_warning(png_ptr, "unknown chunk too large to fit in memory"); |
skip = length - (png_uint_32)65535L; |
length = (png_uint_32)65535L; |
} |
#endif |
png_strcpy((png_charp)chunk.name, (png_charp)png_ptr->chunk_name); |
chunk.data = (png_bytep)png_malloc(png_ptr, length); |
chunk.size = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)chunk.data, length); |
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
if(png_ptr->read_user_chunk_fn != NULL) |
{ |
/* callback to user unknown chunk handler */ |
if ((*(png_ptr->read_user_chunk_fn)) (png_ptr, &chunk) <= 0) |
{ |
if (!(png_ptr->chunk_name[0] & 0x20)) |
if(png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
HANDLE_CHUNK_ALWAYS) |
{ |
png_free(png_ptr, chunk.data); |
png_chunk_error(png_ptr, "unknown critical chunk"); |
} |
png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); |
} |
} |
else |
#endif |
png_set_unknown_chunks(png_ptr, info_ptr, &chunk, 1); |
png_free(png_ptr, chunk.data); |
} |
else |
#endif |
skip = length; |
png_crc_finish(png_ptr, skip); |
#if !defined(PNG_READ_USER_CHUNKS_SUPPORTED) |
info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */ |
#endif |
} |
/* This function is called to verify that a chunk name is valid. |
This function can't have the "critical chunk check" incorporated |
into it, since in the future we will need to be able to call user |
functions to handle unknown critical chunks after we check that |
the chunk name itself is valid. */ |
#define isnonalpha(c) ((c) < 41 || (c) > 122 || ((c) > 90 && (c) < 97)) |
void /* PRIVATE */ |
png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name) |
{ |
png_debug(1, "in png_check_chunk_name\n"); |
if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) || |
isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3])) |
{ |
png_chunk_error(png_ptr, "invalid chunk type"); |
} |
} |
/* Combines the row recently read in with the existing pixels in the |
row. This routine takes care of alpha and transparency if requested. |
This routine also handles the two methods of progressive display |
of interlaced images, depending on the mask value. |
The mask value describes which pixels are to be combined with |
the row. The pattern always repeats every 8 pixels, so just 8 |
bits are needed. A one indicates the pixel is to be combined, |
a zero indicates the pixel is to be skipped. This is in addition |
to any alpha or transparency value associated with the pixel. If |
you want all pixels to be combined, pass 0xff (255) in mask. */ |
#ifndef PNG_HAVE_ASSEMBLER_COMBINE_ROW |
void /* PRIVATE */ |
png_combine_row(png_structp png_ptr, png_bytep row, int mask) |
{ |
png_debug(1,"in png_combine_row\n"); |
if (mask == 0xff) |
{ |
png_memcpy(row, png_ptr->row_buf + 1, |
(png_size_t)((png_ptr->width * |
png_ptr->row_info.pixel_depth + 7) >> 3)); |
} |
else |
{ |
switch (png_ptr->row_info.pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
int s_inc, s_start, s_end; |
int m = 0x80; |
int shift; |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
else |
#endif |
{ |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
shift = s_start; |
for (i = 0; i < row_width; i++) |
{ |
if (m & mask) |
{ |
int value; |
value = (*sp >> shift) & 0x01; |
*dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
int s_start, s_end, s_inc; |
int m = 0x80; |
int shift; |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
int value; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
else |
#endif |
{ |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
shift = s_start; |
for (i = 0; i < row_width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0x03; |
*dp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
int s_start, s_end, s_inc; |
int m = 0x80; |
int shift; |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
int value; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
{ |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
else |
#endif |
{ |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
shift = s_start; |
for (i = 0; i < row_width; i++) |
{ |
if (m & mask) |
{ |
value = (*sp >> shift) & 0xf; |
*dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*dp |= (png_byte)(value << shift); |
} |
if (shift == s_end) |
{ |
shift = s_start; |
sp++; |
dp++; |
} |
else |
shift += s_inc; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
default: |
{ |
png_bytep sp = png_ptr->row_buf + 1; |
png_bytep dp = row; |
png_size_t pixel_bytes = (png_ptr->row_info.pixel_depth >> 3); |
png_uint_32 i; |
png_uint_32 row_width = png_ptr->width; |
png_byte m = 0x80; |
for (i = 0; i < row_width; i++) |
{ |
if (m & mask) |
{ |
png_memcpy(dp, sp, pixel_bytes); |
} |
sp += pixel_bytes; |
dp += pixel_bytes; |
if (m == 1) |
m = 0x80; |
else |
m >>= 1; |
} |
break; |
} |
} |
} |
} |
#endif /* !PNG_HAVE_ASSEMBLER_COMBINE_ROW */ |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
#ifndef PNG_HAVE_ASSEMBLER_READ_INTERLACE /* else in pngvcrd.c, pnggccrd.c */ |
/* OLD pre-1.0.9 interface: |
void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass, |
png_uint_32 transformations) |
*/ |
void /* PRIVATE */ |
png_do_read_interlace(png_structp png_ptr) |
{ |
png_row_infop row_info = &(png_ptr->row_info); |
png_bytep row = png_ptr->row_buf + 1; |
int pass = png_ptr->pass; |
png_uint_32 transformations = png_ptr->transformations; |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* offset to next interlace block */ |
const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
#endif |
png_debug(1,"in png_do_read_interlace (stock C version)\n"); |
if (row != NULL && row_info != NULL) |
{ |
png_uint_32 final_width; |
final_width = row_info->width * png_pass_inc[pass]; |
switch (row_info->pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3); |
png_bytep dp = row + (png_size_t)((final_width - 1) >> 3); |
int sshift, dshift; |
int s_start, s_end, s_inc; |
int jstop = png_pass_inc[pass]; |
png_byte v; |
png_uint_32 i; |
int j; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (int)((row_info->width + 7) & 0x07); |
dshift = (int)((final_width + 7) & 0x07); |
s_start = 7; |
s_end = 0; |
s_inc = -1; |
} |
else |
#endif |
{ |
sshift = 7 - (int)((row_info->width + 7) & 0x07); |
dshift = 7 - (int)((final_width + 7) & 0x07); |
s_start = 0; |
s_end = 7; |
s_inc = 1; |
} |
for (i = 0; i < row_info->width; i++) |
{ |
v = (png_byte)((*sp >> sshift) & 0x01); |
for (j = 0; j < jstop; j++) |
{ |
*dp &= (png_byte)((0x7f7f >> (7 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2); |
png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2); |
int sshift, dshift; |
int s_start, s_end, s_inc; |
int jstop = png_pass_inc[pass]; |
png_uint_32 i; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (int)(((row_info->width + 3) & 0x03) << 1); |
dshift = (int)(((final_width + 3) & 0x03) << 1); |
s_start = 6; |
s_end = 0; |
s_inc = -2; |
} |
else |
#endif |
{ |
sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1); |
dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1); |
s_start = 0; |
s_end = 6; |
s_inc = 2; |
} |
for (i = 0; i < row_info->width; i++) |
{ |
png_byte v; |
int j; |
v = (png_byte)((*sp >> sshift) & 0x03); |
for (j = 0; j < jstop; j++) |
{ |
*dp &= (png_byte)((0x3f3f >> (6 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1); |
png_bytep dp = row + (png_size_t)((final_width - 1) >> 1); |
int sshift, dshift; |
int s_start, s_end, s_inc; |
png_uint_32 i; |
int jstop = png_pass_inc[pass]; |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (transformations & PNG_PACKSWAP) |
{ |
sshift = (int)(((row_info->width + 1) & 0x01) << 2); |
dshift = (int)(((final_width + 1) & 0x01) << 2); |
s_start = 4; |
s_end = 0; |
s_inc = -4; |
} |
else |
#endif |
{ |
sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2); |
dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2); |
s_start = 0; |
s_end = 4; |
s_inc = 4; |
} |
for (i = 0; i < row_info->width; i++) |
{ |
png_byte v = (png_byte)((*sp >> sshift) & 0xf); |
int j; |
for (j = 0; j < jstop; j++) |
{ |
*dp &= (png_byte)((0xf0f >> (4 - dshift)) & 0xff); |
*dp |= (png_byte)(v << dshift); |
if (dshift == s_end) |
{ |
dshift = s_start; |
dp--; |
} |
else |
dshift += s_inc; |
} |
if (sshift == s_end) |
{ |
sshift = s_start; |
sp--; |
} |
else |
sshift += s_inc; |
} |
break; |
} |
default: |
{ |
png_size_t pixel_bytes = (row_info->pixel_depth >> 3); |
png_bytep sp = row + (png_size_t)(row_info->width - 1) * pixel_bytes; |
png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes; |
int jstop = png_pass_inc[pass]; |
png_uint_32 i; |
for (i = 0; i < row_info->width; i++) |
{ |
png_byte v[8]; |
int j; |
png_memcpy(v, sp, pixel_bytes); |
for (j = 0; j < jstop; j++) |
{ |
png_memcpy(dp, v, pixel_bytes); |
dp -= pixel_bytes; |
} |
sp -= pixel_bytes; |
} |
break; |
} |
} |
row_info->width = final_width; |
row_info->rowbytes = ((final_width * |
(png_uint_32)row_info->pixel_depth + 7) >> 3); |
} |
#if !defined(PNG_READ_PACKSWAP_SUPPORTED) |
transformations = transformations; /* silence compiler warning */ |
#endif |
} |
#endif /* !PNG_HAVE_ASSEMBLER_READ_INTERLACE */ |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
#ifndef PNG_HAVE_ASSEMBLER_READ_FILTER_ROW |
void /* PRIVATE */ |
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row, |
png_bytep prev_row, int filter) |
{ |
png_debug(1, "in png_read_filter_row\n"); |
png_debug2(2,"row = %lu, filter = %d\n", png_ptr->row_number, filter); |
switch (filter) |
{ |
case PNG_FILTER_VALUE_NONE: |
break; |
case PNG_FILTER_VALUE_SUB: |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_bytep rp = row + bpp; |
png_bytep lp = row; |
for (i = bpp; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*lp++)) & 0xff); |
rp++; |
} |
break; |
} |
case PNG_FILTER_VALUE_UP: |
{ |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
break; |
} |
case PNG_FILTER_VALUE_AVG: |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop = row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
((int)(*pp++) / 2 )) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + |
(int)(*pp++ + *lp++) / 2 ) & 0xff); |
rp++; |
} |
break; |
} |
case PNG_FILTER_VALUE_PAETH: |
{ |
png_uint_32 i; |
png_bytep rp = row; |
png_bytep pp = prev_row; |
png_bytep lp = row; |
png_bytep cp = prev_row; |
png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; |
png_uint_32 istop=row_info->rowbytes - bpp; |
for (i = 0; i < bpp; i++) |
{ |
*rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); |
rp++; |
} |
for (i = 0; i < istop; i++) /* use leftover rp,pp */ |
{ |
int a, b, c, pa, pb, pc, p; |
a = *lp++; |
b = *pp++; |
c = *cp++; |
p = b - c; |
pc = a - c; |
#ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
#else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
/* |
if (pa <= pb && pa <= pc) |
p = a; |
else if (pb <= pc) |
p = b; |
else |
p = c; |
*/ |
p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; |
*rp = (png_byte)(((int)(*rp) + p) & 0xff); |
rp++; |
} |
break; |
} |
default: |
png_warning(png_ptr, "Ignoring bad adaptive filter type"); |
*row=0; |
break; |
} |
} |
#endif /* !PNG_HAVE_ASSEMBLER_READ_FILTER_ROW */ |
void /* PRIVATE */ |
png_read_finish_row(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
png_debug(1, "in png_read_finish_row\n"); |
png_ptr->row_number++; |
if (png_ptr->row_number < png_ptr->num_rows) |
return; |
if (png_ptr->interlaced) |
{ |
png_ptr->row_number = 0; |
png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
do |
{ |
png_ptr->pass++; |
if (png_ptr->pass >= 7) |
break; |
png_ptr->iwidth = (png_ptr->width + |
png_pass_inc[png_ptr->pass] - 1 - |
png_pass_start[png_ptr->pass]) / |
png_pass_inc[png_ptr->pass]; |
png_ptr->irowbytes = ((png_ptr->iwidth * |
(png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1; |
if (!(png_ptr->transformations & PNG_INTERLACE)) |
{ |
png_ptr->num_rows = (png_ptr->height + |
png_pass_yinc[png_ptr->pass] - 1 - |
png_pass_ystart[png_ptr->pass]) / |
png_pass_yinc[png_ptr->pass]; |
if (!(png_ptr->num_rows)) |
continue; |
} |
else /* if (png_ptr->transformations & PNG_INTERLACE) */ |
break; |
} while (png_ptr->iwidth == 0); |
if (png_ptr->pass < 7) |
return; |
} |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IDAT; |
#endif |
char extra; |
int ret; |
png_ptr->zstream.next_out = (Byte *)&extra; |
png_ptr->zstream.avail_out = (uInt)1; |
for(;;) |
{ |
if (!(png_ptr->zstream.avail_in)) |
{ |
while (!png_ptr->idat_size) |
{ |
png_byte chunk_length[4]; |
png_crc_finish(png_ptr, 0); |
png_read_data(png_ptr, chunk_length, 4); |
png_ptr->idat_size = png_get_uint_32(chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) |
png_error(png_ptr, "Not enough image data"); |
} |
png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_in = png_ptr->zbuf; |
if (png_ptr->zbuf_size > png_ptr->idat_size) |
png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; |
png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in); |
png_ptr->idat_size -= png_ptr->zstream.avail_in; |
} |
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); |
if (ret == Z_STREAM_END) |
{ |
if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in || |
png_ptr->idat_size) |
png_warning(png_ptr, "Extra compressed data"); |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
if (ret != Z_OK) |
png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : |
"Decompression Error"); |
if (!(png_ptr->zstream.avail_out)) |
{ |
png_warning(png_ptr, "Extra compressed data."); |
png_ptr->mode |= PNG_AFTER_IDAT; |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
break; |
} |
} |
png_ptr->zstream.avail_out = 0; |
} |
if (png_ptr->idat_size || png_ptr->zstream.avail_in) |
png_warning(png_ptr, "Extra compression data"); |
inflateReset(&png_ptr->zstream); |
png_ptr->mode |= PNG_AFTER_IDAT; |
} |
void /* PRIVATE */ |
png_read_start_row(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
const int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
const int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
const int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
const int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
int max_pixel_depth; |
png_uint_32 row_bytes; |
png_debug(1, "in png_read_start_row\n"); |
png_ptr->zstream.avail_in = 0; |
png_init_read_transformations(png_ptr); |
if (png_ptr->interlaced) |
{ |
if (!(png_ptr->transformations & PNG_INTERLACE)) |
png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - |
png_pass_ystart[0]) / png_pass_yinc[0]; |
else |
png_ptr->num_rows = png_ptr->height; |
png_ptr->iwidth = (png_ptr->width + |
png_pass_inc[png_ptr->pass] - 1 - |
png_pass_start[png_ptr->pass]) / |
png_pass_inc[png_ptr->pass]; |
row_bytes = ((png_ptr->iwidth * |
(png_uint_32)png_ptr->pixel_depth + 7) >> 3) +1; |
png_ptr->irowbytes = (png_size_t)row_bytes; |
if((png_uint_32)png_ptr->irowbytes != row_bytes) |
png_error(png_ptr, "Rowbytes overflow in png_read_start_row"); |
} |
else |
{ |
png_ptr->num_rows = png_ptr->height; |
png_ptr->iwidth = png_ptr->width; |
png_ptr->irowbytes = png_ptr->rowbytes + 1; |
} |
max_pixel_depth = png_ptr->pixel_depth; |
#if defined(PNG_READ_PACK_SUPPORTED) |
if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8) |
max_pixel_depth = 8; |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
if (png_ptr->transformations & PNG_EXPAND) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (png_ptr->num_trans) |
max_pixel_depth = 32; |
else |
max_pixel_depth = 24; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if (max_pixel_depth < 8) |
max_pixel_depth = 8; |
if (png_ptr->num_trans) |
max_pixel_depth *= 2; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
{ |
if (png_ptr->num_trans) |
{ |
max_pixel_depth *= 4; |
max_pixel_depth /= 3; |
} |
} |
} |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) |
if (png_ptr->transformations & (PNG_FILLER)) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
max_pixel_depth = 32; |
else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if (max_pixel_depth <= 8) |
max_pixel_depth = 16; |
else |
max_pixel_depth = 32; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) |
{ |
if (max_pixel_depth <= 32) |
max_pixel_depth = 32; |
else |
max_pixel_depth = 64; |
} |
} |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
if (png_ptr->transformations & PNG_GRAY_TO_RGB) |
{ |
if ( |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
(png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) || |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) |
(png_ptr->transformations & (PNG_FILLER)) || |
#endif |
png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
if (max_pixel_depth <= 16) |
max_pixel_depth = 32; |
else |
max_pixel_depth = 64; |
} |
else |
{ |
if (max_pixel_depth <= 8) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
max_pixel_depth = 32; |
else |
max_pixel_depth = 24; |
} |
else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
max_pixel_depth = 64; |
else |
max_pixel_depth = 48; |
} |
} |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \ |
defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
if(png_ptr->transformations & PNG_USER_TRANSFORM) |
{ |
int user_pixel_depth=png_ptr->user_transform_depth* |
png_ptr->user_transform_channels; |
if(user_pixel_depth > max_pixel_depth) |
max_pixel_depth=user_pixel_depth; |
} |
#endif |
/* align the width on the next larger 8 pixels. Mainly used |
for interlacing */ |
row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7)); |
/* calculate the maximum bytes needed, adding a byte and a pixel |
for safety's sake */ |
row_bytes = ((row_bytes * (png_uint_32)max_pixel_depth + 7) >> 3) + |
1 + ((max_pixel_depth + 7) >> 3); |
#ifdef PNG_MAX_MALLOC_64K |
if (row_bytes > (png_uint_32)65536L) |
png_error(png_ptr, "This image requires a row greater than 64KB"); |
#endif |
png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64); |
png_ptr->row_buf = png_ptr->big_row_buf+32; |
#if defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD) |
png_ptr->row_buf_size = row_bytes; |
#endif |
#ifdef PNG_MAX_MALLOC_64K |
if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L) |
png_error(png_ptr, "This image requires a row greater than 64KB"); |
#endif |
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)( |
png_ptr->rowbytes + 1)); |
png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
png_debug1(3, "width = %lu,\n", png_ptr->width); |
png_debug1(3, "height = %lu,\n", png_ptr->height); |
png_debug1(3, "iwidth = %lu,\n", png_ptr->iwidth); |
png_debug1(3, "num_rows = %lu\n", png_ptr->num_rows); |
png_debug1(3, "rowbytes = %lu,\n", png_ptr->rowbytes); |
png_debug1(3, "irowbytes = %lu,\n", png_ptr->irowbytes); |
png_ptr->flags |= PNG_FLAG_ROW_INIT; |
} |
/shark/trunk/ports/png/zlib.h |
---|
0,0 → 1,893 |
/* zlib.h -- interface of the 'zlib' general purpose compression library |
version 1.1.4, March 11th, 2002 |
Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler |
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. |
Jean-loup Gailly Mark Adler |
jloup@gzip.org madler@alumni.caltech.edu |
The data format used by the zlib library is described by RFCs (Request for |
Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt |
(zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). |
*/ |
#ifndef _ZLIB_H |
#define _ZLIB_H |
#include "zconf.h" |
#ifdef __cplusplus |
extern "C" { |
#endif |
#define ZLIB_VERSION "1.1.4" |
/* |
The 'zlib' compression library provides in-memory compression and |
decompression functions, including integrity checks of the uncompressed |
data. This version of the library supports only one compression method |
(deflation) but other algorithms will be added later and will have the same |
stream interface. |
Compression can be done in a single step if the buffers are large |
enough (for example if an input file is mmap'ed), or can be done by |
repeated calls of the compression function. In the latter case, the |
application must provide more input and/or consume the output |
(providing more output space) before each call. |
The library also supports reading and writing files in gzip (.gz) format |
with an interface similar to that of stdio. |
The library does not install any signal handler. The decoder checks |
the consistency of the compressed data, so the library should never |
crash even in case of corrupted input. |
*/ |
typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); |
typedef void (*free_func) OF((voidpf opaque, voidpf address)); |
struct internal_state; |
typedef struct z_stream_s { |
Bytef *next_in; /* next input byte */ |
uInt avail_in; /* number of bytes available at next_in */ |
uLong total_in; /* total nb of input bytes read so far */ |
Bytef *next_out; /* next output byte should be put there */ |
uInt avail_out; /* remaining free space at next_out */ |
uLong total_out; /* total nb of bytes output so far */ |
char *msg; /* last error message, NULL if no error */ |
struct internal_state FAR *state; /* not visible by applications */ |
alloc_func zalloc; /* used to allocate the internal state */ |
free_func zfree; /* used to free the internal state */ |
voidpf opaque; /* private data object passed to zalloc and zfree */ |
int data_type; /* best guess about the data type: ascii or binary */ |
uLong adler; /* adler32 value of the uncompressed data */ |
uLong reserved; /* reserved for future use */ |
} z_stream; |
typedef z_stream FAR *z_streamp; |
/* |
The application must update next_in and avail_in when avail_in has |
dropped to zero. It must update next_out and avail_out when avail_out |
has dropped to zero. The application must initialize zalloc, zfree and |
opaque before calling the init function. All other fields are set by the |
compression library and must not be updated by the application. |
The opaque value provided by the application will be passed as the first |
parameter for calls of zalloc and zfree. This can be useful for custom |
memory management. The compression library attaches no meaning to the |
opaque value. |
zalloc must return Z_NULL if there is not enough memory for the object. |
If zlib is used in a multi-threaded application, zalloc and zfree must be |
thread safe. |
On 16-bit systems, the functions zalloc and zfree must be able to allocate |
exactly 65536 bytes, but will not be required to allocate more than this |
if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, |
pointers returned by zalloc for objects of exactly 65536 bytes *must* |
have their offset normalized to zero. The default allocation function |
provided by this library ensures this (see zutil.c). To reduce memory |
requirements and avoid any allocation of 64K objects, at the expense of |
compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). |
The fields total_in and total_out can be used for statistics or |
progress reports. After compression, total_in holds the total size of |
the uncompressed data and may be saved for use in the decompressor |
(particularly if the decompressor wants to decompress everything in |
a single step). |
*/ |
/* constants */ |
#define Z_NO_FLUSH 0 |
#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ |
#define Z_SYNC_FLUSH 2 |
#define Z_FULL_FLUSH 3 |
#define Z_FINISH 4 |
/* Allowed flush values; see deflate() below for details */ |
#define Z_OK 0 |
#define Z_STREAM_END 1 |
#define Z_NEED_DICT 2 |
#define Z_ERRNO (-1) |
#define Z_STREAM_ERROR (-2) |
#define Z_DATA_ERROR (-3) |
#define Z_MEM_ERROR (-4) |
#define Z_BUF_ERROR (-5) |
#define Z_VERSION_ERROR (-6) |
/* Return codes for the compression/decompression functions. Negative |
* values are errors, positive values are used for special but normal events. |
*/ |
#define Z_NO_COMPRESSION 0 |
#define Z_BEST_SPEED 1 |
#define Z_BEST_COMPRESSION 9 |
#define Z_DEFAULT_COMPRESSION (-1) |
/* compression levels */ |
#define Z_FILTERED 1 |
#define Z_HUFFMAN_ONLY 2 |
#define Z_DEFAULT_STRATEGY 0 |
/* compression strategy; see deflateInit2() below for details */ |
#define Z_BINARY 0 |
#define Z_ASCII 1 |
#define Z_UNKNOWN 2 |
/* Possible values of the data_type field */ |
#define Z_DEFLATED 8 |
/* The deflate compression method (the only one supported in this version) */ |
#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ |
#define zlib_version zlibVersion() |
/* for compatibility with versions < 1.0.2 */ |
/* basic functions */ |
ZEXTERN const char * ZEXPORT zlibVersion OF((void)); |
/* The application can compare zlibVersion and ZLIB_VERSION for consistency. |
If the first character differs, the library code actually used is |
not compatible with the zlib.h header file used by the application. |
This check is automatically made by deflateInit and inflateInit. |
*/ |
/* |
ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); |
Initializes the internal stream state for compression. The fields |
zalloc, zfree and opaque must be initialized before by the caller. |
If zalloc and zfree are set to Z_NULL, deflateInit updates them to |
use default allocation functions. |
The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: |
1 gives best speed, 9 gives best compression, 0 gives no compression at |
all (the input data is simply copied a block at a time). |
Z_DEFAULT_COMPRESSION requests a default compromise between speed and |
compression (currently equivalent to level 6). |
deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not |
enough memory, Z_STREAM_ERROR if level is not a valid compression level, |
Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible |
with the version assumed by the caller (ZLIB_VERSION). |
msg is set to null if there is no error message. deflateInit does not |
perform any compression: this will be done by deflate(). |
*/ |
ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); |
/* |
deflate compresses as much data as possible, and stops when the input |
buffer becomes empty or the output buffer becomes full. It may introduce some |
output latency (reading input without producing any output) except when |
forced to flush. |
The detailed semantics are as follows. deflate performs one or both of the |
following actions: |
- Compress more input starting at next_in and update next_in and avail_in |
accordingly. If not all input can be processed (because there is not |
enough room in the output buffer), next_in and avail_in are updated and |
processing will resume at this point for the next call of deflate(). |
- Provide more output starting at next_out and update next_out and avail_out |
accordingly. This action is forced if the parameter flush is non zero. |
Forcing flush frequently degrades the compression ratio, so this parameter |
should be set only when necessary (in interactive applications). |
Some output may be provided even if flush is not set. |
Before the call of deflate(), the application should ensure that at least |
one of the actions is possible, by providing more input and/or consuming |
more output, and updating avail_in or avail_out accordingly; avail_out |
should never be zero before the call. The application can consume the |
compressed output when it wants, for example when the output buffer is full |
(avail_out == 0), or after each call of deflate(). If deflate returns Z_OK |
and with zero avail_out, it must be called again after making room in the |
output buffer because there might be more output pending. |
If the parameter flush is set to Z_SYNC_FLUSH, all pending output is |
flushed to the output buffer and the output is aligned on a byte boundary, so |
that the decompressor can get all input data available so far. (In particular |
avail_in is zero after the call if enough output space has been provided |
before the call.) Flushing may degrade compression for some compression |
algorithms and so it should be used only when necessary. |
If flush is set to Z_FULL_FLUSH, all output is flushed as with |
Z_SYNC_FLUSH, and the compression state is reset so that decompression can |
restart from this point if previous compressed data has been damaged or if |
random access is desired. Using Z_FULL_FLUSH too often can seriously degrade |
the compression. |
If deflate returns with avail_out == 0, this function must be called again |
with the same value of the flush parameter and more output space (updated |
avail_out), until the flush is complete (deflate returns with non-zero |
avail_out). |
If the parameter flush is set to Z_FINISH, pending input is processed, |
pending output is flushed and deflate returns with Z_STREAM_END if there |
was enough output space; if deflate returns with Z_OK, this function must be |
called again with Z_FINISH and more output space (updated avail_out) but no |
more input data, until it returns with Z_STREAM_END or an error. After |
deflate has returned Z_STREAM_END, the only possible operations on the |
stream are deflateReset or deflateEnd. |
Z_FINISH can be used immediately after deflateInit if all the compression |
is to be done in a single step. In this case, avail_out must be at least |
0.1% larger than avail_in plus 12 bytes. If deflate does not return |
Z_STREAM_END, then it must be called again as described above. |
deflate() sets strm->adler to the adler32 checksum of all input read |
so far (that is, total_in bytes). |
deflate() may update data_type if it can make a good guess about |
the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered |
binary. This field is only for information purposes and does not affect |
the compression algorithm in any manner. |
deflate() returns Z_OK if some progress has been made (more input |
processed or more output produced), Z_STREAM_END if all input has been |
consumed and all output has been produced (only when flush is set to |
Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example |
if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible |
(for example avail_in or avail_out was zero). |
*/ |
ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); |
/* |
All dynamically allocated data structures for this stream are freed. |
This function discards any unprocessed input and does not flush any |
pending output. |
deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the |
stream state was inconsistent, Z_DATA_ERROR if the stream was freed |
prematurely (some input or output was discarded). In the error case, |
msg may be set but then points to a static string (which must not be |
deallocated). |
*/ |
/* |
ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); |
Initializes the internal stream state for decompression. The fields |
next_in, avail_in, zalloc, zfree and opaque must be initialized before by |
the caller. If next_in is not Z_NULL and avail_in is large enough (the exact |
value depends on the compression method), inflateInit determines the |
compression method from the zlib header and allocates all data structures |
accordingly; otherwise the allocation will be deferred to the first call of |
inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to |
use default allocation functions. |
inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough |
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the |
version assumed by the caller. msg is set to null if there is no error |
message. inflateInit does not perform any decompression apart from reading |
the zlib header if present: this will be done by inflate(). (So next_in and |
avail_in may be modified, but next_out and avail_out are unchanged.) |
*/ |
ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); |
/* |
inflate decompresses as much data as possible, and stops when the input |
buffer becomes empty or the output buffer becomes full. It may some |
introduce some output latency (reading input without producing any output) |
except when forced to flush. |
The detailed semantics are as follows. inflate performs one or both of the |
following actions: |
- Decompress more input starting at next_in and update next_in and avail_in |
accordingly. If not all input can be processed (because there is not |
enough room in the output buffer), next_in is updated and processing |
will resume at this point for the next call of inflate(). |
- Provide more output starting at next_out and update next_out and avail_out |
accordingly. inflate() provides as much output as possible, until there |
is no more input data or no more space in the output buffer (see below |
about the flush parameter). |
Before the call of inflate(), the application should ensure that at least |
one of the actions is possible, by providing more input and/or consuming |
more output, and updating the next_* and avail_* values accordingly. |
The application can consume the uncompressed output when it wants, for |
example when the output buffer is full (avail_out == 0), or after each |
call of inflate(). If inflate returns Z_OK and with zero avail_out, it |
must be called again after making room in the output buffer because there |
might be more output pending. |
If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much |
output as possible to the output buffer. The flushing behavior of inflate is |
not specified for values of the flush parameter other than Z_SYNC_FLUSH |
and Z_FINISH, but the current implementation actually flushes as much output |
as possible anyway. |
inflate() should normally be called until it returns Z_STREAM_END or an |
error. However if all decompression is to be performed in a single step |
(a single call of inflate), the parameter flush should be set to |
Z_FINISH. In this case all pending input is processed and all pending |
output is flushed; avail_out must be large enough to hold all the |
uncompressed data. (The size of the uncompressed data may have been saved |
by the compressor for this purpose.) The next operation on this stream must |
be inflateEnd to deallocate the decompression state. The use of Z_FINISH |
is never required, but can be used to inform inflate that a faster routine |
may be used for the single inflate() call. |
If a preset dictionary is needed at this point (see inflateSetDictionary |
below), inflate sets strm-adler to the adler32 checksum of the |
dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise |
it sets strm->adler to the adler32 checksum of all output produced |
so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or |
an error code as described below. At the end of the stream, inflate() |
checks that its computed adler32 checksum is equal to that saved by the |
compressor and returns Z_STREAM_END only if the checksum is correct. |
inflate() returns Z_OK if some progress has been made (more input processed |
or more output produced), Z_STREAM_END if the end of the compressed data has |
been reached and all uncompressed output has been produced, Z_NEED_DICT if a |
preset dictionary is needed at this point, Z_DATA_ERROR if the input data was |
corrupted (input stream not conforming to the zlib format or incorrect |
adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent |
(for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not |
enough memory, Z_BUF_ERROR if no progress is possible or if there was not |
enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR |
case, the application may then call inflateSync to look for a good |
compression block. |
*/ |
ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); |
/* |
All dynamically allocated data structures for this stream are freed. |
This function discards any unprocessed input and does not flush any |
pending output. |
inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state |
was inconsistent. In the error case, msg may be set but then points to a |
static string (which must not be deallocated). |
*/ |
/* Advanced functions */ |
/* |
The following functions are needed only in some special applications. |
*/ |
/* |
ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, |
int level, |
int method, |
int windowBits, |
int memLevel, |
int strategy)); |
This is another version of deflateInit with more compression options. The |
fields next_in, zalloc, zfree and opaque must be initialized before by |
the caller. |
The method parameter is the compression method. It must be Z_DEFLATED in |
this version of the library. |
The windowBits parameter is the base two logarithm of the window size |
(the size of the history buffer). It should be in the range 8..15 for this |
version of the library. Larger values of this parameter result in better |
compression at the expense of memory usage. The default value is 15 if |
deflateInit is used instead. |
The memLevel parameter specifies how much memory should be allocated |
for the internal compression state. memLevel=1 uses minimum memory but |
is slow and reduces compression ratio; memLevel=9 uses maximum memory |
for optimal speed. The default value is 8. See zconf.h for total memory |
usage as a function of windowBits and memLevel. |
The strategy parameter is used to tune the compression algorithm. Use the |
value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a |
filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no |
string match). Filtered data consists mostly of small values with a |
somewhat random distribution. In this case, the compression algorithm is |
tuned to compress them better. The effect of Z_FILTERED is to force more |
Huffman coding and less string matching; it is somewhat intermediate |
between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects |
the compression ratio but not the correctness of the compressed output even |
if it is not set appropriately. |
deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid |
method). msg is set to null if there is no error message. deflateInit2 does |
not perform any compression: this will be done by deflate(). |
*/ |
ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, |
const Bytef *dictionary, |
uInt dictLength)); |
/* |
Initializes the compression dictionary from the given byte sequence |
without producing any compressed output. This function must be called |
immediately after deflateInit, deflateInit2 or deflateReset, before any |
call of deflate. The compressor and decompressor must use exactly the same |
dictionary (see inflateSetDictionary). |
The dictionary should consist of strings (byte sequences) that are likely |
to be encountered later in the data to be compressed, with the most commonly |
used strings preferably put towards the end of the dictionary. Using a |
dictionary is most useful when the data to be compressed is short and can be |
predicted with good accuracy; the data can then be compressed better than |
with the default empty dictionary. |
Depending on the size of the compression data structures selected by |
deflateInit or deflateInit2, a part of the dictionary may in effect be |
discarded, for example if the dictionary is larger than the window size in |
deflate or deflate2. Thus the strings most likely to be useful should be |
put at the end of the dictionary, not at the front. |
Upon return of this function, strm->adler is set to the Adler32 value |
of the dictionary; the decompressor may later use this value to determine |
which dictionary has been used by the compressor. (The Adler32 value |
applies to the whole dictionary even if only a subset of the dictionary is |
actually used by the compressor.) |
deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a |
parameter is invalid (such as NULL dictionary) or the stream state is |
inconsistent (for example if deflate has already been called for this stream |
or if the compression method is bsort). deflateSetDictionary does not |
perform any compression: this will be done by deflate(). |
*/ |
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, |
z_streamp source)); |
/* |
Sets the destination stream as a complete copy of the source stream. |
This function can be useful when several compression strategies will be |
tried, for example when there are several ways of pre-processing the input |
data with a filter. The streams that will be discarded should then be freed |
by calling deflateEnd. Note that deflateCopy duplicates the internal |
compression state which can be quite large, so this strategy is slow and |
can consume lots of memory. |
deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not |
enough memory, Z_STREAM_ERROR if the source stream state was inconsistent |
(such as zalloc being NULL). msg is left unchanged in both source and |
destination. |
*/ |
ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); |
/* |
This function is equivalent to deflateEnd followed by deflateInit, |
but does not free and reallocate all the internal compression state. |
The stream will keep the same compression level and any other attributes |
that may have been set by deflateInit2. |
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent (such as zalloc or state being NULL). |
*/ |
ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, |
int level, |
int strategy)); |
/* |
Dynamically update the compression level and compression strategy. The |
interpretation of level and strategy is as in deflateInit2. This can be |
used to switch between compression and straight copy of the input data, or |
to switch to a different kind of input data requiring a different |
strategy. If the compression level is changed, the input available so far |
is compressed with the old level (and may be flushed); the new level will |
take effect only at the next call of deflate(). |
Before the call of deflateParams, the stream state must be set as for |
a call of deflate(), since the currently available input may have to |
be compressed and flushed. In particular, strm->avail_out must be non-zero. |
deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source |
stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR |
if strm->avail_out was zero. |
*/ |
/* |
ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, |
int windowBits)); |
This is another version of inflateInit with an extra parameter. The |
fields next_in, avail_in, zalloc, zfree and opaque must be initialized |
before by the caller. |
The windowBits parameter is the base two logarithm of the maximum window |
size (the size of the history buffer). It should be in the range 8..15 for |
this version of the library. The default value is 15 if inflateInit is used |
instead. If a compressed stream with a larger window size is given as |
input, inflate() will return with the error code Z_DATA_ERROR instead of |
trying to allocate a larger window. |
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative |
memLevel). msg is set to null if there is no error message. inflateInit2 |
does not perform any decompression apart from reading the zlib header if |
present: this will be done by inflate(). (So next_in and avail_in may be |
modified, but next_out and avail_out are unchanged.) |
*/ |
ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, |
const Bytef *dictionary, |
uInt dictLength)); |
/* |
Initializes the decompression dictionary from the given uncompressed byte |
sequence. This function must be called immediately after a call of inflate |
if this call returned Z_NEED_DICT. The dictionary chosen by the compressor |
can be determined from the Adler32 value returned by this call of |
inflate. The compressor and decompressor must use exactly the same |
dictionary (see deflateSetDictionary). |
inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a |
parameter is invalid (such as NULL dictionary) or the stream state is |
inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the |
expected one (incorrect Adler32 value). inflateSetDictionary does not |
perform any decompression: this will be done by subsequent calls of |
inflate(). |
*/ |
ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); |
/* |
Skips invalid compressed data until a full flush point (see above the |
description of deflate with Z_FULL_FLUSH) can be found, or until all |
available input is skipped. No output is provided. |
inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR |
if no more input was provided, Z_DATA_ERROR if no flush point has been found, |
or Z_STREAM_ERROR if the stream structure was inconsistent. In the success |
case, the application may save the current current value of total_in which |
indicates where valid compressed data was found. In the error case, the |
application may repeatedly call inflateSync, providing more input each time, |
until success or end of the input data. |
*/ |
ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); |
/* |
This function is equivalent to inflateEnd followed by inflateInit, |
but does not free and reallocate all the internal decompression state. |
The stream will keep attributes that may have been set by inflateInit2. |
inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent (such as zalloc or state being NULL). |
*/ |
/* utility functions */ |
/* |
The following utility functions are implemented on top of the |
basic stream-oriented functions. To simplify the interface, some |
default options are assumed (compression level and memory usage, |
standard memory allocation functions). The source code of these |
utility functions can easily be modified if you need special options. |
*/ |
ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, |
const Bytef *source, uLong sourceLen)); |
/* |
Compresses the source buffer into the destination buffer. sourceLen is |
the byte length of the source buffer. Upon entry, destLen is the total |
size of the destination buffer, which must be at least 0.1% larger than |
sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the |
compressed buffer. |
This function can be used to compress a whole file at once if the |
input file is mmap'ed. |
compress returns Z_OK if success, Z_MEM_ERROR if there was not |
enough memory, Z_BUF_ERROR if there was not enough room in the output |
buffer. |
*/ |
ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, |
const Bytef *source, uLong sourceLen, |
int level)); |
/* |
Compresses the source buffer into the destination buffer. The level |
parameter has the same meaning as in deflateInit. sourceLen is the byte |
length of the source buffer. Upon entry, destLen is the total size of the |
destination buffer, which must be at least 0.1% larger than sourceLen plus |
12 bytes. Upon exit, destLen is the actual size of the compressed buffer. |
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
memory, Z_BUF_ERROR if there was not enough room in the output buffer, |
Z_STREAM_ERROR if the level parameter is invalid. |
*/ |
ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, |
const Bytef *source, uLong sourceLen)); |
/* |
Decompresses the source buffer into the destination buffer. sourceLen is |
the byte length of the source buffer. Upon entry, destLen is the total |
size of the destination buffer, which must be large enough to hold the |
entire uncompressed data. (The size of the uncompressed data must have |
been saved previously by the compressor and transmitted to the decompressor |
by some mechanism outside the scope of this compression library.) |
Upon exit, destLen is the actual size of the compressed buffer. |
This function can be used to decompress a whole file at once if the |
input file is mmap'ed. |
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not |
enough memory, Z_BUF_ERROR if there was not enough room in the output |
buffer, or Z_DATA_ERROR if the input data was corrupted. |
*/ |
typedef voidp gzFile; |
ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); |
/* |
Opens a gzip (.gz) file for reading or writing. The mode parameter |
is as in fopen ("rb" or "wb") but can also include a compression level |
("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for |
Huffman only compression as in "wb1h". (See the description |
of deflateInit2 for more information about the strategy parameter.) |
gzopen can be used to read a file which is not in gzip format; in this |
case gzread will directly read from the file without decompression. |
gzopen returns NULL if the file could not be opened or if there was |
insufficient memory to allocate the (de)compression state; errno |
can be checked to distinguish the two cases (if errno is zero, the |
zlib error is Z_MEM_ERROR). */ |
ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); |
/* |
gzdopen() associates a gzFile with the file descriptor fd. File |
descriptors are obtained from calls like open, dup, creat, pipe or |
fileno (in the file has been previously opened with fopen). |
The mode parameter is as in gzopen. |
The next call of gzclose on the returned gzFile will also close the |
file descriptor fd, just like fclose(fdopen(fd), mode) closes the file |
descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). |
gzdopen returns NULL if there was insufficient memory to allocate |
the (de)compression state. |
*/ |
ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); |
/* |
Dynamically update the compression level or strategy. See the description |
of deflateInit2 for the meaning of these parameters. |
gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not |
opened for writing. |
*/ |
ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); |
/* |
Reads the given number of uncompressed bytes from the compressed file. |
If the input file was not in gzip format, gzread copies the given number |
of bytes into the buffer. |
gzread returns the number of uncompressed bytes actually read (0 for |
end of file, -1 for error). */ |
ZEXTERN int ZEXPORT gzwrite OF((gzFile file, |
const voidp buf, unsigned len)); |
/* |
Writes the given number of uncompressed bytes into the compressed file. |
gzwrite returns the number of uncompressed bytes actually written |
(0 in case of error). |
*/ |
ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); |
/* |
Converts, formats, and writes the args to the compressed file under |
control of the format string, as in fprintf. gzprintf returns the number of |
uncompressed bytes actually written (0 in case of error). |
*/ |
ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); |
/* |
Writes the given null-terminated string to the compressed file, excluding |
the terminating null character. |
gzputs returns the number of characters written, or -1 in case of error. |
*/ |
ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); |
/* |
Reads bytes from the compressed file until len-1 characters are read, or |
a newline character is read and transferred to buf, or an end-of-file |
condition is encountered. The string is then terminated with a null |
character. |
gzgets returns buf, or Z_NULL in case of error. |
*/ |
ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); |
/* |
Writes c, converted to an unsigned char, into the compressed file. |
gzputc returns the value that was written, or -1 in case of error. |
*/ |
ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); |
/* |
Reads one byte from the compressed file. gzgetc returns this byte |
or -1 in case of end of file or error. |
*/ |
ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); |
/* |
Flushes all pending output into the compressed file. The parameter |
flush is as in the deflate() function. The return value is the zlib |
error number (see function gzerror below). gzflush returns Z_OK if |
the flush parameter is Z_FINISH and all output could be flushed. |
gzflush should be called only when strictly necessary because it can |
degrade compression. |
*/ |
ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, |
z_off_t offset, int whence)); |
/* |
Sets the starting position for the next gzread or gzwrite on the |
given compressed file. The offset represents a number of bytes in the |
uncompressed data stream. The whence parameter is defined as in lseek(2); |
the value SEEK_END is not supported. |
If the file is opened for reading, this function is emulated but can be |
extremely slow. If the file is opened for writing, only forward seeks are |
supported; gzseek then compresses a sequence of zeroes up to the new |
starting position. |
gzseek returns the resulting offset location as measured in bytes from |
the beginning of the uncompressed stream, or -1 in case of error, in |
particular if the file is opened for writing and the new starting position |
would be before the current position. |
*/ |
ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); |
/* |
Rewinds the given file. This function is supported only for reading. |
gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) |
*/ |
ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); |
/* |
Returns the starting position for the next gzread or gzwrite on the |
given compressed file. This position represents a number of bytes in the |
uncompressed data stream. |
gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) |
*/ |
ZEXTERN int ZEXPORT gzeof OF((gzFile file)); |
/* |
Returns 1 when EOF has previously been detected reading the given |
input stream, otherwise zero. |
*/ |
ZEXTERN int ZEXPORT gzclose OF((gzFile file)); |
/* |
Flushes all pending output if necessary, closes the compressed file |
and deallocates all the (de)compression state. The return value is the zlib |
error number (see function gzerror below). |
*/ |
ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); |
/* |
Returns the error message for the last error which occurred on the |
given compressed file. errnum is set to zlib error number. If an |
error occurred in the file system and not in the compression library, |
errnum is set to Z_ERRNO and the application may consult errno |
to get the exact error code. |
*/ |
/* checksum functions */ |
/* |
These functions are not related to compression but are exported |
anyway because they might be useful in applications using the |
compression library. |
*/ |
ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); |
/* |
Update a running Adler-32 checksum with the bytes buf[0..len-1] and |
return the updated checksum. If buf is NULL, this function returns |
the required initial value for the checksum. |
An Adler-32 checksum is almost as reliable as a CRC32 but can be computed |
much faster. Usage example: |
uLong adler = adler32(0L, Z_NULL, 0); |
while (read_buffer(buffer, length) != EOF) { |
adler = adler32(adler, buffer, length); |
} |
if (adler != original_adler) error(); |
*/ |
ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); |
/* |
Update a running crc with the bytes buf[0..len-1] and return the updated |
crc. If buf is NULL, this function returns the required initial value |
for the crc. Pre- and post-conditioning (one's complement) is performed |
within this function so it shouldn't be done by the application. |
Usage example: |
uLong crc = crc32(0L, Z_NULL, 0); |
while (read_buffer(buffer, length) != EOF) { |
crc = crc32(crc, buffer, length); |
} |
if (crc != original_crc) error(); |
*/ |
/* various hacks, don't look :) */ |
/* deflateInit and inflateInit are macros to allow checking the zlib version |
* and the compiler's view of z_stream: |
*/ |
ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, |
const char *version, int stream_size)); |
ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, |
const char *version, int stream_size)); |
ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, |
int windowBits, int memLevel, |
int strategy, const char *version, |
int stream_size)); |
ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, |
const char *version, int stream_size)); |
#define deflateInit(strm, level) \ |
deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) |
#define inflateInit(strm) \ |
inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) |
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ |
deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ |
(strategy), ZLIB_VERSION, sizeof(z_stream)) |
#define inflateInit2(strm, windowBits) \ |
inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) |
#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL) |
struct internal_state {int dummy;}; /* hack for buggy compilers */ |
#endif |
ZEXTERN const char * ZEXPORT zError OF((int err)); |
ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); |
ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); |
#ifdef __cplusplus |
} |
#endif |
#endif /* _ZLIB_H */ |
/shark/trunk/ports/png/pngwutil.c |
---|
0,0 → 1,2675 |
/* pngwutil.c - utilities to write a PNG file |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
#ifdef PNG_WRITE_SUPPORTED |
/* Place a 32-bit number into a buffer in PNG byte order. We work |
* with unsigned numbers for convenience, although one supported |
* ancillary chunk uses signed (two's complement) numbers. |
*/ |
void /* PRIVATE */ |
png_save_uint_32(png_bytep buf, png_uint_32 i) |
{ |
buf[0] = (png_byte)((i >> 24) & 0xff); |
buf[1] = (png_byte)((i >> 16) & 0xff); |
buf[2] = (png_byte)((i >> 8) & 0xff); |
buf[3] = (png_byte)(i & 0xff); |
} |
#if defined(PNG_WRITE_pCAL_SUPPORTED) || defined(PNG_WRITE_oFFs_SUPPORTED) |
/* The png_save_int_32 function assumes integers are stored in two's |
* complement format. If this isn't the case, then this routine needs to |
* be modified to write data in two's complement format. |
*/ |
void /* PRIVATE */ |
png_save_int_32(png_bytep buf, png_int_32 i) |
{ |
buf[0] = (png_byte)((i >> 24) & 0xff); |
buf[1] = (png_byte)((i >> 16) & 0xff); |
buf[2] = (png_byte)((i >> 8) & 0xff); |
buf[3] = (png_byte)(i & 0xff); |
} |
#endif |
/* Place a 16-bit number into a buffer in PNG byte order. |
* The parameter is declared unsigned int, not png_uint_16, |
* just to avoid potential problems on pre-ANSI C compilers. |
*/ |
void /* PRIVATE */ |
png_save_uint_16(png_bytep buf, unsigned int i) |
{ |
buf[0] = (png_byte)((i >> 8) & 0xff); |
buf[1] = (png_byte)(i & 0xff); |
} |
/* Write a PNG chunk all at once. The type is an array of ASCII characters |
* representing the chunk name. The array must be at least 4 bytes in |
* length, and does not need to be null terminated. To be safe, pass the |
* pre-defined chunk names here, and if you need a new one, define it |
* where the others are defined. The length is the length of the data. |
* All the data must be present. If that is not possible, use the |
* png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() |
* functions instead. |
*/ |
void PNGAPI |
png_write_chunk(png_structp png_ptr, png_bytep chunk_name, |
png_bytep data, png_size_t length) |
{ |
png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length); |
png_write_chunk_data(png_ptr, data, length); |
png_write_chunk_end(png_ptr); |
} |
/* Write the start of a PNG chunk. The type is the chunk type. |
* The total_length is the sum of the lengths of all the data you will be |
* passing in png_write_chunk_data(). |
*/ |
void PNGAPI |
png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name, |
png_uint_32 length) |
{ |
png_byte buf[4]; |
png_debug2(0, "Writing %s chunk (%lu bytes)\n", chunk_name, length); |
/* write the length */ |
png_save_uint_32(buf, length); |
png_write_data(png_ptr, buf, (png_size_t)4); |
/* write the chunk name */ |
png_write_data(png_ptr, chunk_name, (png_size_t)4); |
/* reset the crc and run it over the chunk name */ |
png_reset_crc(png_ptr); |
png_calculate_crc(png_ptr, chunk_name, (png_size_t)4); |
} |
/* Write the data of a PNG chunk started with png_write_chunk_start(). |
* Note that multiple calls to this function are allowed, and that the |
* sum of the lengths from these calls *must* add up to the total_length |
* given to png_write_chunk_start(). |
*/ |
void PNGAPI |
png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
/* write the data, and run the CRC over it */ |
if (data != NULL && length > 0) |
{ |
png_calculate_crc(png_ptr, data, length); |
png_write_data(png_ptr, data, length); |
} |
} |
/* Finish a chunk started with png_write_chunk_start(). */ |
void PNGAPI |
png_write_chunk_end(png_structp png_ptr) |
{ |
png_byte buf[4]; |
/* write the crc */ |
png_save_uint_32(buf, png_ptr->crc); |
png_write_data(png_ptr, buf, (png_size_t)4); |
} |
/* Simple function to write the signature. If we have already written |
* the magic bytes of the signature, or more likely, the PNG stream is |
* being embedded into another stream and doesn't need its own signature, |
* we should call png_set_sig_bytes() to tell libpng how many of the |
* bytes have already been written. |
*/ |
void /* PRIVATE */ |
png_write_sig(png_structp png_ptr) |
{ |
png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; |
/* write the rest of the 8 byte signature */ |
png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes], |
(png_size_t)8 - png_ptr->sig_bytes); |
if(png_ptr->sig_bytes < 3) |
png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; |
} |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED) |
/* |
* This pair of functions encapsulates the operation of (a) compressing a |
* text string, and (b) issuing it later as a series of chunk data writes. |
* The compression_state structure is shared context for these functions |
* set up by the caller in order to make the whole mess thread-safe. |
*/ |
typedef struct |
{ |
char *input; /* the uncompressed input data */ |
int input_len; /* its length */ |
int num_output_ptr; /* number of output pointers used */ |
int max_output_ptr; /* size of output_ptr */ |
png_charpp output_ptr; /* array of pointers to output */ |
} compression_state; |
/* compress given text into storage in the png_ptr structure */ |
static int /* PRIVATE */ |
png_text_compress(png_structp png_ptr, |
png_charp text, png_size_t text_len, int compression, |
compression_state *comp) |
{ |
int ret; |
comp->num_output_ptr = comp->max_output_ptr = 0; |
comp->output_ptr = NULL; |
comp->input = NULL; |
/* we may just want to pass the text right through */ |
if (compression == PNG_TEXT_COMPRESSION_NONE) |
{ |
comp->input = text; |
comp->input_len = text_len; |
return((int)text_len); |
} |
if (compression >= PNG_TEXT_COMPRESSION_LAST) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char msg[50]; |
sprintf(msg, "Unknown compression type %d", compression); |
png_warning(png_ptr, msg); |
#else |
png_warning(png_ptr, "Unknown compression type"); |
#endif |
} |
/* We can't write the chunk until we find out how much data we have, |
* which means we need to run the compressor first and save the |
* output. This shouldn't be a problem, as the vast majority of |
* comments should be reasonable, but we will set up an array of |
* malloc'd pointers to be sure. |
* |
* If we knew the application was well behaved, we could simplify this |
* greatly by assuming we can always malloc an output buffer large |
* enough to hold the compressed text ((1001 * text_len / 1000) + 12) |
* and malloc this directly. The only time this would be a bad idea is |
* if we can't malloc more than 64K and we have 64K of random input |
* data, or if the input string is incredibly large (although this |
* wouldn't cause a failure, just a slowdown due to swapping). |
*/ |
/* set up the compression buffers */ |
png_ptr->zstream.avail_in = (uInt)text_len; |
png_ptr->zstream.next_in = (Bytef *)text; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf; |
/* this is the same compression loop as in png_write_row() */ |
do |
{ |
/* compress the data */ |
ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); |
if (ret != Z_OK) |
{ |
/* error */ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
/* check to see if we need more room */ |
if (!png_ptr->zstream.avail_out && png_ptr->zstream.avail_in) |
{ |
/* make sure the output array has room */ |
if (comp->num_output_ptr >= comp->max_output_ptr) |
{ |
int old_max; |
old_max = comp->max_output_ptr; |
comp->max_output_ptr = comp->num_output_ptr + 4; |
if (comp->output_ptr != NULL) |
{ |
png_charpp old_ptr; |
old_ptr = comp->output_ptr; |
comp->output_ptr = (png_charpp)png_malloc(png_ptr, |
(png_uint_32)(comp->max_output_ptr * sizeof (png_charpp))); |
png_memcpy(comp->output_ptr, old_ptr, old_max |
* sizeof (png_charp)); |
png_free(png_ptr, old_ptr); |
} |
else |
comp->output_ptr = (png_charpp)png_malloc(png_ptr, |
(png_uint_32)(comp->max_output_ptr * sizeof (png_charp))); |
} |
/* save the data */ |
comp->output_ptr[comp->num_output_ptr] = (png_charp)png_malloc(png_ptr, |
(png_uint_32)png_ptr->zbuf_size); |
png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, |
png_ptr->zbuf_size); |
comp->num_output_ptr++; |
/* and reset the buffer */ |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = png_ptr->zbuf; |
} |
/* continue until we don't have any more to compress */ |
} while (png_ptr->zstream.avail_in); |
/* finish the compression */ |
do |
{ |
/* tell zlib we are finished */ |
ret = deflate(&png_ptr->zstream, Z_FINISH); |
if (ret == Z_OK) |
{ |
/* check to see if we need more room */ |
if (!(png_ptr->zstream.avail_out)) |
{ |
/* check to make sure our output array has room */ |
if (comp->num_output_ptr >= comp->max_output_ptr) |
{ |
int old_max; |
old_max = comp->max_output_ptr; |
comp->max_output_ptr = comp->num_output_ptr + 4; |
if (comp->output_ptr != NULL) |
{ |
png_charpp old_ptr; |
old_ptr = comp->output_ptr; |
/* This could be optimized to realloc() */ |
comp->output_ptr = (png_charpp)png_malloc(png_ptr, |
(png_uint_32)(comp->max_output_ptr * sizeof (png_charpp))); |
png_memcpy(comp->output_ptr, old_ptr, |
old_max * sizeof (png_charp)); |
png_free(png_ptr, old_ptr); |
} |
else |
comp->output_ptr = (png_charpp)png_malloc(png_ptr, |
(png_uint_32)(comp->max_output_ptr * sizeof (png_charp))); |
} |
/* save off the data */ |
comp->output_ptr[comp->num_output_ptr] = |
(png_charp)png_malloc(png_ptr, (png_uint_32)png_ptr->zbuf_size); |
png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, |
png_ptr->zbuf_size); |
comp->num_output_ptr++; |
/* and reset the buffer pointers */ |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = png_ptr->zbuf; |
} |
} |
else if (ret != Z_STREAM_END) |
{ |
/* we got an error */ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
} while (ret != Z_STREAM_END); |
/* text length is number of buffers plus last buffer */ |
text_len = png_ptr->zbuf_size * comp->num_output_ptr; |
if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) |
text_len += png_ptr->zbuf_size - (png_size_t)png_ptr->zstream.avail_out; |
return((int)text_len); |
} |
/* ship the compressed text out via chunk writes */ |
static void /* PRIVATE */ |
png_write_compressed_data_out(png_structp png_ptr, compression_state *comp) |
{ |
int i; |
/* handle the no-compression case */ |
if (comp->input) |
{ |
png_write_chunk_data(png_ptr, (png_bytep)comp->input, |
(png_size_t)comp->input_len); |
return; |
} |
/* write saved output buffers, if any */ |
for (i = 0; i < comp->num_output_ptr; i++) |
{ |
png_write_chunk_data(png_ptr,(png_bytep)comp->output_ptr[i], |
png_ptr->zbuf_size); |
png_free(png_ptr, comp->output_ptr[i]); |
comp->output_ptr[i]=NULL; |
} |
if (comp->max_output_ptr != 0) |
png_free(png_ptr, comp->output_ptr); |
comp->output_ptr=NULL; |
/* write anything left in zbuf */ |
if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size) |
png_write_chunk_data(png_ptr, png_ptr->zbuf, |
png_ptr->zbuf_size - png_ptr->zstream.avail_out); |
/* reset zlib for another zTXt/iTXt or the image data */ |
deflateReset(&png_ptr->zstream); |
} |
#endif |
/* Write the IHDR chunk, and update the png_struct with the necessary |
* information. Note that the rest of this code depends upon this |
* information being correct. |
*/ |
void /* PRIVATE */ |
png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, |
int bit_depth, int color_type, int compression_type, int filter_type, |
int interlace_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IHDR; |
#endif |
png_byte buf[13]; /* buffer to store the IHDR info */ |
png_debug(1, "in png_write_IHDR\n"); |
/* Check that we have valid input data from the application info */ |
switch (color_type) |
{ |
case PNG_COLOR_TYPE_GRAY: |
switch (bit_depth) |
{ |
case 1: |
case 2: |
case 4: |
case 8: |
case 16: png_ptr->channels = 1; break; |
default: png_error(png_ptr,"Invalid bit depth for grayscale image"); |
} |
break; |
case PNG_COLOR_TYPE_RGB: |
if (bit_depth != 8 && bit_depth != 16) |
png_error(png_ptr, "Invalid bit depth for RGB image"); |
png_ptr->channels = 3; |
break; |
case PNG_COLOR_TYPE_PALETTE: |
switch (bit_depth) |
{ |
case 1: |
case 2: |
case 4: |
case 8: png_ptr->channels = 1; break; |
default: png_error(png_ptr, "Invalid bit depth for paletted image"); |
} |
break; |
case PNG_COLOR_TYPE_GRAY_ALPHA: |
if (bit_depth != 8 && bit_depth != 16) |
png_error(png_ptr, "Invalid bit depth for grayscale+alpha image"); |
png_ptr->channels = 2; |
break; |
case PNG_COLOR_TYPE_RGB_ALPHA: |
if (bit_depth != 8 && bit_depth != 16) |
png_error(png_ptr, "Invalid bit depth for RGBA image"); |
png_ptr->channels = 4; |
break; |
default: |
png_error(png_ptr, "Invalid image color type specified"); |
} |
if (compression_type != PNG_COMPRESSION_TYPE_BASE) |
{ |
png_warning(png_ptr, "Invalid compression type specified"); |
compression_type = PNG_COMPRESSION_TYPE_BASE; |
} |
/* Write filter_method 64 (intrapixel differencing) only if |
* 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and |
* 2. Libpng did not write a PNG signature (this filter_method is only |
* used in PNG datastreams that are embedded in MNG datastreams) and |
* 3. The application called png_permit_mng_features with a mask that |
* included PNG_FLAG_MNG_FILTER_64 and |
* 4. The filter_method is 64 and |
* 5. The color_type is RGB or RGBA |
*/ |
if ( |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && |
((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && |
(color_type == PNG_COLOR_TYPE_RGB || |
color_type == PNG_COLOR_TYPE_RGB_ALPHA) && |
(filter_type == PNG_INTRAPIXEL_DIFFERENCING)) && |
#endif |
filter_type != PNG_FILTER_TYPE_BASE) |
{ |
png_warning(png_ptr, "Invalid filter type specified"); |
filter_type = PNG_FILTER_TYPE_BASE; |
} |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
if (interlace_type != PNG_INTERLACE_NONE && |
interlace_type != PNG_INTERLACE_ADAM7) |
{ |
png_warning(png_ptr, "Invalid interlace type specified"); |
interlace_type = PNG_INTERLACE_ADAM7; |
} |
#else |
interlace_type=PNG_INTERLACE_NONE; |
#endif |
/* save off the relevent information */ |
png_ptr->bit_depth = (png_byte)bit_depth; |
png_ptr->color_type = (png_byte)color_type; |
png_ptr->interlaced = (png_byte)interlace_type; |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
png_ptr->filter_type = (png_byte)filter_type; |
#endif |
png_ptr->width = width; |
png_ptr->height = height; |
png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels); |
png_ptr->rowbytes = ((width * (png_size_t)png_ptr->pixel_depth + 7) >> 3); |
/* set the usr info, so any transformations can modify it */ |
png_ptr->usr_width = png_ptr->width; |
png_ptr->usr_bit_depth = png_ptr->bit_depth; |
png_ptr->usr_channels = png_ptr->channels; |
/* pack the header information into the buffer */ |
png_save_uint_32(buf, width); |
png_save_uint_32(buf + 4, height); |
buf[8] = (png_byte)bit_depth; |
buf[9] = (png_byte)color_type; |
buf[10] = (png_byte)compression_type; |
buf[11] = (png_byte)filter_type; |
buf[12] = (png_byte)interlace_type; |
/* write the chunk */ |
png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13); |
/* initialize zlib with PNG info */ |
png_ptr->zstream.zalloc = png_zalloc; |
png_ptr->zstream.zfree = png_zfree; |
png_ptr->zstream.opaque = (voidpf)png_ptr; |
if (!(png_ptr->do_filter)) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE || |
png_ptr->bit_depth < 8) |
png_ptr->do_filter = PNG_FILTER_NONE; |
else |
png_ptr->do_filter = PNG_ALL_FILTERS; |
} |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)) |
{ |
if (png_ptr->do_filter != PNG_FILTER_NONE) |
png_ptr->zlib_strategy = Z_FILTERED; |
else |
png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY; |
} |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL)) |
png_ptr->zlib_level = Z_DEFAULT_COMPRESSION; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL)) |
png_ptr->zlib_mem_level = 8; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS)) |
png_ptr->zlib_window_bits = 15; |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD)) |
png_ptr->zlib_method = 8; |
deflateInit2(&png_ptr->zstream, png_ptr->zlib_level, |
png_ptr->zlib_method, png_ptr->zlib_window_bits, |
png_ptr->zlib_mem_level, png_ptr->zlib_strategy); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->mode = PNG_HAVE_IHDR; |
} |
/* write the palette. We are careful not to trust png_color to be in the |
* correct order for PNG, so people can redefine it to any convenient |
* structure. |
*/ |
void /* PRIVATE */ |
png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_PLTE; |
#endif |
png_uint_32 i; |
png_colorp pal_ptr; |
png_byte buf[3]; |
png_debug(1, "in png_write_PLTE\n"); |
if (( |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) && |
#endif |
num_pal == 0) || num_pal > 256) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_error(png_ptr, "Invalid number of colors in palette"); |
} |
else |
{ |
png_warning(png_ptr, "Invalid number of colors in palette"); |
return; |
} |
} |
if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) |
{ |
png_warning(png_ptr, |
"Ignoring request to write a PLTE chunk in grayscale PNG"); |
return; |
} |
png_ptr->num_palette = (png_uint_16)num_pal; |
png_debug1(3, "num_palette = %d\n", png_ptr->num_palette); |
png_write_chunk_start(png_ptr, (png_bytep)png_PLTE, num_pal * 3); |
#ifndef PNG_NO_POINTER_INDEXING |
for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++) |
{ |
buf[0] = pal_ptr->red; |
buf[1] = pal_ptr->green; |
buf[2] = pal_ptr->blue; |
png_write_chunk_data(png_ptr, buf, (png_size_t)3); |
} |
#else |
/* This is a little slower but some buggy compilers need to do this instead */ |
pal_ptr=palette; |
for (i = 0; i < num_pal; i++) |
{ |
buf[0] = pal_ptr[i].red; |
buf[1] = pal_ptr[i].green; |
buf[2] = pal_ptr[i].blue; |
png_write_chunk_data(png_ptr, buf, (png_size_t)3); |
} |
#endif |
png_write_chunk_end(png_ptr); |
png_ptr->mode |= PNG_HAVE_PLTE; |
} |
/* write an IDAT chunk */ |
void /* PRIVATE */ |
png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IDAT; |
#endif |
png_debug(1, "in png_write_IDAT\n"); |
png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length); |
png_ptr->mode |= PNG_HAVE_IDAT; |
} |
/* write an IEND chunk */ |
void /* PRIVATE */ |
png_write_IEND(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_IEND; |
#endif |
png_debug(1, "in png_write_IEND\n"); |
png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL, |
(png_size_t)0); |
png_ptr->mode |= PNG_HAVE_IEND; |
} |
#if defined(PNG_WRITE_gAMA_SUPPORTED) |
/* write a gAMA chunk */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void /* PRIVATE */ |
png_write_gAMA(png_structp png_ptr, double file_gamma) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_gAMA; |
#endif |
png_uint_32 igamma; |
png_byte buf[4]; |
png_debug(1, "in png_write_gAMA\n"); |
/* file_gamma is saved in 1/100,000ths */ |
igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5); |
png_save_uint_32(buf, igamma); |
png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void /* PRIVATE */ |
png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_gAMA; |
#endif |
png_byte buf[4]; |
png_debug(1, "in png_write_gAMA\n"); |
/* file_gamma is saved in 1/100,000ths */ |
png_save_uint_32(buf, (png_uint_32)file_gamma); |
png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); |
} |
#endif |
#endif |
#if defined(PNG_WRITE_sRGB_SUPPORTED) |
/* write a sRGB chunk */ |
void /* PRIVATE */ |
png_write_sRGB(png_structp png_ptr, int srgb_intent) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_sRGB; |
#endif |
png_byte buf[1]; |
png_debug(1, "in png_write_sRGB\n"); |
if(srgb_intent >= PNG_sRGB_INTENT_LAST) |
png_warning(png_ptr, |
"Invalid sRGB rendering intent specified"); |
buf[0]=(png_byte)srgb_intent; |
png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1); |
} |
#endif |
#if defined(PNG_WRITE_iCCP_SUPPORTED) |
/* write an iCCP chunk */ |
void /* PRIVATE */ |
png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type, |
png_charp profile, int profile_len) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_iCCP; |
#endif |
png_size_t name_len; |
png_charp new_name; |
compression_state comp; |
png_debug(1, "in png_write_iCCP\n"); |
if (name == NULL || (name_len = png_check_keyword(png_ptr, name, |
&new_name)) == 0) |
{ |
png_warning(png_ptr, "Empty keyword in iCCP chunk"); |
return; |
} |
if (compression_type != PNG_COMPRESSION_TYPE_BASE) |
png_warning(png_ptr, "Unknown compression type in iCCP chunk"); |
if (profile == NULL) |
profile_len = 0; |
if (profile_len) |
profile_len = png_text_compress(png_ptr, profile, (png_size_t)profile_len, |
PNG_COMPRESSION_TYPE_BASE, &comp); |
/* make sure we include the NULL after the name and the compression type */ |
png_write_chunk_start(png_ptr, (png_bytep)png_iCCP, |
(png_uint_32)name_len+profile_len+2); |
new_name[name_len+1]=0x00; |
png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 2); |
if (profile_len) |
png_write_compressed_data_out(png_ptr, &comp); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_name); |
} |
#endif |
#if defined(PNG_WRITE_sPLT_SUPPORTED) |
/* write a sPLT chunk */ |
void /* PRIVATE */ |
png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_sPLT; |
#endif |
png_size_t name_len; |
png_charp new_name; |
png_byte entrybuf[10]; |
int entry_size = (spalette->depth == 8 ? 6 : 10); |
int palette_size = entry_size * spalette->nentries; |
png_sPLT_entryp ep; |
#ifdef PNG_NO_POINTER_INDEXING |
int i; |
#endif |
png_debug(1, "in png_write_sPLT\n"); |
if (spalette->name == NULL || (name_len = png_check_keyword(png_ptr, |
spalette->name, &new_name))==0) |
{ |
png_warning(png_ptr, "Empty keyword in sPLT chunk"); |
return; |
} |
/* make sure we include the NULL after the name */ |
png_write_chunk_start(png_ptr, (png_bytep)png_sPLT, |
(png_uint_32)(name_len + 2 + palette_size)); |
png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 1); |
png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, 1); |
/* loop through each palette entry, writing appropriately */ |
#ifndef PNG_NO_POINTER_INDEXING |
for (ep = spalette->entries; ep<spalette->entries+spalette->nentries; ep++) |
{ |
if (spalette->depth == 8) |
{ |
entrybuf[0] = (png_byte)ep->red; |
entrybuf[1] = (png_byte)ep->green; |
entrybuf[2] = (png_byte)ep->blue; |
entrybuf[3] = (png_byte)ep->alpha; |
png_save_uint_16(entrybuf + 4, ep->frequency); |
} |
else |
{ |
png_save_uint_16(entrybuf + 0, ep->red); |
png_save_uint_16(entrybuf + 2, ep->green); |
png_save_uint_16(entrybuf + 4, ep->blue); |
png_save_uint_16(entrybuf + 6, ep->alpha); |
png_save_uint_16(entrybuf + 8, ep->frequency); |
} |
png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size); |
} |
#else |
ep=spalette->entries; |
for (i=0; i>spalette->nentries; i++) |
{ |
if (spalette->depth == 8) |
{ |
entrybuf[0] = (png_byte)ep[i].red; |
entrybuf[1] = (png_byte)ep[i].green; |
entrybuf[2] = (png_byte)ep[i].blue; |
entrybuf[3] = (png_byte)ep[i].alpha; |
png_save_uint_16(entrybuf + 4, ep[i].frequency); |
} |
else |
{ |
png_save_uint_16(entrybuf + 0, ep[i].red); |
png_save_uint_16(entrybuf + 2, ep[i].green); |
png_save_uint_16(entrybuf + 4, ep[i].blue); |
png_save_uint_16(entrybuf + 6, ep[i].alpha); |
png_save_uint_16(entrybuf + 8, ep[i].frequency); |
} |
png_write_chunk_data(png_ptr, entrybuf, entry_size); |
} |
#endif |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_name); |
} |
#endif |
#if defined(PNG_WRITE_sBIT_SUPPORTED) |
/* write the sBIT chunk */ |
void /* PRIVATE */ |
png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_sBIT; |
#endif |
png_byte buf[4]; |
png_size_t size; |
png_debug(1, "in png_write_sBIT\n"); |
/* make sure we don't depend upon the order of PNG_COLOR_8 */ |
if (color_type & PNG_COLOR_MASK_COLOR) |
{ |
png_byte maxbits; |
maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 : |
png_ptr->usr_bit_depth); |
if (sbit->red == 0 || sbit->red > maxbits || |
sbit->green == 0 || sbit->green > maxbits || |
sbit->blue == 0 || sbit->blue > maxbits) |
{ |
png_warning(png_ptr, "Invalid sBIT depth specified"); |
return; |
} |
buf[0] = sbit->red; |
buf[1] = sbit->green; |
buf[2] = sbit->blue; |
size = 3; |
} |
else |
{ |
if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth) |
{ |
png_warning(png_ptr, "Invalid sBIT depth specified"); |
return; |
} |
buf[0] = sbit->gray; |
size = 1; |
} |
if (color_type & PNG_COLOR_MASK_ALPHA) |
{ |
if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth) |
{ |
png_warning(png_ptr, "Invalid sBIT depth specified"); |
return; |
} |
buf[size++] = sbit->alpha; |
} |
png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size); |
} |
#endif |
#if defined(PNG_WRITE_cHRM_SUPPORTED) |
/* write the cHRM chunk */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void /* PRIVATE */ |
png_write_cHRM(png_structp png_ptr, double white_x, double white_y, |
double red_x, double red_y, double green_x, double green_y, |
double blue_x, double blue_y) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_cHRM; |
#endif |
png_byte buf[32]; |
png_uint_32 itemp; |
png_debug(1, "in png_write_cHRM\n"); |
/* each value is saved in 1/100,000ths */ |
if (white_x < 0 || white_x > 0.8 || white_y < 0 || white_y > 0.8 || |
white_x + white_y > 1.0) |
{ |
png_warning(png_ptr, "Invalid cHRM white point specified"); |
#if !defined(PNG_NO_CONSOLE_IO) |
cprintf("white_x=%f, white_y=%f\n",white_x, white_y); |
#endif |
return; |
} |
itemp = (png_uint_32)(white_x * 100000.0 + 0.5); |
png_save_uint_32(buf, itemp); |
itemp = (png_uint_32)(white_y * 100000.0 + 0.5); |
png_save_uint_32(buf + 4, itemp); |
if (red_x < 0 || red_x > 0.8 || red_y < 0 || red_y > 0.8 || |
red_x + red_y > 1.0) |
{ |
png_warning(png_ptr, "Invalid cHRM red point specified"); |
return; |
} |
itemp = (png_uint_32)(red_x * 100000.0 + 0.5); |
png_save_uint_32(buf + 8, itemp); |
itemp = (png_uint_32)(red_y * 100000.0 + 0.5); |
png_save_uint_32(buf + 12, itemp); |
if (green_x < 0 || green_x > 0.8 || green_y < 0 || green_y > 0.8 || |
green_x + green_y > 1.0) |
{ |
png_warning(png_ptr, "Invalid cHRM green point specified"); |
return; |
} |
itemp = (png_uint_32)(green_x * 100000.0 + 0.5); |
png_save_uint_32(buf + 16, itemp); |
itemp = (png_uint_32)(green_y * 100000.0 + 0.5); |
png_save_uint_32(buf + 20, itemp); |
if (blue_x < 0 || blue_x > 0.8 || blue_y < 0 || blue_y > 0.8 || |
blue_x + blue_y > 1.0) |
{ |
png_warning(png_ptr, "Invalid cHRM blue point specified"); |
return; |
} |
itemp = (png_uint_32)(blue_x * 100000.0 + 0.5); |
png_save_uint_32(buf + 24, itemp); |
itemp = (png_uint_32)(blue_y * 100000.0 + 0.5); |
png_save_uint_32(buf + 28, itemp); |
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void /* PRIVATE */ |
png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, |
png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, |
png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, |
png_fixed_point blue_y) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_cHRM; |
#endif |
png_byte buf[32]; |
png_debug(1, "in png_write_cHRM\n"); |
/* each value is saved in 1/100,000ths */ |
if (white_x > 80000L || white_y > 80000L || white_x + white_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid fixed cHRM white point specified"); |
#if !defined(PNG_NO_CONSOLE_IO) |
cprintf("white_x=%ld, white_y=%ld\n",white_x, white_y); |
#endif |
return; |
} |
png_save_uint_32(buf, (png_uint_32)white_x); |
png_save_uint_32(buf + 4, (png_uint_32)white_y); |
if (red_x > 80000L || red_y > 80000L || red_x + red_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid cHRM fixed red point specified"); |
return; |
} |
png_save_uint_32(buf + 8, (png_uint_32)red_x); |
png_save_uint_32(buf + 12, (png_uint_32)red_y); |
if (green_x > 80000L || green_y > 80000L || green_x + green_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid fixed cHRM green point specified"); |
return; |
} |
png_save_uint_32(buf + 16, (png_uint_32)green_x); |
png_save_uint_32(buf + 20, (png_uint_32)green_y); |
if (blue_x > 80000L || blue_y > 80000L || blue_x + blue_y > 100000L) |
{ |
png_warning(png_ptr, "Invalid fixed cHRM blue point specified"); |
return; |
} |
png_save_uint_32(buf + 24, (png_uint_32)blue_x); |
png_save_uint_32(buf + 28, (png_uint_32)blue_y); |
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); |
} |
#endif |
#endif |
#if defined(PNG_WRITE_tRNS_SUPPORTED) |
/* write the tRNS chunk */ |
void /* PRIVATE */ |
png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, |
int num_trans, int color_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_tRNS; |
#endif |
png_byte buf[6]; |
png_debug(1, "in png_write_tRNS\n"); |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette) |
{ |
png_warning(png_ptr,"Invalid number of transparent colors specified"); |
return; |
} |
/* write the chunk out as it is */ |
png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans, (png_size_t)num_trans); |
} |
else if (color_type == PNG_COLOR_TYPE_GRAY) |
{ |
/* one 16 bit value */ |
if(tran->gray >= (1 << png_ptr->bit_depth)) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to write tRNS chunk out-of-range for bit_depth"); |
return; |
} |
png_save_uint_16(buf, tran->gray); |
png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2); |
} |
else if (color_type == PNG_COLOR_TYPE_RGB) |
{ |
/* three 16 bit values */ |
png_save_uint_16(buf, tran->red); |
png_save_uint_16(buf + 2, tran->green); |
png_save_uint_16(buf + 4, tran->blue); |
if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8"); |
return; |
} |
png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6); |
} |
else |
{ |
png_warning(png_ptr, "Can't write tRNS with an alpha channel"); |
} |
} |
#endif |
#if defined(PNG_WRITE_bKGD_SUPPORTED) |
/* write the background chunk */ |
void /* PRIVATE */ |
png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_bKGD; |
#endif |
png_byte buf[6]; |
png_debug(1, "in png_write_bKGD\n"); |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if ( |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
(png_ptr->num_palette || |
(!(png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE))) && |
#endif |
back->index > png_ptr->num_palette) |
{ |
png_warning(png_ptr, "Invalid background palette index"); |
return; |
} |
buf[0] = back->index; |
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1); |
} |
else if (color_type & PNG_COLOR_MASK_COLOR) |
{ |
png_save_uint_16(buf, back->red); |
png_save_uint_16(buf + 2, back->green); |
png_save_uint_16(buf + 4, back->blue); |
if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8"); |
return; |
} |
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6); |
} |
else |
{ |
if(back->gray >= (1 << png_ptr->bit_depth)) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to write bKGD chunk out-of-range for bit_depth"); |
return; |
} |
png_save_uint_16(buf, back->gray); |
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2); |
} |
} |
#endif |
#if defined(PNG_WRITE_hIST_SUPPORTED) |
/* write the histogram */ |
void /* PRIVATE */ |
png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_hIST; |
#endif |
int i; |
png_byte buf[3]; |
png_debug(1, "in png_write_hIST\n"); |
if (num_hist > (int)png_ptr->num_palette) |
{ |
png_debug2(3, "num_hist = %d, num_palette = %d\n", num_hist, |
png_ptr->num_palette); |
png_warning(png_ptr, "Invalid number of histogram entries specified"); |
return; |
} |
png_write_chunk_start(png_ptr, (png_bytep)png_hIST, (png_uint_32)(num_hist * 2)); |
for (i = 0; i < num_hist; i++) |
{ |
png_save_uint_16(buf, hist[i]); |
png_write_chunk_data(png_ptr, buf, (png_size_t)2); |
} |
png_write_chunk_end(png_ptr); |
} |
#endif |
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ |
defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) |
/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification, |
* and if invalid, correct the keyword rather than discarding the entire |
* chunk. The PNG 1.0 specification requires keywords 1-79 characters in |
* length, forbids leading or trailing whitespace, multiple internal spaces, |
* and the non-break space (0x80) from ISO 8859-1. Returns keyword length. |
* |
* The new_key is allocated to hold the corrected keyword and must be freed |
* by the calling routine. This avoids problems with trying to write to |
* static keywords without having to have duplicate copies of the strings. |
*/ |
png_size_t /* PRIVATE */ |
png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key) |
{ |
png_size_t key_len; |
png_charp kp, dp; |
int kflag; |
int kwarn=0; |
png_debug(1, "in png_check_keyword\n"); |
*new_key = NULL; |
if (key == NULL || (key_len = png_strlen(key)) == 0) |
{ |
png_warning(png_ptr, "zero length keyword"); |
return ((png_size_t)0); |
} |
png_debug1(2, "Keyword to be checked is '%s'\n", key); |
*new_key = (png_charp)png_malloc(png_ptr, (png_uint_32)(key_len + 2)); |
/* Replace non-printing characters with a blank and print a warning */ |
for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++) |
{ |
if (*kp < 0x20 || (*kp > 0x7E && (png_byte)*kp < 0xA1)) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char msg[40]; |
sprintf(msg, "invalid keyword character 0x%02X", *kp); |
png_warning(png_ptr, msg); |
#else |
png_warning(png_ptr, "invalid character in keyword"); |
#endif |
*dp = ' '; |
} |
else |
{ |
*dp = *kp; |
} |
} |
*dp = '\0'; |
/* Remove any trailing white space. */ |
kp = *new_key + key_len - 1; |
if (*kp == ' ') |
{ |
png_warning(png_ptr, "trailing spaces removed from keyword"); |
while (*kp == ' ') |
{ |
*(kp--) = '\0'; |
key_len--; |
} |
} |
/* Remove any leading white space. */ |
kp = *new_key; |
if (*kp == ' ') |
{ |
png_warning(png_ptr, "leading spaces removed from keyword"); |
while (*kp == ' ') |
{ |
kp++; |
key_len--; |
} |
} |
png_debug1(2, "Checking for multiple internal spaces in '%s'\n", kp); |
/* Remove multiple internal spaces. */ |
for (kflag = 0, dp = *new_key; *kp != '\0'; kp++) |
{ |
if (*kp == ' ' && kflag == 0) |
{ |
*(dp++) = *kp; |
kflag = 1; |
} |
else if (*kp == ' ') |
{ |
key_len--; |
kwarn=1; |
} |
else |
{ |
*(dp++) = *kp; |
kflag = 0; |
} |
} |
*dp = '\0'; |
if(kwarn) |
png_warning(png_ptr, "extra interior spaces removed from keyword"); |
if (key_len == 0) |
{ |
png_free(png_ptr, *new_key); |
*new_key=NULL; |
png_warning(png_ptr, "Zero length keyword"); |
} |
if (key_len > 79) |
{ |
png_warning(png_ptr, "keyword length must be 1 - 79 characters"); |
new_key[79] = '\0'; |
key_len = 79; |
} |
return (key_len); |
} |
#endif |
#if defined(PNG_WRITE_tEXt_SUPPORTED) |
/* write a tEXt chunk */ |
void /* PRIVATE */ |
png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text, |
png_size_t text_len) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_tEXt; |
#endif |
png_size_t key_len; |
png_charp new_key; |
png_debug(1, "in png_write_tEXt\n"); |
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) |
{ |
png_warning(png_ptr, "Empty keyword in tEXt chunk"); |
return; |
} |
if (text == NULL || *text == '\0') |
text_len = 0; |
else |
text_len = png_strlen(text); |
/* make sure we include the 0 after the key */ |
png_write_chunk_start(png_ptr, (png_bytep)png_tEXt, (png_uint_32)key_len+text_len+1); |
/* |
* We leave it to the application to meet PNG-1.0 requirements on the |
* contents of the text. PNG-1.0 through PNG-1.2 discourage the use of |
* any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. |
* The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. |
*/ |
png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1); |
if (text_len) |
png_write_chunk_data(png_ptr, (png_bytep)text, text_len); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_key); |
} |
#endif |
#if defined(PNG_WRITE_zTXt_SUPPORTED) |
/* write a compressed text chunk */ |
void /* PRIVATE */ |
png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text, |
png_size_t text_len, int compression) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_zTXt; |
#endif |
png_size_t key_len; |
char buf[1]; |
png_charp new_key; |
compression_state comp; |
png_debug(1, "in png_write_zTXt\n"); |
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) |
{ |
png_warning(png_ptr, "Empty keyword in zTXt chunk"); |
return; |
} |
if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE) |
{ |
png_write_tEXt(png_ptr, new_key, text, (png_size_t)0); |
png_free(png_ptr, new_key); |
return; |
} |
text_len = png_strlen(text); |
png_free(png_ptr, new_key); |
/* compute the compressed data; do it now for the length */ |
text_len = png_text_compress(png_ptr, text, text_len, compression, |
&comp); |
/* write start of chunk */ |
png_write_chunk_start(png_ptr, (png_bytep)png_zTXt, (png_uint_32) |
(key_len+text_len+2)); |
/* write key */ |
png_write_chunk_data(png_ptr, (png_bytep)key, key_len + 1); |
buf[0] = (png_byte)compression; |
/* write compression */ |
png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1); |
/* write the compressed data */ |
png_write_compressed_data_out(png_ptr, &comp); |
/* close the chunk */ |
png_write_chunk_end(png_ptr); |
} |
#endif |
#if defined(PNG_WRITE_iTXt_SUPPORTED) |
/* write an iTXt chunk */ |
void /* PRIVATE */ |
png_write_iTXt(png_structp png_ptr, int compression, png_charp key, |
png_charp lang, png_charp lang_key, png_charp text) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_iTXt; |
#endif |
png_size_t lang_len, key_len, lang_key_len, text_len; |
png_charp new_lang, new_key; |
png_byte cbuf[2]; |
compression_state comp; |
png_debug(1, "in png_write_iTXt\n"); |
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0) |
{ |
png_warning(png_ptr, "Empty keyword in iTXt chunk"); |
return; |
} |
if (lang == NULL || (lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0) |
{ |
png_warning(png_ptr, "Empty language field in iTXt chunk"); |
new_lang = NULL; |
lang_len = 0; |
} |
if (lang_key == NULL) |
lang_key_len = 0; |
else |
lang_key_len = png_strlen(lang_key); |
if (text == NULL) |
text_len = 0; |
else |
text_len = png_strlen(text); |
/* compute the compressed data; do it now for the length */ |
text_len = png_text_compress(png_ptr, text, text_len, compression-2, |
&comp); |
/* make sure we include the compression flag, the compression byte, |
* and the NULs after the key, lang, and lang_key parts */ |
png_write_chunk_start(png_ptr, (png_bytep)png_iTXt, |
(png_uint_32)( |
5 /* comp byte, comp flag, terminators for key, lang and lang_key */ |
+ key_len |
+ lang_len |
+ lang_key_len |
+ text_len)); |
/* |
* We leave it to the application to meet PNG-1.0 requirements on the |
* contents of the text. PNG-1.0 through PNG-1.2 discourage the use of |
* any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. |
* The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. |
*/ |
png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1); |
/* set the compression flag */ |
if (compression == PNG_ITXT_COMPRESSION_NONE || \ |
compression == PNG_TEXT_COMPRESSION_NONE) |
cbuf[0] = 0; |
else /* compression == PNG_ITXT_COMPRESSION_zTXt */ |
cbuf[0] = 1; |
/* set the compression method */ |
cbuf[1] = 0; |
png_write_chunk_data(png_ptr, cbuf, 2); |
cbuf[0] = 0; |
png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf), lang_len + 1); |
png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf), lang_key_len + 1); |
png_write_compressed_data_out(png_ptr, &comp); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_key); |
if (new_lang) |
png_free(png_ptr, new_lang); |
} |
#endif |
#if defined(PNG_WRITE_oFFs_SUPPORTED) |
/* write the oFFs chunk */ |
void /* PRIVATE */ |
png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, |
int unit_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_oFFs; |
#endif |
png_byte buf[9]; |
png_debug(1, "in png_write_oFFs\n"); |
if (unit_type >= PNG_OFFSET_LAST) |
png_warning(png_ptr, "Unrecognized unit type for oFFs chunk"); |
png_save_int_32(buf, x_offset); |
png_save_int_32(buf + 4, y_offset); |
buf[8] = (png_byte)unit_type; |
png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9); |
} |
#endif |
#if defined(PNG_WRITE_pCAL_SUPPORTED) |
/* write the pCAL chunk (described in the PNG extensions document) */ |
void /* PRIVATE */ |
png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, |
png_int_32 X1, int type, int nparams, png_charp units, png_charpp params) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_pCAL; |
#endif |
png_size_t purpose_len, units_len, total_len; |
png_uint_32p params_len; |
png_byte buf[10]; |
png_charp new_purpose; |
int i; |
png_debug1(1, "in png_write_pCAL (%d parameters)\n", nparams); |
if (type >= PNG_EQUATION_LAST) |
png_warning(png_ptr, "Unrecognized equation type for pCAL chunk"); |
purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1; |
png_debug1(3, "pCAL purpose length = %d\n", (int)purpose_len); |
units_len = png_strlen(units) + (nparams == 0 ? 0 : 1); |
png_debug1(3, "pCAL units length = %d\n", (int)units_len); |
total_len = purpose_len + units_len + 10; |
params_len = (png_uint_32p)png_malloc(png_ptr, (png_uint_32)(nparams |
*sizeof(png_uint_32))); |
/* Find the length of each parameter, making sure we don't count the |
null terminator for the last parameter. */ |
for (i = 0; i < nparams; i++) |
{ |
params_len[i] = png_strlen(params[i]) + (i == nparams - 1 ? 0 : 1); |
png_debug2(3, "pCAL parameter %d length = %lu\n", i, params_len[i]); |
total_len += (png_size_t)params_len[i]; |
} |
png_debug1(3, "pCAL total length = %d\n", (int)total_len); |
png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len); |
png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len); |
png_save_int_32(buf, X0); |
png_save_int_32(buf + 4, X1); |
buf[8] = (png_byte)type; |
buf[9] = (png_byte)nparams; |
png_write_chunk_data(png_ptr, buf, (png_size_t)10); |
png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len); |
png_free(png_ptr, new_purpose); |
for (i = 0; i < nparams; i++) |
{ |
png_write_chunk_data(png_ptr, (png_bytep)params[i], |
(png_size_t)params_len[i]); |
} |
png_free(png_ptr, params_len); |
png_write_chunk_end(png_ptr); |
} |
#endif |
#if defined(PNG_WRITE_sCAL_SUPPORTED) |
/* write the sCAL chunk */ |
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) |
void /* PRIVATE */ |
png_write_sCAL(png_structp png_ptr, int unit, double width,double height) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_sCAL; |
#endif |
png_size_t total_len; |
char wbuf[32], hbuf[32]; |
png_debug(1, "in png_write_sCAL\n"); |
#if defined(_WIN32_WCE) |
/* sprintf() function is not supported on WindowsCE */ |
{ |
wchar_t wc_buf[32]; |
swprintf(wc_buf, TEXT("%12.12e"), width); |
WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, wbuf, 32, NULL, NULL); |
swprintf(wc_buf, TEXT("%12.12e"), height); |
WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, hbuf, 32, NULL, NULL); |
} |
#else |
sprintf(wbuf, "%12.12e", width); |
sprintf(hbuf, "%12.12e", height); |
#endif |
total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf); |
png_debug1(3, "sCAL total length = %d\n", (int)total_len); |
png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len); |
png_write_chunk_data(png_ptr, (png_bytep)&unit, 1); |
png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1); |
png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf)); |
png_write_chunk_end(png_ptr); |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void /* PRIVATE */ |
png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width, |
png_charp height) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_sCAL; |
#endif |
png_size_t total_len; |
char wbuf[32], hbuf[32]; |
png_debug(1, "in png_write_sCAL_s\n"); |
png_strcpy(wbuf,(const char *)width); |
png_strcpy(hbuf,(const char *)height); |
total_len = 1 + png_strlen(wbuf)+1 + png_strlen(hbuf); |
png_debug1(3, "sCAL total length = %d\n", total_len); |
png_write_chunk_start(png_ptr, (png_bytep)png_sCAL, (png_uint_32)total_len); |
png_write_chunk_data(png_ptr, (png_bytep)&unit, 1); |
png_write_chunk_data(png_ptr, (png_bytep)wbuf, png_strlen(wbuf)+1); |
png_write_chunk_data(png_ptr, (png_bytep)hbuf, png_strlen(hbuf)); |
png_write_chunk_end(png_ptr); |
} |
#endif |
#endif |
#endif |
#if defined(PNG_WRITE_pHYs_SUPPORTED) |
/* write the pHYs chunk */ |
void /* PRIVATE */ |
png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, |
png_uint_32 y_pixels_per_unit, |
int unit_type) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_pHYs; |
#endif |
png_byte buf[9]; |
png_debug(1, "in png_write_pHYs\n"); |
if (unit_type >= PNG_RESOLUTION_LAST) |
png_warning(png_ptr, "Unrecognized unit type for pHYs chunk"); |
png_save_uint_32(buf, x_pixels_per_unit); |
png_save_uint_32(buf + 4, y_pixels_per_unit); |
buf[8] = (png_byte)unit_type; |
png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9); |
} |
#endif |
#if defined(PNG_WRITE_tIME_SUPPORTED) |
/* Write the tIME chunk. Use either png_convert_from_struct_tm() |
* or png_convert_from_time_t(), or fill in the structure yourself. |
*/ |
void /* PRIVATE */ |
png_write_tIME(png_structp png_ptr, png_timep mod_time) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
PNG_tIME; |
#endif |
png_byte buf[7]; |
png_debug(1, "in png_write_tIME\n"); |
if (mod_time->month > 12 || mod_time->month < 1 || |
mod_time->day > 31 || mod_time->day < 1 || |
mod_time->hour > 23 || mod_time->second > 60) |
{ |
png_warning(png_ptr, "Invalid time specified for tIME chunk"); |
return; |
} |
png_save_uint_16(buf, mod_time->year); |
buf[2] = mod_time->month; |
buf[3] = mod_time->day; |
buf[4] = mod_time->hour; |
buf[5] = mod_time->minute; |
buf[6] = mod_time->second; |
png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7); |
} |
#endif |
/* initializes the row writing capability of libpng */ |
void /* PRIVATE */ |
png_write_start_row(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
png_size_t buf_size; |
png_debug(1, "in png_write_start_row\n"); |
buf_size = (png_size_t)(((png_ptr->width * png_ptr->usr_channels * |
png_ptr->usr_bit_depth + 7) >> 3) + 1); |
/* set up row buffer */ |
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); |
png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; |
/* set up filtering buffer, if using this filter */ |
if (png_ptr->do_filter & PNG_FILTER_SUB) |
{ |
png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; |
} |
/* We only need to keep the previous row if we are using one of these. */ |
if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) |
{ |
/* set up previous row buffer */ |
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); |
png_memset(png_ptr->prev_row, 0, buf_size); |
if (png_ptr->do_filter & PNG_FILTER_UP) |
{ |
png_ptr->up_row = (png_bytep )png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; |
} |
if (png_ptr->do_filter & PNG_FILTER_AVG) |
{ |
png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; |
} |
if (png_ptr->do_filter & PNG_FILTER_PAETH) |
{ |
png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr, |
(png_ptr->rowbytes + 1)); |
png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; |
} |
} |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
/* if interlaced, we need to set up width and height of pass */ |
if (png_ptr->interlaced) |
{ |
if (!(png_ptr->transformations & PNG_INTERLACE)) |
{ |
png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - |
png_pass_ystart[0]) / png_pass_yinc[0]; |
png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 - |
png_pass_start[0]) / png_pass_inc[0]; |
} |
else |
{ |
png_ptr->num_rows = png_ptr->height; |
png_ptr->usr_width = png_ptr->width; |
} |
} |
else |
#endif |
{ |
png_ptr->num_rows = png_ptr->height; |
png_ptr->usr_width = png_ptr->width; |
} |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_ptr->zstream.next_out = png_ptr->zbuf; |
} |
/* Internal use only. Called when finished processing a row of data. */ |
void /* PRIVATE */ |
png_write_finish_row(png_structp png_ptr) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* start of interlace block in the y direction */ |
int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* offset to next interlace block in the y direction */ |
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
int ret; |
png_debug(1, "in png_write_finish_row\n"); |
/* next row */ |
png_ptr->row_number++; |
/* see if we are done */ |
if (png_ptr->row_number < png_ptr->num_rows) |
return; |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
/* if interlaced, go to next pass */ |
if (png_ptr->interlaced) |
{ |
png_ptr->row_number = 0; |
if (png_ptr->transformations & PNG_INTERLACE) |
{ |
png_ptr->pass++; |
} |
else |
{ |
/* loop until we find a non-zero width or height pass */ |
do |
{ |
png_ptr->pass++; |
if (png_ptr->pass >= 7) |
break; |
png_ptr->usr_width = (png_ptr->width + |
png_pass_inc[png_ptr->pass] - 1 - |
png_pass_start[png_ptr->pass]) / |
png_pass_inc[png_ptr->pass]; |
png_ptr->num_rows = (png_ptr->height + |
png_pass_yinc[png_ptr->pass] - 1 - |
png_pass_ystart[png_ptr->pass]) / |
png_pass_yinc[png_ptr->pass]; |
if (png_ptr->transformations & PNG_INTERLACE) |
break; |
} while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0); |
} |
/* reset the row above the image for the next pass */ |
if (png_ptr->pass < 7) |
{ |
if (png_ptr->prev_row != NULL) |
png_memset(png_ptr->prev_row, 0, |
(png_size_t) (((png_uint_32)png_ptr->usr_channels * |
(png_uint_32)png_ptr->usr_bit_depth * |
png_ptr->width + 7) >> 3) + 1); |
return; |
} |
} |
#endif |
/* if we get here, we've just written the last row, so we need |
to flush the compressor */ |
do |
{ |
/* tell the compressor we are done */ |
ret = deflate(&png_ptr->zstream, Z_FINISH); |
/* check for an error */ |
if (ret == Z_OK) |
{ |
/* check to see if we need more room */ |
if (!(png_ptr->zstream.avail_out)) |
{ |
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
} |
else if (ret != Z_STREAM_END) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
} while (ret != Z_STREAM_END); |
/* write any extra space */ |
if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) |
{ |
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size - |
png_ptr->zstream.avail_out); |
} |
deflateReset(&png_ptr->zstream); |
} |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
/* Pick out the correct pixels for the interlace pass. |
* The basic idea here is to go through the row with a source |
* pointer and a destination pointer (sp and dp), and copy the |
* correct pixels for the pass. As the row gets compacted, |
* sp will always be >= dp, so we should never overwrite anything. |
* See the default: case for the easiest code to understand. |
*/ |
void /* PRIVATE */ |
png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) |
{ |
#ifdef PNG_USE_LOCAL_ARRAYS |
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* start of interlace block */ |
int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* offset to next interlace block */ |
int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
#endif |
png_debug(1, "in png_do_write_interlace\n"); |
/* we don't have to do anything on the last pass (6) */ |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL && pass < 6) |
#else |
if (pass < 6) |
#endif |
{ |
/* each pixel depth is handled separately */ |
switch (row_info->pixel_depth) |
{ |
case 1: |
{ |
png_bytep sp; |
png_bytep dp; |
int shift; |
int d; |
int value; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
dp = row; |
d = 0; |
shift = 7; |
for (i = png_pass_start[pass]; i < row_width; |
i += png_pass_inc[pass]) |
{ |
sp = row + (png_size_t)(i >> 3); |
value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01; |
d |= (value << shift); |
if (shift == 0) |
{ |
shift = 7; |
*dp++ = (png_byte)d; |
d = 0; |
} |
else |
shift--; |
} |
if (shift != 7) |
*dp = (png_byte)d; |
break; |
} |
case 2: |
{ |
png_bytep sp; |
png_bytep dp; |
int shift; |
int d; |
int value; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
dp = row; |
shift = 6; |
d = 0; |
for (i = png_pass_start[pass]; i < row_width; |
i += png_pass_inc[pass]) |
{ |
sp = row + (png_size_t)(i >> 2); |
value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03; |
d |= (value << shift); |
if (shift == 0) |
{ |
shift = 6; |
*dp++ = (png_byte)d; |
d = 0; |
} |
else |
shift -= 2; |
} |
if (shift != 6) |
*dp = (png_byte)d; |
break; |
} |
case 4: |
{ |
png_bytep sp; |
png_bytep dp; |
int shift; |
int d; |
int value; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
dp = row; |
shift = 4; |
d = 0; |
for (i = png_pass_start[pass]; i < row_width; |
i += png_pass_inc[pass]) |
{ |
sp = row + (png_size_t)(i >> 1); |
value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f; |
d |= (value << shift); |
if (shift == 0) |
{ |
shift = 4; |
*dp++ = (png_byte)d; |
d = 0; |
} |
else |
shift -= 4; |
} |
if (shift != 4) |
*dp = (png_byte)d; |
break; |
} |
default: |
{ |
png_bytep sp; |
png_bytep dp; |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
png_size_t pixel_bytes; |
/* start at the beginning */ |
dp = row; |
/* find out how many bytes each pixel takes up */ |
pixel_bytes = (row_info->pixel_depth >> 3); |
/* loop through the row, only looking at the pixels that |
matter */ |
for (i = png_pass_start[pass]; i < row_width; |
i += png_pass_inc[pass]) |
{ |
/* find out where the original pixel is */ |
sp = row + (png_size_t)i * pixel_bytes; |
/* move the pixel */ |
if (dp != sp) |
png_memcpy(dp, sp, pixel_bytes); |
/* next pixel */ |
dp += pixel_bytes; |
} |
break; |
} |
} |
/* set new row width */ |
row_info->width = (row_info->width + |
png_pass_inc[pass] - 1 - |
png_pass_start[pass]) / |
png_pass_inc[pass]; |
row_info->rowbytes = ((row_info->width * |
row_info->pixel_depth + 7) >> 3); |
} |
} |
#endif |
/* This filters the row, chooses which filter to use, if it has not already |
* been specified by the application, and then writes the row out with the |
* chosen filter. |
*/ |
#define PNG_MAXSUM (~((png_uint_32)0) >> 1) |
#define PNG_HISHIFT 10 |
#define PNG_LOMASK ((png_uint_32)0xffffL) |
#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT)) |
void /* PRIVATE */ |
png_write_find_filter(png_structp png_ptr, png_row_infop row_info) |
{ |
png_bytep prev_row, best_row, row_buf; |
png_uint_32 mins, bpp; |
png_byte filter_to_do = png_ptr->do_filter; |
png_uint_32 row_bytes = row_info->rowbytes; |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
int num_p_filters = (int)png_ptr->num_prev_filters; |
#endif |
png_debug(1, "in png_write_find_filter\n"); |
/* find out how many bytes offset each pixel is */ |
bpp = (row_info->pixel_depth + 7) / 8; |
prev_row = png_ptr->prev_row; |
best_row = row_buf = png_ptr->row_buf; |
mins = PNG_MAXSUM; |
/* The prediction method we use is to find which method provides the |
* smallest value when summing the absolute values of the distances |
* from zero, using anything >= 128 as negative numbers. This is known |
* as the "minimum sum of absolute differences" heuristic. Other |
* heuristics are the "weighted minimum sum of absolute differences" |
* (experimental and can in theory improve compression), and the "zlib |
* predictive" method (not implemented yet), which does test compressions |
* of lines using different filter methods, and then chooses the |
* (series of) filter(s) that give minimum compressed data size (VERY |
* computationally expensive). |
* |
* GRR 980525: consider also |
* (1) minimum sum of absolute differences from running average (i.e., |
* keep running sum of non-absolute differences & count of bytes) |
* [track dispersion, too? restart average if dispersion too large?] |
* (1b) minimum sum of absolute differences from sliding average, probably |
* with window size <= deflate window (usually 32K) |
* (2) minimum sum of squared differences from zero or running average |
* (i.e., ~ root-mean-square approach) |
*/ |
/* We don't need to test the 'no filter' case if this is the only filter |
* that has been chosen, as it doesn't actually do anything to the data. |
*/ |
if ((filter_to_do & PNG_FILTER_NONE) && |
filter_to_do != PNG_FILTER_NONE) |
{ |
png_bytep rp; |
png_uint_32 sum = 0; |
png_uint_32 i; |
int v; |
for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++) |
{ |
v = *rp; |
sum += (v < 128) ? v : 256 - v; |
} |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
png_uint_32 sumhi, sumlo; |
int j; |
sumlo = sum & PNG_LOMASK; |
sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */ |
/* Reduce the sum if we match any of the previous rows */ |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) |
{ |
sumlo = (sumlo * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
sumhi = (sumhi * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
/* Factor in the cost of this filter (this is here for completeness, |
* but it makes no sense to have a "cost" for the NONE filter, as |
* it has the minimum possible computational cost - none). |
*/ |
sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> |
PNG_COST_SHIFT; |
sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> |
PNG_COST_SHIFT; |
if (sumhi > PNG_HIMASK) |
sum = PNG_MAXSUM; |
else |
sum = (sumhi << PNG_HISHIFT) + sumlo; |
} |
#endif |
mins = sum; |
} |
/* sub filter */ |
if (filter_to_do == PNG_FILTER_SUB) |
/* it's the only filter so no testing is needed */ |
{ |
png_bytep rp, lp, dp; |
png_uint_32 i; |
for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; |
i++, rp++, dp++) |
{ |
*dp = *rp; |
} |
for (lp = row_buf + 1; i < row_bytes; |
i++, rp++, lp++, dp++) |
{ |
*dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); |
} |
best_row = png_ptr->sub_row; |
} |
else if (filter_to_do & PNG_FILTER_SUB) |
{ |
png_bytep rp, dp, lp; |
png_uint_32 sum = 0, lmins = mins; |
png_uint_32 i; |
int v; |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
/* We temporarily increase the "minimum sum" by the factor we |
* would reduce the sum of this filter, so that we can do the |
* early exit comparison without scaling the sum each time. |
*/ |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 lmhi, lmlo; |
lmlo = lmins & PNG_LOMASK; |
lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) |
{ |
lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> |
PNG_COST_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> |
PNG_COST_SHIFT; |
if (lmhi > PNG_HIMASK) |
lmins = PNG_MAXSUM; |
else |
lmins = (lmhi << PNG_HISHIFT) + lmlo; |
} |
#endif |
for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; |
i++, rp++, dp++) |
{ |
v = *dp = *rp; |
sum += (v < 128) ? v : 256 - v; |
} |
for (lp = row_buf + 1; i < row_info->rowbytes; |
i++, rp++, lp++, dp++) |
{ |
v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
if (sum > lmins) /* We are already worse, don't continue. */ |
break; |
} |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 sumhi, sumlo; |
sumlo = sum & PNG_LOMASK; |
sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) |
{ |
sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> |
PNG_COST_SHIFT; |
sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> |
PNG_COST_SHIFT; |
if (sumhi > PNG_HIMASK) |
sum = PNG_MAXSUM; |
else |
sum = (sumhi << PNG_HISHIFT) + sumlo; |
} |
#endif |
if (sum < mins) |
{ |
mins = sum; |
best_row = png_ptr->sub_row; |
} |
} |
/* up filter */ |
if (filter_to_do == PNG_FILTER_UP) |
{ |
png_bytep rp, dp, pp; |
png_uint_32 i; |
for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, |
pp = prev_row + 1; i < row_bytes; |
i++, rp++, pp++, dp++) |
{ |
*dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); |
} |
best_row = png_ptr->up_row; |
} |
else if (filter_to_do & PNG_FILTER_UP) |
{ |
png_bytep rp, dp, pp; |
png_uint_32 sum = 0, lmins = mins; |
png_uint_32 i; |
int v; |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 lmhi, lmlo; |
lmlo = lmins & PNG_LOMASK; |
lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) |
{ |
lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> |
PNG_COST_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> |
PNG_COST_SHIFT; |
if (lmhi > PNG_HIMASK) |
lmins = PNG_MAXSUM; |
else |
lmins = (lmhi << PNG_HISHIFT) + lmlo; |
} |
#endif |
for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, |
pp = prev_row + 1; i < row_bytes; i++) |
{ |
v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
if (sum > lmins) /* We are already worse, don't continue. */ |
break; |
} |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 sumhi, sumlo; |
sumlo = sum & PNG_LOMASK; |
sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) |
{ |
sumlo = (sumlo * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
sumhi = (sumhi * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> |
PNG_COST_SHIFT; |
sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> |
PNG_COST_SHIFT; |
if (sumhi > PNG_HIMASK) |
sum = PNG_MAXSUM; |
else |
sum = (sumhi << PNG_HISHIFT) + sumlo; |
} |
#endif |
if (sum < mins) |
{ |
mins = sum; |
best_row = png_ptr->up_row; |
} |
} |
/* avg filter */ |
if (filter_to_do == PNG_FILTER_AVG) |
{ |
png_bytep rp, dp, pp, lp; |
png_uint_32 i; |
for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, |
pp = prev_row + 1; i < bpp; i++) |
{ |
*dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); |
} |
for (lp = row_buf + 1; i < row_bytes; i++) |
{ |
*dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) |
& 0xff); |
} |
best_row = png_ptr->avg_row; |
} |
else if (filter_to_do & PNG_FILTER_AVG) |
{ |
png_bytep rp, dp, pp, lp; |
png_uint_32 sum = 0, lmins = mins; |
png_uint_32 i; |
int v; |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 lmhi, lmlo; |
lmlo = lmins & PNG_LOMASK; |
lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG) |
{ |
lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> |
PNG_COST_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> |
PNG_COST_SHIFT; |
if (lmhi > PNG_HIMASK) |
lmins = PNG_MAXSUM; |
else |
lmins = (lmhi << PNG_HISHIFT) + lmlo; |
} |
#endif |
for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, |
pp = prev_row + 1; i < bpp; i++) |
{ |
v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
} |
for (lp = row_buf + 1; i < row_bytes; i++) |
{ |
v = *dp++ = |
(png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
if (sum > lmins) /* We are already worse, don't continue. */ |
break; |
} |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 sumhi, sumlo; |
sumlo = sum & PNG_LOMASK; |
sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) |
{ |
sumlo = (sumlo * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
sumhi = (sumhi * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> |
PNG_COST_SHIFT; |
sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> |
PNG_COST_SHIFT; |
if (sumhi > PNG_HIMASK) |
sum = PNG_MAXSUM; |
else |
sum = (sumhi << PNG_HISHIFT) + sumlo; |
} |
#endif |
if (sum < mins) |
{ |
mins = sum; |
best_row = png_ptr->avg_row; |
} |
} |
/* Paeth filter */ |
if (filter_to_do == PNG_FILTER_PAETH) |
{ |
png_bytep rp, dp, pp, cp, lp; |
png_uint_32 i; |
for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, |
pp = prev_row + 1; i < bpp; i++) |
{ |
*dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); |
} |
for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) |
{ |
int a, b, c, pa, pb, pc, p; |
b = *pp++; |
c = *cp++; |
a = *lp++; |
p = b - c; |
pc = a - c; |
#ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
#else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; |
*dp++ = (png_byte)(((int)*rp++ - p) & 0xff); |
} |
best_row = png_ptr->paeth_row; |
} |
else if (filter_to_do & PNG_FILTER_PAETH) |
{ |
png_bytep rp, dp, pp, cp, lp; |
png_uint_32 sum = 0, lmins = mins; |
png_uint_32 i; |
int v; |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 lmhi, lmlo; |
lmlo = lmins & PNG_LOMASK; |
lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) |
{ |
lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> |
PNG_COST_SHIFT; |
lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> |
PNG_COST_SHIFT; |
if (lmhi > PNG_HIMASK) |
lmins = PNG_MAXSUM; |
else |
lmins = (lmhi << PNG_HISHIFT) + lmlo; |
} |
#endif |
for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, |
pp = prev_row + 1; i < bpp; i++) |
{ |
v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
} |
for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) |
{ |
int a, b, c, pa, pb, pc, p; |
b = *pp++; |
c = *cp++; |
a = *lp++; |
#ifndef PNG_SLOW_PAETH |
p = b - c; |
pc = a - c; |
#ifdef PNG_USE_ABS |
pa = abs(p); |
pb = abs(pc); |
pc = abs(p + pc); |
#else |
pa = p < 0 ? -p : p; |
pb = pc < 0 ? -pc : pc; |
pc = (p + pc) < 0 ? -(p + pc) : p + pc; |
#endif |
p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; |
#else /* PNG_SLOW_PAETH */ |
p = a + b - c; |
pa = abs(p - a); |
pb = abs(p - b); |
pc = abs(p - c); |
if (pa <= pb && pa <= pc) |
p = a; |
else if (pb <= pc) |
p = b; |
else |
p = c; |
#endif /* PNG_SLOW_PAETH */ |
v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); |
sum += (v < 128) ? v : 256 - v; |
if (sum > lmins) /* We are already worse, don't continue. */ |
break; |
} |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int j; |
png_uint_32 sumhi, sumlo; |
sumlo = sum & PNG_LOMASK; |
sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; |
for (j = 0; j < num_p_filters; j++) |
{ |
if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) |
{ |
sumlo = (sumlo * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
sumhi = (sumhi * png_ptr->filter_weights[j]) >> |
PNG_WEIGHT_SHIFT; |
} |
} |
sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> |
PNG_COST_SHIFT; |
sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> |
PNG_COST_SHIFT; |
if (sumhi > PNG_HIMASK) |
sum = PNG_MAXSUM; |
else |
sum = (sumhi << PNG_HISHIFT) + sumlo; |
} |
#endif |
if (sum < mins) |
{ |
best_row = png_ptr->paeth_row; |
} |
} |
/* Do the actual writing of the filtered row data from the chosen filter. */ |
png_write_filtered_row(png_ptr, best_row); |
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
/* Save the type of filter we picked this time for future calculations */ |
if (png_ptr->num_prev_filters > 0) |
{ |
int j; |
for (j = 1; j < num_p_filters; j++) |
{ |
png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1]; |
} |
png_ptr->prev_filters[j] = best_row[0]; |
} |
#endif |
} |
/* Do the actual writing of a previously filtered row. */ |
void /* PRIVATE */ |
png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row) |
{ |
png_debug(1, "in png_write_filtered_row\n"); |
png_debug1(2, "filter = %d\n", filtered_row[0]); |
/* set up the zlib input buffer */ |
png_ptr->zstream.next_in = filtered_row; |
png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1; |
/* repeat until we have compressed all the data */ |
do |
{ |
int ret; /* return of zlib */ |
/* compress the data */ |
ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); |
/* check for compression errors */ |
if (ret != Z_OK) |
{ |
if (png_ptr->zstream.msg != NULL) |
png_error(png_ptr, png_ptr->zstream.msg); |
else |
png_error(png_ptr, "zlib error"); |
} |
/* see if it is time to write another IDAT */ |
if (!(png_ptr->zstream.avail_out)) |
{ |
/* write the IDAT and reset the zlib output buffer */ |
png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
} |
/* repeat until all data has been compressed */ |
} while (png_ptr->zstream.avail_in); |
/* swap the current and previous rows */ |
if (png_ptr->prev_row != NULL) |
{ |
png_bytep tptr; |
tptr = png_ptr->prev_row; |
png_ptr->prev_row = png_ptr->row_buf; |
png_ptr->row_buf = tptr; |
} |
/* finish row - updates counters and flushes zlib if last row */ |
png_write_finish_row(png_ptr); |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
png_ptr->flush_rows++; |
if (png_ptr->flush_dist > 0 && |
png_ptr->flush_rows >= png_ptr->flush_dist) |
{ |
png_write_flush(png_ptr); |
} |
#endif |
} |
#endif /* PNG_WRITE_SUPPORTED */ |
/shark/trunk/ports/png/readme |
---|
0,0 → 1,15 |
Project: S.Ha.R.K. |
PNG Lib and Zlib porting |
Coordinators: |
Giorgio Buttazzo <giorgio@sssup.it> |
Paolo Gai <pj@gandalf.sssup.it> |
Authors: |
Giacomo Guidi <giacomo@gandalf.sssup.it> |
Shark lib to open png graphic files |
/shark/trunk/ports/png/inftrees.c |
---|
0,0 → 1,454 |
/* inftrees.c -- generate Huffman trees for efficient decoding |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
#include "zutil.h" |
#include "inftrees.h" |
#if !defined(BUILDFIXED) && !defined(STDC) |
# define BUILDFIXED /* non ANSI compilers may not accept inffixed.h */ |
#endif |
const char inflate_copyright[] = |
" inflate 1.1.4 Copyright 1995-2002 Mark Adler "; |
/* |
If you use the zlib library in a product, an acknowledgment is welcome |
in the documentation of your product. If for some reason you cannot |
include such an acknowledgment, I would appreciate that you keep this |
copyright string in the executable of your product. |
*/ |
struct internal_state {int dummy;}; /* for buggy compilers */ |
/* simplify the use of the inflate_huft type with some defines */ |
#define exop word.what.Exop |
#define bits word.what.Bits |
local int huft_build OF(( |
uIntf *, /* code lengths in bits */ |
uInt, /* number of codes */ |
uInt, /* number of "simple" codes */ |
const uIntf *, /* list of base values for non-simple codes */ |
const uIntf *, /* list of extra bits for non-simple codes */ |
inflate_huft * FAR*,/* result: starting table */ |
uIntf *, /* maximum lookup bits (returns actual) */ |
inflate_huft *, /* space for trees */ |
uInt *, /* hufts used in space */ |
uIntf * )); /* space for values */ |
/* Tables for deflate from PKZIP's appnote.txt. */ |
local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */ |
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, 0, 0}; |
/* see note #13 above about 258 */ |
local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */ |
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, 112, 112}; /* 112==invalid */ |
local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */ |
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}; |
local const uInt cpdext[30] = { /* Extra bits for distance codes */ |
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}; |
/* |
Huffman code decoding is performed using a multi-level table lookup. |
The fastest way to decode is to simply build a lookup table whose |
size is determined by the longest code. However, the time it takes |
to build this table can also be a factor if the data being decoded |
is not very long. The most common codes are necessarily the |
shortest codes, so those codes dominate the decoding time, and hence |
the speed. The idea is you can have a shorter table that decodes the |
shorter, more probable codes, and then point to subsidiary tables for |
the longer codes. The time it costs to decode the longer codes is |
then traded against the time it takes to make longer tables. |
This results of this trade are in the variables lbits and dbits |
below. lbits is the number of bits the first level table for literal/ |
length codes can decode in one step, and dbits is the same thing for |
the distance codes. Subsequent tables are also less than or equal to |
those sizes. These values may be adjusted either when all of the |
codes are shorter than that, in which case the longest code length in |
bits is used, or when the shortest code is *longer* than the requested |
table size, in which case the length of the shortest code in bits is |
used. |
There are two different values for the two tables, since they code a |
different number of possibilities each. The literal/length table |
codes 286 possible values, or in a flat code, a little over eight |
bits. The distance table codes 30 possible values, or a little less |
than five bits, flat. The optimum values for speed end up being |
about one bit more than those, so lbits is 8+1 and dbits is 5+1. |
The optimum values may differ though from machine to machine, and |
possibly even between compilers. Your mileage may vary. |
*/ |
/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */ |
#define BMAX 15 /* maximum bit length of any code */ |
local int huft_build(b, n, s, d, e, t, m, hp, hn, v) |
uIntf *b; /* code lengths in bits (all assumed <= BMAX) */ |
uInt n; /* number of codes (assumed <= 288) */ |
uInt s; /* number of simple-valued codes (0..s-1) */ |
const uIntf *d; /* list of base values for non-simple codes */ |
const uIntf *e; /* list of extra bits for non-simple codes */ |
inflate_huft * FAR *t; /* result: starting table */ |
uIntf *m; /* maximum lookup bits, returns actual */ |
inflate_huft *hp; /* space for trees */ |
uInt *hn; /* hufts used in space */ |
uIntf *v; /* working area: values in order of bit length */ |
/* Given a list of code lengths and a maximum table size, make a set of |
tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR |
if the given code set is incomplete (the tables are still built in this |
case), or Z_DATA_ERROR if the input is invalid. */ |
{ |
uInt a; /* counter for codes of length k */ |
uInt c[BMAX+1]; /* bit length count table */ |
uInt f; /* i repeats in table every f entries */ |
int g; /* maximum code length */ |
int h; /* table level */ |
register uInt i; /* counter, current code */ |
register uInt j; /* counter */ |
register int k; /* number of bits in current code */ |
int l; /* bits per table (returned in m) */ |
uInt mask; /* (1 << w) - 1, to avoid cc -O bug on HP */ |
register uIntf *p; /* pointer into c[], b[], or v[] */ |
inflate_huft *q; /* points to current table */ |
struct inflate_huft_s r; /* table entry for structure assignment */ |
inflate_huft *u[BMAX]; /* table stack */ |
register int w; /* bits before this table == (l * h) */ |
uInt x[BMAX+1]; /* bit offsets, then code stack */ |
uIntf *xp; /* pointer into x */ |
int y; /* number of dummy codes added */ |
uInt z; /* number of entries in current table */ |
/* Generate counts for each bit length */ |
p = c; |
#define C0 *p++ = 0; |
#define C2 C0 C0 C0 C0 |
#define C4 C2 C2 C2 C2 |
C4 /* clear c[]--assume BMAX+1 is 16 */ |
p = b; i = n; |
do { |
c[*p++]++; /* assume all entries <= BMAX */ |
} while (--i); |
if (c[0] == n) /* null input--all zero length codes */ |
{ |
*t = (inflate_huft *)Z_NULL; |
*m = 0; |
return Z_OK; |
} |
/* Find minimum and maximum length, bound *m by those */ |
l = *m; |
for (j = 1; j <= BMAX; j++) |
if (c[j]) |
break; |
k = j; /* minimum code length */ |
if ((uInt)l < j) |
l = j; |
for (i = BMAX; i; i--) |
if (c[i]) |
break; |
g = i; /* maximum code length */ |
if ((uInt)l > i) |
l = i; |
*m = l; |
/* Adjust last length count to fill out codes, if needed */ |
for (y = 1 << j; j < i; j++, y <<= 1) |
if ((y -= c[j]) < 0) |
return Z_DATA_ERROR; |
if ((y -= c[i]) < 0) |
return Z_DATA_ERROR; |
c[i] += y; |
/* Generate starting offsets into the value table for each length */ |
x[1] = j = 0; |
p = c + 1; xp = x + 2; |
while (--i) { /* note that i == g from above */ |
*xp++ = (j += *p++); |
} |
/* Make a table of values in order of bit lengths */ |
p = b; i = 0; |
do { |
if ((j = *p++) != 0) |
v[x[j]++] = i; |
} while (++i < n); |
n = x[g]; /* set n to length of v */ |
/* Generate the Huffman codes and for each, make the table entries */ |
x[0] = i = 0; /* first Huffman code is zero */ |
p = v; /* grab values in bit order */ |
h = -1; /* no tables yet--level -1 */ |
w = -l; /* bits decoded == (l * h) */ |
u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */ |
q = (inflate_huft *)Z_NULL; /* ditto */ |
z = 0; /* ditto */ |
/* go through the bit lengths (k already is bits in shortest code) */ |
for (; k <= g; k++) |
{ |
a = c[k]; |
while (a--) |
{ |
/* here i is the Huffman code of length k bits for value *p */ |
/* make tables up to required level */ |
while (k > w + l) |
{ |
h++; |
w += l; /* previous table always l bits */ |
/* compute minimum size table less than or equal to l bits */ |
z = g - w; |
z = z > (uInt)l ? l : z; /* table size upper limit */ |
if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */ |
{ /* too few codes for k-w bit table */ |
f -= a + 1; /* deduct codes from patterns left */ |
xp = c + k; |
if (j < z) |
while (++j < z) /* try smaller tables up to z bits */ |
{ |
if ((f <<= 1) <= *++xp) |
break; /* enough codes to use up j bits */ |
f -= *xp; /* else deduct codes from patterns */ |
} |
} |
z = 1 << j; /* table entries for j-bit table */ |
/* allocate new table */ |
if (*hn + z > MANY) /* (note: doesn't matter for fixed) */ |
return Z_DATA_ERROR; /* overflow of MANY */ |
u[h] = q = hp + *hn; |
*hn += z; |
/* connect to last table, if there is one */ |
if (h) |
{ |
x[h] = i; /* save pattern for backing up */ |
r.bits = (Byte)l; /* bits to dump before this table */ |
r.exop = (Byte)j; /* bits in this table */ |
j = i >> (w - l); |
r.base = (uInt)(q - u[h-1] - j); /* offset to this table */ |
u[h-1][j] = r; /* connect to last table */ |
} |
else |
*t = q; /* first table is returned result */ |
} |
/* set up table entry in r */ |
r.bits = (Byte)(k - w); |
if (p >= v + n) |
r.exop = 128 + 64; /* out of values--invalid code */ |
else if (*p < s) |
{ |
r.exop = (Byte)(*p < 256 ? 0 : 32 + 64); /* 256 is end-of-block */ |
r.base = *p++; /* simple code is just the value */ |
} |
else |
{ |
r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */ |
r.base = d[*p++ - s]; |
} |
/* fill code-like entries with r */ |
f = 1 << (k - w); |
for (j = i >> w; j < z; j += f) |
q[j] = r; |
/* backwards increment the k-bit code i */ |
for (j = 1 << (k - 1); i & j; j >>= 1) |
i ^= j; |
i ^= j; |
/* backup over finished tables */ |
mask = (1 << w) - 1; /* needed on HP, cc -O bug */ |
while ((i & mask) != x[h]) |
{ |
h--; /* don't need to update q */ |
w -= l; |
mask = (1 << w) - 1; |
} |
} |
} |
/* Return Z_BUF_ERROR if we were given an incomplete table */ |
return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK; |
} |
int inflate_trees_bits(c, bb, tb, hp, z) |
uIntf *c; /* 19 code lengths */ |
uIntf *bb; /* bits tree desired/actual depth */ |
inflate_huft * FAR *tb; /* bits tree result */ |
inflate_huft *hp; /* space for trees */ |
z_streamp z; /* for messages */ |
{ |
int r; |
uInt hn = 0; /* hufts used in space */ |
uIntf *v; /* work area for huft_build */ |
if ((v = (uIntf*)ZALLOC(z, 19, sizeof(uInt))) == Z_NULL) |
return Z_MEM_ERROR; |
r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, |
tb, bb, hp, &hn, v); |
if (r == Z_DATA_ERROR) |
z->msg = (char*)"oversubscribed dynamic bit lengths tree"; |
else if (r == Z_BUF_ERROR || *bb == 0) |
{ |
z->msg = (char*)"incomplete dynamic bit lengths tree"; |
r = Z_DATA_ERROR; |
} |
ZFREE(z, v); |
return r; |
} |
int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z) |
uInt nl; /* number of literal/length codes */ |
uInt nd; /* number of distance codes */ |
uIntf *c; /* that many (total) code lengths */ |
uIntf *bl; /* literal desired/actual bit depth */ |
uIntf *bd; /* distance desired/actual bit depth */ |
inflate_huft * FAR *tl; /* literal/length tree result */ |
inflate_huft * FAR *td; /* distance tree result */ |
inflate_huft *hp; /* space for trees */ |
z_streamp z; /* for messages */ |
{ |
int r; |
uInt hn = 0; /* hufts used in space */ |
uIntf *v; /* work area for huft_build */ |
/* allocate work area */ |
if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) |
return Z_MEM_ERROR; |
/* build literal/length tree */ |
r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v); |
if (r != Z_OK || *bl == 0) |
{ |
if (r == Z_DATA_ERROR) |
z->msg = (char*)"oversubscribed literal/length tree"; |
else if (r != Z_MEM_ERROR) |
{ |
z->msg = (char*)"incomplete literal/length tree"; |
r = Z_DATA_ERROR; |
} |
ZFREE(z, v); |
return r; |
} |
/* build distance tree */ |
r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v); |
if (r != Z_OK || (*bd == 0 && nl > 257)) |
{ |
if (r == Z_DATA_ERROR) |
z->msg = (char*)"oversubscribed distance tree"; |
else if (r == Z_BUF_ERROR) { |
#ifdef PKZIP_BUG_WORKAROUND |
r = Z_OK; |
} |
#else |
z->msg = (char*)"incomplete distance tree"; |
r = Z_DATA_ERROR; |
} |
else if (r != Z_MEM_ERROR) |
{ |
z->msg = (char*)"empty distance tree with lengths"; |
r = Z_DATA_ERROR; |
} |
ZFREE(z, v); |
return r; |
#endif |
} |
/* done */ |
ZFREE(z, v); |
return Z_OK; |
} |
/* build fixed tables only once--keep them here */ |
#ifdef BUILDFIXED |
local int fixed_built = 0; |
#define FIXEDH 544 /* number of hufts used by fixed tables */ |
local inflate_huft fixed_mem[FIXEDH]; |
local uInt fixed_bl; |
local uInt fixed_bd; |
local inflate_huft *fixed_tl; |
local inflate_huft *fixed_td; |
#else |
#include "inffixed.h" |
#endif |
int inflate_trees_fixed(bl, bd, tl, td, z) |
uIntf *bl; /* literal desired/actual bit depth */ |
uIntf *bd; /* distance desired/actual bit depth */ |
inflate_huft * FAR *tl; /* literal/length tree result */ |
inflate_huft * FAR *td; /* distance tree result */ |
z_streamp z; /* for memory allocation */ |
{ |
#ifdef BUILDFIXED |
/* build fixed tables if not already */ |
if (!fixed_built) |
{ |
int k; /* temporary variable */ |
uInt f = 0; /* number of hufts used in fixed_mem */ |
uIntf *c; /* length list for huft_build */ |
uIntf *v; /* work area for huft_build */ |
/* allocate memory */ |
if ((c = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) |
return Z_MEM_ERROR; |
if ((v = (uIntf*)ZALLOC(z, 288, sizeof(uInt))) == Z_NULL) |
{ |
ZFREE(z, c); |
return Z_MEM_ERROR; |
} |
/* literal table */ |
for (k = 0; k < 144; k++) |
c[k] = 8; |
for (; k < 256; k++) |
c[k] = 9; |
for (; k < 280; k++) |
c[k] = 7; |
for (; k < 288; k++) |
c[k] = 8; |
fixed_bl = 9; |
huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, |
fixed_mem, &f, v); |
/* distance table */ |
for (k = 0; k < 30; k++) |
c[k] = 5; |
fixed_bd = 5; |
huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, |
fixed_mem, &f, v); |
/* done */ |
ZFREE(z, v); |
ZFREE(z, c); |
fixed_built = 1; |
} |
#endif |
*bl = fixed_bl; |
*bd = fixed_bd; |
*tl = fixed_tl; |
*td = fixed_td; |
return Z_OK; |
} |
/shark/trunk/ports/png/pngasmrd.h |
---|
0,0 → 1,11 |
/* pngasmrd.h - assembler version of utilities to read a PNG file |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 2002 Glenn Randers-Pehrson |
* |
*/ |
/* This file is obsolete in libpng-1.0.9 and later; its contents now appear |
* at the end of pngconf.h. |
*/ |
/shark/trunk/ports/png/inflate.c |
---|
0,0 → 1,366 |
/* inflate.c -- zlib interface to inflate modules |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
#include "zutil.h" |
#include "infblock.h" |
struct inflate_blocks_state {int dummy;}; /* for buggy compilers */ |
typedef enum { |
METHOD, /* waiting for method byte */ |
FLAG, /* waiting for flag byte */ |
DICT4, /* four dictionary check bytes to go */ |
DICT3, /* three dictionary check bytes to go */ |
DICT2, /* two dictionary check bytes to go */ |
DICT1, /* one dictionary check byte to go */ |
DICT0, /* waiting for inflateSetDictionary */ |
BLOCKS, /* decompressing blocks */ |
CHECK4, /* four check bytes to go */ |
CHECK3, /* three check bytes to go */ |
CHECK2, /* two check bytes to go */ |
CHECK1, /* one check byte to go */ |
DONE, /* finished check, done */ |
BAD} /* got an error--stay here */ |
inflate_mode; |
/* inflate private state */ |
struct internal_state { |
/* mode */ |
inflate_mode mode; /* current inflate mode */ |
/* mode dependent information */ |
union { |
uInt method; /* if FLAGS, method byte */ |
struct { |
uLong was; /* computed check value */ |
uLong need; /* stream check value */ |
} check; /* if CHECK, check values to compare */ |
uInt marker; /* if BAD, inflateSync's marker bytes count */ |
} sub; /* submode */ |
/* mode independent information */ |
int nowrap; /* flag for no wrapper */ |
uInt wbits; /* log2(window size) (8..15, defaults to 15) */ |
inflate_blocks_statef |
*blocks; /* current inflate_blocks state */ |
}; |
int ZEXPORT inflateReset(z) |
z_streamp z; |
{ |
if (z == Z_NULL || z->state == Z_NULL) |
return Z_STREAM_ERROR; |
z->total_in = z->total_out = 0; |
z->msg = Z_NULL; |
z->state->mode = z->state->nowrap ? BLOCKS : METHOD; |
inflate_blocks_reset(z->state->blocks, z, Z_NULL); |
Tracev((stderr, "inflate: reset\n")); |
return Z_OK; |
} |
int ZEXPORT inflateEnd(z) |
z_streamp z; |
{ |
if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL) |
return Z_STREAM_ERROR; |
if (z->state->blocks != Z_NULL) |
inflate_blocks_free(z->state->blocks, z); |
ZFREE(z, z->state); |
z->state = Z_NULL; |
Tracev((stderr, "inflate: end\n")); |
return Z_OK; |
} |
int ZEXPORT inflateInit2_(z, w, version, stream_size) |
z_streamp z; |
int w; |
const char *version; |
int stream_size; |
{ |
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || |
stream_size != sizeof(z_stream)) |
return Z_VERSION_ERROR; |
/* initialize state */ |
if (z == Z_NULL) |
return Z_STREAM_ERROR; |
z->msg = Z_NULL; |
if (z->zalloc == Z_NULL) |
{ |
z->zalloc = zcalloc; |
z->opaque = (voidpf)0; |
} |
if (z->zfree == Z_NULL) z->zfree = zcfree; |
if ((z->state = (struct internal_state FAR *) |
ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL) |
return Z_MEM_ERROR; |
z->state->blocks = Z_NULL; |
/* handle undocumented nowrap option (no zlib header or check) */ |
z->state->nowrap = 0; |
if (w < 0) |
{ |
w = - w; |
z->state->nowrap = 1; |
} |
/* set window size */ |
if (w < 8 || w > 15) |
{ |
inflateEnd(z); |
return Z_STREAM_ERROR; |
} |
z->state->wbits = (uInt)w; |
/* create inflate_blocks state */ |
if ((z->state->blocks = |
inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w)) |
== Z_NULL) |
{ |
inflateEnd(z); |
return Z_MEM_ERROR; |
} |
Tracev((stderr, "inflate: allocated\n")); |
/* reset state */ |
inflateReset(z); |
return Z_OK; |
} |
int ZEXPORT inflateInit_(z, version, stream_size) |
z_streamp z; |
const char *version; |
int stream_size; |
{ |
return inflateInit2_(z, DEF_WBITS, version, stream_size); |
} |
#define NEEDBYTE {if(z->avail_in==0)return r;r=f;} |
#define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++) |
int ZEXPORT inflate(z, f) |
z_streamp z; |
int f; |
{ |
int r; |
uInt b; |
if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL) |
return Z_STREAM_ERROR; |
f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK; |
r = Z_BUF_ERROR; |
while (1) switch (z->state->mode) |
{ |
case METHOD: |
NEEDBYTE |
if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED) |
{ |
z->state->mode = BAD; |
z->msg = (char*)"unknown compression method"; |
z->state->sub.marker = 5; /* can't try inflateSync */ |
break; |
} |
if ((z->state->sub.method >> 4) + 8 > z->state->wbits) |
{ |
z->state->mode = BAD; |
z->msg = (char*)"invalid window size"; |
z->state->sub.marker = 5; /* can't try inflateSync */ |
break; |
} |
z->state->mode = FLAG; |
case FLAG: |
NEEDBYTE |
b = NEXTBYTE; |
if (((z->state->sub.method << 8) + b) % 31) |
{ |
z->state->mode = BAD; |
z->msg = (char*)"incorrect header check"; |
z->state->sub.marker = 5; /* can't try inflateSync */ |
break; |
} |
Tracev((stderr, "inflate: zlib header ok\n")); |
if (!(b & PRESET_DICT)) |
{ |
z->state->mode = BLOCKS; |
break; |
} |
z->state->mode = DICT4; |
case DICT4: |
NEEDBYTE |
z->state->sub.check.need = (uLong)NEXTBYTE << 24; |
z->state->mode = DICT3; |
case DICT3: |
NEEDBYTE |
z->state->sub.check.need += (uLong)NEXTBYTE << 16; |
z->state->mode = DICT2; |
case DICT2: |
NEEDBYTE |
z->state->sub.check.need += (uLong)NEXTBYTE << 8; |
z->state->mode = DICT1; |
case DICT1: |
NEEDBYTE |
z->state->sub.check.need += (uLong)NEXTBYTE; |
z->adler = z->state->sub.check.need; |
z->state->mode = DICT0; |
return Z_NEED_DICT; |
case DICT0: |
z->state->mode = BAD; |
z->msg = (char*)"need dictionary"; |
z->state->sub.marker = 0; /* can try inflateSync */ |
return Z_STREAM_ERROR; |
case BLOCKS: |
r = inflate_blocks(z->state->blocks, z, r); |
if (r == Z_DATA_ERROR) |
{ |
z->state->mode = BAD; |
z->state->sub.marker = 0; /* can try inflateSync */ |
break; |
} |
if (r == Z_OK) |
r = f; |
if (r != Z_STREAM_END) |
return r; |
r = f; |
inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was); |
if (z->state->nowrap) |
{ |
z->state->mode = DONE; |
break; |
} |
z->state->mode = CHECK4; |
case CHECK4: |
NEEDBYTE |
z->state->sub.check.need = (uLong)NEXTBYTE << 24; |
z->state->mode = CHECK3; |
case CHECK3: |
NEEDBYTE |
z->state->sub.check.need += (uLong)NEXTBYTE << 16; |
z->state->mode = CHECK2; |
case CHECK2: |
NEEDBYTE |
z->state->sub.check.need += (uLong)NEXTBYTE << 8; |
z->state->mode = CHECK1; |
case CHECK1: |
NEEDBYTE |
z->state->sub.check.need += (uLong)NEXTBYTE; |
if (z->state->sub.check.was != z->state->sub.check.need) |
{ |
z->state->mode = BAD; |
z->msg = (char*)"incorrect data check"; |
z->state->sub.marker = 5; /* can't try inflateSync */ |
break; |
} |
Tracev((stderr, "inflate: zlib check ok\n")); |
z->state->mode = DONE; |
case DONE: |
return Z_STREAM_END; |
case BAD: |
return Z_DATA_ERROR; |
default: |
return Z_STREAM_ERROR; |
} |
#ifdef NEED_DUMMY_RETURN |
return Z_STREAM_ERROR; /* Some dumb compilers complain without this */ |
#endif |
} |
int ZEXPORT inflateSetDictionary(z, dictionary, dictLength) |
z_streamp z; |
const Bytef *dictionary; |
uInt dictLength; |
{ |
uInt length = dictLength; |
if (z == Z_NULL || z->state == Z_NULL || z->state->mode != DICT0) |
return Z_STREAM_ERROR; |
if (adler32(1L, dictionary, dictLength) != z->adler) return Z_DATA_ERROR; |
z->adler = 1L; |
if (length >= ((uInt)1<<z->state->wbits)) |
{ |
length = (1<<z->state->wbits)-1; |
dictionary += dictLength - length; |
} |
inflate_set_dictionary(z->state->blocks, dictionary, length); |
z->state->mode = BLOCKS; |
return Z_OK; |
} |
int ZEXPORT inflateSync(z) |
z_streamp z; |
{ |
uInt n; /* number of bytes to look at */ |
Bytef *p; /* pointer to bytes */ |
uInt m; /* number of marker bytes found in a row */ |
uLong r, w; /* temporaries to save total_in and total_out */ |
/* set up */ |
if (z == Z_NULL || z->state == Z_NULL) |
return Z_STREAM_ERROR; |
if (z->state->mode != BAD) |
{ |
z->state->mode = BAD; |
z->state->sub.marker = 0; |
} |
if ((n = z->avail_in) == 0) |
return Z_BUF_ERROR; |
p = z->next_in; |
m = z->state->sub.marker; |
/* search */ |
while (n && m < 4) |
{ |
static const Byte mark[4] = {0, 0, 0xff, 0xff}; |
if (*p == mark[m]) |
m++; |
else if (*p) |
m = 0; |
else |
m = 4 - m; |
p++, n--; |
} |
/* restore */ |
z->total_in += p - z->next_in; |
z->next_in = p; |
z->avail_in = n; |
z->state->sub.marker = m; |
/* return no joy or set up to restart on a new block */ |
if (m != 4) |
return Z_DATA_ERROR; |
r = z->total_in; w = z->total_out; |
inflateReset(z); |
z->total_in = r; z->total_out = w; |
z->state->mode = BLOCKS; |
return Z_OK; |
} |
/* Returns true if inflate is currently at the end of a block generated |
* by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP |
* implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH |
* but removes the length bytes of the resulting empty stored block. When |
* decompressing, PPP checks that at the end of input packet, inflate is |
* waiting for these length bytes. |
*/ |
int ZEXPORT inflateSyncPoint(z) |
z_streamp z; |
{ |
if (z == Z_NULL || z->state == Z_NULL || z->state->blocks == Z_NULL) |
return Z_STREAM_ERROR; |
return inflate_blocks_sync_point(z->state->blocks); |
} |
/shark/trunk/ports/png/uncompr.c |
---|
0,0 → 1,58 |
/* uncompr.c -- decompress a memory buffer |
* Copyright (C) 1995-2002 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* @(#) $Id: uncompr.c,v 1.1 2003-03-20 13:08:13 giacomo Exp $ */ |
#include "zlib.h" |
/* =========================================================================== |
Decompresses the source buffer into the destination buffer. sourceLen is |
the byte length of the source buffer. Upon entry, destLen is the total |
size of the destination buffer, which must be large enough to hold the |
entire uncompressed data. (The size of the uncompressed data must have |
been saved previously by the compressor and transmitted to the decompressor |
by some mechanism outside the scope of this compression library.) |
Upon exit, destLen is the actual size of the compressed buffer. |
This function can be used to decompress a whole file at once if the |
input file is mmap'ed. |
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not |
enough memory, Z_BUF_ERROR if there was not enough room in the output |
buffer, or Z_DATA_ERROR if the input data was corrupted. |
*/ |
int ZEXPORT uncompress (dest, destLen, source, sourceLen) |
Bytef *dest; |
uLongf *destLen; |
const Bytef *source; |
uLong sourceLen; |
{ |
z_stream stream; |
int err; |
stream.next_in = (Bytef*)source; |
stream.avail_in = (uInt)sourceLen; |
/* Check for source > 64K on 16-bit machine: */ |
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; |
stream.next_out = dest; |
stream.avail_out = (uInt)*destLen; |
if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; |
stream.zalloc = (alloc_func)0; |
stream.zfree = (free_func)0; |
err = inflateInit(&stream); |
if (err != Z_OK) return err; |
err = inflate(&stream, Z_FINISH); |
if (err != Z_STREAM_END) { |
inflateEnd(&stream); |
return err == Z_OK ? Z_BUF_ERROR : err; |
} |
*destLen = stream.total_out; |
err = inflateEnd(&stream); |
return err; |
} |
/shark/trunk/ports/png/pngtest.c |
---|
0,0 → 1,1531 |
/* pngtest.c - a simple test program to test libpng |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This program reads in a PNG image, writes it out again, and then |
* compares the two files. If the files are identical, this shows that |
* the basic chunk handling, filtering, and (de)compression code is working |
* properly. It does not currently test all of the transforms, although |
* it probably should. |
* |
* The program will report "FAIL" in certain legitimate cases: |
* 1) when the compression level or filter selection method is changed. |
* 2) when the maximum IDAT size (PNG_ZBUF_SIZE in pngconf.h) is not 8192. |
* 3) unknown unsafe-to-copy ancillary chunks or unknown critical chunks |
* exist in the input file. |
* 4) others not listed here... |
* In these cases, it is best to check with another tool such as "pngcheck" |
* to see what the differences between the two files are. |
* |
* If a filename is given on the command-line, then this file is used |
* for the input, rather than the default "pngtest.png". This allows |
* testing a wide variety of files easily. You can also test a number |
* of files at once by typing "pngtest -m file1.png file2.png ..." |
*/ |
#if defined(_WIN32_WCE) |
# if _WIN32_WCE < 211 |
__error__ (f|w)printf functions are not supported on old WindowsCE.; |
# endif |
# include <windows.h> |
# include <stdlib.h> |
# define READFILE(file, data, length, check) \ |
if (ReadFile(file, data, length, &check,NULL)) check = 0 |
# define WRITEFILE(file, data, length, check)) \ |
if (WriteFile(file, data, length, &check, NULL)) check = 0 |
# define FCLOSE(file) CloseHandle(file) |
#else |
# include <stdio.h> |
# include <stdlib.h> |
# include <assert.h> |
# define READFILE(file, data, length, check) \ |
check=(png_size_t)fread(data,(png_size_t)1,length,file) |
# define WRITEFILE(file, data, length, check) \ |
check=(png_size_t)fwrite(data,(png_size_t)1, length, file) |
# define FCLOSE(file) fclose(file) |
#endif |
#if defined(PNG_NO_STDIO) |
# if defined(_WIN32_WCE) |
typedef HANDLE png_FILE_p; |
# else |
typedef FILE * png_FILE_p; |
# endif |
#endif |
/* Makes pngtest verbose so we can find problems (needs to be before png.h) */ |
#ifndef PNG_DEBUG |
# define PNG_DEBUG 0 |
#endif |
#if !PNG_DEBUG |
# define SINGLE_ROWBUF_ALLOC /* makes buffer overruns easier to nail */ |
#endif |
/* Turn on CPU timing |
#define PNGTEST_TIMING |
*/ |
#ifdef PNG_NO_FLOATING_POINT_SUPPORTED |
#undef PNGTEST_TIMING |
#endif |
#ifdef PNGTEST_TIMING |
static float t_start, t_stop, t_decode, t_encode, t_misc; |
#include <time.h> |
#endif |
#include "png.h" |
/* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */ |
#ifndef png_jmpbuf |
# define png_jmpbuf(png_ptr) png_ptr->jmpbuf |
#endif |
#ifdef PNGTEST_TIMING |
static float t_start, t_stop, t_decode, t_encode, t_misc; |
#if !defined(PNG_tIME_SUPPORTED) |
#include <time.h> |
#endif |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
static int tIME_chunk_present=0; |
static char tIME_string[30] = "no tIME chunk present in file"; |
#endif |
static int verbose = 0; |
int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname)); |
#ifdef __TURBOC__ |
#include <mem.h> |
#endif |
/* defined so I can write to a file on gui/windowing platforms */ |
/* #define STDERR stderr */ |
#define STDERR stdout /* for DOS */ |
/* example of using row callbacks to make a simple progress meter */ |
static int status_pass=1; |
static int status_dots_requested=0; |
static int status_dots=1; |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass); |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass) |
{ |
if(png_ptr == NULL || row_number > PNG_MAX_UINT) return; |
if(status_pass != pass) |
{ |
cprintf("\n Pass %d: ",pass); |
status_pass = pass; |
status_dots = 31; |
} |
status_dots--; |
if(status_dots == 0) |
{ |
cprintf("\n "); |
status_dots=30; |
} |
cprintf("r"); |
} |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass); |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass) |
{ |
if(png_ptr == NULL || row_number > PNG_MAX_UINT || pass > 7) return; |
cprintf("w"); |
} |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
/* Example of using user transform callback (we don't transform anything, |
but merely examine the row filters. We set this to 256 rather than |
5 in case illegal filter values are present.) */ |
static png_uint_32 filters_used[256]; |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data); |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data) |
{ |
if(png_ptr != NULL && row_info != NULL) |
++filters_used[*(data-1)]; |
} |
#endif |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
/* example of using user transform callback (we don't transform anything, |
but merely count the zero samples) */ |
static png_uint_32 zero_samples; |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data); |
void |
#ifdef PNG_1_0_X |
PNGAPI |
#endif |
count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data) |
{ |
png_bytep dp = data; |
if(png_ptr == NULL)return; |
/* contents of row_info: |
* png_uint_32 width width of row |
* png_uint_32 rowbytes number of bytes in row |
* png_byte color_type color type of pixels |
* png_byte bit_depth bit depth of samples |
* png_byte channels number of channels (1-4) |
* png_byte pixel_depth bits per pixel (depth*channels) |
*/ |
/* counts the number of zero samples (or zero pixels if color_type is 3 */ |
if(row_info->color_type == 0 || row_info->color_type == 3) |
{ |
int pos=0; |
png_uint_32 n, nstop; |
for (n=0, nstop=row_info->width; n<nstop; n++) |
{ |
if(row_info->bit_depth == 1) |
{ |
if(((*dp << pos++ ) & 0x80) == 0) zero_samples++; |
if(pos == 8) |
{ |
pos = 0; |
dp++; |
} |
} |
if(row_info->bit_depth == 2) |
{ |
if(((*dp << (pos+=2)) & 0xc0) == 0) zero_samples++; |
if(pos == 8) |
{ |
pos = 0; |
dp++; |
} |
} |
if(row_info->bit_depth == 4) |
{ |
if(((*dp << (pos+=4)) & 0xf0) == 0) zero_samples++; |
if(pos == 8) |
{ |
pos = 0; |
dp++; |
} |
} |
if(row_info->bit_depth == 8) |
if(*dp++ == 0) zero_samples++; |
if(row_info->bit_depth == 16) |
{ |
if((*dp | *(dp+1)) == 0) zero_samples++; |
dp+=2; |
} |
} |
} |
else /* other color types */ |
{ |
png_uint_32 n, nstop; |
int channel; |
int color_channels = row_info->channels; |
if(row_info->color_type > 3)color_channels--; |
for (n=0, nstop=row_info->width; n<nstop; n++) |
{ |
for (channel = 0; channel < color_channels; channel++) |
{ |
if(row_info->bit_depth == 8) |
if(*dp++ == 0) zero_samples++; |
if(row_info->bit_depth == 16) |
{ |
if((*dp | *(dp+1)) == 0) zero_samples++; |
dp+=2; |
} |
} |
if(row_info->color_type > 3) |
{ |
dp++; |
if(row_info->bit_depth == 16)dp++; |
} |
} |
} |
} |
#endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */ |
static int wrote_question = 0; |
#if defined(PNG_NO_STDIO) |
/* START of code to validate stdio-free compilation */ |
/* These copies of the default read/write functions come from pngrio.c and */ |
/* pngwio.c. They allow "don't include stdio" testing of the library. */ |
/* This is the function that does the actual reading of data. If you are |
not reading from a standard C stream, you should create a replacement |
read_data function and use it at run time with png_set_read_fn(), rather |
than changing the library. */ |
#ifndef USE_FAR_KEYWORD |
static void |
pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_size_t check; |
/* fread() returns 0 on error, so it is OK to store this in a png_size_t |
* instead of an int, which is what fread() actually returns. |
*/ |
READFILE((png_FILE_p)png_ptr->io_ptr, data, length, check); |
if (check != length) |
{ |
png_error(png_ptr, "Read Error!"); |
} |
} |
#else |
/* this is the model-independent version. Since the standard I/O library |
can't handle far buffers in the medium and small models, we have to copy |
the data. |
*/ |
#define NEAR_BUF_SIZE 1024 |
#define MIN(a,b) (a <= b ? a : b) |
static void |
pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
int check; |
png_byte *n_data; |
png_FILE_p io_ptr; |
/* Check if data really is near. If so, use usual code. */ |
n_data = (png_byte *)CVT_PTR_NOCHECK(data); |
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
if ((png_bytep)n_data == data) |
{ |
READFILE(io_ptr, n_data, length, check); |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t read, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
read = MIN(NEAR_BUF_SIZE, remaining); |
READFILE(io_ptr, buf, 1, err); |
png_memcpy(data, buf, read); /* copy far buffer to near buffer */ |
if(err != read) |
break; |
else |
check += err; |
data += read; |
remaining -= read; |
} |
while (remaining != 0); |
} |
if (check != length) |
{ |
png_error(png_ptr, "read Error"); |
} |
} |
#endif /* USE_FAR_KEYWORD */ |
#if defined(PNG_WRITE_FLUSH_SUPPORTED) |
static void |
pngtest_flush(png_structp png_ptr) |
{ |
#if !defined(_WIN32_WCE) |
png_FILE_p io_ptr; |
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); |
if (io_ptr != NULL) |
fflush(io_ptr); |
#endif |
} |
#endif |
/* This is the function that does the actual writing of data. If you are |
not writing to a standard C stream, you should create a replacement |
write_data function and use it at run time with png_set_write_fn(), rather |
than changing the library. */ |
#ifndef USE_FAR_KEYWORD |
static void |
pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_uint_32 check; |
WRITEFILE((png_FILE_p)png_ptr->io_ptr, data, length, check); |
if (check != length) |
{ |
png_error(png_ptr, "Write Error"); |
} |
} |
#else |
/* this is the model-independent version. Since the standard I/O library |
can't handle far buffers in the medium and small models, we have to copy |
the data. |
*/ |
#define NEAR_BUF_SIZE 1024 |
#define MIN(a,b) (a <= b ? a : b) |
static void |
pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_uint_32 check; |
png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ |
png_FILE_p io_ptr; |
/* Check if data really is near. If so, use usual code. */ |
near_data = (png_byte *)CVT_PTR_NOCHECK(data); |
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); |
if ((png_bytep)near_data == data) |
{ |
WRITEFILE(io_ptr, near_data, length, check); |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t written, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
written = MIN(NEAR_BUF_SIZE, remaining); |
png_memcpy(buf, data, written); /* copy far buffer to near buffer */ |
WRITEFILE(io_ptr, buf, written, err); |
if (err != written) |
break; |
else |
check += err; |
data += written; |
remaining -= written; |
} |
while (remaining != 0); |
} |
if (check != length) |
{ |
png_error(png_ptr, "Write Error"); |
} |
} |
#endif /* USE_FAR_KEYWORD */ |
/* This function is called when there is a warning, but the library thinks |
* it can continue anyway. Replacement functions don't have to do anything |
* here if you don't want to. In the default configuration, png_ptr is |
* not used, but it is passed in case it may be useful. |
*/ |
static void |
pngtest_warning(png_structp png_ptr, png_const_charp message) |
{ |
PNG_CONST char *name = "UNKNOWN (ERROR!)"; |
if (png_ptr != NULL && png_ptr->error_ptr != NULL) |
name = png_ptr->error_ptr; |
cprintf("%s: libpng warning: %s\n", name, message); |
} |
/* This is the default error handling function. Note that replacements for |
* this function MUST NOT RETURN, or the program will likely crash. This |
* function is used by default, or if the program supplies NULL for the |
* error function pointer in png_set_error_fn(). |
*/ |
static void |
pngtest_error(png_structp png_ptr, png_const_charp message) |
{ |
pngtest_warning(png_ptr, message); |
/* We can return because png_error calls the default handler, which is |
* actually OK in this case. */ |
} |
#endif /* PNG_NO_STDIO */ |
/* END of code to validate stdio-free compilation */ |
/* START of code to validate memory allocation and deallocation */ |
#ifdef PNG_USER_MEM_SUPPORTED |
/* Allocate memory. For reasonable files, size should never exceed |
64K. However, zlib may allocate more then 64K if you don't tell |
it not to. See zconf.h and png.h for more information. zlib does |
need to allocate exactly 64K, so whatever you call here must |
have the ability to do that. |
This piece of code can be compiled to validate max 64K allocations |
by setting MAXSEG_64K in zlib zconf.h *or* PNG_MAX_MALLOC_64K. */ |
typedef struct memory_information |
{ |
png_uint_32 size; |
png_voidp pointer; |
struct memory_information FAR *next; |
} memory_information; |
typedef memory_information FAR *memory_infop; |
static memory_infop pinformation = NULL; |
static int current_allocation = 0; |
static int maximum_allocation = 0; |
static int total_allocation = 0; |
static int num_allocations = 0; |
png_voidp png_debug_malloc PNGARG((png_structp png_ptr, png_uint_32 size)); |
void png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr)); |
png_voidp |
png_debug_malloc(png_structp png_ptr, png_uint_32 size) |
{ |
/* png_malloc has already tested for NULL; png_create_struct calls |
png_debug_malloc directly, with png_ptr == NULL which is OK */ |
if (size == 0) |
return (NULL); |
/* This calls the library allocator twice, once to get the requested |
buffer and once to get a new free list entry. */ |
{ |
memory_infop pinfo = (memory_infop)png_malloc_default(png_ptr, |
(png_uint_32)sizeof *pinfo); |
pinfo->size = size; |
current_allocation += size; |
total_allocation += size; |
num_allocations ++; |
if (current_allocation > maximum_allocation) |
maximum_allocation = current_allocation; |
pinfo->pointer = (png_voidp)png_malloc_default(png_ptr, size); |
pinfo->next = pinformation; |
pinformation = pinfo; |
/* Make sure the caller isn't assuming zeroed memory. */ |
png_memset(pinfo->pointer, 0xdd, pinfo->size); |
#if PNG_DEBUG |
if(verbose) |
printf("png_malloc %lu bytes at %x\n",size,pinfo->pointer); |
#endif |
assert(pinfo->size != 12345678); |
return (png_voidp)(pinfo->pointer); |
} |
} |
/* Free a pointer. It is removed from the list at the same time. */ |
void |
png_debug_free(png_structp png_ptr, png_voidp ptr) |
{ |
if (png_ptr == NULL) |
cprintf("NULL pointer to png_debug_free.\n"); |
if (ptr == 0) |
{ |
#if 0 /* This happens all the time. */ |
cprintf("WARNING: freeing NULL pointer\n"); |
#endif |
return; |
} |
/* Unlink the element from the list. */ |
{ |
memory_infop FAR *ppinfo = &pinformation; |
for (;;) |
{ |
memory_infop pinfo = *ppinfo; |
if (pinfo->pointer == ptr) |
{ |
*ppinfo = pinfo->next; |
current_allocation -= pinfo->size; |
if (current_allocation < 0) |
cprintf("Duplicate free of memory\n"); |
/* We must free the list element too, but first kill |
the memory that is to be freed. */ |
png_memset(ptr, 0x55, pinfo->size); |
png_free_default(png_ptr, pinfo); |
pinfo=NULL; |
break; |
} |
if (pinfo->next == NULL) |
{ |
cprintf("Pointer %x not found\n", (unsigned int)ptr); |
break; |
} |
ppinfo = &pinfo->next; |
} |
} |
/* Finally free the data. */ |
#if PNG_DEBUG |
if(verbose) |
cprintf("Freeing %x\n",ptr); |
#endif |
png_free_default(png_ptr, ptr); |
ptr=NULL; |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
/* END of code to test memory allocation/deallocation */ |
/* Test one file */ |
int |
test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) |
{ |
static png_FILE_p fpin; |
static png_FILE_p fpout; /* "static" prevents setjmp corruption */ |
png_structp read_ptr; |
png_infop read_info_ptr, end_info_ptr; |
#ifdef PNG_WRITE_SUPPORTED |
png_structp write_ptr; |
png_infop write_info_ptr; |
png_infop write_end_info_ptr; |
#else |
png_structp write_ptr = NULL; |
png_infop write_info_ptr = NULL; |
png_infop write_end_info_ptr = NULL; |
#endif |
png_bytep row_buf; |
png_uint_32 y; |
png_uint_32 width, height; |
int num_pass, pass; |
int bit_depth, color_type; |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
jmp_buf jmpbuf; |
#endif |
#endif |
#if defined(_WIN32_WCE) |
TCHAR path[MAX_PATH]; |
#endif |
char inbuf[256], outbuf[256]; |
row_buf = NULL; |
#if defined(_WIN32_WCE) |
MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH); |
if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE) |
#else |
if ((fpin = fopen(inname, "rb")) == NULL) |
#endif |
{ |
cprintf("Could not find input file %s\n", inname); |
return (1); |
} |
#if defined(_WIN32_WCE) |
MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH); |
if ((fpout = CreateFile(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE) |
#else |
if ((fpout = fopen(outname, "wb")) == NULL) |
#endif |
{ |
cprintf("Could not open output file %s\n", outname); |
FCLOSE(fpin); |
return (1); |
} |
png_debug(0, "Allocating read and write structures\n"); |
#ifdef PNG_USER_MEM_SUPPORTED |
read_ptr = png_create_read_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL, |
png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL, |
(png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free); |
#else |
read_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL, |
png_error_ptr_NULL, png_error_ptr_NULL); |
#endif |
#if defined(PNG_NO_STDIO) |
png_set_error_fn(read_ptr, (png_voidp)inname, pngtest_error, |
pngtest_warning); |
#endif |
#ifdef PNG_WRITE_SUPPORTED |
#ifdef PNG_USER_MEM_SUPPORTED |
write_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL, |
png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL, |
(png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free); |
#else |
write_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL, |
png_error_ptr_NULL, png_error_ptr_NULL); |
#endif |
#if defined(PNG_NO_STDIO) |
png_set_error_fn(write_ptr, (png_voidp)inname, pngtest_error, |
pngtest_warning); |
#endif |
#endif |
png_debug(0, "Allocating read_info, write_info and end_info structures\n"); |
read_info_ptr = png_create_info_struct(read_ptr); |
end_info_ptr = png_create_info_struct(read_ptr); |
#ifdef PNG_WRITE_SUPPORTED |
write_info_ptr = png_create_info_struct(write_ptr); |
write_end_info_ptr = png_create_info_struct(write_ptr); |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
png_debug(0, "Setting jmpbuf for read struct\n"); |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
#else |
if (setjmp(png_jmpbuf(read_ptr))) |
#endif |
{ |
cprintf("%s -> %s: libpng read error\n", inname, outname); |
if (row_buf) |
png_free(read_ptr, row_buf); |
png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr); |
#ifdef PNG_WRITE_SUPPORTED |
png_destroy_info_struct(write_ptr, &write_end_info_ptr); |
png_destroy_write_struct(&write_ptr, &write_info_ptr); |
#endif |
FCLOSE(fpin); |
FCLOSE(fpout); |
return (1); |
} |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_jmpbuf(read_ptr),jmpbuf,sizeof(jmp_buf)); |
#endif |
#ifdef PNG_WRITE_SUPPORTED |
png_debug(0, "Setting jmpbuf for write struct\n"); |
#ifdef USE_FAR_KEYWORD |
if (setjmp(jmpbuf)) |
#else |
if (setjmp(png_jmpbuf(write_ptr))) |
#endif |
{ |
cprintf("%s -> %s: libpng write error\n", inname, outname); |
png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr); |
png_destroy_info_struct(write_ptr, &write_end_info_ptr); |
#ifdef PNG_WRITE_SUPPORTED |
png_destroy_write_struct(&write_ptr, &write_info_ptr); |
#endif |
FCLOSE(fpin); |
FCLOSE(fpout); |
return (1); |
} |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_jmpbuf(write_ptr),jmpbuf,sizeof(jmp_buf)); |
#endif |
#endif |
#endif |
png_debug(0, "Initializing input and output streams\n"); |
#if !defined(PNG_NO_STDIO) |
png_init_io(read_ptr, fpin); |
# ifdef PNG_WRITE_SUPPORTED |
png_init_io(write_ptr, fpout); |
# endif |
#else |
png_set_read_fn(read_ptr, (png_voidp)fpin, pngtest_read_data); |
# ifdef PNG_WRITE_SUPPORTED |
png_set_write_fn(write_ptr, (png_voidp)fpout, pngtest_write_data, |
# if defined(PNG_WRITE_FLUSH_SUPPORTED) |
pngtest_flush); |
# else |
NULL); |
# endif |
# endif |
#endif |
if(status_dots_requested == 1) |
{ |
#ifdef PNG_WRITE_SUPPORTED |
png_set_write_status_fn(write_ptr, write_row_callback); |
#endif |
png_set_read_status_fn(read_ptr, read_row_callback); |
} |
else |
{ |
#ifdef PNG_WRITE_SUPPORTED |
png_set_write_status_fn(write_ptr, png_write_status_ptr_NULL); |
#endif |
png_set_read_status_fn(read_ptr, png_read_status_ptr_NULL); |
} |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
{ |
int i; |
for(i=0; i<256; i++) |
filters_used[i]=0; |
png_set_read_user_transform_fn(read_ptr, count_filters); |
} |
#endif |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
zero_samples=0; |
png_set_write_user_transform_fn(write_ptr, count_zero_samples); |
#endif |
#define HANDLE_CHUNK_IF_SAFE 2 |
#define HANDLE_CHUNK_ALWAYS 3 |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
png_set_keep_unknown_chunks(read_ptr, HANDLE_CHUNK_ALWAYS, |
png_bytep_NULL, 0); |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
png_set_keep_unknown_chunks(write_ptr, HANDLE_CHUNK_IF_SAFE, |
png_bytep_NULL, 0); |
#endif |
png_debug(0, "Reading info struct\n"); |
png_read_info(read_ptr, read_info_ptr); |
png_debug(0, "Transferring info struct\n"); |
{ |
int interlace_type, compression_type, filter_type; |
if (png_get_IHDR(read_ptr, read_info_ptr, &width, &height, &bit_depth, |
&color_type, &interlace_type, &compression_type, &filter_type)) |
{ |
png_set_IHDR(write_ptr, write_info_ptr, width, height, bit_depth, |
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) |
color_type, interlace_type, compression_type, filter_type); |
#else |
color_type, PNG_INTERLACE_NONE, compression_type, filter_type); |
#endif |
} |
} |
#if defined(PNG_FIXED_POINT_SUPPORTED) |
#if defined(PNG_cHRM_SUPPORTED) |
{ |
png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x, |
blue_y; |
if (png_get_cHRM_fixed(read_ptr, read_info_ptr, &white_x, &white_y, &red_x, |
&red_y, &green_x, &green_y, &blue_x, &blue_y)) |
{ |
png_set_cHRM_fixed(write_ptr, write_info_ptr, white_x, white_y, red_x, |
red_y, green_x, green_y, blue_x, blue_y); |
} |
} |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
{ |
png_fixed_point gamma; |
if (png_get_gAMA_fixed(read_ptr, read_info_ptr, &gamma)) |
{ |
png_set_gAMA_fixed(write_ptr, write_info_ptr, gamma); |
} |
} |
#endif |
#else /* Use floating point versions */ |
#if defined(PNG_FLOATING_POINT_SUPPORTED) |
#if defined(PNG_cHRM_SUPPORTED) |
{ |
double white_x, white_y, red_x, red_y, green_x, green_y, blue_x, |
blue_y; |
if (png_get_cHRM(read_ptr, read_info_ptr, &white_x, &white_y, &red_x, |
&red_y, &green_x, &green_y, &blue_x, &blue_y)) |
{ |
png_set_cHRM(write_ptr, write_info_ptr, white_x, white_y, red_x, |
red_y, green_x, green_y, blue_x, blue_y); |
} |
} |
#endif |
#if defined(PNG_gAMA_SUPPORTED) |
{ |
double gamma; |
if (png_get_gAMA(read_ptr, read_info_ptr, &gamma)) |
{ |
png_set_gAMA(write_ptr, write_info_ptr, gamma); |
} |
} |
#endif |
#endif /* floating point */ |
#endif /* fixed point */ |
#if defined(PNG_iCCP_SUPPORTED) |
{ |
png_charp name; |
png_charp profile; |
png_uint_32 proflen; |
int compression_type; |
if (png_get_iCCP(read_ptr, read_info_ptr, &name, &compression_type, |
&profile, &proflen)) |
{ |
png_set_iCCP(write_ptr, write_info_ptr, name, compression_type, |
profile, proflen); |
} |
} |
#endif |
#if defined(PNG_sRGB_SUPPORTED) |
{ |
int intent; |
if (png_get_sRGB(read_ptr, read_info_ptr, &intent)) |
{ |
png_set_sRGB(write_ptr, write_info_ptr, intent); |
} |
} |
#endif |
{ |
png_colorp palette; |
int num_palette; |
if (png_get_PLTE(read_ptr, read_info_ptr, &palette, &num_palette)) |
{ |
png_set_PLTE(write_ptr, write_info_ptr, palette, num_palette); |
} |
} |
#if defined(PNG_bKGD_SUPPORTED) |
{ |
png_color_16p background; |
if (png_get_bKGD(read_ptr, read_info_ptr, &background)) |
{ |
png_set_bKGD(write_ptr, write_info_ptr, background); |
} |
} |
#endif |
#if defined(PNG_hIST_SUPPORTED) |
{ |
png_uint_16p hist; |
if (png_get_hIST(read_ptr, read_info_ptr, &hist)) |
{ |
png_set_hIST(write_ptr, write_info_ptr, hist); |
} |
} |
#endif |
#if defined(PNG_oFFs_SUPPORTED) |
{ |
png_int_32 offset_x, offset_y; |
int unit_type; |
if (png_get_oFFs(read_ptr, read_info_ptr,&offset_x,&offset_y,&unit_type)) |
{ |
png_set_oFFs(write_ptr, write_info_ptr, offset_x, offset_y, unit_type); |
} |
} |
#endif |
#if defined(PNG_pCAL_SUPPORTED) |
{ |
png_charp purpose, units; |
png_charpp params; |
png_int_32 X0, X1; |
int type, nparams; |
if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type, |
&nparams, &units, ¶ms)) |
{ |
png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type, |
nparams, units, params); |
} |
} |
#endif |
#if defined(PNG_pHYs_SUPPORTED) |
{ |
png_uint_32 res_x, res_y; |
int unit_type; |
if (png_get_pHYs(read_ptr, read_info_ptr, &res_x, &res_y, &unit_type)) |
{ |
png_set_pHYs(write_ptr, write_info_ptr, res_x, res_y, unit_type); |
} |
} |
#endif |
#if defined(PNG_sBIT_SUPPORTED) |
{ |
png_color_8p sig_bit; |
if (png_get_sBIT(read_ptr, read_info_ptr, &sig_bit)) |
{ |
png_set_sBIT(write_ptr, write_info_ptr, sig_bit); |
} |
} |
#endif |
#if defined(PNG_sCAL_SUPPORTED) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
{ |
int unit; |
double scal_width, scal_height; |
if (png_get_sCAL(read_ptr, read_info_ptr, &unit, &scal_width, |
&scal_height)) |
{ |
png_set_sCAL(write_ptr, write_info_ptr, unit, scal_width, scal_height); |
} |
} |
#else |
#ifdef PNG_FIXED_POINT_SUPPORTED |
{ |
int unit; |
png_charp scal_width, scal_height; |
if (png_get_sCAL_s(read_ptr, read_info_ptr, &unit, &scal_width, |
&scal_height)) |
{ |
png_set_sCAL_s(write_ptr, write_info_ptr, unit, scal_width, scal_height); |
} |
} |
#endif |
#endif |
#endif |
#if defined(PNG_TEXT_SUPPORTED) |
{ |
png_textp text_ptr; |
int num_text; |
if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0) |
{ |
png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text); |
png_set_text(write_ptr, write_info_ptr, text_ptr, num_text); |
} |
} |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
{ |
png_timep mod_time; |
if (png_get_tIME(read_ptr, read_info_ptr, &mod_time)) |
{ |
png_set_tIME(write_ptr, write_info_ptr, mod_time); |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
/* we have to use png_strcpy instead of "=" because the string |
pointed to by png_convert_to_rfc1123() gets free'ed before |
we use it */ |
png_strcpy(tIME_string,png_convert_to_rfc1123(read_ptr, mod_time)); |
tIME_chunk_present++; |
#endif /* PNG_TIME_RFC1123_SUPPORTED */ |
} |
} |
#endif |
#if defined(PNG_tRNS_SUPPORTED) |
{ |
png_bytep trans; |
int num_trans; |
png_color_16p trans_values; |
if (png_get_tRNS(read_ptr, read_info_ptr, &trans, &num_trans, |
&trans_values)) |
{ |
png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans, |
trans_values); |
} |
} |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
{ |
png_unknown_chunkp unknowns; |
int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr, |
&unknowns); |
if (num_unknowns) |
{ |
png_size_t i; |
png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns, |
num_unknowns); |
/* copy the locations from the read_info_ptr. The automatically |
generated locations in write_info_ptr are wrong because we |
haven't written anything yet */ |
for (i = 0; i < (png_size_t)num_unknowns; i++) |
png_set_unknown_chunk_location(write_ptr, write_info_ptr, i, |
unknowns[i].location); |
} |
} |
#endif |
#ifdef PNG_WRITE_SUPPORTED |
png_debug(0, "\nWriting info struct\n"); |
/* If we wanted, we could write info in two steps: |
png_write_info_before_PLTE(write_ptr, write_info_ptr); |
*/ |
png_write_info(write_ptr, write_info_ptr); |
#endif |
#ifdef SINGLE_ROWBUF_ALLOC |
png_debug(0, "\nAllocating row buffer..."); |
row_buf = (png_bytep)png_malloc(read_ptr, |
png_get_rowbytes(read_ptr, read_info_ptr)); |
png_debug1(0, "0x%08lx\n\n", (unsigned long)row_buf); |
#endif /* SINGLE_ROWBUF_ALLOC */ |
png_debug(0, "Writing row data\n"); |
#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ |
defined(PNG_WRITE_INTERLACING_SUPPORTED) |
num_pass = png_set_interlace_handling(read_ptr); |
# ifdef PNG_WRITE_SUPPORTED |
png_set_interlace_handling(write_ptr); |
# endif |
#else |
num_pass=1; |
#endif |
#ifdef PNGTEST_TIMING |
t_stop = (float)clock(); |
t_misc += (t_stop - t_start); |
t_start = t_stop; |
#endif |
for (pass = 0; pass < num_pass; pass++) |
{ |
png_debug1(0, "Writing row data for pass %d\n",pass); |
for (y = 0; y < height; y++) |
{ |
#ifndef SINGLE_ROWBUF_ALLOC |
png_debug2(0, "\nAllocating row buffer (pass %d, y = %ld)...", pass,y); |
row_buf = (png_bytep)png_malloc(read_ptr, |
png_get_rowbytes(read_ptr, read_info_ptr)); |
png_debug2(0, "0x%08lx (%ld bytes)\n", (unsigned long)row_buf, |
png_get_rowbytes(read_ptr, read_info_ptr)); |
#endif /* !SINGLE_ROWBUF_ALLOC */ |
png_read_rows(read_ptr, (png_bytepp)&row_buf, png_bytepp_NULL, 1); |
#ifdef PNG_WRITE_SUPPORTED |
#ifdef PNGTEST_TIMING |
t_stop = (float)clock(); |
t_decode += (t_stop - t_start); |
t_start = t_stop; |
#endif |
png_write_rows(write_ptr, (png_bytepp)&row_buf, 1); |
#ifdef PNGTEST_TIMING |
t_stop = (float)clock(); |
t_encode += (t_stop - t_start); |
t_start = t_stop; |
#endif |
#endif /* PNG_WRITE_SUPPORTED */ |
#ifndef SINGLE_ROWBUF_ALLOC |
png_debug2(0, "Freeing row buffer (pass %d, y = %ld)\n\n", pass, y); |
png_free(read_ptr, row_buf); |
#endif /* !SINGLE_ROWBUF_ALLOC */ |
} |
} |
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) |
png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1); |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1); |
#endif |
png_debug(0, "Reading and writing end_info data\n"); |
png_read_end(read_ptr, end_info_ptr); |
#if defined(PNG_TEXT_SUPPORTED) |
{ |
png_textp text_ptr; |
int num_text; |
if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0) |
{ |
png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks\n", num_text); |
png_set_text(write_ptr, write_end_info_ptr, text_ptr, num_text); |
} |
} |
#endif |
#if defined(PNG_tIME_SUPPORTED) |
{ |
png_timep mod_time; |
if (png_get_tIME(read_ptr, end_info_ptr, &mod_time)) |
{ |
png_set_tIME(write_ptr, write_end_info_ptr, mod_time); |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
/* we have to use png_strcpy instead of "=" because the string |
pointed to by png_convert_to_rfc1123() gets free'ed before |
we use it */ |
png_strcpy(tIME_string,png_convert_to_rfc1123(read_ptr, mod_time)); |
tIME_chunk_present++; |
#endif /* PNG_TIME_RFC1123_SUPPORTED */ |
} |
} |
#endif |
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) |
{ |
png_unknown_chunkp unknowns; |
int num_unknowns; |
num_unknowns = (int)png_get_unknown_chunks(read_ptr, end_info_ptr, |
&unknowns); |
if (num_unknowns) |
{ |
png_size_t i; |
png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns, |
num_unknowns); |
/* copy the locations from the read_info_ptr. The automatically |
generated locations in write_end_info_ptr are wrong because we |
haven't written the end_info yet */ |
for (i = 0; i < (png_size_t)num_unknowns; i++) |
png_set_unknown_chunk_location(write_ptr, write_end_info_ptr, i, |
unknowns[i].location); |
} |
} |
#endif |
#ifdef PNG_WRITE_SUPPORTED |
png_write_end(write_ptr, write_end_info_ptr); |
#endif |
#ifdef PNG_EASY_ACCESS_SUPPORTED |
if(verbose) |
{ |
png_uint_32 iwidth, iheight; |
iwidth = png_get_image_width(write_ptr, write_info_ptr); |
iheight = png_get_image_height(write_ptr, write_info_ptr); |
cprintf("Image width = %lu, height = %lu\n", |
iwidth, iheight); |
} |
#endif |
png_debug(0, "Destroying data structs\n"); |
#ifdef SINGLE_ROWBUF_ALLOC |
png_debug(1, "destroying row_buf for read_ptr\n"); |
png_free(read_ptr, row_buf); |
row_buf=NULL; |
#endif /* SINGLE_ROWBUF_ALLOC */ |
png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr\n"); |
png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr); |
#ifdef PNG_WRITE_SUPPORTED |
png_debug(1, "destroying write_end_info_ptr\n"); |
png_destroy_info_struct(write_ptr, &write_end_info_ptr); |
png_debug(1, "destroying write_ptr, write_info_ptr\n"); |
png_destroy_write_struct(&write_ptr, &write_info_ptr); |
#endif |
png_debug(0, "Destruction complete.\n"); |
FCLOSE(fpin); |
FCLOSE(fpout); |
png_debug(0, "Opening files for comparison\n"); |
#if defined(_WIN32_WCE) |
MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH); |
if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE) |
#else |
if ((fpin = fopen(inname, "rb")) == NULL) |
#endif |
{ |
cprintf("Could not find file %s\n", inname); |
return (1); |
} |
#if defined(_WIN32_WCE) |
MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH); |
if ((fpout = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE) |
#else |
if ((fpout = fopen(outname, "rb")) == NULL) |
#endif |
{ |
cprintf("Could not find file %s\n", outname); |
FCLOSE(fpin); |
return (1); |
} |
for(;;) |
{ |
png_size_t num_in, num_out; |
READFILE(fpin, inbuf, 1, num_in); |
READFILE(fpout, outbuf, 1, num_out); |
if (num_in != num_out) |
{ |
cprintf("\nFiles %s and %s are of a different size\n", |
inname, outname); |
if(wrote_question == 0) |
{ |
cprintf(" Was %s written with the same maximum IDAT chunk size (%d bytes),", |
inname,PNG_ZBUF_SIZE); |
cprintf("\n filtering heuristic (libpng default), compression"); |
cprintf(" level (zlib default),\n and zlib version (%s)?\n\n", |
ZLIB_VERSION); |
wrote_question=1; |
} |
FCLOSE(fpin); |
FCLOSE(fpout); |
return (0); |
} |
if (!num_in) |
break; |
if (png_memcmp(inbuf, outbuf, num_in)) |
{ |
cprintf("\nFiles %s and %s are different\n", inname, outname); |
if(wrote_question == 0) |
{ |
cprintf(" Was %s written with the same maximum IDAT chunk size (%d bytes),", |
inname,PNG_ZBUF_SIZE); |
cprintf("\n filtering heuristic (libpng default), compression"); |
cprintf(" level (zlib default),\n and zlib version (%s)?\n\n", |
ZLIB_VERSION); |
wrote_question=1; |
} |
FCLOSE(fpin); |
FCLOSE(fpout); |
return (0); |
} |
} |
FCLOSE(fpin); |
FCLOSE(fpout); |
return (0); |
} |
/* input and output filenames */ |
#ifdef RISCOS |
static PNG_CONST char *inname = "pngtest/png"; |
static PNG_CONST char *outname = "pngout/png"; |
#else |
static PNG_CONST char *inname = "pngtest.png"; |
static PNG_CONST char *outname = "pngout.png"; |
#endif |
int |
main(int argc, char *argv[]) |
{ |
int multiple = 0; |
int ierror = 0; |
cprintf("Testing libpng version %s\n", PNG_LIBPNG_VER_STRING); |
cprintf(" with zlib version %s\n", ZLIB_VERSION); |
cprintf("%s",png_get_copyright(NULL)); |
/* Show the version of libpng used in building the library */ |
cprintf(" library (%lu):%s", png_access_version_number(), |
png_get_header_version(NULL)); |
/* Show the version of libpng used in building the application */ |
cprintf(" pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER, |
PNG_HEADER_VERSION_STRING); |
cprintf(" sizeof(png_struct)=%ld, sizeof(png_info)=%ld\n", |
(long)sizeof(png_struct), (long)sizeof(png_info)); |
/* Do some consistency checking on the memory allocation settings, I'm |
not sure this matters, but it is nice to know, the first of these |
tests should be impossible because of the way the macros are set |
in pngconf.h */ |
#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) |
cprintf(" NOTE: Zlib compiled for max 64k, libpng not\n"); |
#endif |
/* I think the following can happen. */ |
#if !defined(MAXSEG_64K) && defined(PNG_MAX_MALLOC_64K) |
cprintf(" NOTE: libpng compiled for max 64k, zlib not\n"); |
#endif |
if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING)) |
{ |
cprintf("Warning: versions are different between png.h and png.c\n"); |
cprintf(" png.h version: %s\n", PNG_LIBPNG_VER_STRING); |
cprintf(" png.c version: %s\n\n", png_libpng_ver); |
++ierror; |
} |
if (argc > 1) |
{ |
if (strcmp(argv[1], "-m") == 0) |
{ |
multiple = 1; |
status_dots_requested = 0; |
} |
else if (strcmp(argv[1], "-mv") == 0 || |
strcmp(argv[1], "-vm") == 0 ) |
{ |
multiple = 1; |
verbose = 1; |
status_dots_requested = 1; |
} |
else if (strcmp(argv[1], "-v") == 0) |
{ |
verbose = 1; |
status_dots_requested = 1; |
inname = argv[2]; |
} |
else |
{ |
inname = argv[1]; |
status_dots_requested = 0; |
} |
} |
if (!multiple && argc == 3+verbose) |
outname = argv[2+verbose]; |
if ((!multiple && argc > 3+verbose) || (multiple && argc < 2)) |
{ |
cprintf("usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n", |
argv[0], argv[0]); |
cprintf(" reads/writes one PNG file (without -m) or multiple files (-m)\n"); |
cprintf(" with -m %s is used as a temporary file\n", outname); |
exit(1); |
} |
if (multiple) |
{ |
int i; |
#ifdef PNG_USER_MEM_SUPPORTED |
int allocation_now = current_allocation; |
#endif |
for (i=2; i<argc; ++i) |
{ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
int k; |
#endif |
int kerror; |
cprintf("Testing %s:",argv[i]); |
kerror = test_one_file(argv[i], outname); |
if (kerror == 0) |
{ |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
cprintf("\n PASS (%lu zero samples)\n",zero_samples); |
#else |
cprintf(" PASS\n"); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
for (k=0; k<256; k++) |
if(filters_used[k]) |
cprintf(" Filter %d was used %lu times\n", |
k,filters_used[k]); |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
if(tIME_chunk_present != 0) |
cprintf(" tIME = %s\n",tIME_string); |
tIME_chunk_present = 0; |
#endif /* PNG_TIME_RFC1123_SUPPORTED */ |
} |
else |
{ |
cprintf(" FAIL\n"); |
ierror += kerror; |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
if (allocation_now != current_allocation) |
cprintf("MEMORY ERROR: %d bytes lost\n", |
current_allocation-allocation_now); |
if (current_allocation != 0) |
{ |
memory_infop pinfo = pinformation; |
cprintf("MEMORY ERROR: %d bytes still allocated\n", |
current_allocation); |
while (pinfo != NULL) |
{ |
cprintf(" %lu bytes at %x\n", pinfo->size, |
(unsigned int) pinfo->pointer); |
pinfo = pinfo->next; |
} |
} |
#endif |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
cprintf(" Current memory allocation: %10d bytes\n", |
current_allocation); |
cprintf(" Maximum memory allocation: %10d bytes\n", |
maximum_allocation); |
cprintf(" Total memory allocation: %10d bytes\n", |
total_allocation); |
cprintf(" Number of allocations: %10d\n", |
num_allocations); |
#endif |
} |
else |
{ |
int i; |
for (i=0; i<3; ++i) |
{ |
int kerror; |
#ifdef PNG_USER_MEM_SUPPORTED |
int allocation_now = current_allocation; |
#endif |
if (i == 1) status_dots_requested = 1; |
else if(verbose == 0)status_dots_requested = 0; |
if (i == 0 || verbose == 1 || ierror != 0) |
cprintf("Testing %s:",inname); |
kerror = test_one_file(inname, outname); |
if(kerror == 0) |
{ |
if(verbose == 1 || i == 2) |
{ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
int k; |
#endif |
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
cprintf("\n PASS (%lu zero samples)\n",zero_samples); |
#else |
cprintf(" PASS\n"); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
for (k=0; k<256; k++) |
if(filters_used[k]) |
cprintf(" Filter %d was used %lu times\n", |
k,filters_used[k]); |
#endif |
#if defined(PNG_TIME_RFC1123_SUPPORTED) |
if(tIME_chunk_present != 0) |
cprintf(" tIME = %s\n",tIME_string); |
#endif /* PNG_TIME_RFC1123_SUPPORTED */ |
} |
} |
else |
{ |
if(verbose == 0 && i != 2) |
cprintf("Testing %s:",inname); |
cprintf(" FAIL\n"); |
ierror += kerror; |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
if (allocation_now != current_allocation) |
cprintf("MEMORY ERROR: %d bytes lost\n", |
current_allocation-allocation_now); |
if (current_allocation != 0) |
{ |
memory_infop pinfo = pinformation; |
cprintf("MEMORY ERROR: %d bytes still allocated\n", |
current_allocation); |
while (pinfo != NULL) |
{ |
cprintf(" %lu bytes at %x\n", |
pinfo->size, (unsigned int)pinfo->pointer); |
pinfo = pinfo->next; |
} |
} |
#endif |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
cprintf(" Current memory allocation: %10d bytes\n", |
current_allocation); |
cprintf(" Maximum memory allocation: %10d bytes\n", |
maximum_allocation); |
cprintf(" Total memory allocation: %10d bytes\n", |
total_allocation); |
cprintf(" Number of allocations: %10d\n", |
num_allocations); |
#endif |
} |
#ifdef PNGTEST_TIMING |
t_stop = (float)clock(); |
t_misc += (t_stop - t_start); |
t_start = t_stop; |
cprintf(" CPU time used = %.3f seconds", |
(t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC); |
cprintf(" (decoding %.3f,\n", |
t_decode/(float)CLOCKS_PER_SEC); |
cprintf(" encoding %.3f ,", |
t_encode/(float)CLOCKS_PER_SEC); |
cprintf(" other %.3f seconds)\n\n", |
t_misc/(float)CLOCKS_PER_SEC); |
#endif |
if (ierror == 0) |
cprintf("libpng passes test\n"); |
else |
cprintf("libpng FAILS test\n"); |
return (int)(ierror != 0); |
} |
/* Generate a compiler error if there is an old png.h in the search path. */ |
typedef version_1_2_5 your_png_h_is_not_version_1_2_5; |
/shark/trunk/ports/png/inftrees.h |
---|
0,0 → 1,58 |
/* inftrees.h -- header to use inftrees.c |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* WARNING: this file should *not* be used by applications. It is |
part of the implementation of the compression library and is |
subject to change. Applications should only use zlib.h. |
*/ |
/* Huffman code lookup table entry--this entry is four bytes for machines |
that have 16-bit pointers (e.g. PC's in the small or medium model). */ |
typedef struct inflate_huft_s FAR inflate_huft; |
struct inflate_huft_s { |
union { |
struct { |
Byte Exop; /* number of extra bits or operation */ |
Byte Bits; /* number of bits in this code or subcode */ |
} what; |
uInt pad; /* pad structure to a power of 2 (4 bytes for */ |
} word; /* 16-bit, 8 bytes for 32-bit int's) */ |
uInt base; /* literal, length base, distance base, |
or table offset */ |
}; |
/* Maximum size of dynamic tree. The maximum found in a long but non- |
exhaustive search was 1004 huft structures (850 for length/literals |
and 154 for distances, the latter actually the result of an |
exhaustive search). The actual maximum is not known, but the |
value below is more than safe. */ |
#define MANY 1440 |
extern int inflate_trees_bits OF(( |
uIntf *, /* 19 code lengths */ |
uIntf *, /* bits tree desired/actual depth */ |
inflate_huft * FAR *, /* bits tree result */ |
inflate_huft *, /* space for trees */ |
z_streamp)); /* for messages */ |
extern int inflate_trees_dynamic OF(( |
uInt, /* number of literal/length codes */ |
uInt, /* number of distance codes */ |
uIntf *, /* that many (total) code lengths */ |
uIntf *, /* literal desired/actual bit depth */ |
uIntf *, /* distance desired/actual bit depth */ |
inflate_huft * FAR *, /* literal/length tree result */ |
inflate_huft * FAR *, /* distance tree result */ |
inflate_huft *, /* space for trees */ |
z_streamp)); /* for messages */ |
extern int inflate_trees_fixed OF(( |
uIntf *, /* literal desired/actual bit depth */ |
uIntf *, /* distance desired/actual bit depth */ |
inflate_huft * FAR *, /* literal/length tree result */ |
inflate_huft * FAR *, /* distance tree result */ |
z_streamp)); /* for memory allocation */ |
/shark/trunk/ports/png/infcodes.c |
---|
0,0 → 1,251 |
/* infcodes.c -- process literals and length/distance pairs |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
#include "zutil.h" |
#include "inftrees.h" |
#include "infblock.h" |
#include "infcodes.h" |
#include "infutil.h" |
#include "inffast.h" |
/* simplify the use of the inflate_huft type with some defines */ |
#define exop word.what.Exop |
#define bits word.what.Bits |
typedef enum { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */ |
START, /* x: set up for LEN */ |
LEN, /* i: get length/literal/eob next */ |
LENEXT, /* i: getting length extra (have base) */ |
DIST, /* i: get distance next */ |
DISTEXT, /* i: getting distance extra */ |
COPY, /* o: copying bytes in window, waiting for space */ |
LIT, /* o: got literal, waiting for output space */ |
WASH, /* o: got eob, possibly still output waiting */ |
END, /* x: got eob and all data flushed */ |
BADCODE} /* x: got error */ |
inflate_codes_mode; |
/* inflate codes private state */ |
struct inflate_codes_state { |
/* mode */ |
inflate_codes_mode mode; /* current inflate_codes mode */ |
/* mode dependent information */ |
uInt len; |
union { |
struct { |
inflate_huft *tree; /* pointer into tree */ |
uInt need; /* bits needed */ |
} code; /* if LEN or DIST, where in tree */ |
uInt lit; /* if LIT, literal */ |
struct { |
uInt get; /* bits to get for extra */ |
uInt dist; /* distance back to copy from */ |
} copy; /* if EXT or COPY, where and how much */ |
} sub; /* submode */ |
/* mode independent information */ |
Byte lbits; /* ltree bits decoded per branch */ |
Byte dbits; /* dtree bits decoder per branch */ |
inflate_huft *ltree; /* literal/length/eob tree */ |
inflate_huft *dtree; /* distance tree */ |
}; |
inflate_codes_statef *inflate_codes_new(bl, bd, tl, td, z) |
uInt bl, bd; |
inflate_huft *tl; |
inflate_huft *td; /* need separate declaration for Borland C++ */ |
z_streamp z; |
{ |
inflate_codes_statef *c; |
if ((c = (inflate_codes_statef *) |
ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL) |
{ |
c->mode = START; |
c->lbits = (Byte)bl; |
c->dbits = (Byte)bd; |
c->ltree = tl; |
c->dtree = td; |
Tracev((stderr, "inflate: codes new\n")); |
} |
return c; |
} |
int inflate_codes(s, z, r) |
inflate_blocks_statef *s; |
z_streamp z; |
int r; |
{ |
uInt j; /* temporary storage */ |
inflate_huft *t; /* temporary pointer */ |
uInt e; /* extra bits or operation */ |
uLong b; /* bit buffer */ |
uInt k; /* bits in bit buffer */ |
Bytef *p; /* input data pointer */ |
uInt n; /* bytes available there */ |
Bytef *q; /* output window write pointer */ |
uInt m; /* bytes to end of window or read pointer */ |
Bytef *f; /* pointer to copy strings from */ |
inflate_codes_statef *c = s->sub.decode.codes; /* codes state */ |
/* copy input/output information to locals (UPDATE macro restores) */ |
LOAD |
/* process input and output based on current state */ |
while (1) switch (c->mode) |
{ /* waiting for "i:"=input, "o:"=output, "x:"=nothing */ |
case START: /* x: set up for LEN */ |
#ifndef SLOW |
if (m >= 258 && n >= 10) |
{ |
UPDATE |
r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z); |
LOAD |
if (r != Z_OK) |
{ |
c->mode = r == Z_STREAM_END ? WASH : BADCODE; |
break; |
} |
} |
#endif /* !SLOW */ |
c->sub.code.need = c->lbits; |
c->sub.code.tree = c->ltree; |
c->mode = LEN; |
case LEN: /* i: get length/literal/eob next */ |
j = c->sub.code.need; |
NEEDBITS(j) |
t = c->sub.code.tree + ((uInt)b & inflate_mask[j]); |
DUMPBITS(t->bits) |
e = (uInt)(t->exop); |
if (e == 0) /* literal */ |
{ |
c->sub.lit = t->base; |
Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ? |
"inflate: literal '%c'\n" : |
"inflate: literal 0x%02x\n", t->base)); |
c->mode = LIT; |
break; |
} |
if (e & 16) /* length */ |
{ |
c->sub.copy.get = e & 15; |
c->len = t->base; |
c->mode = LENEXT; |
break; |
} |
if ((e & 64) == 0) /* next table */ |
{ |
c->sub.code.need = e; |
c->sub.code.tree = t + t->base; |
break; |
} |
if (e & 32) /* end of block */ |
{ |
Tracevv((stderr, "inflate: end of block\n")); |
c->mode = WASH; |
break; |
} |
c->mode = BADCODE; /* invalid code */ |
z->msg = (char*)"invalid literal/length code"; |
r = Z_DATA_ERROR; |
LEAVE |
case LENEXT: /* i: getting length extra (have base) */ |
j = c->sub.copy.get; |
NEEDBITS(j) |
c->len += (uInt)b & inflate_mask[j]; |
DUMPBITS(j) |
c->sub.code.need = c->dbits; |
c->sub.code.tree = c->dtree; |
Tracevv((stderr, "inflate: length %u\n", c->len)); |
c->mode = DIST; |
case DIST: /* i: get distance next */ |
j = c->sub.code.need; |
NEEDBITS(j) |
t = c->sub.code.tree + ((uInt)b & inflate_mask[j]); |
DUMPBITS(t->bits) |
e = (uInt)(t->exop); |
if (e & 16) /* distance */ |
{ |
c->sub.copy.get = e & 15; |
c->sub.copy.dist = t->base; |
c->mode = DISTEXT; |
break; |
} |
if ((e & 64) == 0) /* next table */ |
{ |
c->sub.code.need = e; |
c->sub.code.tree = t + t->base; |
break; |
} |
c->mode = BADCODE; /* invalid code */ |
z->msg = (char*)"invalid distance code"; |
r = Z_DATA_ERROR; |
LEAVE |
case DISTEXT: /* i: getting distance extra */ |
j = c->sub.copy.get; |
NEEDBITS(j) |
c->sub.copy.dist += (uInt)b & inflate_mask[j]; |
DUMPBITS(j) |
Tracevv((stderr, "inflate: distance %u\n", c->sub.copy.dist)); |
c->mode = COPY; |
case COPY: /* o: copying bytes in window, waiting for space */ |
f = q - c->sub.copy.dist; |
while (f < s->window) /* modulo window size-"while" instead */ |
f += s->end - s->window; /* of "if" handles invalid distances */ |
while (c->len) |
{ |
NEEDOUT |
OUTBYTE(*f++) |
if (f == s->end) |
f = s->window; |
c->len--; |
} |
c->mode = START; |
break; |
case LIT: /* o: got literal, waiting for output space */ |
NEEDOUT |
OUTBYTE(c->sub.lit) |
c->mode = START; |
break; |
case WASH: /* o: got eob, possibly more output */ |
if (k > 7) /* return unused byte, if any */ |
{ |
Assert(k < 16, "inflate_codes grabbed too many bytes") |
k -= 8; |
n++; |
p--; /* can always return one */ |
} |
FLUSH |
if (s->read != s->write) |
LEAVE |
c->mode = END; |
case END: |
r = Z_STREAM_END; |
LEAVE |
case BADCODE: /* x: got error */ |
r = Z_DATA_ERROR; |
LEAVE |
default: |
r = Z_STREAM_ERROR; |
LEAVE |
} |
#ifdef NEED_DUMMY_RETURN |
return Z_STREAM_ERROR; /* Some dumb compilers complain without this */ |
#endif |
} |
void inflate_codes_free(c, z) |
inflate_codes_statef *c; |
z_streamp z; |
{ |
ZFREE(z, c); |
Tracev((stderr, "inflate: codes free\n")); |
} |
/shark/trunk/ports/png/pngrtran.c |
---|
0,0 → 1,4175 |
/* pngrtran.c - transforms the data in a row for PNG readers |
* |
* libpng 1.2.5 - October 3, 2002 |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2002 Glenn Randers-Pehrson |
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) |
* |
* This file contains functions optionally called by an application |
* in order to tell libpng how to handle data when reading a PNG. |
* Transformations that are used in both reading and writing are |
* in pngtrans.c. |
*/ |
#define PNG_INTERNAL |
#include "png.h" |
/* Set the action on getting a CRC error for an ancillary or critical chunk. */ |
void PNGAPI |
png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action) |
{ |
png_debug(1, "in png_set_crc_action\n"); |
/* Tell libpng how we react to CRC errors in critical chunks */ |
switch (crit_action) |
{ |
case PNG_CRC_NO_CHANGE: /* leave setting as is */ |
break; |
case PNG_CRC_WARN_USE: /* warn/use data */ |
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; |
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE; |
break; |
case PNG_CRC_QUIET_USE: /* quiet/use data */ |
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; |
png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE | |
PNG_FLAG_CRC_CRITICAL_IGNORE; |
break; |
case PNG_CRC_WARN_DISCARD: /* not a valid action for critical data */ |
png_warning(png_ptr, "Can't discard critical data on CRC error."); |
case PNG_CRC_ERROR_QUIT: /* error/quit */ |
case PNG_CRC_DEFAULT: |
default: |
png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK; |
break; |
} |
switch (ancil_action) |
{ |
case PNG_CRC_NO_CHANGE: /* leave setting as is */ |
break; |
case PNG_CRC_WARN_USE: /* warn/use data */ |
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; |
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE; |
break; |
case PNG_CRC_QUIET_USE: /* quiet/use data */ |
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; |
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE | |
PNG_FLAG_CRC_ANCILLARY_NOWARN; |
break; |
case PNG_CRC_ERROR_QUIT: /* error/quit */ |
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; |
png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN; |
break; |
case PNG_CRC_WARN_DISCARD: /* warn/discard data */ |
case PNG_CRC_DEFAULT: |
default: |
png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK; |
break; |
} |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ |
defined(PNG_FLOATING_POINT_SUPPORTED) |
/* handle alpha and tRNS via a background color */ |
void PNGAPI |
png_set_background(png_structp png_ptr, |
png_color_16p background_color, int background_gamma_code, |
int need_expand, double background_gamma) |
{ |
png_debug(1, "in png_set_background\n"); |
if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN) |
{ |
png_warning(png_ptr, "Application must supply a known background gamma"); |
return; |
} |
png_ptr->transformations |= PNG_BACKGROUND; |
png_memcpy(&(png_ptr->background), background_color, sizeof(png_color_16)); |
png_ptr->background_gamma = (float)background_gamma; |
png_ptr->background_gamma_type = (png_byte)(background_gamma_code); |
png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0); |
/* Note: if need_expand is set and color_type is either RGB or RGB_ALPHA |
* (in which case need_expand is superfluous anyway), the background color |
* might actually be gray yet not be flagged as such. This is not a problem |
* for the current code, which uses PNG_BACKGROUND_IS_GRAY only to |
* decide when to do the png_do_gray_to_rgb() transformation. |
*/ |
if ((need_expand && !(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) || |
(!need_expand && background_color->red == background_color->green && |
background_color->red == background_color->blue)) |
png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; |
} |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
/* strip 16 bit depth files to 8 bit depth */ |
void PNGAPI |
png_set_strip_16(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_strip_16\n"); |
png_ptr->transformations |= PNG_16_TO_8; |
} |
#endif |
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
void PNGAPI |
png_set_strip_alpha(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_strip_alpha\n"); |
png_ptr->transformations |= PNG_STRIP_ALPHA; |
} |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
/* Dither file to 8 bit. Supply a palette, the current number |
* of elements in the palette, the maximum number of elements |
* allowed, and a histogram if possible. If the current number |
* of colors is greater then the maximum number, the palette will be |
* modified to fit in the maximum number. "full_dither" indicates |
* whether we need a dithering cube set up for RGB images, or if we |
* simply are reducing the number of colors in a paletted image. |
*/ |
typedef struct png_dsort_struct |
{ |
struct png_dsort_struct FAR * next; |
png_byte left; |
png_byte right; |
} png_dsort; |
typedef png_dsort FAR * png_dsortp; |
typedef png_dsort FAR * FAR * png_dsortpp; |
void PNGAPI |
png_set_dither(png_structp png_ptr, png_colorp palette, |
int num_palette, int maximum_colors, png_uint_16p histogram, |
int full_dither) |
{ |
png_debug(1, "in png_set_dither\n"); |
png_ptr->transformations |= PNG_DITHER; |
if (!full_dither) |
{ |
int i; |
png_ptr->dither_index = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * sizeof (png_byte))); |
for (i = 0; i < num_palette; i++) |
png_ptr->dither_index[i] = (png_byte)i; |
} |
if (num_palette > maximum_colors) |
{ |
if (histogram != NULL) |
{ |
/* This is easy enough, just throw out the least used colors. |
Perhaps not the best solution, but good enough. */ |
int i; |
/* initialize an array to sort colors */ |
png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * sizeof (png_byte))); |
/* initialize the dither_sort array */ |
for (i = 0; i < num_palette; i++) |
png_ptr->dither_sort[i] = (png_byte)i; |
/* Find the least used palette entries by starting a |
bubble sort, and running it until we have sorted |
out enough colors. Note that we don't care about |
sorting all the colors, just finding which are |
least used. */ |
for (i = num_palette - 1; i >= maximum_colors; i--) |
{ |
int done; /* to stop early if the list is pre-sorted */ |
int j; |
done = 1; |
for (j = 0; j < i; j++) |
{ |
if (histogram[png_ptr->dither_sort[j]] |
< histogram[png_ptr->dither_sort[j + 1]]) |
{ |
png_byte t; |
t = png_ptr->dither_sort[j]; |
png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1]; |
png_ptr->dither_sort[j + 1] = t; |
done = 0; |
} |
} |
if (done) |
break; |
} |
/* swap the palette around, and set up a table, if necessary */ |
if (full_dither) |
{ |
int j = num_palette; |
/* put all the useful colors within the max, but don't |
move the others */ |
for (i = 0; i < maximum_colors; i++) |
{ |
if ((int)png_ptr->dither_sort[i] >= maximum_colors) |
{ |
do |
j--; |
while ((int)png_ptr->dither_sort[j] >= maximum_colors); |
palette[i] = palette[j]; |
} |
} |
} |
else |
{ |
int j = num_palette; |
/* move all the used colors inside the max limit, and |
develop a translation table */ |
for (i = 0; i < maximum_colors; i++) |
{ |
/* only move the colors we need to */ |
if ((int)png_ptr->dither_sort[i] >= maximum_colors) |
{ |
png_color tmp_color; |
do |
j--; |
while ((int)png_ptr->dither_sort[j] >= maximum_colors); |
tmp_color = palette[j]; |
palette[j] = palette[i]; |
palette[i] = tmp_color; |
/* indicate where the color went */ |
png_ptr->dither_index[j] = (png_byte)i; |
png_ptr->dither_index[i] = (png_byte)j; |
} |
} |
/* find closest color for those colors we are not using */ |
for (i = 0; i < num_palette; i++) |
{ |
if ((int)png_ptr->dither_index[i] >= maximum_colors) |
{ |
int min_d, k, min_k, d_index; |
/* find the closest color to one we threw out */ |
d_index = png_ptr->dither_index[i]; |
min_d = PNG_COLOR_DIST(palette[d_index], palette[0]); |
for (k = 1, min_k = 0; k < maximum_colors; k++) |
{ |
int d; |
d = PNG_COLOR_DIST(palette[d_index], palette[k]); |
if (d < min_d) |
{ |
min_d = d; |
min_k = k; |
} |
} |
/* point to closest color */ |
png_ptr->dither_index[i] = (png_byte)min_k; |
} |
} |
} |
png_free(png_ptr, png_ptr->dither_sort); |
png_ptr->dither_sort=NULL; |
} |
else |
{ |
/* This is much harder to do simply (and quickly). Perhaps |
we need to go through a median cut routine, but those |
don't always behave themselves with only a few colors |
as input. So we will just find the closest two colors, |
and throw out one of them (chosen somewhat randomly). |
[We don't understand this at all, so if someone wants to |
work on improving it, be our guest - AED, GRP] |
*/ |
int i; |
int max_d; |
int num_new_palette; |
png_dsortp t; |
png_dsortpp hash; |
t=NULL; |
/* initialize palette index arrays */ |
png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * sizeof (png_byte))); |
png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * sizeof (png_byte))); |
/* initialize the sort array */ |
for (i = 0; i < num_palette; i++) |
{ |
png_ptr->index_to_palette[i] = (png_byte)i; |
png_ptr->palette_to_index[i] = (png_byte)i; |
} |
hash = (png_dsortpp)png_malloc(png_ptr, (png_uint_32)(769 * |
sizeof (png_dsortp))); |
for (i = 0; i < 769; i++) |
hash[i] = NULL; |
/* png_memset(hash, 0, 769 * sizeof (png_dsortp)); */ |
num_new_palette = num_palette; |
/* initial wild guess at how far apart the farthest pixel |
pair we will be eliminating will be. Larger |
numbers mean more areas will be allocated, Smaller |
numbers run the risk of not saving enough data, and |
having to do this all over again. |
I have not done extensive checking on this number. |
*/ |
max_d = 96; |
while (num_new_palette > maximum_colors) |
{ |
for (i = 0; i < num_new_palette - 1; i++) |
{ |
int j; |
for (j = i + 1; j < num_new_palette; j++) |
{ |
int d; |
d = PNG_COLOR_DIST(palette[i], palette[j]); |
if (d <= max_d) |
{ |
t = (png_dsortp)png_malloc_warn(png_ptr, |
(png_uint_32)(sizeof(png_dsort))); |
if (t == NULL) |
break; |
t->next = hash[d]; |
t->left = (png_byte)i; |
t->right = (png_byte)j; |
hash[d] = t; |
} |
} |
if (t == NULL) |
break; |
} |
if (t != NULL) |
for (i = 0; i <= max_d; i++) |
{ |
if (hash[i] != NULL) |
{ |
png_dsortp p; |
for (p = hash[i]; p; p = p->next) |
{ |
if ((int)png_ptr->index_to_palette[p->left] |
< num_new_palette && |
(int)png_ptr->index_to_palette[p->right] |
< num_new_palette) |
{ |
int j, next_j; |
if (num_new_palette & 0x01) |
{ |
j = p->left; |
next_j = p->right; |
} |
else |
{ |
j = p->right; |
next_j = p->left; |
} |
num_new_palette--; |
palette[png_ptr->index_to_palette[j]] |
= palette[num_new_palette]; |
if (!full_dither) |
{ |
int k; |
for (k = 0; k < num_palette; k++) |
{ |
if (png_ptr->dither_index[k] == |
png_ptr->index_to_palette[j]) |
png_ptr->dither_index[k] = |
png_ptr->index_to_palette[next_j]; |
if ((int)png_ptr->dither_index[k] == |
num_new_palette) |
png_ptr->dither_index[k] = |
png_ptr->index_to_palette[j]; |
} |
} |
png_ptr->index_to_palette[png_ptr->palette_to_index |
[num_new_palette]] = png_ptr->index_to_palette[j]; |
png_ptr->palette_to_index[png_ptr->index_to_palette[j]] |
= png_ptr->palette_to_index[num_new_palette]; |
png_ptr->index_to_palette[j] = (png_byte)num_new_palette; |
png_ptr->palette_to_index[num_new_palette] = (png_byte)j; |
} |
if (num_new_palette <= maximum_colors) |
break; |
} |
if (num_new_palette <= maximum_colors) |
break; |
} |
} |
for (i = 0; i < 769; i++) |
{ |
if (hash[i] != NULL) |
{ |
png_dsortp p = hash[i]; |
while (p) |
{ |
t = p->next; |
png_free(png_ptr, p); |
p = t; |
} |
} |
hash[i] = 0; |
} |
max_d += 96; |
} |
png_free(png_ptr, hash); |
png_free(png_ptr, png_ptr->palette_to_index); |
png_free(png_ptr, png_ptr->index_to_palette); |
png_ptr->palette_to_index=NULL; |
png_ptr->index_to_palette=NULL; |
} |
num_palette = maximum_colors; |
} |
if (png_ptr->palette == NULL) |
{ |
png_ptr->palette = palette; |
} |
png_ptr->num_palette = (png_uint_16)num_palette; |
if (full_dither) |
{ |
int i; |
png_bytep distance; |
int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS + |
PNG_DITHER_BLUE_BITS; |
int num_red = (1 << PNG_DITHER_RED_BITS); |
int num_green = (1 << PNG_DITHER_GREEN_BITS); |
int num_blue = (1 << PNG_DITHER_BLUE_BITS); |
png_size_t num_entries = ((png_size_t)1 << total_bits); |
png_ptr->palette_lookup = (png_bytep )png_malloc(png_ptr, |
(png_uint_32)(num_entries * sizeof (png_byte))); |
png_memset(png_ptr->palette_lookup, 0, num_entries * sizeof (png_byte)); |
distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries * |
sizeof(png_byte))); |
png_memset(distance, 0xff, num_entries * sizeof(png_byte)); |
for (i = 0; i < num_palette; i++) |
{ |
int ir, ig, ib; |
int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS)); |
int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS)); |
int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS)); |
for (ir = 0; ir < num_red; ir++) |
{ |
int dr = abs(ir - r); |
int index_r = (ir << (PNG_DITHER_BLUE_BITS + PNG_DITHER_GREEN_BITS)); |
for (ig = 0; ig < num_green; ig++) |
{ |
int dg = abs(ig - g); |
int dt = dr + dg; |
int dm = ((dr > dg) ? dr : dg); |
int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS); |
for (ib = 0; ib < num_blue; ib++) |
{ |
int d_index = index_g | ib; |
int db = abs(ib - b); |
int dmax = ((dm > db) ? dm : db); |
int d = dmax + dt + db; |
if (d < (int)distance[d_index]) |
{ |
distance[d_index] = (png_byte)d; |
png_ptr->palette_lookup[d_index] = (png_byte)i; |
} |
} |
} |
} |
} |
png_free(png_ptr, distance); |
} |
} |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) |
/* Transform the image from the file_gamma to the screen_gamma. We |
* only do transformations on images where the file_gamma and screen_gamma |
* are not close reciprocals, otherwise it slows things down slightly, and |
* also needlessly introduces small errors. |
* |
* We will turn off gamma transformation later if no semitransparent entries |
* are present in the tRNS array for palette images. We can't do it here |
* because we don't necessarily have the tRNS chunk yet. |
*/ |
void PNGAPI |
png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma) |
{ |
png_debug(1, "in png_set_gamma\n"); |
if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) || |
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA) || |
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) |
png_ptr->transformations |= PNG_GAMMA; |
png_ptr->gamma = (float)file_gamma; |
png_ptr->screen_gamma = (float)scrn_gamma; |
} |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
/* Expand paletted images to RGB, expand grayscale images of |
* less than 8-bit depth to 8-bit depth, and expand tRNS chunks |
* to alpha channels. |
*/ |
void PNGAPI |
png_set_expand(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_expand\n"); |
png_ptr->transformations |= PNG_EXPAND; |
} |
/* GRR 19990627: the following three functions currently are identical |
* to png_set_expand(). However, it is entirely reasonable that someone |
* might wish to expand an indexed image to RGB but *not* expand a single, |
* fully transparent palette entry to a full alpha channel--perhaps instead |
* convert tRNS to the grayscale/RGB format (16-bit RGB value), or replace |
* the transparent color with a particular RGB value, or drop tRNS entirely. |
* IOW, a future version of the library may make the transformations flag |
* a bit more fine-grained, with separate bits for each of these three |
* functions. |
* |
* More to the point, these functions make it obvious what libpng will be |
* doing, whereas "expand" can (and does) mean any number of things. |
*/ |
/* Expand paletted images to RGB. */ |
void PNGAPI |
png_set_palette_to_rgb(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_expand\n"); |
png_ptr->transformations |= PNG_EXPAND; |
} |
/* Expand grayscale images of less than 8-bit depth to 8 bits. */ |
void PNGAPI |
png_set_gray_1_2_4_to_8(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_expand\n"); |
png_ptr->transformations |= PNG_EXPAND; |
} |
/* Expand tRNS chunks to alpha channels. */ |
void PNGAPI |
png_set_tRNS_to_alpha(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_expand\n"); |
png_ptr->transformations |= PNG_EXPAND; |
} |
#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */ |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
void PNGAPI |
png_set_gray_to_rgb(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_gray_to_rgb\n"); |
png_ptr->transformations |= PNG_GRAY_TO_RGB; |
} |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
#if defined(PNG_FLOATING_POINT_SUPPORTED) |
/* Convert a RGB image to a grayscale of the same width. This allows us, |
* for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image. |
*/ |
void PNGAPI |
png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red, |
double green) |
{ |
int red_fixed = (int)((float)red*100000.0 + 0.5); |
int green_fixed = (int)((float)green*100000.0 + 0.5); |
png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed); |
} |
#endif |
void PNGAPI |
png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action, |
png_fixed_point red, png_fixed_point green) |
{ |
png_debug(1, "in png_set_rgb_to_gray\n"); |
switch(error_action) |
{ |
case 1: png_ptr->transformations |= PNG_RGB_TO_GRAY; |
break; |
case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN; |
break; |
case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR; |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
png_ptr->transformations |= PNG_EXPAND; |
#else |
{ |
png_warning(png_ptr, "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED."); |
png_ptr->transformations &= ~PNG_RGB_TO_GRAY; |
} |
#endif |
{ |
png_uint_16 red_int, green_int; |
if(red < 0 || green < 0) |
{ |
red_int = 6968; /* .212671 * 32768 + .5 */ |
green_int = 23434; /* .715160 * 32768 + .5 */ |
} |
else if(red + green < 100000L) |
{ |
red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L); |
green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L); |
} |
else |
{ |
png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients"); |
red_int = 6968; |
green_int = 23434; |
} |
png_ptr->rgb_to_gray_red_coeff = red_int; |
png_ptr->rgb_to_gray_green_coeff = green_int; |
png_ptr->rgb_to_gray_blue_coeff = (png_uint_16)(32768-red_int-green_int); |
} |
} |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_LEGACY_SUPPORTED) |
void PNGAPI |
png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr |
read_user_transform_fn) |
{ |
png_debug(1, "in png_set_read_user_transform_fn\n"); |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
png_ptr->transformations |= PNG_USER_TRANSFORM; |
png_ptr->read_user_transform_fn = read_user_transform_fn; |
#endif |
#ifdef PNG_LEGACY_SUPPORTED |
if(read_user_transform_fn) |
png_warning(png_ptr, |
"This version of libpng does not support user transforms"); |
#endif |
} |
#endif |
/* Initialize everything needed for the read. This includes modifying |
* the palette. |
*/ |
void /* PRIVATE */ |
png_init_read_transformations(png_structp png_ptr) |
{ |
png_debug(1, "in png_init_read_transformations\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if(png_ptr != NULL) |
#endif |
{ |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || defined(PNG_READ_SHIFT_SUPPORTED) \ |
|| defined(PNG_READ_GAMMA_SUPPORTED) |
int color_type = png_ptr->color_type; |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) |
if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && |
(png_ptr->transformations & PNG_EXPAND)) |
{ |
if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */ |
{ |
/* expand background chunk. */ |
switch (png_ptr->bit_depth) |
{ |
case 1: |
png_ptr->background.gray *= (png_uint_16)0xff; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
break; |
case 2: |
png_ptr->background.gray *= (png_uint_16)0x55; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
break; |
case 4: |
png_ptr->background.gray *= (png_uint_16)0x11; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
break; |
case 8: |
case 16: |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
break; |
} |
} |
else if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_ptr->background.red = |
png_ptr->palette[png_ptr->background.index].red; |
png_ptr->background.green = |
png_ptr->palette[png_ptr->background.index].green; |
png_ptr->background.blue = |
png_ptr->palette[png_ptr->background.index].blue; |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
{ |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
if (!(png_ptr->transformations & PNG_EXPAND)) |
#endif |
{ |
/* invert the alpha channel (in tRNS) unless the pixels are |
going to be expanded, in which case leave it for later */ |
int i,istop; |
istop=(int)png_ptr->num_trans; |
for (i=0; i<istop; i++) |
png_ptr->trans[i] = (png_byte)(255 - png_ptr->trans[i]); |
} |
} |
#endif |
} |
} |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) |
png_ptr->background_1 = png_ptr->background; |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) |
if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0) |
&& (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0) |
< PNG_GAMMA_THRESHOLD)) |
{ |
int i,k; |
k=0; |
for (i=0; i<png_ptr->num_trans; i++) |
{ |
if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff) |
k=1; /* partial transparency is present */ |
} |
if (k == 0) |
png_ptr->transformations &= (~PNG_GAMMA); |
} |
if (png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) |
{ |
png_build_gamma_table(png_ptr); |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->transformations & PNG_BACKGROUND) |
{ |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
/* could skip if no transparency and |
*/ |
png_color back, back_1; |
png_colorp palette = png_ptr->palette; |
int num_palette = png_ptr->num_palette; |
int i; |
if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) |
{ |
back.red = png_ptr->gamma_table[png_ptr->background.red]; |
back.green = png_ptr->gamma_table[png_ptr->background.green]; |
back.blue = png_ptr->gamma_table[png_ptr->background.blue]; |
back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; |
back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; |
back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; |
} |
else |
{ |
double g, gs; |
switch (png_ptr->background_gamma_type) |
{ |
case PNG_BACKGROUND_GAMMA_SCREEN: |
g = (png_ptr->screen_gamma); |
gs = 1.0; |
break; |
case PNG_BACKGROUND_GAMMA_FILE: |
g = 1.0 / (png_ptr->gamma); |
gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); |
break; |
case PNG_BACKGROUND_GAMMA_UNIQUE: |
g = 1.0 / (png_ptr->background_gamma); |
gs = 1.0 / (png_ptr->background_gamma * |
png_ptr->screen_gamma); |
break; |
default: |
g = 1.0; /* back_1 */ |
gs = 1.0; /* back */ |
} |
if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD) |
{ |
back.red = (png_byte)png_ptr->background.red; |
back.green = (png_byte)png_ptr->background.green; |
back.blue = (png_byte)png_ptr->background.blue; |
} |
else |
{ |
back.red = (png_byte)(pow( |
(double)png_ptr->background.red/255, gs) * 255.0 + .5); |
back.green = (png_byte)(pow( |
(double)png_ptr->background.green/255, gs) * 255.0 + .5); |
back.blue = (png_byte)(pow( |
(double)png_ptr->background.blue/255, gs) * 255.0 + .5); |
} |
back_1.red = (png_byte)(pow( |
(double)png_ptr->background.red/255, g) * 255.0 + .5); |
back_1.green = (png_byte)(pow( |
(double)png_ptr->background.green/255, g) * 255.0 + .5); |
back_1.blue = (png_byte)(pow( |
(double)png_ptr->background.blue/255, g) * 255.0 + .5); |
} |
for (i = 0; i < num_palette; i++) |
{ |
if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff) |
{ |
if (png_ptr->trans[i] == 0) |
{ |
palette[i] = back; |
} |
else /* if (png_ptr->trans[i] != 0xff) */ |
{ |
png_byte v, w; |
v = png_ptr->gamma_to_1[palette[i].red]; |
png_composite(w, v, png_ptr->trans[i], back_1.red); |
palette[i].red = png_ptr->gamma_from_1[w]; |
v = png_ptr->gamma_to_1[palette[i].green]; |
png_composite(w, v, png_ptr->trans[i], back_1.green); |
palette[i].green = png_ptr->gamma_from_1[w]; |
v = png_ptr->gamma_to_1[palette[i].blue]; |
png_composite(w, v, png_ptr->trans[i], back_1.blue); |
palette[i].blue = png_ptr->gamma_from_1[w]; |
} |
} |
else |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
palette[i].green = png_ptr->gamma_table[palette[i].green]; |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
} |
/* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */ |
else |
/* color_type != PNG_COLOR_TYPE_PALETTE */ |
{ |
double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1); |
double g = 1.0; |
double gs = 1.0; |
switch (png_ptr->background_gamma_type) |
{ |
case PNG_BACKGROUND_GAMMA_SCREEN: |
g = (png_ptr->screen_gamma); |
gs = 1.0; |
break; |
case PNG_BACKGROUND_GAMMA_FILE: |
g = 1.0 / (png_ptr->gamma); |
gs = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); |
break; |
case PNG_BACKGROUND_GAMMA_UNIQUE: |
g = 1.0 / (png_ptr->background_gamma); |
gs = 1.0 / (png_ptr->background_gamma * |
png_ptr->screen_gamma); |
break; |
} |
png_ptr->background_1.gray = (png_uint_16)(pow( |
(double)png_ptr->background.gray / m, g) * m + .5); |
png_ptr->background.gray = (png_uint_16)(pow( |
(double)png_ptr->background.gray / m, gs) * m + .5); |
if ((png_ptr->background.red != png_ptr->background.green) || |
(png_ptr->background.red != png_ptr->background.blue) || |
(png_ptr->background.red != png_ptr->background.gray)) |
{ |
/* RGB or RGBA with color background */ |
png_ptr->background_1.red = (png_uint_16)(pow( |
(double)png_ptr->background.red / m, g) * m + .5); |
png_ptr->background_1.green = (png_uint_16)(pow( |
(double)png_ptr->background.green / m, g) * m + .5); |
png_ptr->background_1.blue = (png_uint_16)(pow( |
(double)png_ptr->background.blue / m, g) * m + .5); |
png_ptr->background.red = (png_uint_16)(pow( |
(double)png_ptr->background.red / m, gs) * m + .5); |
png_ptr->background.green = (png_uint_16)(pow( |
(double)png_ptr->background.green / m, gs) * m + .5); |
png_ptr->background.blue = (png_uint_16)(pow( |
(double)png_ptr->background.blue / m, gs) * m + .5); |
} |
else |
{ |
/* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */ |
png_ptr->background_1.red = png_ptr->background_1.green |
= png_ptr->background_1.blue = png_ptr->background_1.gray; |
png_ptr->background.red = png_ptr->background.green |
= png_ptr->background.blue = png_ptr->background.gray; |
} |
} |
} |
else |
/* transformation does not include PNG_BACKGROUND */ |
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_colorp palette = png_ptr->palette; |
int num_palette = png_ptr->num_palette; |
int i; |
for (i = 0; i < num_palette; i++) |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
palette[i].green = png_ptr->gamma_table[palette[i].green]; |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
else |
#endif |
#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */ |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* No GAMMA transformation */ |
if ((png_ptr->transformations & PNG_BACKGROUND) && |
(color_type == PNG_COLOR_TYPE_PALETTE)) |
{ |
int i; |
int istop = (int)png_ptr->num_trans; |
png_color back; |
png_colorp palette = png_ptr->palette; |
back.red = (png_byte)png_ptr->background.red; |
back.green = (png_byte)png_ptr->background.green; |
back.blue = (png_byte)png_ptr->background.blue; |
for (i = 0; i < istop; i++) |
{ |
if (png_ptr->trans[i] == 0) |
{ |
palette[i] = back; |
} |
else if (png_ptr->trans[i] != 0xff) |
{ |
/* The png_composite() macro is defined in png.h */ |
png_composite(palette[i].red, palette[i].red, |
png_ptr->trans[i], back.red); |
png_composite(palette[i].green, palette[i].green, |
png_ptr->trans[i], back.green); |
png_composite(palette[i].blue, palette[i].blue, |
png_ptr->trans[i], back.blue); |
} |
} |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ |
#if defined(PNG_READ_SHIFT_SUPPORTED) |
if ((png_ptr->transformations & PNG_SHIFT) && |
(color_type == PNG_COLOR_TYPE_PALETTE)) |
{ |
png_uint_16 i; |
png_uint_16 istop = png_ptr->num_palette; |
int sr = 8 - png_ptr->sig_bit.red; |
int sg = 8 - png_ptr->sig_bit.green; |
int sb = 8 - png_ptr->sig_bit.blue; |
if (sr < 0 || sr > 8) |
sr = 0; |
if (sg < 0 || sg > 8) |
sg = 0; |
if (sb < 0 || sb > 8) |
sb = 0; |
for (i = 0; i < istop; i++) |
{ |
png_ptr->palette[i].red >>= sr; |
png_ptr->palette[i].green >>= sg; |
png_ptr->palette[i].blue >>= sb; |
} |
} |
#endif /* PNG_READ_SHIFT_SUPPORTED */ |
} |
#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \ |
&& !defined(PNG_READ_BACKGROUND_SUPPORTED) |
if(png_ptr) |
return; |
#endif |
} |
/* Modify the info structure to reflect the transformations. The |
* info should be updated so a PNG file could be written with it, |
* assuming the transformations result in valid PNG data. |
*/ |
void /* PRIVATE */ |
png_read_transform_info(png_structp png_ptr, png_infop info_ptr) |
{ |
png_debug(1, "in png_read_transform_info\n"); |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
if (png_ptr->transformations & PNG_EXPAND) |
{ |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (png_ptr->num_trans) |
info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA; |
else |
info_ptr->color_type = PNG_COLOR_TYPE_RGB; |
info_ptr->bit_depth = 8; |
info_ptr->num_trans = 0; |
} |
else |
{ |
if (png_ptr->num_trans) |
info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; |
if (info_ptr->bit_depth < 8) |
info_ptr->bit_depth = 8; |
info_ptr->num_trans = 0; |
} |
} |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->transformations & PNG_BACKGROUND) |
{ |
info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; |
info_ptr->num_trans = 0; |
info_ptr->background = png_ptr->background; |
} |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (png_ptr->transformations & PNG_GAMMA) |
{ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
info_ptr->gamma = png_ptr->gamma; |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
info_ptr->int_gamma = png_ptr->int_gamma; |
#endif |
} |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16)) |
info_ptr->bit_depth = 8; |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
if (png_ptr->transformations & PNG_DITHER) |
{ |
if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || |
(info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) && |
png_ptr->palette_lookup && info_ptr->bit_depth == 8) |
{ |
info_ptr->color_type = PNG_COLOR_TYPE_PALETTE; |
} |
} |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) |
if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8)) |
info_ptr->bit_depth = 8; |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
if (png_ptr->transformations & PNG_GRAY_TO_RGB) |
info_ptr->color_type |= PNG_COLOR_MASK_COLOR; |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & PNG_RGB_TO_GRAY) |
info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR; |
#endif |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
info_ptr->channels = 1; |
else if (info_ptr->color_type & PNG_COLOR_MASK_COLOR) |
info_ptr->channels = 3; |
else |
info_ptr->channels = 1; |
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_STRIP_ALPHA) |
info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; |
#endif |
if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) |
info_ptr->channels++; |
#if defined(PNG_READ_FILLER_SUPPORTED) |
/* STRIP_ALPHA and FILLER allowed: MASK_ALPHA bit stripped above */ |
if ((png_ptr->transformations & PNG_FILLER) && |
((info_ptr->color_type == PNG_COLOR_TYPE_RGB) || |
(info_ptr->color_type == PNG_COLOR_TYPE_GRAY))) |
{ |
info_ptr->channels++; |
#if 0 /* if adding a true alpha channel not just filler */ |
info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; |
#endif |
} |
#endif |
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \ |
defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
if(png_ptr->transformations & PNG_USER_TRANSFORM) |
{ |
if(info_ptr->bit_depth < png_ptr->user_transform_depth) |
info_ptr->bit_depth = png_ptr->user_transform_depth; |
if(info_ptr->channels < png_ptr->user_transform_channels) |
info_ptr->channels = png_ptr->user_transform_channels; |
} |
#endif |
info_ptr->pixel_depth = (png_byte)(info_ptr->channels * |
info_ptr->bit_depth); |
info_ptr->rowbytes = ((info_ptr->width * info_ptr->pixel_depth + 7) >> 3); |
#if !defined(PNG_READ_EXPAND_SUPPORTED) |
if(png_ptr) |
return; |
#endif |
} |
/* Transform the row. The order of transformations is significant, |
* and is very touchy. If you add a transformation, take care to |
* decide how it fits in with the other transformations here. |
*/ |
void /* PRIVATE */ |
png_do_read_transformations(png_structp png_ptr) |
{ |
png_debug(1, "in png_do_read_transformations\n"); |
#if !defined(PNG_USELESS_TESTS_SUPPORTED) |
if (png_ptr->row_buf == NULL) |
{ |
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
char msg[50]; |
sprintf(msg, "NULL row buffer for row %ld, pass %d", png_ptr->row_number, |
png_ptr->pass); |
png_error(png_ptr, msg); |
#else |
png_error(png_ptr, "NULL row buffer"); |
#endif |
} |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
if (png_ptr->transformations & PNG_EXPAND) |
{ |
if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->palette, png_ptr->trans, png_ptr->num_trans); |
} |
else |
{ |
if (png_ptr->num_trans) |
png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, |
&(png_ptr->trans_values)); |
else |
png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, |
NULL); |
} |
} |
#endif |
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_STRIP_ALPHA) |
png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, |
PNG_FLAG_FILLER_AFTER); |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & PNG_RGB_TO_GRAY) |
{ |
int rgb_error = |
png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), png_ptr->row_buf + 1); |
if(rgb_error) |
{ |
png_ptr->rgb_to_gray_status=1; |
if(png_ptr->transformations == PNG_RGB_TO_GRAY_WARN) |
png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel"); |
if(png_ptr->transformations == PNG_RGB_TO_GRAY_ERR) |
png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel"); |
} |
} |
#endif |
/* |
From Andreas Dilger e-mail to png-implement, 26 March 1998: |
In most cases, the "simple transparency" should be done prior to doing |
gray-to-RGB, or you will have to test 3x as many bytes to check if a |
pixel is transparent. You would also need to make sure that the |
transparency information is upgraded to RGB. |
To summarize, the current flow is: |
- Gray + simple transparency -> compare 1 or 2 gray bytes and composite |
with background "in place" if transparent, |
convert to RGB if necessary |
- Gray + alpha -> composite with gray background and remove alpha bytes, |
convert to RGB if necessary |
To support RGB backgrounds for gray images we need: |
- Gray + simple transparency -> convert to RGB + simple transparency, compare |
3 or 6 bytes and composite with background |
"in place" if transparent (3x compare/pixel |
compared to doing composite with gray bkgrnd) |
- Gray + alpha -> convert to RGB + alpha, composite with background and |
remove alpha bytes (3x float operations/pixel |
compared with composite on gray background) |
Greg's change will do this. The reason it wasn't done before is for |
performance, as this increases the per-pixel operations. If we would check |
in advance if the background was gray or RGB, and position the gray-to-RGB |
transform appropriately, then it would save a lot of work/time. |
*/ |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
/* if gray -> RGB, do so now only if background is non-gray; else do later |
* for performance reasons */ |
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && |
!(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) |
png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
if ((png_ptr->transformations & PNG_BACKGROUND) && |
((png_ptr->num_trans != 0 ) || |
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) |
png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1, |
&(png_ptr->trans_values), &(png_ptr->background) |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
, &(png_ptr->background_1), |
png_ptr->gamma_table, png_ptr->gamma_from_1, |
png_ptr->gamma_to_1, png_ptr->gamma_16_table, |
png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1, |
png_ptr->gamma_shift |
#endif |
); |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if ((png_ptr->transformations & PNG_GAMMA) && |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
!((png_ptr->transformations & PNG_BACKGROUND) && |
((png_ptr->num_trans != 0) || |
(png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) && |
#endif |
(png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)) |
png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->gamma_table, png_ptr->gamma_16_table, |
png_ptr->gamma_shift); |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
if (png_ptr->transformations & PNG_16_TO_8) |
png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
if (png_ptr->transformations & PNG_DITHER) |
{ |
png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->palette_lookup, png_ptr->dither_index); |
if(png_ptr->row_info.rowbytes == (png_uint_32)0) |
png_error(png_ptr, "png_do_dither returned rowbytes=0"); |
} |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) |
if (png_ptr->transformations & PNG_SHIFT) |
png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1, |
&(png_ptr->shift)); |
#endif |
#if defined(PNG_READ_PACK_SUPPORTED) |
if (png_ptr->transformations & PNG_PACK) |
png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) |
if (png_ptr->transformations & PNG_BGR) |
png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
/* if gray -> RGB, do so now only if we did not do so above */ |
if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && |
(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) |
png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) |
if (png_ptr->transformations & PNG_FILLER) |
png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, |
(png_uint_32)png_ptr->filler, png_ptr->flags); |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_ALPHA) |
png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_SWAP_SUPPORTED) |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) |
if (png_ptr->transformations & PNG_USER_TRANSFORM) |
{ |
if(png_ptr->read_user_transform_fn != NULL) |
(*(png_ptr->read_user_transform_fn)) /* user read transform function */ |
(png_ptr, /* png_ptr */ |
&(png_ptr->row_info), /* row_info: */ |
/* png_uint_32 width; width of row */ |
/* png_uint_32 rowbytes; number of bytes in row */ |
/* png_byte color_type; color type of pixels */ |
/* png_byte bit_depth; bit depth of samples */ |
/* png_byte channels; number of channels (1-4) */ |
/* png_byte pixel_depth; bits per pixel (depth*channels) */ |
png_ptr->row_buf + 1); /* start of pixel data for row */ |
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) |
if(png_ptr->user_transform_depth) |
png_ptr->row_info.bit_depth = png_ptr->user_transform_depth; |
if(png_ptr->user_transform_channels) |
png_ptr->row_info.channels = png_ptr->user_transform_channels; |
#endif |
png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * |
png_ptr->row_info.channels); |
png_ptr->row_info.rowbytes = (png_ptr->row_info.width * |
png_ptr->row_info.pixel_depth+7)>>3; |
} |
#endif |
} |
#if defined(PNG_READ_PACK_SUPPORTED) |
/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel, |
* without changing the actual values. Thus, if you had a row with |
* a bit depth of 1, you would end up with bytes that only contained |
* the numbers 0 or 1. If you would rather they contain 0 and 255, use |
* png_do_shift() after this. |
*/ |
void /* PRIVATE */ |
png_do_unpack(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_unpack\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL && row_info->bit_depth < 8) |
#else |
if (row_info->bit_depth < 8) |
#endif |
{ |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
switch (row_info->bit_depth) |
{ |
case 1: |
{ |
png_bytep sp = row + (png_size_t)((row_width - 1) >> 3); |
png_bytep dp = row + (png_size_t)row_width - 1; |
png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07); |
for (i = 0; i < row_width; i++) |
{ |
*dp = (png_byte)((*sp >> shift) & 0x01); |
if (shift == 7) |
{ |
shift = 0; |
sp--; |
} |
else |
shift++; |
dp--; |
} |
break; |
} |
case 2: |
{ |
png_bytep sp = row + (png_size_t)((row_width - 1) >> 2); |
png_bytep dp = row + (png_size_t)row_width - 1; |
png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); |
for (i = 0; i < row_width; i++) |
{ |
*dp = (png_byte)((*sp >> shift) & 0x03); |
if (shift == 6) |
{ |
shift = 0; |
sp--; |
} |
else |
shift += 2; |
dp--; |
} |
break; |
} |
case 4: |
{ |
png_bytep sp = row + (png_size_t)((row_width - 1) >> 1); |
png_bytep dp = row + (png_size_t)row_width - 1; |
png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); |
for (i = 0; i < row_width; i++) |
{ |
*dp = (png_byte)((*sp >> shift) & 0x0f); |
if (shift == 4) |
{ |
shift = 0; |
sp--; |
} |
else |
shift = 4; |
dp--; |
} |
break; |
} |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = (png_byte)(8 * row_info->channels); |
row_info->rowbytes = row_width * row_info->channels; |
} |
} |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) |
/* Reverse the effects of png_do_shift. This routine merely shifts the |
* pixels back to their significant bits values. Thus, if you have |
* a row of bit depth 8, but only 5 are significant, this will shift |
* the values back to 0 through 31. |
*/ |
void /* PRIVATE */ |
png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits) |
{ |
png_debug(1, "in png_do_unshift\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && sig_bits != NULL && |
#endif |
row_info->color_type != PNG_COLOR_TYPE_PALETTE) |
{ |
int shift[4]; |
int channels = 0; |
int c; |
png_uint_16 value = 0; |
png_uint_32 row_width = row_info->width; |
if (row_info->color_type & PNG_COLOR_MASK_COLOR) |
{ |
shift[channels++] = row_info->bit_depth - sig_bits->red; |
shift[channels++] = row_info->bit_depth - sig_bits->green; |
shift[channels++] = row_info->bit_depth - sig_bits->blue; |
} |
else |
{ |
shift[channels++] = row_info->bit_depth - sig_bits->gray; |
} |
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) |
{ |
shift[channels++] = row_info->bit_depth - sig_bits->alpha; |
} |
for (c = 0; c < channels; c++) |
{ |
if (shift[c] <= 0) |
shift[c] = 0; |
else |
value = 1; |
} |
if (!value) |
return; |
switch (row_info->bit_depth) |
{ |
case 2: |
{ |
png_bytep bp; |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
for (bp = row, i = 0; i < istop; i++) |
{ |
*bp >>= 1; |
*bp++ &= 0x55; |
} |
break; |
} |
case 4: |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->rowbytes; |
png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) | |
(png_byte)((int)0xf >> shift[0])); |
for (i = 0; i < istop; i++) |
{ |
*bp >>= shift[0]; |
*bp++ &= mask; |
} |
break; |
} |
case 8: |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_uint_32 istop = row_width * channels; |
for (i = 0; i < istop; i++) |
{ |
*bp++ >>= shift[i%channels]; |
} |
break; |
} |
case 16: |
{ |
png_bytep bp = row; |
png_uint_32 i; |
png_uint_32 istop = channels * row_width; |
for (i = 0; i < istop; i++) |
{ |
value = (png_uint_16)((*bp << 8) + *(bp + 1)); |
value >>= shift[i%channels]; |
*bp++ = (png_byte)(value >> 8); |
*bp++ = (png_byte)(value & 0xff); |
} |
break; |
} |
} |
} |
} |
#endif |
#if defined(PNG_READ_16_TO_8_SUPPORTED) |
/* chop rows of bit depth 16 down to 8 */ |
void /* PRIVATE */ |
png_do_chop(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_chop\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL && row_info->bit_depth == 16) |
#else |
if (row_info->bit_depth == 16) |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
png_uint_32 i; |
png_uint_32 istop = row_info->width * row_info->channels; |
for (i = 0; i<istop; i++, sp += 2, dp++) |
{ |
#if defined(PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED) |
/* This does a more accurate scaling of the 16-bit color |
* value, rather than a simple low-byte truncation. |
* |
* What the ideal calculation should be: |
* *dp = (((((png_uint_32)(*sp) << 8) | |
* (png_uint_32)(*(sp + 1))) * 255 + 127) / (png_uint_32)65535L; |
* |
* GRR: no, I think this is what it really should be: |
* *dp = (((((png_uint_32)(*sp) << 8) | |
* (png_uint_32)(*(sp + 1))) + 128L) / (png_uint_32)257L; |
* |
* GRR: here's the exact calculation with shifts: |
* temp = (((png_uint_32)(*sp) << 8) | (png_uint_32)(*(sp + 1))) + 128L; |
* *dp = (temp - (temp >> 8)) >> 8; |
* |
* Approximate calculation with shift/add instead of multiply/divide: |
* *dp = ((((png_uint_32)(*sp) << 8) | |
* (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8; |
* |
* What we actually do to avoid extra shifting and conversion: |
*/ |
*dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0); |
#else |
/* Simply discard the low order byte */ |
*dp = *sp; |
#endif |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = (png_byte)(8 * row_info->channels); |
row_info->rowbytes = row_info->width * row_info->channels; |
} |
} |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) |
void /* PRIVATE */ |
png_do_read_swap_alpha(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_read_swap_alpha\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
png_uint_32 row_width = row_info->width; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
/* This converts from RGBA to ARGB */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_byte save; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
save = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = save; |
} |
} |
/* This converts from RRGGBBAA to AARRGGBB */ |
else |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_byte save[2]; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
save[0] = *(--sp); |
save[1] = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = save[0]; |
*(--dp) = save[1]; |
} |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
/* This converts from GA to AG */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_byte save; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
save = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = save; |
} |
} |
/* This converts from GGAA to AAGG */ |
else |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_byte save[2]; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
save[0] = *(--sp); |
save[1] = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = save[0]; |
*(--dp) = save[1]; |
} |
} |
} |
} |
} |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) |
void /* PRIVATE */ |
png_do_read_invert_alpha(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_read_invert_alpha\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
png_uint_32 row_width = row_info->width; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
/* This inverts the alpha channel in RGBA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = (png_byte)(255 - *(--sp)); |
/* This does nothing: |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
We can replace it with: |
*/ |
sp-=3; |
dp=sp; |
} |
} |
/* This inverts the alpha channel in RRGGBBAA */ |
else |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = (png_byte)(255 - *(--sp)); |
*(--dp) = (png_byte)(255 - *(--sp)); |
/* This does nothing: |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
We can replace it with: |
*/ |
sp-=6; |
dp=sp; |
} |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
/* This inverts the alpha channel in GA */ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = (png_byte)(255 - *(--sp)); |
*(--dp) = *(--sp); |
} |
} |
/* This inverts the alpha channel in GGAA */ |
else |
{ |
png_bytep sp = row + row_info->rowbytes; |
png_bytep dp = sp; |
png_uint_32 i; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = (png_byte)(255 - *(--sp)); |
*(--dp) = (png_byte)(255 - *(--sp)); |
/* |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*/ |
sp-=2; |
dp=sp; |
} |
} |
} |
} |
} |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) |
/* Add filler channel if we have RGB color */ |
void /* PRIVATE */ |
png_do_read_filler(png_row_infop row_info, png_bytep row, |
png_uint_32 filler, png_uint_32 flags) |
{ |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
png_byte hi_filler = (png_byte)((filler>>8) & 0xff); |
png_byte lo_filler = (png_byte)(filler & 0xff); |
png_debug(1, "in png_do_read_filler\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if(row_info->bit_depth == 8) |
{ |
/* This changes the data from G to GX */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
png_bytep sp = row + (png_size_t)row_width; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 1; i < row_width; i++) |
{ |
*(--dp) = lo_filler; |
*(--dp) = *(--sp); |
} |
*(--dp) = lo_filler; |
row_info->channels = 2; |
row_info->pixel_depth = 16; |
row_info->rowbytes = row_width * 2; |
} |
/* This changes the data from G to XG */ |
else |
{ |
png_bytep sp = row + (png_size_t)row_width; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = *(--sp); |
*(--dp) = lo_filler; |
} |
row_info->channels = 2; |
row_info->pixel_depth = 16; |
row_info->rowbytes = row_width * 2; |
} |
} |
else if(row_info->bit_depth == 16) |
{ |
/* This changes the data from GG to GGXX */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
png_bytep sp = row + (png_size_t)row_width; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 1; i < row_width; i++) |
{ |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
} |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
row_info->channels = 2; |
row_info->pixel_depth = 32; |
row_info->rowbytes = row_width * 4; |
} |
/* This changes the data from GG to XXGG */ |
else |
{ |
png_bytep sp = row + (png_size_t)row_width; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
} |
row_info->channels = 2; |
row_info->pixel_depth = 32; |
row_info->rowbytes = row_width * 4; |
} |
} |
} /* COLOR_TYPE == GRAY */ |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
{ |
if(row_info->bit_depth == 8) |
{ |
/* This changes the data from RGB to RGBX */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
png_bytep sp = row + (png_size_t)row_width * 3; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 1; i < row_width; i++) |
{ |
*(--dp) = lo_filler; |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
} |
*(--dp) = lo_filler; |
row_info->channels = 4; |
row_info->pixel_depth = 32; |
row_info->rowbytes = row_width * 4; |
} |
/* This changes the data from RGB to XRGB */ |
else |
{ |
png_bytep sp = row + (png_size_t)row_width * 3; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = lo_filler; |
} |
row_info->channels = 4; |
row_info->pixel_depth = 32; |
row_info->rowbytes = row_width * 4; |
} |
} |
else if(row_info->bit_depth == 16) |
{ |
/* This changes the data from RRGGBB to RRGGBBXX */ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
png_bytep sp = row + (png_size_t)row_width * 3; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 1; i < row_width; i++) |
{ |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
} |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
row_info->channels = 4; |
row_info->pixel_depth = 64; |
row_info->rowbytes = row_width * 8; |
} |
/* This changes the data from RRGGBB to XXRRGGBB */ |
else |
{ |
png_bytep sp = row + (png_size_t)row_width * 3; |
png_bytep dp = sp + (png_size_t)row_width; |
for (i = 0; i < row_width; i++) |
{ |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = *(--sp); |
*(--dp) = hi_filler; |
*(--dp) = lo_filler; |
} |
row_info->channels = 4; |
row_info->pixel_depth = 64; |
row_info->rowbytes = row_width * 8; |
} |
} |
} /* COLOR_TYPE == RGB */ |
} |
#endif |
#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) |
/* expand grayscale files to RGB, with or without alpha */ |
void /* PRIVATE */ |
png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) |
{ |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
png_debug(1, "in png_do_gray_to_rgb\n"); |
if (row_info->bit_depth >= 8 && |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
!(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + (png_size_t)row_width - 1; |
png_bytep dp = sp + (png_size_t)row_width * 2; |
for (i = 0; i < row_width; i++) |
{ |
*(dp--) = *sp; |
*(dp--) = *sp; |
*(dp--) = *(sp--); |
} |
} |
else |
{ |
png_bytep sp = row + (png_size_t)row_width * 2 - 1; |
png_bytep dp = sp + (png_size_t)row_width * 4; |
for (i = 0; i < row_width; i++) |
{ |
*(dp--) = *sp; |
*(dp--) = *(sp - 1); |
*(dp--) = *sp; |
*(dp--) = *(sp - 1); |
*(dp--) = *(sp--); |
*(dp--) = *(sp--); |
} |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
png_bytep sp = row + (png_size_t)row_width * 2 - 1; |
png_bytep dp = sp + (png_size_t)row_width * 2; |
for (i = 0; i < row_width; i++) |
{ |
*(dp--) = *(sp--); |
*(dp--) = *sp; |
*(dp--) = *sp; |
*(dp--) = *(sp--); |
} |
} |
else |
{ |
png_bytep sp = row + (png_size_t)row_width * 4 - 1; |
png_bytep dp = sp + (png_size_t)row_width * 4; |
for (i = 0; i < row_width; i++) |
{ |
*(dp--) = *(sp--); |
*(dp--) = *(sp--); |
*(dp--) = *sp; |
*(dp--) = *(sp - 1); |
*(dp--) = *sp; |
*(dp--) = *(sp - 1); |
*(dp--) = *(sp--); |
*(dp--) = *(sp--); |
} |
} |
} |
row_info->channels += (png_byte)2; |
row_info->color_type |= PNG_COLOR_MASK_COLOR; |
row_info->pixel_depth = (png_byte)(row_info->channels * |
row_info->bit_depth); |
row_info->rowbytes = ((row_width * |
row_info->pixel_depth + 7) >> 3); |
} |
} |
#endif |
#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
/* reduce RGB files to grayscale, with or without alpha |
* using the equation given in Poynton's ColorFAQ at |
* <http://www.inforamp.net/~poynton/> |
* Copyright (c) 1998-01-04 Charles Poynton poynton@inforamp.net |
* |
* Y = 0.212671 * R + 0.715160 * G + 0.072169 * B |
* |
* We approximate this with |
* |
* Y = 0.21268 * R + 0.7151 * G + 0.07217 * B |
* |
* which can be expressed with integers as |
* |
* Y = (6969 * R + 23434 * G + 2365 * B)/32768 |
* |
* The calculation is to be done in a linear colorspace. |
* |
* Other integer coefficents can be used via png_set_rgb_to_gray(). |
*/ |
int /* PRIVATE */ |
png_do_rgb_to_gray(png_structp png_ptr, png_row_infop row_info, png_bytep row) |
{ |
png_uint_32 i; |
png_uint_32 row_width = row_info->width; |
int rgb_error = 0; |
png_debug(1, "in png_do_rgb_to_gray\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
png_uint_32 rc = png_ptr->rgb_to_gray_red_coeff; |
png_uint_32 gc = png_ptr->rgb_to_gray_green_coeff; |
png_uint_32 bc = png_ptr->rgb_to_gray_blue_coeff; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = png_ptr->gamma_to_1[*(sp++)]; |
png_byte green = png_ptr->gamma_to_1[*(sp++)]; |
png_byte blue = png_ptr->gamma_to_1[*(sp++)]; |
if(red != green || red != blue) |
{ |
rgb_error |= 1; |
*(dp++) = png_ptr->gamma_from_1[ |
(rc*red+gc*green+bc*blue)>>15]; |
} |
else |
*(dp++) = *(sp-1); |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = *(sp++); |
png_byte green = *(sp++); |
png_byte blue = *(sp++); |
if(red != green || red != blue) |
{ |
rgb_error |= 1; |
*(dp++) = (png_byte)((rc*red+gc*green+bc*blue)>>15); |
} |
else |
*(dp++) = *(sp-1); |
} |
} |
} |
else /* RGB bit_depth == 16 */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_16_to_1 != NULL && |
png_ptr->gamma_16_from_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, w; |
red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
if(red == green && red == blue) |
w = red; |
else |
{ |
png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >> |
png_ptr->gamma_shift][red>>8]; |
png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >> |
png_ptr->gamma_shift][green>>8]; |
png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >> |
png_ptr->gamma_shift][blue>>8]; |
png_uint_16 gray16 = (png_uint_16)((rc*red_1 + gc*green_1 |
+ bc*blue_1)>>15); |
w = png_ptr->gamma_16_from_1[(gray16&0xff) >> |
png_ptr->gamma_shift][gray16 >> 8]; |
rgb_error |= 1; |
} |
*(dp++) = (png_byte)((w>>8) & 0xff); |
*(dp++) = (png_byte)(w & 0xff); |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, gray16; |
red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
if(red != green || red != blue) |
rgb_error |= 1; |
gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15); |
*(dp++) = (png_byte)((gray16>>8) & 0xff); |
*(dp++) = (png_byte)(gray16 & 0xff); |
} |
} |
} |
} |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_from_1 != NULL && png_ptr->gamma_to_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = png_ptr->gamma_to_1[*(sp++)]; |
png_byte green = png_ptr->gamma_to_1[*(sp++)]; |
png_byte blue = png_ptr->gamma_to_1[*(sp++)]; |
if(red != green || red != blue) |
rgb_error |= 1; |
*(dp++) = png_ptr->gamma_from_1 |
[(rc*red + gc*green + bc*blue)>>15]; |
*(dp++) = *(sp++); /* alpha */ |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_byte red = *(sp++); |
png_byte green = *(sp++); |
png_byte blue = *(sp++); |
if(red != green || red != blue) |
rgb_error |= 1; |
*(dp++) = (png_byte)((gc*red + gc*green + bc*blue)>>8); |
*(dp++) = *(sp++); /* alpha */ |
} |
} |
} |
else /* RGBA bit_depth == 16 */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->gamma_16_to_1 != NULL && |
png_ptr->gamma_16_from_1 != NULL) |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, w; |
red = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
green = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
blue = (png_uint_16)(((*(sp))<<8) | *(sp+1)); sp+=2; |
if(red == green && red == blue) |
w = red; |
else |
{ |
png_uint_16 red_1 = png_ptr->gamma_16_to_1[(red&0xff) >> |
png_ptr->gamma_shift][red>>8]; |
png_uint_16 green_1 = png_ptr->gamma_16_to_1[(green&0xff) >> |
png_ptr->gamma_shift][green>>8]; |
png_uint_16 blue_1 = png_ptr->gamma_16_to_1[(blue&0xff) >> |
png_ptr->gamma_shift][blue>>8]; |
png_uint_16 gray16 = (png_uint_16)((rc * red_1 |
+ gc * green_1 + bc * blue_1)>>15); |
w = png_ptr->gamma_16_from_1[(gray16&0xff) >> |
png_ptr->gamma_shift][gray16 >> 8]; |
rgb_error |= 1; |
} |
*(dp++) = (png_byte)((w>>8) & 0xff); |
*(dp++) = (png_byte)(w & 0xff); |
*(dp++) = *(sp++); /* alpha */ |
*(dp++) = *(sp++); |
} |
} |
else |
#endif |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 red, green, blue, gray16; |
red = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; |
green = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; |
blue = (png_uint_16)((*(sp)<<8) | *(sp+1)); sp+=2; |
if(red != green || red != blue) |
rgb_error |= 1; |
gray16 = (png_uint_16)((rc*red + gc*green + bc*blue)>>15); |
*(dp++) = (png_byte)((gray16>>8) & 0xff); |
*(dp++) = (png_byte)(gray16 & 0xff); |
*(dp++) = *(sp++); /* alpha */ |
*(dp++) = *(sp++); |
} |
} |
} |
} |
row_info->channels -= (png_byte)2; |
row_info->color_type &= ~PNG_COLOR_MASK_COLOR; |
row_info->pixel_depth = (png_byte)(row_info->channels * |
row_info->bit_depth); |
row_info->rowbytes = ((row_width * |
row_info->pixel_depth + 7) >> 3); |
} |
return rgb_error; |
} |
#endif |
/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth |
* large of png_color. This lets grayscale images be treated as |
* paletted. Most useful for gamma correction and simplification |
* of code. |
*/ |
void PNGAPI |
png_build_grayscale_palette(int bit_depth, png_colorp palette) |
{ |
int num_palette; |
int color_inc; |
int i; |
int v; |
png_debug(1, "in png_do_build_grayscale_palette\n"); |
if (palette == NULL) |
return; |
switch (bit_depth) |
{ |
case 1: |
num_palette = 2; |
color_inc = 0xff; |
break; |
case 2: |
num_palette = 4; |
color_inc = 0x55; |
break; |
case 4: |
num_palette = 16; |
color_inc = 0x11; |
break; |
case 8: |
num_palette = 256; |
color_inc = 1; |
break; |
default: |
num_palette = 0; |
color_inc = 0; |
break; |
} |
for (i = 0, v = 0; i < num_palette; i++, v += color_inc) |
{ |
palette[i].red = (png_byte)v; |
palette[i].green = (png_byte)v; |
palette[i].blue = (png_byte)v; |
} |
} |
/* This function is currently unused. Do we really need it? */ |
#if defined(PNG_READ_DITHER_SUPPORTED) && defined(PNG_CORRECT_PALETTE_SUPPORTED) |
void /* PRIVATE */ |
png_correct_palette(png_structp png_ptr, png_colorp palette, |
int num_palette) |
{ |
png_debug(1, "in png_correct_palette\n"); |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ |
defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) |
if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND)) |
{ |
png_color back, back_1; |
if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) |
{ |
back.red = png_ptr->gamma_table[png_ptr->background.red]; |
back.green = png_ptr->gamma_table[png_ptr->background.green]; |
back.blue = png_ptr->gamma_table[png_ptr->background.blue]; |
back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; |
back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; |
back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; |
} |
else |
{ |
double g; |
g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma); |
if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN || |
fabs(g - 1.0) < PNG_GAMMA_THRESHOLD) |
{ |
back.red = png_ptr->background.red; |
back.green = png_ptr->background.green; |
back.blue = png_ptr->background.blue; |
} |
else |
{ |
back.red = |
(png_byte)(pow((double)png_ptr->background.red/255, g) * |
255.0 + 0.5); |
back.green = |
(png_byte)(pow((double)png_ptr->background.green/255, g) * |
255.0 + 0.5); |
back.blue = |
(png_byte)(pow((double)png_ptr->background.blue/255, g) * |
255.0 + 0.5); |
} |
g = 1.0 / png_ptr->background_gamma; |
back_1.red = |
(png_byte)(pow((double)png_ptr->background.red/255, g) * |
255.0 + 0.5); |
back_1.green = |
(png_byte)(pow((double)png_ptr->background.green/255, g) * |
255.0 + 0.5); |
back_1.blue = |
(png_byte)(pow((double)png_ptr->background.blue/255, g) * |
255.0 + 0.5); |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_uint_32 i; |
for (i = 0; i < (png_uint_32)num_palette; i++) |
{ |
if (i < png_ptr->num_trans && png_ptr->trans[i] == 0) |
{ |
palette[i] = back; |
} |
else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff) |
{ |
png_byte v, w; |
v = png_ptr->gamma_to_1[png_ptr->palette[i].red]; |
png_composite(w, v, png_ptr->trans[i], back_1.red); |
palette[i].red = png_ptr->gamma_from_1[w]; |
v = png_ptr->gamma_to_1[png_ptr->palette[i].green]; |
png_composite(w, v, png_ptr->trans[i], back_1.green); |
palette[i].green = png_ptr->gamma_from_1[w]; |
v = png_ptr->gamma_to_1[png_ptr->palette[i].blue]; |
png_composite(w, v, png_ptr->trans[i], back_1.blue); |
palette[i].blue = png_ptr->gamma_from_1[w]; |
} |
else |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
palette[i].green = png_ptr->gamma_table[palette[i].green]; |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
} |
else |
{ |
int i; |
for (i = 0; i < num_palette; i++) |
{ |
if (palette[i].red == (png_byte)png_ptr->trans_values.gray) |
{ |
palette[i] = back; |
} |
else |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
palette[i].green = png_ptr->gamma_table[palette[i].green]; |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
} |
} |
else |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (png_ptr->transformations & PNG_GAMMA) |
{ |
int i; |
for (i = 0; i < num_palette; i++) |
{ |
palette[i].red = png_ptr->gamma_table[palette[i].red]; |
palette[i].green = png_ptr->gamma_table[palette[i].green]; |
palette[i].blue = png_ptr->gamma_table[palette[i].blue]; |
} |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
else |
#endif |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->transformations & PNG_BACKGROUND) |
{ |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
png_color back; |
back.red = (png_byte)png_ptr->background.red; |
back.green = (png_byte)png_ptr->background.green; |
back.blue = (png_byte)png_ptr->background.blue; |
for (i = 0; i < (int)png_ptr->num_trans; i++) |
{ |
if (png_ptr->trans[i] == 0) |
{ |
palette[i].red = back.red; |
palette[i].green = back.green; |
palette[i].blue = back.blue; |
} |
else if (png_ptr->trans[i] != 0xff) |
{ |
png_composite(palette[i].red, png_ptr->palette[i].red, |
png_ptr->trans[i], back.red); |
png_composite(palette[i].green, png_ptr->palette[i].green, |
png_ptr->trans[i], back.green); |
png_composite(palette[i].blue, png_ptr->palette[i].blue, |
png_ptr->trans[i], back.blue); |
} |
} |
} |
else /* assume grayscale palette (what else could it be?) */ |
{ |
int i; |
for (i = 0; i < num_palette; i++) |
{ |
if (i == (png_byte)png_ptr->trans_values.gray) |
{ |
palette[i].red = (png_byte)png_ptr->background.red; |
palette[i].green = (png_byte)png_ptr->background.green; |
palette[i].blue = (png_byte)png_ptr->background.blue; |
} |
} |
} |
} |
#endif |
} |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) |
/* Replace any alpha or transparency with the supplied background color. |
* "background" is already in the screen gamma, while "background_1" is |
* at a gamma of 1.0. Paletted files have already been taken care of. |
*/ |
void /* PRIVATE */ |
png_do_background(png_row_infop row_info, png_bytep row, |
png_color_16p trans_values, png_color_16p background |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
, png_color_16p background_1, |
png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, |
png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, |
png_uint_16pp gamma_16_to_1, int gamma_shift |
#endif |
) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
int shift; |
png_debug(1, "in png_do_background\n"); |
if (background != NULL && |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
(!(row_info->color_type & PNG_COLOR_MASK_ALPHA) || |
(row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values))) |
{ |
switch (row_info->color_type) |
{ |
case PNG_COLOR_TYPE_GRAY: |
{ |
switch (row_info->bit_depth) |
{ |
case 1: |
{ |
sp = row; |
shift = 7; |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x01) |
== trans_values->gray) |
{ |
*sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
if (!shift) |
{ |
shift = 7; |
sp++; |
} |
else |
shift--; |
} |
break; |
} |
case 2: |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_table != NULL) |
{ |
sp = row; |
shift = 6; |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x03) |
== trans_values->gray) |
{ |
*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
else |
{ |
png_byte p = (png_byte)((*sp >> shift) & 0x03); |
png_byte g = (png_byte)((gamma_table [p | (p << 2) | |
(p << 4) | (p << 6)] >> 6) & 0x03); |
*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*sp |= (png_byte)(g << shift); |
} |
if (!shift) |
{ |
shift = 6; |
sp++; |
} |
else |
shift -= 2; |
} |
} |
else |
#endif |
{ |
sp = row; |
shift = 6; |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x03) |
== trans_values->gray) |
{ |
*sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
if (!shift) |
{ |
shift = 6; |
sp++; |
} |
else |
shift -= 2; |
} |
} |
break; |
} |
case 4: |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_table != NULL) |
{ |
sp = row; |
shift = 4; |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x0f) |
== trans_values->gray) |
{ |
*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
else |
{ |
png_byte p = (png_byte)((*sp >> shift) & 0x0f); |
png_byte g = (png_byte)((gamma_table[p | |
(p << 4)] >> 4) & 0x0f); |
*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*sp |= (png_byte)(g << shift); |
} |
if (!shift) |
{ |
shift = 4; |
sp++; |
} |
else |
shift -= 4; |
} |
} |
else |
#endif |
{ |
sp = row; |
shift = 4; |
for (i = 0; i < row_width; i++) |
{ |
if ((png_uint_16)((*sp >> shift) & 0x0f) |
== trans_values->gray) |
{ |
*sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
if (!shift) |
{ |
shift = 4; |
sp++; |
} |
else |
shift -= 4; |
} |
} |
break; |
} |
case 8: |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_table != NULL) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp++) |
{ |
if (*sp == trans_values->gray) |
{ |
*sp = (png_byte)background->gray; |
} |
else |
{ |
*sp = gamma_table[*sp]; |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp++) |
{ |
if (*sp == trans_values->gray) |
{ |
*sp = (png_byte)background->gray; |
} |
} |
} |
break; |
} |
case 16: |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_16 != NULL) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 2) |
{ |
png_uint_16 v; |
v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
if (v == trans_values->gray) |
{ |
/* background is already in screen gamma */ |
*sp = (png_byte)((background->gray >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->gray & 0xff); |
} |
else |
{ |
v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 2) |
{ |
png_uint_16 v; |
v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
if (v == trans_values->gray) |
{ |
*sp = (png_byte)((background->gray >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->gray & 0xff); |
} |
} |
} |
break; |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_RGB: |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_table != NULL) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 3) |
{ |
if (*sp == trans_values->red && |
*(sp + 1) == trans_values->green && |
*(sp + 2) == trans_values->blue) |
{ |
*sp = (png_byte)background->red; |
*(sp + 1) = (png_byte)background->green; |
*(sp + 2) = (png_byte)background->blue; |
} |
else |
{ |
*sp = gamma_table[*sp]; |
*(sp + 1) = gamma_table[*(sp + 1)]; |
*(sp + 2) = gamma_table[*(sp + 2)]; |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 3) |
{ |
if (*sp == trans_values->red && |
*(sp + 1) == trans_values->green && |
*(sp + 2) == trans_values->blue) |
{ |
*sp = (png_byte)background->red; |
*(sp + 1) = (png_byte)background->green; |
*(sp + 2) = (png_byte)background->blue; |
} |
} |
} |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_16 != NULL) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 6) |
{ |
png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); |
png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5)); |
if (r == trans_values->red && g == trans_values->green && |
b == trans_values->blue) |
{ |
/* background is already in screen gamma */ |
*sp = (png_byte)((background->red >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->red & 0xff); |
*(sp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(sp + 3) = (png_byte)(background->green & 0xff); |
*(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(sp + 5) = (png_byte)(background->blue & 0xff); |
} |
else |
{ |
png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; |
*(sp + 2) = (png_byte)((v >> 8) & 0xff); |
*(sp + 3) = (png_byte)(v & 0xff); |
v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; |
*(sp + 4) = (png_byte)((v >> 8) & 0xff); |
*(sp + 5) = (png_byte)(v & 0xff); |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 6) |
{ |
png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1)); |
png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); |
png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5)); |
if (r == trans_values->red && g == trans_values->green && |
b == trans_values->blue) |
{ |
*sp = (png_byte)((background->red >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->red & 0xff); |
*(sp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(sp + 3) = (png_byte)(background->green & 0xff); |
*(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(sp + 5) = (png_byte)(background->blue & 0xff); |
} |
} |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_GRAY_ALPHA: |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_to_1 != NULL && gamma_from_1 != NULL && |
gamma_table != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 2, dp++) |
{ |
png_uint_16 a = *(sp + 1); |
if (a == 0xff) |
{ |
*dp = gamma_table[*sp]; |
} |
else if (a == 0) |
{ |
/* background is already in screen gamma */ |
*dp = (png_byte)background->gray; |
} |
else |
{ |
png_byte v, w; |
v = gamma_to_1[*sp]; |
png_composite(w, v, a, background_1->gray); |
*dp = gamma_from_1[w]; |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 2, dp++) |
{ |
png_byte a = *(sp + 1); |
if (a == 0xff) |
{ |
*dp = *sp; |
} |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
else if (a == 0) |
{ |
*dp = (png_byte)background->gray; |
} |
else |
{ |
png_composite(*dp, *sp, a, background_1->gray); |
} |
#else |
*dp = (png_byte)background->gray; |
#endif |
} |
} |
} |
else /* if (png_ptr->bit_depth == 16) */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_16 != NULL && gamma_16_from_1 != NULL && |
gamma_16_to_1 != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 2) |
{ |
png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); |
if (a == (png_uint_16)0xffff) |
{ |
png_uint_16 v; |
v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
} |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
else if (a == 0) |
#else |
else |
#endif |
{ |
/* background is already in screen gamma */ |
*dp = (png_byte)((background->gray >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->gray & 0xff); |
} |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
else |
{ |
png_uint_16 g, v, w; |
g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; |
png_composite_16(v, g, a, background_1->gray); |
w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8]; |
*dp = (png_byte)((w >> 8) & 0xff); |
*(dp + 1) = (png_byte)(w & 0xff); |
} |
#endif |
} |
} |
else |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 2) |
{ |
png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); |
if (a == (png_uint_16)0xffff) |
{ |
png_memcpy(dp, sp, 2); |
} |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
else if (a == 0) |
#else |
else |
#endif |
{ |
*dp = (png_byte)((background->gray >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->gray & 0xff); |
} |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
else |
{ |
png_uint_16 g, v; |
g = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
png_composite_16(v, g, a, background_1->gray); |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
} |
#endif |
} |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_RGB_ALPHA: |
{ |
if (row_info->bit_depth == 8) |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_to_1 != NULL && gamma_from_1 != NULL && |
gamma_table != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 3) |
{ |
png_byte a = *(sp + 3); |
if (a == 0xff) |
{ |
*dp = gamma_table[*sp]; |
*(dp + 1) = gamma_table[*(sp + 1)]; |
*(dp + 2) = gamma_table[*(sp + 2)]; |
} |
else if (a == 0) |
{ |
/* background is already in screen gamma */ |
*dp = (png_byte)background->red; |
*(dp + 1) = (png_byte)background->green; |
*(dp + 2) = (png_byte)background->blue; |
} |
else |
{ |
png_byte v, w; |
v = gamma_to_1[*sp]; |
png_composite(w, v, a, background_1->red); |
*dp = gamma_from_1[w]; |
v = gamma_to_1[*(sp + 1)]; |
png_composite(w, v, a, background_1->green); |
*(dp + 1) = gamma_from_1[w]; |
v = gamma_to_1[*(sp + 2)]; |
png_composite(w, v, a, background_1->blue); |
*(dp + 2) = gamma_from_1[w]; |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 4, dp += 3) |
{ |
png_byte a = *(sp + 3); |
if (a == 0xff) |
{ |
*dp = *sp; |
*(dp + 1) = *(sp + 1); |
*(dp + 2) = *(sp + 2); |
} |
else if (a == 0) |
{ |
*dp = (png_byte)background->red; |
*(dp + 1) = (png_byte)background->green; |
*(dp + 2) = (png_byte)background->blue; |
} |
else |
{ |
png_composite(*dp, *sp, a, background->red); |
png_composite(*(dp + 1), *(sp + 1), a, |
background->green); |
png_composite(*(dp + 2), *(sp + 2), a, |
background->blue); |
} |
} |
} |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
if (gamma_16 != NULL && gamma_16_from_1 != NULL && |
gamma_16_to_1 != NULL) |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 8, dp += 6) |
{ |
png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) |
<< 8) + (png_uint_16)(*(sp + 7))); |
if (a == (png_uint_16)0xffff) |
{ |
png_uint_16 v; |
v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; |
*(dp + 2) = (png_byte)((v >> 8) & 0xff); |
*(dp + 3) = (png_byte)(v & 0xff); |
v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; |
*(dp + 4) = (png_byte)((v >> 8) & 0xff); |
*(dp + 5) = (png_byte)(v & 0xff); |
} |
else if (a == 0) |
{ |
/* background is already in screen gamma */ |
*dp = (png_byte)((background->red >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->red & 0xff); |
*(dp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(dp + 3) = (png_byte)(background->green & 0xff); |
*(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(dp + 5) = (png_byte)(background->blue & 0xff); |
} |
else |
{ |
png_uint_16 v, w, x; |
v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; |
png_composite_16(w, v, a, background_1->red); |
x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; |
*dp = (png_byte)((x >> 8) & 0xff); |
*(dp + 1) = (png_byte)(x & 0xff); |
v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)]; |
png_composite_16(w, v, a, background_1->green); |
x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; |
*(dp + 2) = (png_byte)((x >> 8) & 0xff); |
*(dp + 3) = (png_byte)(x & 0xff); |
v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)]; |
png_composite_16(w, v, a, background_1->blue); |
x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8]; |
*(dp + 4) = (png_byte)((x >> 8) & 0xff); |
*(dp + 5) = (png_byte)(x & 0xff); |
} |
} |
} |
else |
#endif |
{ |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++, sp += 8, dp += 6) |
{ |
png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) |
<< 8) + (png_uint_16)(*(sp + 7))); |
if (a == (png_uint_16)0xffff) |
{ |
png_memcpy(dp, sp, 6); |
} |
else if (a == 0) |
{ |
*dp = (png_byte)((background->red >> 8) & 0xff); |
*(dp + 1) = (png_byte)(background->red & 0xff); |
*(dp + 2) = (png_byte)((background->green >> 8) & 0xff); |
*(dp + 3) = (png_byte)(background->green & 0xff); |
*(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); |
*(dp + 5) = (png_byte)(background->blue & 0xff); |
} |
else |
{ |
png_uint_16 v; |
png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); |
png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) |
+ *(sp + 3)); |
png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) |
+ *(sp + 5)); |
png_composite_16(v, r, a, background->red); |
*dp = (png_byte)((v >> 8) & 0xff); |
*(dp + 1) = (png_byte)(v & 0xff); |
png_composite_16(v, g, a, background->green); |
*(dp + 2) = (png_byte)((v >> 8) & 0xff); |
*(dp + 3) = (png_byte)(v & 0xff); |
png_composite_16(v, b, a, background->blue); |
*(dp + 4) = (png_byte)((v >> 8) & 0xff); |
*(dp + 5) = (png_byte)(v & 0xff); |
} |
} |
} |
} |
break; |
} |
} |
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) |
{ |
row_info->color_type &= ~PNG_COLOR_MASK_ALPHA; |
row_info->channels--; |
row_info->pixel_depth = (png_byte)(row_info->channels * |
row_info->bit_depth); |
row_info->rowbytes = ((row_width * |
row_info->pixel_depth + 7) >> 3); |
} |
} |
} |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
/* Gamma correct the image, avoiding the alpha channel. Make sure |
* you do this after you deal with the transparency issue on grayscale |
* or RGB images. If your bit depth is 8, use gamma_table, if it |
* is 16, use gamma_16_table and gamma_shift. Build these with |
* build_gamma_table(). |
*/ |
void /* PRIVATE */ |
png_do_gamma(png_row_infop row_info, png_bytep row, |
png_bytep gamma_table, png_uint_16pp gamma_16_table, |
int gamma_shift) |
{ |
png_bytep sp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
png_debug(1, "in png_do_gamma\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
((row_info->bit_depth <= 8 && gamma_table != NULL) || |
(row_info->bit_depth == 16 && gamma_16_table != NULL))) |
{ |
switch (row_info->color_type) |
{ |
case PNG_COLOR_TYPE_RGB: |
{ |
if (row_info->bit_depth == 8) |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
*sp = gamma_table[*sp]; |
sp++; |
*sp = gamma_table[*sp]; |
sp++; |
*sp = gamma_table[*sp]; |
sp++; |
} |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 v; |
v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_RGB_ALPHA: |
{ |
if (row_info->bit_depth == 8) |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
*sp = gamma_table[*sp]; |
sp++; |
*sp = gamma_table[*sp]; |
sp++; |
*sp = gamma_table[*sp]; |
sp++; |
sp++; |
} |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 4; |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_GRAY_ALPHA: |
{ |
if (row_info->bit_depth == 8) |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
*sp = gamma_table[*sp]; |
sp += 2; |
} |
} |
else /* if (row_info->bit_depth == 16) */ |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 4; |
} |
} |
break; |
} |
case PNG_COLOR_TYPE_GRAY: |
{ |
if (row_info->bit_depth == 2) |
{ |
sp = row; |
for (i = 0; i < row_width; i += 4) |
{ |
int a = *sp & 0xc0; |
int b = *sp & 0x30; |
int c = *sp & 0x0c; |
int d = *sp & 0x03; |
*sp = (png_byte)( |
((((int)gamma_table[a|(a>>2)|(a>>4)|(a>>6)]) ) & 0xc0)| |
((((int)gamma_table[(b<<2)|b|(b>>2)|(b>>4)])>>2) & 0x30)| |
((((int)gamma_table[(c<<4)|(c<<2)|c|(c>>2)])>>4) & 0x0c)| |
((((int)gamma_table[(d<<6)|(d<<4)|(d<<2)|d])>>6) )); |
sp++; |
} |
} |
if (row_info->bit_depth == 4) |
{ |
sp = row; |
for (i = 0; i < row_width; i += 2) |
{ |
int msb = *sp & 0xf0; |
int lsb = *sp & 0x0f; |
*sp = (png_byte)((((int)gamma_table[msb | (msb >> 4)]) & 0xf0) |
| (((int)gamma_table[(lsb << 4) | lsb]) >> 4)); |
sp++; |
} |
} |
else if (row_info->bit_depth == 8) |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
*sp = gamma_table[*sp]; |
sp++; |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
sp = row; |
for (i = 0; i < row_width; i++) |
{ |
png_uint_16 v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; |
*sp = (png_byte)((v >> 8) & 0xff); |
*(sp + 1) = (png_byte)(v & 0xff); |
sp += 2; |
} |
} |
break; |
} |
} |
} |
} |
#endif |
#if defined(PNG_READ_EXPAND_SUPPORTED) |
/* Expands a palette row to an RGB or RGBA row depending |
* upon whether you supply trans and num_trans. |
*/ |
void /* PRIVATE */ |
png_do_expand_palette(png_row_infop row_info, png_bytep row, |
png_colorp palette, png_bytep trans, int num_trans) |
{ |
int shift, value; |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
png_debug(1, "in png_do_expand_palette\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
row_info->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (row_info->bit_depth < 8) |
{ |
switch (row_info->bit_depth) |
{ |
case 1: |
{ |
sp = row + (png_size_t)((row_width - 1) >> 3); |
dp = row + (png_size_t)row_width - 1; |
shift = 7 - (int)((row_width + 7) & 0x07); |
for (i = 0; i < row_width; i++) |
{ |
if ((*sp >> shift) & 0x01) |
*dp = 1; |
else |
*dp = 0; |
if (shift == 7) |
{ |
shift = 0; |
sp--; |
} |
else |
shift++; |
dp--; |
} |
break; |
} |
case 2: |
{ |
sp = row + (png_size_t)((row_width - 1) >> 2); |
dp = row + (png_size_t)row_width - 1; |
shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); |
for (i = 0; i < row_width; i++) |
{ |
value = (*sp >> shift) & 0x03; |
*dp = (png_byte)value; |
if (shift == 6) |
{ |
shift = 0; |
sp--; |
} |
else |
shift += 2; |
dp--; |
} |
break; |
} |
case 4: |
{ |
sp = row + (png_size_t)((row_width - 1) >> 1); |
dp = row + (png_size_t)row_width - 1; |
shift = (int)((row_width & 0x01) << 2); |
for (i = 0; i < row_width; i++) |
{ |
value = (*sp >> shift) & 0x0f; |
*dp = (png_byte)value; |
if (shift == 4) |
{ |
shift = 0; |
sp--; |
} |
else |
shift += 4; |
dp--; |
} |
break; |
} |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = 8; |
row_info->rowbytes = row_width; |
} |
switch (row_info->bit_depth) |
{ |
case 8: |
{ |
if (trans != NULL) |
{ |
sp = row + (png_size_t)row_width - 1; |
dp = row + (png_size_t)(row_width << 2) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if ((int)(*sp) >= num_trans) |
*dp-- = 0xff; |
else |
*dp-- = trans[*sp]; |
*dp-- = palette[*sp].blue; |
*dp-- = palette[*sp].green; |
*dp-- = palette[*sp].red; |
sp--; |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = 32; |
row_info->rowbytes = row_width * 4; |
row_info->color_type = 6; |
row_info->channels = 4; |
} |
else |
{ |
sp = row + (png_size_t)row_width - 1; |
dp = row + (png_size_t)(row_width * 3) - 1; |
for (i = 0; i < row_width; i++) |
{ |
*dp-- = palette[*sp].blue; |
*dp-- = palette[*sp].green; |
*dp-- = palette[*sp].red; |
sp--; |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = 24; |
row_info->rowbytes = row_width * 3; |
row_info->color_type = 2; |
row_info->channels = 3; |
} |
break; |
} |
} |
} |
} |
/* If the bit depth < 8, it is expanded to 8. Also, if the |
* transparency value is supplied, an alpha channel is built. |
*/ |
void /* PRIVATE */ |
png_do_expand(png_row_infop row_info, png_bytep row, |
png_color_16p trans_value) |
{ |
int shift, value; |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
png_debug(1, "in png_do_expand\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0); |
if (row_info->bit_depth < 8) |
{ |
switch (row_info->bit_depth) |
{ |
case 1: |
{ |
gray = (png_uint_16)(gray*0xff); |
sp = row + (png_size_t)((row_width - 1) >> 3); |
dp = row + (png_size_t)row_width - 1; |
shift = 7 - (int)((row_width + 7) & 0x07); |
for (i = 0; i < row_width; i++) |
{ |
if ((*sp >> shift) & 0x01) |
*dp = 0xff; |
else |
*dp = 0; |
if (shift == 7) |
{ |
shift = 0; |
sp--; |
} |
else |
shift++; |
dp--; |
} |
break; |
} |
case 2: |
{ |
gray = (png_uint_16)(gray*0x55); |
sp = row + (png_size_t)((row_width - 1) >> 2); |
dp = row + (png_size_t)row_width - 1; |
shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); |
for (i = 0; i < row_width; i++) |
{ |
value = (*sp >> shift) & 0x03; |
*dp = (png_byte)(value | (value << 2) | (value << 4) | |
(value << 6)); |
if (shift == 6) |
{ |
shift = 0; |
sp--; |
} |
else |
shift += 2; |
dp--; |
} |
break; |
} |
case 4: |
{ |
gray = (png_uint_16)(gray*0x11); |
sp = row + (png_size_t)((row_width - 1) >> 1); |
dp = row + (png_size_t)row_width - 1; |
shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); |
for (i = 0; i < row_width; i++) |
{ |
value = (*sp >> shift) & 0x0f; |
*dp = (png_byte)(value | (value << 4)); |
if (shift == 4) |
{ |
shift = 0; |
sp--; |
} |
else |
shift = 4; |
dp--; |
} |
break; |
} |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = 8; |
row_info->rowbytes = row_width; |
} |
if (trans_value != NULL) |
{ |
if (row_info->bit_depth == 8) |
{ |
sp = row + (png_size_t)row_width - 1; |
dp = row + (png_size_t)(row_width << 1) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if (*sp == gray) |
*dp-- = 0; |
else |
*dp-- = 0xff; |
*dp-- = *sp--; |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
sp = row + row_info->rowbytes - 1; |
dp = row + (row_info->rowbytes << 1) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if (((png_uint_16)*(sp) | |
((png_uint_16)*(sp - 1) << 8)) == gray) |
{ |
*dp-- = 0; |
*dp-- = 0; |
} |
else |
{ |
*dp-- = 0xff; |
*dp-- = 0xff; |
} |
*dp-- = *sp--; |
*dp-- = *sp--; |
} |
} |
row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA; |
row_info->channels = 2; |
row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); |
row_info->rowbytes = |
((row_width * row_info->pixel_depth) >> 3); |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value) |
{ |
if (row_info->bit_depth == 8) |
{ |
sp = row + (png_size_t)row_info->rowbytes - 1; |
dp = row + (png_size_t)(row_width << 2) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if (*(sp - 2) == trans_value->red && |
*(sp - 1) == trans_value->green && |
*(sp - 0) == trans_value->blue) |
*dp-- = 0; |
else |
*dp-- = 0xff; |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
sp = row + row_info->rowbytes - 1; |
dp = row + (png_size_t)(row_width << 3) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if ((((png_uint_16)*(sp - 4) | |
((png_uint_16)*(sp - 5) << 8)) == trans_value->red) && |
(((png_uint_16)*(sp - 2) | |
((png_uint_16)*(sp - 3) << 8)) == trans_value->green) && |
(((png_uint_16)*(sp - 0) | |
((png_uint_16)*(sp - 1) << 8)) == trans_value->blue)) |
{ |
*dp-- = 0; |
*dp-- = 0; |
} |
else |
{ |
*dp-- = 0xff; |
*dp-- = 0xff; |
} |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
} |
} |
row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA; |
row_info->channels = 4; |
row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2); |
row_info->rowbytes = |
((row_width * row_info->pixel_depth) >> 3); |
} |
} |
} |
#endif |
#if defined(PNG_READ_DITHER_SUPPORTED) |
void /* PRIVATE */ |
png_do_dither(png_row_infop row_info, png_bytep row, |
png_bytep palette_lookup, png_bytep dither_lookup) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
png_debug(1, "in png_do_dither\n"); |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
if (row != NULL && row_info != NULL) |
#endif |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB && |
palette_lookup && row_info->bit_depth == 8) |
{ |
int r, g, b, p; |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++) |
{ |
r = *sp++; |
g = *sp++; |
b = *sp++; |
/* this looks real messy, but the compiler will reduce |
it down to a reasonable formula. For example, with |
5 bits per color, we get: |
p = (((r >> 3) & 0x1f) << 10) | |
(((g >> 3) & 0x1f) << 5) | |
((b >> 3) & 0x1f); |
*/ |
p = (((r >> (8 - PNG_DITHER_RED_BITS)) & |
((1 << PNG_DITHER_RED_BITS) - 1)) << |
(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | |
(((g >> (8 - PNG_DITHER_GREEN_BITS)) & |
((1 << PNG_DITHER_GREEN_BITS) - 1)) << |
(PNG_DITHER_BLUE_BITS)) | |
((b >> (8 - PNG_DITHER_BLUE_BITS)) & |
((1 << PNG_DITHER_BLUE_BITS) - 1)); |
*dp++ = palette_lookup[p]; |
} |
row_info->color_type = PNG_COLOR_TYPE_PALETTE; |
row_info->channels = 1; |
row_info->pixel_depth = row_info->bit_depth; |
row_info->rowbytes = |
((row_width * row_info->pixel_depth + 7) >> 3); |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && |
palette_lookup != NULL && row_info->bit_depth == 8) |
{ |
int r, g, b, p; |
sp = row; |
dp = row; |
for (i = 0; i < row_width; i++) |
{ |
r = *sp++; |
g = *sp++; |
b = *sp++; |
sp++; |
p = (((r >> (8 - PNG_DITHER_RED_BITS)) & |
((1 << PNG_DITHER_RED_BITS) - 1)) << |
(PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | |
(((g >> (8 - PNG_DITHER_GREEN_BITS)) & |
((1 << PNG_DITHER_GREEN_BITS) - 1)) << |
(PNG_DITHER_BLUE_BITS)) | |
((b >> (8 - PNG_DITHER_BLUE_BITS)) & |
((1 << PNG_DITHER_BLUE_BITS) - 1)); |
*dp++ = palette_lookup[p]; |
} |
row_info->color_type = PNG_COLOR_TYPE_PALETTE; |
row_info->channels = 1; |
row_info->pixel_depth = row_info->bit_depth; |
row_info->rowbytes = |
((row_width * row_info->pixel_depth + 7) >> 3); |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && |
dither_lookup && row_info->bit_depth == 8) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp++) |
{ |
*sp = dither_lookup[*sp]; |
} |
} |
} |
} |
#endif |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
#if defined(PNG_READ_GAMMA_SUPPORTED) |
static int png_gamma_shift[] = |
{0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0}; |
/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit |
* tables, we don't make a full table if we are reducing to 8-bit in |
* the future. Note also how the gamma_16 tables are segmented so that |
* we don't need to allocate > 64K chunks for a full 16-bit table. |
*/ |
void /* PRIVATE */ |
png_build_gamma_table(png_structp png_ptr) |
{ |
png_debug(1, "in png_build_gamma_table\n"); |
if(png_ptr->gamma != 0.0) |
{ |
if (png_ptr->bit_depth <= 8) |
{ |
int i; |
double g; |
if (png_ptr->screen_gamma > .000001) |
g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); |
else |
g = 1.0; |
png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)256); |
for (i = 0; i < 256; i++) |
{ |
png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0, |
g) * 255.0 + .5); |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY)) |
{ |
g = 1.0 / (png_ptr->gamma); |
png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)256); |
for (i = 0; i < 256; i++) |
{ |
png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0, |
g) * 255.0 + .5); |
} |
png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)256); |
if(png_ptr->screen_gamma > 0.000001) |
g = 1.0 / png_ptr->screen_gamma; |
else |
g = png_ptr->gamma; /* probably doing rgb_to_gray */ |
for (i = 0; i < 256; i++) |
{ |
png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0, |
g) * 255.0 + .5); |
} |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ |
} |
else |
{ |
double g; |
int i, j, shift, num; |
int sig_bit; |
png_uint_32 ig; |
if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) |
{ |
sig_bit = (int)png_ptr->sig_bit.red; |
if ((int)png_ptr->sig_bit.green > sig_bit) |
sig_bit = png_ptr->sig_bit.green; |
if ((int)png_ptr->sig_bit.blue > sig_bit) |
sig_bit = png_ptr->sig_bit.blue; |
} |
else |
{ |
sig_bit = (int)png_ptr->sig_bit.gray; |
} |
if (sig_bit > 0) |
shift = 16 - sig_bit; |
else |
shift = 0; |
if (png_ptr->transformations & PNG_16_TO_8) |
{ |
if (shift < (16 - PNG_MAX_GAMMA_8)) |
shift = (16 - PNG_MAX_GAMMA_8); |
} |
if (shift > 8) |
shift = 8; |
if (shift < 0) |
shift = 0; |
png_ptr->gamma_shift = (png_byte)shift; |
num = (1 << (8 - shift)); |
if (png_ptr->screen_gamma > .000001) |
g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); |
else |
g = 1.0; |
png_ptr->gamma_16_table = (png_uint_16pp)png_malloc(png_ptr, |
(png_uint_32)(num * sizeof (png_uint_16p))); |
if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND)) |
{ |
double fin, fout; |
png_uint_32 last, max; |
for (i = 0; i < num; i++) |
{ |
png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(256 * sizeof (png_uint_16))); |
} |
g = 1.0 / g; |
last = 0; |
for (i = 0; i < 256; i++) |
{ |
fout = ((double)i + 0.5) / 256.0; |
fin = pow(fout, g); |
max = (png_uint_32)(fin * (double)((png_uint_32)num << 8)); |
while (last <= max) |
{ |
png_ptr->gamma_16_table[(int)(last & (0xff >> shift))] |
[(int)(last >> (8 - shift))] = (png_uint_16)( |
(png_uint_16)i | ((png_uint_16)i << 8)); |
last++; |
} |
} |
while (last < ((png_uint_32)num << 8)) |
{ |
png_ptr->gamma_16_table[(int)(last & (0xff >> shift))] |
[(int)(last >> (8 - shift))] = (png_uint_16)65535L; |
last++; |
} |
} |
else |
{ |
for (i = 0; i < num; i++) |
{ |
png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(256 * sizeof (png_uint_16))); |
ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4); |
for (j = 0; j < 256; j++) |
{ |
png_ptr->gamma_16_table[i][j] = |
(png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / |
65535.0, g) * 65535.0 + .5); |
} |
} |
} |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY)) |
{ |
g = 1.0 / (png_ptr->gamma); |
png_ptr->gamma_16_to_1 = (png_uint_16pp)png_malloc(png_ptr, |
(png_uint_32)(num * sizeof (png_uint_16p ))); |
for (i = 0; i < num; i++) |
{ |
png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(256 * sizeof (png_uint_16))); |
ig = (((png_uint_32)i * |
(png_uint_32)png_gamma_shift[shift]) >> 4); |
for (j = 0; j < 256; j++) |
{ |
png_ptr->gamma_16_to_1[i][j] = |
(png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / |
65535.0, g) * 65535.0 + .5); |
} |
} |
if(png_ptr->screen_gamma > 0.000001) |
g = 1.0 / png_ptr->screen_gamma; |
else |
g = png_ptr->gamma; /* probably doing rgb_to_gray */ |
png_ptr->gamma_16_from_1 = (png_uint_16pp)png_malloc(png_ptr, |
(png_uint_32)(num * sizeof (png_uint_16p))); |
for (i = 0; i < num; i++) |
{ |
png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(256 * sizeof (png_uint_16))); |
ig = (((png_uint_32)i * |
(png_uint_32)png_gamma_shift[shift]) >> 4); |
for (j = 0; j < 256; j++) |
{ |
png_ptr->gamma_16_from_1[i][j] = |
(png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / |
65535.0, g) * 65535.0 + .5); |
} |
} |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ |
} |
} |
} |
#endif |
/* To do: install integer version of png_build_gamma_table here */ |
#endif |
#if defined(PNG_MNG_FEATURES_SUPPORTED) |
/* undoes intrapixel differencing */ |
void /* PRIVATE */ |
png_do_read_intrapixel(png_row_infop row_info, png_bytep row) |
{ |
png_debug(1, "in png_do_read_intrapixel\n"); |
if ( |
#if defined(PNG_USELESS_TESTS_SUPPORTED) |
row != NULL && row_info != NULL && |
#endif |
(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
int bytes_per_pixel; |
png_uint_32 row_width = row_info->width; |
if (row_info->bit_depth == 8) |
{ |
png_bytep rp; |
png_uint_32 i; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
bytes_per_pixel = 3; |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
bytes_per_pixel = 4; |
else |
return; |
for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) |
{ |
*(rp) = (png_byte)((256 + *rp + *(rp+1))&0xff); |
*(rp+2) = (png_byte)((256 + *(rp+2) + *(rp+1))&0xff); |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
png_bytep rp; |
png_uint_32 i; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
bytes_per_pixel = 6; |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
bytes_per_pixel = 8; |
else |
return; |
for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) |
{ |
png_uint_32 s0=*(rp )<<8 | *(rp+1); |
png_uint_32 s1=*(rp+2)<<8 | *(rp+3); |
png_uint_32 s2=*(rp+4)<<8 | *(rp+5); |
png_uint_32 red=(65536+s0+s1)&0xffff; |
png_uint_32 blue=(65536+s2+s1)&0xffff; |
*(rp ) = (png_byte)((red>>8)&0xff); |
*(rp+1) = (png_byte)(red&0xff); |
*(rp+4) = (png_byte)((blue>>8)&0xff); |
*(rp+5) = (png_byte)(blue&0xff); |
} |
} |
} |
} |
#endif /* PNG_MNG_FEATURES_SUPPORTED */ |
/shark/trunk/ports/png/adler32.c |
---|
0,0 → 1,48 |
/* adler32.c -- compute the Adler-32 checksum of a data stream |
* Copyright (C) 1995-2002 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
/* @(#) $Id: adler32.c,v 1.1 2003-03-20 13:08:10 giacomo Exp $ */ |
#include "zlib.h" |
#define BASE 65521L /* largest prime smaller than 65536 */ |
#define NMAX 5552 |
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ |
#define DO1(buf,i) {s1 += buf[i]; s2 += s1;} |
#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); |
#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); |
#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); |
#define DO16(buf) DO8(buf,0); DO8(buf,8); |
/* ========================================================================= */ |
uLong ZEXPORT adler32(adler, buf, len) |
uLong adler; |
const Bytef *buf; |
uInt len; |
{ |
unsigned long s1 = adler & 0xffff; |
unsigned long s2 = (adler >> 16) & 0xffff; |
int k; |
if (buf == Z_NULL) return 1L; |
while (len > 0) { |
k = len < NMAX ? len : NMAX; |
len -= k; |
while (k >= 16) { |
DO16(buf); |
buf += 16; |
k -= 16; |
} |
if (k != 0) do { |
s1 += *buf++; |
s2 += s1; |
} while (--k); |
s1 %= BASE; |
s2 %= BASE; |
} |
return (s2 << 16) | s1; |
} |