/programs/develop/libraries/cairo/Makefile |
---|
8,9 → 8,9 |
DEFINES = -DHAVE_CONFIG_H -DCAIRO_NO_MUTEX -U_WIN32 -U_MSC_VER -U__WIN32__ |
INCLUDES = -I../pixman -I../newlib/include -I../newlib/include/sys |
INCLUDES = -I../newlib/include -I../pixman -I../zlib -I../libpng |
SOURCES = \ |
CAIRO_SOURCES = \ |
cairo-analysis-surface.c \ |
cairo-arc.c \ |
cairo-array.c \ |
55,7 → 55,9 |
cairo-path-in-fill.c \ |
cairo-path-stroke.c \ |
cairo-pattern.c \ |
cairo-pdf-operators.c \ |
cairo-pen.c \ |
cairo-png.c \ |
cairo-polygon.c \ |
cairo-rectangle.c \ |
cairo-rectangular-scan-converter.c \ |
73,6 → 75,7 |
cairo-surface-snapshot.c \ |
cairo-surface-subsurface.c \ |
cairo-surface-wrapper.c \ |
cairo-svg-surface.c \ |
cairo-tor-scan-converter.c \ |
cairo-toy-font-face.c \ |
cairo-traps.c \ |
83,8 → 86,18 |
$(NULL) |
CAIRO_FONT = \ |
cairo-cff-subset.c \ |
cairo-scaled-font-subsets.c \ |
cairo-truetype-subset.c \ |
cairo-type1-fallback.c \ |
cairo-type1-subset.c \ |
cairo-type3-glyph-surface.c \ |
$(NULL) |
SOURCES= $(CAIRO_SOURCES) $(CAIRO_FONT) |
OBJECTS = $(patsubst %.c, src/%.o, $(SOURCES)) |
/programs/develop/libraries/cairo/config.h |
---|
24,11 → 24,13 |
/* Define to 1 to enable cairo's cairo-script-interpreter feature */ |
//#define CAIRO_HAS_INTERPRETER 1 |
#define CAIRO_NO_MUTEX 1 |
/* Define to 1 to enable cairo's pthread feature */ |
//#define CAIRO_HAS_PTHREAD 1 |
/* #undef CAIRO_HAS_PTHREAD */ |
/* Define to 1 if we have full pthread support */ |
//#define CAIRO_HAS_REAL_PTHREAD 1 |
/* #undef CAIRO_HAS_REAL_PTHREAD */ |
/* Define to 1 if libspectre is available */ |
/* #undef CAIRO_HAS_SPECTRE */ |
40,7 → 42,7 |
/* #undef CAIRO_HAS_TEST_SURFACES */ |
/* Define to 1 to enable cairo's cairo-trace feature */ |
//#define CAIRO_HAS_TRACE 1 |
/* #undef CAIRO_HAS_TRACE */ |
/* Define to 1 to disable certain code paths that rely heavily on double |
precision floating-point calculation */ |
73,7 → 75,7 |
#define HAVE_DLFCN_H 1 |
/* Define to 1 if you have the `drand48' function. */ |
//#define HAVE_DRAND48 1 |
#define HAVE_DRAND48 1 |
/* Define to 1 if you have the `FcFini' function. */ |
/* #undef HAVE_FCFINI */ |
173,7 → 175,7 |
//#define HAVE_SCHED_H 1 |
/* Define to 1 if you have the <setjmp.h> header file. */ |
//#define HAVE_SETJMP_H 1 |
#define HAVE_SETJMP_H 1 |
/* Define to 1 if you have the <signal.h> header file. */ |
//#define HAVE_SIGNAL_H 1 |
342,7 → 344,7 |
#define X_DISPLAY_MISSING 1 |
/* Number of bits in a file offset, on hosts where this is settable. */ |
#define _FILE_OFFSET_BITS 64 |
/* #undef _FILE_OFFSET_BITS */ |
/* Define for large files, on AIX-style hosts. */ |
/* #undef _LARGE_FILES */ |
362,5 → 364,3 |
#ifndef __cplusplus |
/* #undef inline */ |
#endif |
/programs/develop/libraries/cairo/src/cairo-cff-subset.c |
---|
0,0 → 1,2271 |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2006 Adrian Johnson |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is Adrian Johnson. |
* |
* Contributor(s): |
* Adrian Johnson <ajohnson@redneon.com> |
* Eugeniy Meshcheryakov <eugen@debian.org> |
*/ |
/* |
* Useful links: |
* http://www.adobe.com/devnet/font/pdfs/5176.CFF.pdf |
*/ |
#define _BSD_SOURCE /* for snprintf(), strdup() */ |
#include "cairoint.h" |
#include "cairo-error-private.h" |
#if CAIRO_HAS_FONT_SUBSET |
#include "cairo-scaled-font-subsets-private.h" |
#include "cairo-truetype-subset-private.h" |
#include <string.h> |
/* CFF Dict Operators. If the high byte is 0 the command is encoded |
* with a single byte. */ |
#define BASEFONTNAME_OP 0x0c16 |
#define CIDCOUNT_OP 0x0c22 |
#define CHARSET_OP 0x000f |
#define CHARSTRINGS_OP 0x0011 |
#define COPYRIGHT_OP 0x0c00 |
#define ENCODING_OP 0x0010 |
#define FAMILYNAME_OP 0x0003 |
#define FDARRAY_OP 0x0c24 |
#define FDSELECT_OP 0x0c25 |
#define FONTBBOX_OP 0x0005 |
#define FONTNAME_OP 0x0c26 |
#define FULLNAME_OP 0x0002 |
#define LOCAL_SUB_OP 0x0013 |
#define NOTICE_OP 0x0001 |
#define POSTSCRIPT_OP 0x0c15 |
#define PRIVATE_OP 0x0012 |
#define ROS_OP 0x0c1e |
#define UNIQUEID_OP 0x000d |
#define VERSION_OP 0x0000 |
#define WEIGHT_OP 0x0004 |
#define XUID_OP 0x000e |
#define NUM_STD_STRINGS 391 |
typedef struct _cff_header { |
uint8_t major; |
uint8_t minor; |
uint8_t header_size; |
uint8_t offset_size; |
} cff_header_t; |
typedef struct _cff_index_element { |
cairo_bool_t is_copy; |
unsigned char *data; |
int length; |
} cff_index_element_t; |
typedef struct _cff_dict_operator { |
cairo_hash_entry_t base; |
unsigned short operator; |
unsigned char *operand; |
int operand_length; |
int operand_offset; |
} cff_dict_operator_t; |
typedef struct _cairo_cff_font { |
cairo_scaled_font_subset_t *scaled_font_subset; |
const cairo_scaled_font_backend_t *backend; |
/* Font Data */ |
unsigned char *data; |
unsigned long data_length; |
unsigned char *current_ptr; |
unsigned char *data_end; |
cff_header_t *header; |
char *font_name; |
char *ps_name; |
cairo_hash_table_t *top_dict; |
cairo_hash_table_t *private_dict; |
cairo_array_t strings_index; |
cairo_array_t charstrings_index; |
cairo_array_t global_sub_index; |
cairo_array_t local_sub_index; |
int num_glyphs; |
cairo_bool_t is_cid; |
int units_per_em; |
/* CID Font Data */ |
int *fdselect; |
unsigned int num_fontdicts; |
cairo_hash_table_t **fd_dict; |
cairo_hash_table_t **fd_private_dict; |
cairo_array_t *fd_local_sub_index; |
/* Subsetted Font Data */ |
char *subset_font_name; |
cairo_array_t charstrings_subset_index; |
cairo_array_t strings_subset_index; |
int *fdselect_subset; |
unsigned int num_subset_fontdicts; |
int *fd_subset_map; |
int *private_dict_offset; |
cairo_array_t output; |
/* Subset Metrics */ |
int *widths; |
int x_min, y_min, x_max, y_max; |
int ascent, descent; |
} cairo_cff_font_t; |
/* Encoded integer using maximum sized encoding. This is required for |
* operands that are later modified after encoding. */ |
static unsigned char * |
encode_integer_max (unsigned char *p, int i) |
{ |
*p++ = 29; |
*p++ = i >> 24; |
*p++ = (i >> 16) & 0xff; |
*p++ = (i >> 8) & 0xff; |
*p++ = i & 0xff; |
return p; |
} |
static unsigned char * |
encode_integer (unsigned char *p, int i) |
{ |
if (i >= -107 && i <= 107) { |
*p++ = i + 139; |
} else if (i >= 108 && i <= 1131) { |
i -= 108; |
*p++ = (i >> 8)+ 247; |
*p++ = i & 0xff; |
} else if (i >= -1131 && i <= -108) { |
i = -i - 108; |
*p++ = (i >> 8)+ 251; |
*p++ = i & 0xff; |
} else if (i >= -32768 && i <= 32767) { |
*p++ = 28; |
*p++ = (i >> 8) & 0xff; |
*p++ = i & 0xff; |
} else { |
p = encode_integer_max (p, i); |
} |
return p; |
} |
static unsigned char * |
decode_integer (unsigned char *p, int *integer) |
{ |
if (*p == 28) { |
*integer = (int)(p[1]<<8 | p[2]); |
p += 3; |
} else if (*p == 29) { |
*integer = (int)((p[1] << 24) | (p[2] << 16) | (p[3] << 8) | p[4]); |
p += 5; |
} else if (*p >= 32 && *p <= 246) { |
*integer = *p++ - 139; |
} else if (*p <= 250) { |
*integer = (p[0] - 247) * 256 + p[1] + 108; |
p += 2; |
} else if (*p <= 254) { |
*integer = -(p[0] - 251) * 256 - p[1] - 108; |
p += 2; |
} else { |
*integer = 0; |
p += 1; |
} |
return p; |
} |
static unsigned char * |
decode_operator (unsigned char *p, unsigned short *operator) |
{ |
unsigned short op = 0; |
op = *p++; |
if (op == 12) { |
op <<= 8; |
op |= *p++; |
} |
*operator = op; |
return p; |
} |
/* return 0 if not an operand */ |
static int |
operand_length (unsigned char *p) |
{ |
unsigned char *begin = p; |
if (*p == 28) |
return 3; |
if (*p == 29) |
return 5; |
if (*p >= 32 && *p <= 246) |
return 1; |
if (*p >= 247 && *p <= 254) |
return 2; |
if (*p == 30) { |
while ((*p & 0x0f) != 0x0f) |
p++; |
return p - begin + 1; |
} |
return 0; |
} |
static unsigned char * |
encode_index_offset (unsigned char *p, int offset_size, unsigned long offset) |
{ |
while (--offset_size >= 0) { |
p[offset_size] = (unsigned char) (offset & 0xff); |
offset >>= 8; |
} |
return p + offset_size; |
} |
static unsigned long |
decode_index_offset(unsigned char *p, int off_size) |
{ |
unsigned long offset = 0; |
while (off_size-- > 0) |
offset = offset*256 + *p++; |
return offset; |
} |
static void |
cff_index_init (cairo_array_t *index) |
{ |
_cairo_array_init (index, sizeof (cff_index_element_t)); |
} |
static cairo_int_status_t |
cff_index_read (cairo_array_t *index, unsigned char **ptr, unsigned char *end_ptr) |
{ |
cff_index_element_t element; |
unsigned char *data, *p; |
cairo_status_t status; |
int offset_size, count, start, i; |
int end = 0; |
p = *ptr; |
if (p + 2 > end_ptr) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
count = be16_to_cpu( *((uint16_t *)p) ); |
p += 2; |
if (count > 0) { |
offset_size = *p++; |
if (p + (count + 1)*offset_size > end_ptr) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
data = p + offset_size*(count + 1) - 1; |
start = decode_index_offset (p, offset_size); |
p += offset_size; |
for (i = 0; i < count; i++) { |
end = decode_index_offset (p, offset_size); |
p += offset_size; |
if (p > end_ptr) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
element.length = end - start; |
element.is_copy = FALSE; |
element.data = data + start; |
status = _cairo_array_append (index, &element); |
if (unlikely (status)) |
return status; |
start = end; |
} |
p = data + end; |
} |
*ptr = p; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cff_index_write (cairo_array_t *index, cairo_array_t *output) |
{ |
int offset_size; |
int offset; |
int num_elem; |
int i; |
cff_index_element_t *element; |
uint16_t count; |
unsigned char buf[5]; |
cairo_status_t status; |
num_elem = _cairo_array_num_elements (index); |
count = cpu_to_be16 ((uint16_t) num_elem); |
status = _cairo_array_append_multiple (output, &count, 2); |
if (unlikely (status)) |
return status; |
if (num_elem == 0) |
return CAIRO_STATUS_SUCCESS; |
/* Find maximum offset to determine offset size */ |
offset = 1; |
for (i = 0; i < num_elem; i++) { |
element = _cairo_array_index (index, i); |
offset += element->length; |
} |
if (offset < 0x100) |
offset_size = 1; |
else if (offset < 0x10000) |
offset_size = 2; |
else if (offset < 0x1000000) |
offset_size = 3; |
else |
offset_size = 4; |
buf[0] = (unsigned char) offset_size; |
status = _cairo_array_append (output, buf); |
if (unlikely (status)) |
return status; |
offset = 1; |
encode_index_offset (buf, offset_size, offset); |
status = _cairo_array_append_multiple (output, buf, offset_size); |
if (unlikely (status)) |
return status; |
for (i = 0; i < num_elem; i++) { |
element = _cairo_array_index (index, i); |
offset += element->length; |
encode_index_offset (buf, offset_size, offset); |
status = _cairo_array_append_multiple (output, buf, offset_size); |
if (unlikely (status)) |
return status; |
} |
for (i = 0; i < num_elem; i++) { |
element = _cairo_array_index (index, i); |
status = _cairo_array_append_multiple (output, |
element->data, |
element->length); |
if (unlikely (status)) |
return status; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cff_index_append (cairo_array_t *index, unsigned char *object , int length) |
{ |
cff_index_element_t element; |
element.length = length; |
element.is_copy = FALSE; |
element.data = object; |
return _cairo_array_append (index, &element); |
} |
static cairo_status_t |
cff_index_append_copy (cairo_array_t *index, |
const unsigned char *object, |
unsigned int length) |
{ |
cff_index_element_t element; |
cairo_status_t status; |
element.length = length; |
element.is_copy = TRUE; |
element.data = malloc (element.length); |
if (unlikely (element.data == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
memcpy (element.data, object, element.length); |
status = _cairo_array_append (index, &element); |
if (unlikely (status)) { |
free (element.data); |
return status; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
cff_index_fini (cairo_array_t *index) |
{ |
cff_index_element_t *element; |
int i; |
for (i = 0; i < _cairo_array_num_elements (index); i++) { |
element = _cairo_array_index (index, i); |
if (element->is_copy) |
free (element->data); |
} |
_cairo_array_fini (index); |
} |
static cairo_bool_t |
_cairo_cff_dict_equal (const void *key_a, const void *key_b) |
{ |
const cff_dict_operator_t *op_a = key_a; |
const cff_dict_operator_t *op_b = key_b; |
return op_a->operator == op_b->operator; |
} |
static cairo_status_t |
cff_dict_init (cairo_hash_table_t **dict) |
{ |
*dict = _cairo_hash_table_create (_cairo_cff_dict_equal); |
if (unlikely (*dict == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
_cairo_dict_init_key (cff_dict_operator_t *key, int operator) |
{ |
key->base.hash = (unsigned long) operator; |
key->operator = operator; |
} |
static cairo_status_t |
cff_dict_create_operator (int operator, |
unsigned char *operand, |
int size, |
cff_dict_operator_t **out) |
{ |
cff_dict_operator_t *op; |
op = malloc (sizeof (cff_dict_operator_t)); |
if (unlikely (op == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
_cairo_dict_init_key (op, operator); |
op->operand = malloc (size); |
if (unlikely (op->operand == NULL)) { |
free (op); |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
} |
memcpy (op->operand, operand, size); |
op->operand_length = size; |
op->operand_offset = -1; |
*out = op; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cff_dict_read (cairo_hash_table_t *dict, unsigned char *p, int dict_size) |
{ |
unsigned char *end; |
cairo_array_t operands; |
cff_dict_operator_t *op; |
unsigned short operator; |
cairo_status_t status = CAIRO_STATUS_SUCCESS; |
int size; |
end = p + dict_size; |
_cairo_array_init (&operands, 1); |
while (p < end) { |
size = operand_length (p); |
if (size != 0) { |
status = _cairo_array_append_multiple (&operands, p, size); |
if (unlikely (status)) |
goto fail; |
p += size; |
} else { |
p = decode_operator (p, &operator); |
status = cff_dict_create_operator (operator, |
_cairo_array_index (&operands, 0), |
_cairo_array_num_elements (&operands), |
&op); |
if (unlikely (status)) |
goto fail; |
status = _cairo_hash_table_insert (dict, &op->base); |
if (unlikely (status)) |
goto fail; |
_cairo_array_truncate (&operands, 0); |
} |
} |
fail: |
_cairo_array_fini (&operands); |
return status; |
} |
static void |
cff_dict_remove (cairo_hash_table_t *dict, unsigned short operator) |
{ |
cff_dict_operator_t key, *op; |
_cairo_dict_init_key (&key, operator); |
op = _cairo_hash_table_lookup (dict, &key.base); |
if (op != NULL) { |
free (op->operand); |
_cairo_hash_table_remove (dict, (cairo_hash_entry_t *) op); |
free (op); |
} |
} |
static unsigned char * |
cff_dict_get_operands (cairo_hash_table_t *dict, |
unsigned short operator, |
int *size) |
{ |
cff_dict_operator_t key, *op; |
_cairo_dict_init_key (&key, operator); |
op = _cairo_hash_table_lookup (dict, &key.base); |
if (op != NULL) { |
*size = op->operand_length; |
return op->operand; |
} |
return NULL; |
} |
static cairo_status_t |
cff_dict_set_operands (cairo_hash_table_t *dict, |
unsigned short operator, |
unsigned char *operand, |
int size) |
{ |
cff_dict_operator_t key, *op; |
cairo_status_t status; |
_cairo_dict_init_key (&key, operator); |
op = _cairo_hash_table_lookup (dict, &key.base); |
if (op != NULL) { |
free (op->operand); |
op->operand = malloc (size); |
if (unlikely (op->operand == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
memcpy (op->operand, operand, size); |
op->operand_length = size; |
} |
else |
{ |
status = cff_dict_create_operator (operator, operand, size, &op); |
if (unlikely (status)) |
return status; |
status = _cairo_hash_table_insert (dict, &op->base); |
if (unlikely (status)) |
return status; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static int |
cff_dict_get_location (cairo_hash_table_t *dict, |
unsigned short operator, |
int *size) |
{ |
cff_dict_operator_t key, *op; |
_cairo_dict_init_key (&key, operator); |
op = _cairo_hash_table_lookup (dict, &key.base); |
if (op != NULL) { |
*size = op->operand_length; |
return op->operand_offset; |
} |
return -1; |
} |
typedef struct _dict_write_info { |
cairo_array_t *output; |
cairo_status_t status; |
} dict_write_info_t; |
static void |
cairo_dict_write_operator (cff_dict_operator_t *op, dict_write_info_t *write_info) |
{ |
unsigned char data; |
op->operand_offset = _cairo_array_num_elements (write_info->output); |
write_info->status = _cairo_array_append_multiple (write_info->output, op->operand, op->operand_length); |
if (write_info->status) |
return; |
if (op->operator & 0xff00) { |
data = op->operator >> 8; |
write_info->status = _cairo_array_append (write_info->output, &data); |
if (write_info->status) |
return; |
} |
data = op->operator & 0xff; |
write_info->status = _cairo_array_append (write_info->output, &data); |
} |
static void |
_cairo_dict_collect (void *entry, void *closure) |
{ |
dict_write_info_t *write_info = closure; |
cff_dict_operator_t *op = entry; |
if (write_info->status) |
return; |
/* The ROS operator is handled separately in cff_dict_write() */ |
if (op->operator != ROS_OP) |
cairo_dict_write_operator (op, write_info); |
} |
static cairo_status_t |
cff_dict_write (cairo_hash_table_t *dict, cairo_array_t *output) |
{ |
dict_write_info_t write_info; |
cff_dict_operator_t key, *op; |
write_info.output = output; |
write_info.status = CAIRO_STATUS_SUCCESS; |
/* The CFF specification requires that the Top Dict of CID fonts |
* begin with the ROS operator. */ |
_cairo_dict_init_key (&key, ROS_OP); |
op = _cairo_hash_table_lookup (dict, &key.base); |
if (op != NULL) |
cairo_dict_write_operator (op, &write_info); |
_cairo_hash_table_foreach (dict, _cairo_dict_collect, &write_info); |
return write_info.status; |
} |
static void |
_cff_dict_entry_pluck (void *_entry, void *dict) |
{ |
cff_dict_operator_t *entry = _entry; |
_cairo_hash_table_remove (dict, &entry->base); |
free (entry->operand); |
free (entry); |
} |
static void |
cff_dict_fini (cairo_hash_table_t *dict) |
{ |
_cairo_hash_table_foreach (dict, _cff_dict_entry_pluck, dict); |
_cairo_hash_table_destroy (dict); |
} |
static cairo_int_status_t |
cairo_cff_font_read_header (cairo_cff_font_t *font) |
{ |
if (font->data_length < sizeof (cff_header_t)) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
font->header = (cff_header_t *) font->data; |
font->current_ptr = font->data + font->header->header_size; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
cairo_cff_font_read_name (cairo_cff_font_t *font) |
{ |
cairo_array_t index; |
cairo_int_status_t status; |
/* The original font name is not used in the subset. Read the name |
* index to skip over it. */ |
cff_index_init (&index); |
status = cff_index_read (&index, &font->current_ptr, font->data_end); |
cff_index_fini (&index); |
return status; |
} |
static cairo_int_status_t |
cairo_cff_font_read_private_dict (cairo_cff_font_t *font, |
cairo_hash_table_t *private_dict, |
cairo_array_t *local_sub_index, |
unsigned char *ptr, |
int size) |
{ |
cairo_int_status_t status; |
unsigned char buf[10]; |
unsigned char *end_buf; |
int offset; |
int i; |
unsigned char *operand; |
unsigned char *p; |
status = cff_dict_read (private_dict, ptr, size); |
if (unlikely (status)) |
return status; |
operand = cff_dict_get_operands (private_dict, LOCAL_SUB_OP, &i); |
if (operand) { |
decode_integer (operand, &offset); |
p = ptr + offset; |
status = cff_index_read (local_sub_index, &p, font->data_end); |
if (unlikely (status)) |
return status; |
/* Use maximum sized encoding to reserve space for later modification. */ |
end_buf = encode_integer_max (buf, 0); |
status = cff_dict_set_operands (private_dict, LOCAL_SUB_OP, buf, end_buf - buf); |
if (unlikely (status)) |
return status; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
cairo_cff_font_read_fdselect (cairo_cff_font_t *font, unsigned char *p) |
{ |
int type, num_ranges, first, last, fd, i, j; |
font->fdselect = calloc (font->num_glyphs, sizeof (int)); |
if (unlikely (font->fdselect == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
type = *p++; |
if (type == 0) |
{ |
for (i = 0; i < font->num_glyphs; i++) |
font->fdselect[i] = *p++; |
} else if (type == 3) { |
num_ranges = be16_to_cpu( *((uint16_t *)p) ); |
p += 2; |
for (i = 0; i < num_ranges; i++) |
{ |
first = be16_to_cpu( *((uint16_t *)p) ); |
p += 2; |
fd = *p++; |
last = be16_to_cpu( *((uint16_t *)p) ); |
for (j = first; j < last; j++) |
font->fdselect[j] = fd; |
} |
} else { |
return CAIRO_INT_STATUS_UNSUPPORTED; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
cairo_cff_font_read_cid_fontdict (cairo_cff_font_t *font, unsigned char *ptr) |
{ |
cairo_array_t index; |
cff_index_element_t *element; |
unsigned int i; |
int size; |
unsigned char *operand; |
int offset; |
cairo_int_status_t status; |
unsigned char buf[100]; |
unsigned char *end_buf; |
cff_index_init (&index); |
status = cff_index_read (&index, &ptr, font->data_end); |
if (unlikely (status)) |
goto fail; |
font->num_fontdicts = _cairo_array_num_elements (&index); |
font->fd_dict = calloc (sizeof (cairo_hash_table_t *), font->num_fontdicts); |
if (unlikely (font->fd_dict == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail; |
} |
font->fd_private_dict = calloc (sizeof (cairo_hash_table_t *), font->num_fontdicts); |
if (unlikely (font->fd_private_dict == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail; |
} |
font->fd_local_sub_index = calloc (sizeof (cairo_array_t), font->num_fontdicts); |
if (unlikely (font->fd_local_sub_index == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail; |
} |
for (i = 0; i < font->num_fontdicts; i++) { |
status = cff_dict_init (&font->fd_dict[i]); |
if (unlikely (status)) |
goto fail; |
element = _cairo_array_index (&index, i); |
status = cff_dict_read (font->fd_dict[i], element->data, element->length); |
if (unlikely (status)) |
goto fail; |
operand = cff_dict_get_operands (font->fd_dict[i], PRIVATE_OP, &size); |
if (operand == NULL) { |
status = CAIRO_INT_STATUS_UNSUPPORTED; |
goto fail; |
} |
operand = decode_integer (operand, &size); |
decode_integer (operand, &offset); |
status = cff_dict_init (&font->fd_private_dict[i]); |
if (unlikely (status)) |
goto fail; |
cff_index_init (&font->fd_local_sub_index[i]); |
status = cairo_cff_font_read_private_dict (font, |
font->fd_private_dict[i], |
&font->fd_local_sub_index[i], |
font->data + offset, |
size); |
if (unlikely (status)) |
goto fail; |
/* Set integer operand to max value to use max size encoding to reserve |
* space for any value later */ |
end_buf = encode_integer_max (buf, 0); |
end_buf = encode_integer_max (end_buf, 0); |
status = cff_dict_set_operands (font->fd_dict[i], PRIVATE_OP, buf, end_buf - buf); |
if (unlikely (status)) |
goto fail; |
} |
return CAIRO_STATUS_SUCCESS; |
fail: |
cff_index_fini (&index); |
return status; |
} |
static cairo_int_status_t |
cairo_cff_font_read_top_dict (cairo_cff_font_t *font) |
{ |
cairo_array_t index; |
cff_index_element_t *element; |
unsigned char buf[20]; |
unsigned char *end_buf; |
unsigned char *operand; |
cairo_int_status_t status; |
unsigned char *p; |
int size; |
int offset; |
cff_index_init (&index); |
status = cff_index_read (&index, &font->current_ptr, font->data_end); |
if (unlikely (status)) |
goto fail; |
element = _cairo_array_index (&index, 0); |
status = cff_dict_read (font->top_dict, element->data, element->length); |
if (unlikely (status)) |
goto fail; |
if (cff_dict_get_operands (font->top_dict, ROS_OP, &size) != NULL) |
font->is_cid = TRUE; |
else |
font->is_cid = FALSE; |
operand = cff_dict_get_operands (font->top_dict, CHARSTRINGS_OP, &size); |
decode_integer (operand, &offset); |
p = font->data + offset; |
status = cff_index_read (&font->charstrings_index, &p, font->data_end); |
if (unlikely (status)) |
goto fail; |
font->num_glyphs = _cairo_array_num_elements (&font->charstrings_index); |
if (font->is_cid) { |
operand = cff_dict_get_operands (font->top_dict, FDSELECT_OP, &size); |
decode_integer (operand, &offset); |
status = cairo_cff_font_read_fdselect (font, font->data + offset); |
if (unlikely (status)) |
goto fail; |
operand = cff_dict_get_operands (font->top_dict, FDARRAY_OP, &size); |
decode_integer (operand, &offset); |
status = cairo_cff_font_read_cid_fontdict (font, font->data + offset); |
if (unlikely (status)) |
goto fail; |
} else { |
operand = cff_dict_get_operands (font->top_dict, PRIVATE_OP, &size); |
operand = decode_integer (operand, &size); |
decode_integer (operand, &offset); |
status = cairo_cff_font_read_private_dict (font, |
font->private_dict, |
&font->local_sub_index, |
font->data + offset, |
size); |
if (unlikely (status)) |
goto fail; |
} |
/* Use maximum sized encoding to reserve space for later modification. */ |
end_buf = encode_integer_max (buf, 0); |
status = cff_dict_set_operands (font->top_dict, |
CHARSTRINGS_OP, buf, end_buf - buf); |
if (unlikely (status)) |
goto fail; |
status = cff_dict_set_operands (font->top_dict, |
FDSELECT_OP, buf, end_buf - buf); |
if (unlikely (status)) |
goto fail; |
status = cff_dict_set_operands (font->top_dict, |
FDARRAY_OP, buf, end_buf - buf); |
if (unlikely (status)) |
goto fail; |
status = cff_dict_set_operands (font->top_dict, |
CHARSET_OP, buf, end_buf - buf); |
if (unlikely (status)) |
goto fail; |
cff_dict_remove (font->top_dict, ENCODING_OP); |
cff_dict_remove (font->top_dict, PRIVATE_OP); |
/* Remove the unique identifier operators as the subsetted font is |
* not the same is the original font. */ |
cff_dict_remove (font->top_dict, UNIQUEID_OP); |
cff_dict_remove (font->top_dict, XUID_OP); |
fail: |
cff_index_fini (&index); |
return status; |
} |
static cairo_int_status_t |
cairo_cff_font_read_strings (cairo_cff_font_t *font) |
{ |
return cff_index_read (&font->strings_index, &font->current_ptr, font->data_end); |
} |
static cairo_int_status_t |
cairo_cff_font_read_global_subroutines (cairo_cff_font_t *font) |
{ |
return cff_index_read (&font->global_sub_index, &font->current_ptr, font->data_end); |
} |
typedef cairo_int_status_t |
(*font_read_t) (cairo_cff_font_t *font); |
static const font_read_t font_read_funcs[] = { |
cairo_cff_font_read_header, |
cairo_cff_font_read_name, |
cairo_cff_font_read_top_dict, |
cairo_cff_font_read_strings, |
cairo_cff_font_read_global_subroutines, |
}; |
static cairo_int_status_t |
cairo_cff_font_read_font (cairo_cff_font_t *font) |
{ |
cairo_int_status_t status; |
unsigned int i; |
for (i = 0; i < ARRAY_LENGTH (font_read_funcs); i++) { |
status = font_read_funcs[i] (font); |
if (unlikely (status)) |
return status; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_set_ros_strings (cairo_cff_font_t *font) |
{ |
cairo_status_t status; |
unsigned char buf[30]; |
unsigned char *p; |
int sid1, sid2; |
const char *registry = "Adobe"; |
const char *ordering = "Identity"; |
sid1 = NUM_STD_STRINGS + _cairo_array_num_elements (&font->strings_subset_index); |
status = cff_index_append_copy (&font->strings_subset_index, |
(unsigned char *)registry, |
strlen(registry)); |
if (unlikely (status)) |
return status; |
sid2 = NUM_STD_STRINGS + _cairo_array_num_elements (&font->strings_subset_index); |
status = cff_index_append_copy (&font->strings_subset_index, |
(unsigned char *)ordering, |
strlen(ordering)); |
if (unlikely (status)) |
return status; |
p = encode_integer (buf, sid1); |
p = encode_integer (p, sid2); |
p = encode_integer (p, 0); |
status = cff_dict_set_operands (font->top_dict, ROS_OP, buf, p - buf); |
if (unlikely (status)) |
return status; |
p = encode_integer (buf, font->scaled_font_subset->num_glyphs); |
status = cff_dict_set_operands (font->top_dict, CIDCOUNT_OP, buf, p - buf); |
if (unlikely (status)) |
return status; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_subset_dict_string(cairo_cff_font_t *font, |
cairo_hash_table_t *dict, |
int operator) |
{ |
int size; |
unsigned char *p; |
int sid; |
unsigned char buf[100]; |
cff_index_element_t *element; |
cairo_status_t status; |
p = cff_dict_get_operands (dict, operator, &size); |
if (!p) |
return CAIRO_STATUS_SUCCESS; |
decode_integer (p, &sid); |
if (sid < NUM_STD_STRINGS) |
return CAIRO_STATUS_SUCCESS; |
element = _cairo_array_index (&font->strings_index, sid - NUM_STD_STRINGS); |
sid = NUM_STD_STRINGS + _cairo_array_num_elements (&font->strings_subset_index); |
status = cff_index_append (&font->strings_subset_index, element->data, element->length); |
if (unlikely (status)) |
return status; |
p = encode_integer (buf, sid); |
status = cff_dict_set_operands (dict, operator, buf, p - buf); |
if (unlikely (status)) |
return status; |
return CAIRO_STATUS_SUCCESS; |
} |
static const int dict_strings[] = { |
VERSION_OP, |
NOTICE_OP, |
COPYRIGHT_OP, |
FULLNAME_OP, |
FAMILYNAME_OP, |
WEIGHT_OP, |
POSTSCRIPT_OP, |
BASEFONTNAME_OP, |
FONTNAME_OP, |
}; |
static cairo_status_t |
cairo_cff_font_subset_dict_strings (cairo_cff_font_t *font, |
cairo_hash_table_t *dict) |
{ |
cairo_status_t status; |
unsigned int i; |
for (i = 0; i < ARRAY_LENGTH (dict_strings); i++) { |
status = cairo_cff_font_subset_dict_string (font, dict, dict_strings[i]); |
if (unlikely (status)) |
return status; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_subset_charstrings (cairo_cff_font_t *font) |
{ |
cff_index_element_t *element; |
unsigned int i; |
cairo_status_t status; |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) { |
element = _cairo_array_index (&font->charstrings_index, |
font->scaled_font_subset->glyphs[i]); |
status = cff_index_append (&font->charstrings_subset_index, |
element->data, |
element->length); |
if (unlikely (status)) |
return status; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_subset_fontdict (cairo_cff_font_t *font) |
{ |
unsigned int i; |
int fd; |
int *reverse_map; |
font->fdselect_subset = calloc (font->scaled_font_subset->num_glyphs, |
sizeof (int)); |
if (unlikely (font->fdselect_subset == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
font->fd_subset_map = calloc (font->num_fontdicts, sizeof (int)); |
if (unlikely (font->fd_subset_map == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
font->private_dict_offset = calloc (font->num_fontdicts, sizeof (int)); |
if (unlikely (font->private_dict_offset == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
reverse_map = calloc (font->num_fontdicts, sizeof (int)); |
if (unlikely (reverse_map == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
for (i = 0; i < font->num_fontdicts; i++) |
reverse_map[i] = -1; |
font->num_subset_fontdicts = 0; |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) { |
fd = font->fdselect[font->scaled_font_subset->glyphs[i]]; |
if (reverse_map[fd] < 0) { |
font->fd_subset_map[font->num_subset_fontdicts] = fd; |
reverse_map[fd] = font->num_subset_fontdicts++; |
} |
font->fdselect_subset[i] = reverse_map[fd]; |
} |
free (reverse_map); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_create_cid_fontdict (cairo_cff_font_t *font) |
{ |
unsigned char buf[100]; |
unsigned char *end_buf; |
cairo_status_t status; |
font->num_fontdicts = 1; |
font->fd_dict = malloc (sizeof (cairo_hash_table_t *)); |
if (unlikely (font->fd_dict == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
if (cff_dict_init (&font->fd_dict[0])) { |
free (font->fd_dict); |
font->fd_dict = NULL; |
font->num_fontdicts = 0; |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
} |
font->fd_subset_map = malloc (sizeof (int)); |
if (unlikely (font->fd_subset_map == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
font->private_dict_offset = malloc (sizeof (int)); |
if (unlikely (font->private_dict_offset == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
font->fd_subset_map[0] = 0; |
font->num_subset_fontdicts = 1; |
/* Set integer operand to max value to use max size encoding to reserve |
* space for any value later */ |
end_buf = encode_integer_max (buf, 0); |
end_buf = encode_integer_max (end_buf, 0); |
status = cff_dict_set_operands (font->fd_dict[0], PRIVATE_OP, buf, end_buf - buf); |
if (unlikely (status)) |
return status; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_subset_strings (cairo_cff_font_t *font) |
{ |
cairo_status_t status; |
unsigned int i; |
status = cairo_cff_font_subset_dict_strings (font, font->top_dict); |
if (unlikely (status)) |
return status; |
if (font->is_cid) { |
for (i = 0; i < font->num_subset_fontdicts; i++) { |
status = cairo_cff_font_subset_dict_strings (font, font->fd_dict[font->fd_subset_map[i]]); |
if (unlikely (status)) |
return status; |
status = cairo_cff_font_subset_dict_strings (font, font->fd_private_dict[font->fd_subset_map[i]]); |
if (unlikely (status)) |
return status; |
} |
} else { |
status = cairo_cff_font_subset_dict_strings (font, font->private_dict); |
} |
return status; |
} |
static cairo_status_t |
cairo_cff_font_subset_font (cairo_cff_font_t *font) |
{ |
cairo_status_t status; |
status = cairo_cff_font_set_ros_strings (font); |
if (unlikely (status)) |
return status; |
status = cairo_cff_font_subset_charstrings (font); |
if (unlikely (status)) |
return status; |
if (font->is_cid) |
status = cairo_cff_font_subset_fontdict (font); |
else |
status = cairo_cff_font_create_cid_fontdict (font); |
if (unlikely (status)) |
return status; |
status = cairo_cff_font_subset_strings (font); |
if (unlikely (status)) |
return status; |
return status; |
} |
/* Set the operand of the specified operator in the (already written) |
* top dict to point to the current position in the output |
* array. Operands updated with this function must have previously |
* been encoded with the 5-byte (max) integer encoding. */ |
static void |
cairo_cff_font_set_topdict_operator_to_cur_pos (cairo_cff_font_t *font, |
int operator) |
{ |
int cur_pos; |
int offset; |
int size; |
unsigned char buf[10]; |
unsigned char *buf_end; |
unsigned char *op_ptr; |
cur_pos = _cairo_array_num_elements (&font->output); |
buf_end = encode_integer_max (buf, cur_pos); |
offset = cff_dict_get_location (font->top_dict, operator, &size); |
assert (offset > 0); |
op_ptr = _cairo_array_index (&font->output, offset); |
memcpy (op_ptr, buf, buf_end - buf); |
} |
static cairo_status_t |
cairo_cff_font_write_header (cairo_cff_font_t *font) |
{ |
return _cairo_array_append_multiple (&font->output, |
font->header, |
font->header->header_size); |
} |
static cairo_status_t |
cairo_cff_font_write_name (cairo_cff_font_t *font) |
{ |
cairo_status_t status = CAIRO_STATUS_SUCCESS; |
cairo_array_t index; |
cff_index_init (&index); |
status = cff_index_append_copy (&index, |
(unsigned char *) font->subset_font_name, |
strlen(font->subset_font_name)); |
if (unlikely (status)) |
goto FAIL; |
status = cff_index_write (&index, &font->output); |
if (unlikely (status)) |
goto FAIL; |
FAIL: |
cff_index_fini (&index); |
return status; |
} |
static cairo_status_t |
cairo_cff_font_write_top_dict (cairo_cff_font_t *font) |
{ |
uint16_t count; |
unsigned char buf[10]; |
unsigned char *p; |
int offset_index; |
int dict_start, dict_size; |
int offset_size = 4; |
cairo_status_t status; |
/* Write an index containing the top dict */ |
count = cpu_to_be16 (1); |
status = _cairo_array_append_multiple (&font->output, &count, 2); |
if (unlikely (status)) |
return status; |
buf[0] = offset_size; |
status = _cairo_array_append (&font->output, buf); |
if (unlikely (status)) |
return status; |
encode_index_offset (buf, offset_size, 1); |
status = _cairo_array_append_multiple (&font->output, buf, offset_size); |
if (unlikely (status)) |
return status; |
/* Reserve space for last element of offset array and update after |
* dict is written */ |
offset_index = _cairo_array_num_elements (&font->output); |
status = _cairo_array_append_multiple (&font->output, buf, offset_size); |
if (unlikely (status)) |
return status; |
dict_start = _cairo_array_num_elements (&font->output); |
status = cff_dict_write (font->top_dict, &font->output); |
if (unlikely (status)) |
return status; |
dict_size = _cairo_array_num_elements (&font->output) - dict_start; |
encode_index_offset (buf, offset_size, dict_size + 1); |
p = _cairo_array_index (&font->output, offset_index); |
memcpy (p, buf, offset_size); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_write_strings (cairo_cff_font_t *font) |
{ |
return cff_index_write (&font->strings_subset_index, &font->output); |
} |
static cairo_status_t |
cairo_cff_font_write_global_subrs (cairo_cff_font_t *font) |
{ |
return cff_index_write (&font->global_sub_index, &font->output); |
} |
static cairo_status_t |
cairo_cff_font_write_fdselect (cairo_cff_font_t *font) |
{ |
unsigned char data; |
unsigned int i; |
cairo_int_status_t status; |
cairo_cff_font_set_topdict_operator_to_cur_pos (font, FDSELECT_OP); |
if (font->is_cid) { |
data = 0; |
status = _cairo_array_append (&font->output, &data); |
if (unlikely (status)) |
return status; |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) { |
data = font->fdselect_subset[i]; |
status = _cairo_array_append (&font->output, &data); |
if (unlikely (status)) |
return status; |
} |
} else { |
unsigned char byte; |
uint16_t word; |
status = _cairo_array_grow_by (&font->output, 9); |
if (unlikely (status)) |
return status; |
byte = 3; |
status = _cairo_array_append (&font->output, &byte); |
assert (status == CAIRO_STATUS_SUCCESS); |
word = cpu_to_be16 (1); |
status = _cairo_array_append_multiple (&font->output, &word, 2); |
assert (status == CAIRO_STATUS_SUCCESS); |
word = cpu_to_be16 (0); |
status = _cairo_array_append_multiple (&font->output, &word, 2); |
assert (status == CAIRO_STATUS_SUCCESS); |
byte = 0; |
status = _cairo_array_append (&font->output, &byte); |
assert (status == CAIRO_STATUS_SUCCESS); |
word = cpu_to_be16 (font->scaled_font_subset->num_glyphs); |
status = _cairo_array_append_multiple (&font->output, &word, 2); |
assert (status == CAIRO_STATUS_SUCCESS); |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_write_charset (cairo_cff_font_t *font) |
{ |
unsigned char byte; |
uint16_t word; |
cairo_status_t status; |
cairo_cff_font_set_topdict_operator_to_cur_pos (font, CHARSET_OP); |
status = _cairo_array_grow_by (&font->output, 5); |
if (unlikely (status)) |
return status; |
byte = 2; |
status = _cairo_array_append (&font->output, &byte); |
assert (status == CAIRO_STATUS_SUCCESS); |
word = cpu_to_be16 (1); |
status = _cairo_array_append_multiple (&font->output, &word, 2); |
assert (status == CAIRO_STATUS_SUCCESS); |
word = cpu_to_be16 (font->scaled_font_subset->num_glyphs - 2); |
status = _cairo_array_append_multiple (&font->output, &word, 2); |
assert (status == CAIRO_STATUS_SUCCESS); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_write_charstrings (cairo_cff_font_t *font) |
{ |
cairo_cff_font_set_topdict_operator_to_cur_pos (font, CHARSTRINGS_OP); |
return cff_index_write (&font->charstrings_subset_index, &font->output); |
} |
static cairo_status_t |
cairo_cff_font_write_cid_fontdict (cairo_cff_font_t *font) |
{ |
unsigned int i; |
cairo_int_status_t status; |
uint32_t *offset_array; |
int offset_base; |
uint16_t count; |
uint8_t offset_size = 4; |
cairo_cff_font_set_topdict_operator_to_cur_pos (font, FDARRAY_OP); |
count = cpu_to_be16 (font->num_subset_fontdicts); |
status = _cairo_array_append_multiple (&font->output, &count, sizeof (uint16_t)); |
if (unlikely (status)) |
return status; |
status = _cairo_array_append (&font->output, &offset_size); |
if (unlikely (status)) |
return status; |
status = _cairo_array_allocate (&font->output, |
(font->num_subset_fontdicts + 1)*offset_size, |
(void **) &offset_array); |
if (unlikely (status)) |
return status; |
offset_base = _cairo_array_num_elements (&font->output) - 1; |
*offset_array++ = cpu_to_be32(1); |
for (i = 0; i < font->num_subset_fontdicts; i++) { |
status = cff_dict_write (font->fd_dict[font->fd_subset_map[i]], |
&font->output); |
if (unlikely (status)) |
return status; |
*offset_array++ = cpu_to_be32(_cairo_array_num_elements (&font->output) - offset_base); |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_write_private_dict (cairo_cff_font_t *font, |
int dict_num, |
cairo_hash_table_t *parent_dict, |
cairo_hash_table_t *private_dict) |
{ |
int offset; |
int size; |
unsigned char buf[10]; |
unsigned char *buf_end; |
unsigned char *p; |
cairo_status_t status; |
/* Write private dict and update offset and size in top dict */ |
font->private_dict_offset[dict_num] = _cairo_array_num_elements (&font->output); |
status = cff_dict_write (private_dict, &font->output); |
if (unlikely (status)) |
return status; |
size = _cairo_array_num_elements (&font->output) - font->private_dict_offset[dict_num]; |
/* private entry has two operands - size and offset */ |
buf_end = encode_integer_max (buf, size); |
buf_end = encode_integer_max (buf_end, font->private_dict_offset[dict_num]); |
offset = cff_dict_get_location (parent_dict, PRIVATE_OP, &size); |
assert (offset > 0); |
p = _cairo_array_index (&font->output, offset); |
memcpy (p, buf, buf_end - buf); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_write_local_sub (cairo_cff_font_t *font, |
int dict_num, |
cairo_hash_table_t *private_dict, |
cairo_array_t *local_sub_index) |
{ |
int offset; |
int size; |
unsigned char buf[10]; |
unsigned char *buf_end; |
unsigned char *p; |
cairo_status_t status; |
if (_cairo_array_num_elements (local_sub_index) > 0) { |
/* Write local subroutines and update offset in private |
* dict. Local subroutines offset is relative to start of |
* private dict */ |
offset = _cairo_array_num_elements (&font->output) - font->private_dict_offset[dict_num]; |
buf_end = encode_integer_max (buf, offset); |
offset = cff_dict_get_location (private_dict, LOCAL_SUB_OP, &size); |
assert (offset > 0); |
p = _cairo_array_index (&font->output, offset); |
memcpy (p, buf, buf_end - buf); |
status = cff_index_write (local_sub_index, &font->output); |
if (unlikely (status)) |
return status; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_cff_font_write_cid_private_dict_and_local_sub (cairo_cff_font_t *font) |
{ |
unsigned int i; |
cairo_int_status_t status; |
if (font->is_cid) { |
for (i = 0; i < font->num_subset_fontdicts; i++) { |
status = cairo_cff_font_write_private_dict ( |
font, |
i, |
font->fd_dict[font->fd_subset_map[i]], |
font->fd_private_dict[font->fd_subset_map[i]]); |
if (unlikely (status)) |
return status; |
} |
for (i = 0; i < font->num_subset_fontdicts; i++) { |
status = cairo_cff_font_write_local_sub ( |
font, |
i, |
font->fd_private_dict[font->fd_subset_map[i]], |
&font->fd_local_sub_index[font->fd_subset_map[i]]); |
if (unlikely (status)) |
return status; |
} |
} else { |
status = cairo_cff_font_write_private_dict (font, |
0, |
font->fd_dict[0], |
font->private_dict); |
if (unlikely (status)) |
return status; |
status = cairo_cff_font_write_local_sub (font, |
0, |
font->private_dict, |
&font->local_sub_index); |
if (unlikely (status)) |
return status; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
typedef cairo_status_t |
(*font_write_t) (cairo_cff_font_t *font); |
static const font_write_t font_write_funcs[] = { |
cairo_cff_font_write_header, |
cairo_cff_font_write_name, |
cairo_cff_font_write_top_dict, |
cairo_cff_font_write_strings, |
cairo_cff_font_write_global_subrs, |
cairo_cff_font_write_charset, |
cairo_cff_font_write_fdselect, |
cairo_cff_font_write_charstrings, |
cairo_cff_font_write_cid_fontdict, |
cairo_cff_font_write_cid_private_dict_and_local_sub, |
}; |
static cairo_status_t |
cairo_cff_font_write_subset (cairo_cff_font_t *font) |
{ |
cairo_int_status_t status; |
unsigned int i; |
for (i = 0; i < ARRAY_LENGTH (font_write_funcs); i++) { |
status = font_write_funcs[i] (font); |
if (unlikely (status)) |
return status; |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
cairo_cff_font_generate (cairo_cff_font_t *font, |
const char **data, |
unsigned long *length) |
{ |
cairo_int_status_t status; |
status = cairo_cff_font_read_font (font); |
if (unlikely (status)) |
return status; |
status = cairo_cff_font_subset_font (font); |
if (unlikely (status)) |
return status; |
status = cairo_cff_font_write_subset (font); |
if (unlikely (status)) |
return status; |
*data = _cairo_array_index (&font->output, 0); |
*length = _cairo_array_num_elements (&font->output); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
cairo_cff_font_create_set_widths (cairo_cff_font_t *font) |
{ |
unsigned long size; |
unsigned long long_entry_size; |
unsigned long short_entry_size; |
unsigned int i; |
tt_hhea_t hhea; |
int num_hmetrics; |
unsigned char buf[10]; |
int glyph_index; |
cairo_int_status_t status; |
size = sizeof (tt_hhea_t); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hhea, 0, |
(unsigned char*) &hhea, &size); |
if (unlikely (status)) |
return status; |
num_hmetrics = be16_to_cpu (hhea.num_hmetrics); |
for (i = 1; i < font->scaled_font_subset->num_glyphs; i++) { |
glyph_index = font->scaled_font_subset->glyphs[i]; |
long_entry_size = 2 * sizeof (int16_t); |
short_entry_size = sizeof (int16_t); |
if (glyph_index < num_hmetrics) { |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hmtx, |
glyph_index * long_entry_size, |
buf, &short_entry_size); |
if (unlikely (status)) |
return status; |
} |
else |
{ |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hmtx, |
(num_hmetrics - 1) * long_entry_size, |
buf, &short_entry_size); |
if (unlikely (status)) |
return status; |
} |
font->widths[i] = be16_to_cpu (*((int16_t*)buf)); |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
_cairo_cff_font_create (cairo_scaled_font_subset_t *scaled_font_subset, |
cairo_cff_font_t **font_return, |
const char *subset_name) |
{ |
const cairo_scaled_font_backend_t *backend; |
cairo_status_t status; |
cairo_cff_font_t *font; |
tt_head_t head; |
tt_hhea_t hhea; |
unsigned long size, data_length; |
backend = scaled_font_subset->scaled_font->backend; |
if (!backend->load_truetype_table) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
data_length = 0; |
status = backend->load_truetype_table( scaled_font_subset->scaled_font, |
TT_TAG_CFF, 0, NULL, &data_length); |
if (unlikely (status)) |
return status; |
size = sizeof (tt_head_t); |
status = backend->load_truetype_table (scaled_font_subset->scaled_font, |
TT_TAG_head, 0, |
(unsigned char *) &head, &size); |
if (unlikely (status)) |
return status; |
size = sizeof (tt_hhea_t); |
status = backend->load_truetype_table (scaled_font_subset->scaled_font, |
TT_TAG_hhea, 0, |
(unsigned char *) &hhea, &size); |
if (unlikely (status)) |
return status; |
size = 0; |
status = backend->load_truetype_table (scaled_font_subset->scaled_font, |
TT_TAG_hmtx, 0, NULL, &size); |
if (unlikely (status)) |
return status; |
font = malloc (sizeof (cairo_cff_font_t)); |
if (unlikely (font == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
font->backend = backend; |
font->scaled_font_subset = scaled_font_subset; |
_cairo_array_init (&font->output, sizeof (char)); |
status = _cairo_array_grow_by (&font->output, 4096); |
if (unlikely (status)) |
goto fail2; |
font->subset_font_name = strdup (subset_name); |
if (unlikely (font->subset_font_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail2; |
} |
font->x_min = (int16_t) be16_to_cpu (head.x_min); |
font->y_min = (int16_t) be16_to_cpu (head.y_min); |
font->x_max = (int16_t) be16_to_cpu (head.x_max); |
font->y_max = (int16_t) be16_to_cpu (head.y_max); |
font->ascent = (int16_t) be16_to_cpu (hhea.ascender); |
font->descent = (int16_t) be16_to_cpu (hhea.descender); |
font->units_per_em = (int16_t) be16_to_cpu (head.units_per_em); |
if (font->units_per_em == 0) |
font->units_per_em = 1000; |
font->font_name = NULL; |
status = _cairo_truetype_read_font_name (scaled_font_subset->scaled_font, |
&font->ps_name, |
&font->font_name); |
if (_cairo_status_is_error (status)) |
goto fail3; |
/* If the PS name is not found, create a CairoFont-x-y name. */ |
if (font->ps_name == NULL) { |
font->ps_name = malloc (30); |
if (unlikely (font->ps_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail3; |
} |
snprintf(font->ps_name, 30, "CairoFont-%u-%u", |
scaled_font_subset->font_id, |
scaled_font_subset->subset_id); |
} |
font->widths = calloc (font->scaled_font_subset->num_glyphs, sizeof (int)); |
if (unlikely (font->widths == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail4; |
} |
status = cairo_cff_font_create_set_widths (font); |
if (unlikely (status)) |
goto fail5; |
font->data_length = data_length; |
font->data = malloc (data_length); |
if (unlikely (font->data == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail5; |
} |
status = font->backend->load_truetype_table ( font->scaled_font_subset->scaled_font, |
TT_TAG_CFF, 0, font->data, |
&font->data_length); |
if (unlikely (status)) |
goto fail6; |
font->data_end = font->data + font->data_length; |
status = cff_dict_init (&font->top_dict); |
if (unlikely (status)) |
goto fail6; |
status = cff_dict_init (&font->private_dict); |
if (unlikely (status)) |
goto fail7; |
cff_index_init (&font->strings_index); |
cff_index_init (&font->charstrings_index); |
cff_index_init (&font->global_sub_index); |
cff_index_init (&font->local_sub_index); |
cff_index_init (&font->charstrings_subset_index); |
cff_index_init (&font->strings_subset_index); |
font->fdselect = NULL; |
font->fd_dict = NULL; |
font->fd_private_dict = NULL; |
font->fd_local_sub_index = NULL; |
font->fdselect_subset = NULL; |
font->fd_subset_map = NULL; |
font->private_dict_offset = NULL; |
*font_return = font; |
return CAIRO_STATUS_SUCCESS; |
fail7: |
_cairo_hash_table_destroy (font->top_dict); |
fail6: |
free (font->data); |
fail5: |
free (font->widths); |
fail4: |
if (font->font_name) |
free (font->font_name); |
fail3: |
free (font->subset_font_name); |
fail2: |
_cairo_array_fini (&font->output); |
free (font); |
return status; |
} |
static void |
cairo_cff_font_destroy (cairo_cff_font_t *font) |
{ |
unsigned int i; |
free (font->widths); |
if (font->font_name) |
free (font->font_name); |
free (font->ps_name); |
free (font->subset_font_name); |
_cairo_array_fini (&font->output); |
cff_dict_fini (font->top_dict); |
cff_dict_fini (font->private_dict); |
cff_index_fini (&font->strings_index); |
cff_index_fini (&font->charstrings_index); |
cff_index_fini (&font->global_sub_index); |
cff_index_fini (&font->local_sub_index); |
cff_index_fini (&font->charstrings_subset_index); |
cff_index_fini (&font->strings_subset_index); |
/* If we bailed out early as a result of an error some of the |
* following cairo_cff_font_t members may still be NULL */ |
if (font->fd_dict) { |
for (i = 0; i < font->num_fontdicts; i++) { |
if (font->fd_dict[i]) |
cff_dict_fini (font->fd_dict[i]); |
} |
free (font->fd_dict); |
} |
if (font->fd_subset_map) |
free (font->fd_subset_map); |
if (font->private_dict_offset) |
free (font->private_dict_offset); |
if (font->is_cid) { |
if (font->fdselect) |
free (font->fdselect); |
if (font->fdselect_subset) |
free (font->fdselect_subset); |
if (font->fd_private_dict) { |
for (i = 0; i < font->num_fontdicts; i++) { |
if (font->fd_private_dict[i]) |
cff_dict_fini (font->fd_private_dict[i]); |
} |
free (font->fd_private_dict); |
} |
if (font->fd_local_sub_index) { |
for (i = 0; i < font->num_fontdicts; i++) |
cff_index_fini (&font->fd_local_sub_index[i]); |
free (font->fd_local_sub_index); |
} |
} |
if (font->data) |
free (font->data); |
free (font); |
} |
cairo_status_t |
_cairo_cff_subset_init (cairo_cff_subset_t *cff_subset, |
const char *subset_name, |
cairo_scaled_font_subset_t *font_subset) |
{ |
cairo_cff_font_t *font = NULL; /* squelch bogus compiler warning */ |
cairo_status_t status; |
const char *data = NULL; /* squelch bogus compiler warning */ |
unsigned long length = 0; /* squelch bogus compiler warning */ |
unsigned int i; |
status = _cairo_cff_font_create (font_subset, &font, subset_name); |
if (unlikely (status)) |
return status; |
status = cairo_cff_font_generate (font, &data, &length); |
if (unlikely (status)) |
goto fail1; |
cff_subset->ps_name = strdup (font->ps_name); |
if (unlikely (cff_subset->ps_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail1; |
} |
if (font->font_name) { |
cff_subset->font_name = strdup (font->font_name); |
if (cff_subset->font_name == NULL) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail2; |
} |
} else { |
cff_subset->font_name = NULL; |
} |
cff_subset->widths = calloc (sizeof (double), font->scaled_font_subset->num_glyphs); |
if (unlikely (cff_subset->widths == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail3; |
} |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) |
cff_subset->widths[i] = (double)font->widths[i]/font->units_per_em; |
cff_subset->x_min = (double)font->x_min/font->units_per_em; |
cff_subset->y_min = (double)font->y_min/font->units_per_em; |
cff_subset->x_max = (double)font->x_max/font->units_per_em; |
cff_subset->y_max = (double)font->y_max/font->units_per_em; |
cff_subset->ascent = (double)font->ascent/font->units_per_em; |
cff_subset->descent = (double)font->descent/font->units_per_em; |
cff_subset->data = malloc (length); |
if (unlikely (cff_subset->data == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail4; |
} |
memcpy (cff_subset->data, data, length); |
cff_subset->data_length = length; |
cairo_cff_font_destroy (font); |
return CAIRO_STATUS_SUCCESS; |
fail4: |
free (cff_subset->widths); |
fail3: |
if (cff_subset->font_name) |
free (cff_subset->font_name); |
fail2: |
free (cff_subset->ps_name); |
fail1: |
cairo_cff_font_destroy (font); |
return status; |
} |
void |
_cairo_cff_subset_fini (cairo_cff_subset_t *subset) |
{ |
free (subset->ps_name); |
if (subset->font_name) |
free (subset->font_name); |
free (subset->widths); |
free (subset->data); |
} |
static cairo_int_status_t |
_cairo_cff_font_fallback_create (cairo_scaled_font_subset_t *scaled_font_subset, |
cairo_cff_font_t **font_return, |
const char *subset_name) |
{ |
cairo_status_t status; |
cairo_cff_font_t *font; |
font = malloc (sizeof (cairo_cff_font_t)); |
if (unlikely (font == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
font->backend = NULL; |
font->scaled_font_subset = scaled_font_subset; |
_cairo_array_init (&font->output, sizeof (char)); |
status = _cairo_array_grow_by (&font->output, 4096); |
if (unlikely (status)) |
goto fail1; |
font->subset_font_name = strdup (subset_name); |
if (unlikely (font->subset_font_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail1; |
} |
font->ps_name = strdup (subset_name); |
if (unlikely (font->ps_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail2; |
} |
font->font_name = NULL; |
font->x_min = 0; |
font->y_min = 0; |
font->x_max = 0; |
font->y_max = 0; |
font->ascent = 0; |
font->descent = 0; |
font->widths = calloc (font->scaled_font_subset->num_glyphs, sizeof (int)); |
if (unlikely (font->widths == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail3; |
} |
font->data_length = 0; |
font->data = NULL; |
font->data_end = NULL; |
status = cff_dict_init (&font->top_dict); |
if (unlikely (status)) |
goto fail4; |
status = cff_dict_init (&font->private_dict); |
if (unlikely (status)) |
goto fail5; |
cff_index_init (&font->strings_index); |
cff_index_init (&font->charstrings_index); |
cff_index_init (&font->global_sub_index); |
cff_index_init (&font->local_sub_index); |
cff_index_init (&font->charstrings_subset_index); |
cff_index_init (&font->strings_subset_index); |
font->fdselect = NULL; |
font->fd_dict = NULL; |
font->fd_private_dict = NULL; |
font->fd_local_sub_index = NULL; |
font->fdselect_subset = NULL; |
font->fd_subset_map = NULL; |
font->private_dict_offset = NULL; |
*font_return = font; |
return CAIRO_STATUS_SUCCESS; |
fail5: |
_cairo_hash_table_destroy (font->top_dict); |
fail4: |
free (font->widths); |
fail3: |
if (font->font_name) |
free (font->font_name); |
free (font->ps_name); |
fail2: |
free (font->subset_font_name); |
fail1: |
_cairo_array_fini (&font->output); |
free (font); |
return status; |
} |
static cairo_int_status_t |
cairo_cff_font_fallback_generate (cairo_cff_font_t *font, |
cairo_type2_charstrings_t *type2_subset, |
const char **data, |
unsigned long *length) |
{ |
cairo_int_status_t status; |
cff_header_t header; |
cairo_array_t *charstring; |
unsigned char buf[40]; |
unsigned char *end_buf; |
unsigned int i; |
/* Create header */ |
header.major = 1; |
header.minor = 0; |
header.header_size = 4; |
header.offset_size = 4; |
font->header = &header; |
/* Create Top Dict */ |
font->is_cid = FALSE; |
end_buf = encode_integer (buf, type2_subset->x_min); |
end_buf = encode_integer (end_buf, type2_subset->y_min); |
end_buf = encode_integer (end_buf, type2_subset->x_max); |
end_buf = encode_integer (end_buf, type2_subset->y_max); |
status = cff_dict_set_operands (font->top_dict, |
FONTBBOX_OP, buf, end_buf - buf); |
if (unlikely (status)) |
return status; |
end_buf = encode_integer_max (buf, 0); |
status = cff_dict_set_operands (font->top_dict, |
CHARSTRINGS_OP, buf, end_buf - buf); |
if (unlikely (status)) |
return status; |
status = cff_dict_set_operands (font->top_dict, |
FDSELECT_OP, buf, end_buf - buf); |
if (unlikely (status)) |
return status; |
status = cff_dict_set_operands (font->top_dict, |
FDARRAY_OP, buf, end_buf - buf); |
if (unlikely (status)) |
return status; |
status = cff_dict_set_operands (font->top_dict, |
CHARSET_OP, buf, end_buf - buf); |
if (unlikely (status)) |
return status; |
status = cairo_cff_font_set_ros_strings (font); |
if (unlikely (status)) |
return status; |
/* Create CID FD dictionary */ |
status = cairo_cff_font_create_cid_fontdict (font); |
if (unlikely (status)) |
return status; |
/* Create charstrings */ |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) { |
charstring = _cairo_array_index(&type2_subset->charstrings, i); |
status = cff_index_append (&font->charstrings_subset_index, |
_cairo_array_index (charstring, 0), |
_cairo_array_num_elements (charstring)); |
if (unlikely (status)) |
return status; |
} |
status = cairo_cff_font_write_subset (font); |
if (unlikely (status)) |
return status; |
*data = _cairo_array_index (&font->output, 0); |
*length = _cairo_array_num_elements (&font->output); |
return CAIRO_STATUS_SUCCESS; |
} |
cairo_status_t |
_cairo_cff_fallback_init (cairo_cff_subset_t *cff_subset, |
const char *subset_name, |
cairo_scaled_font_subset_t *font_subset) |
{ |
cairo_cff_font_t *font = NULL; /* squelch bogus compiler warning */ |
cairo_status_t status; |
const char *data = NULL; /* squelch bogus compiler warning */ |
unsigned long length = 0; /* squelch bogus compiler warning */ |
unsigned int i; |
cairo_type2_charstrings_t type2_subset; |
status = _cairo_cff_font_fallback_create (font_subset, &font, subset_name); |
if (unlikely (status)) |
return status; |
status = _cairo_type2_charstrings_init (&type2_subset, font_subset); |
if (unlikely (status)) |
goto fail1; |
status = cairo_cff_font_fallback_generate (font, &type2_subset, &data, &length); |
if (unlikely (status)) |
goto fail2; |
cff_subset->font_name = NULL; |
cff_subset->ps_name = strdup (font->ps_name); |
if (unlikely (cff_subset->ps_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail2; |
} |
cff_subset->widths = calloc (sizeof (double), font->scaled_font_subset->num_glyphs); |
if (unlikely (cff_subset->widths == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail3; |
} |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) |
cff_subset->widths[i] = (double)type2_subset.widths[i]/1000; |
cff_subset->x_min = (double)type2_subset.x_min/1000; |
cff_subset->y_min = (double)type2_subset.y_min/1000; |
cff_subset->x_max = (double)type2_subset.x_max/1000; |
cff_subset->y_max = (double)type2_subset.y_max/1000; |
cff_subset->ascent = (double)type2_subset.y_max/1000; |
cff_subset->descent = (double)type2_subset.y_min/1000; |
cff_subset->data = malloc (length); |
if (unlikely (cff_subset->data == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail4; |
} |
memcpy (cff_subset->data, data, length); |
cff_subset->data_length = length; |
cff_subset->data_length = length; |
_cairo_type2_charstrings_fini (&type2_subset); |
cairo_cff_font_destroy (font); |
return CAIRO_STATUS_SUCCESS; |
fail4: |
free (cff_subset->widths); |
fail3: |
free (cff_subset->ps_name); |
fail2: |
_cairo_type2_charstrings_fini (&type2_subset); |
fail1: |
cairo_cff_font_destroy (font); |
return status; |
} |
void |
_cairo_cff_fallback_fini (cairo_cff_subset_t *subset) |
{ |
free (subset->ps_name); |
free (subset->widths); |
free (subset->data); |
} |
#endif /* CAIRO_HAS_FONT_SUBSET */ |
/programs/develop/libraries/cairo/src/cairo-pdf-operators.c |
---|
0,0 → 1,1475 |
/* -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2004 Red Hat, Inc |
* Copyright © 2006 Red Hat, Inc |
* Copyright © 2007, 2008 Adrian Johnson |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is University of Southern |
* California. |
* |
* Contributor(s): |
* Kristian Høgsberg <krh@redhat.com> |
* Carl Worth <cworth@cworth.org> |
* Adrian Johnson <ajohnson@redneon.com> |
*/ |
#include "cairoint.h" |
#if CAIRO_HAS_PDF_OPERATORS |
#include "cairo-error-private.h" |
#include "cairo-pdf-operators-private.h" |
#include "cairo-path-fixed-private.h" |
#include "cairo-output-stream-private.h" |
#include "cairo-scaled-font-subsets-private.h" |
static cairo_status_t |
_cairo_pdf_operators_end_text (cairo_pdf_operators_t *pdf_operators); |
void |
_cairo_pdf_operators_init (cairo_pdf_operators_t *pdf_operators, |
cairo_output_stream_t *stream, |
cairo_matrix_t *cairo_to_pdf, |
cairo_scaled_font_subsets_t *font_subsets) |
{ |
pdf_operators->stream = stream; |
pdf_operators->cairo_to_pdf = *cairo_to_pdf; |
pdf_operators->font_subsets = font_subsets; |
pdf_operators->use_font_subset = NULL; |
pdf_operators->use_font_subset_closure = NULL; |
pdf_operators->in_text_object = FALSE; |
pdf_operators->num_glyphs = 0; |
pdf_operators->has_line_style = FALSE; |
pdf_operators->use_actual_text = FALSE; |
} |
cairo_status_t |
_cairo_pdf_operators_fini (cairo_pdf_operators_t *pdf_operators) |
{ |
return _cairo_pdf_operators_flush (pdf_operators); |
} |
void |
_cairo_pdf_operators_set_font_subsets_callback (cairo_pdf_operators_t *pdf_operators, |
cairo_pdf_operators_use_font_subset_t use_font_subset, |
void *closure) |
{ |
pdf_operators->use_font_subset = use_font_subset; |
pdf_operators->use_font_subset_closure = closure; |
} |
/* Change the output stream to a different stream. |
* _cairo_pdf_operators_flush() should always be called before calling |
* this function. |
*/ |
void |
_cairo_pdf_operators_set_stream (cairo_pdf_operators_t *pdf_operators, |
cairo_output_stream_t *stream) |
{ |
pdf_operators->stream = stream; |
pdf_operators->has_line_style = FALSE; |
} |
void |
_cairo_pdf_operators_set_cairo_to_pdf_matrix (cairo_pdf_operators_t *pdf_operators, |
cairo_matrix_t *cairo_to_pdf) |
{ |
pdf_operators->cairo_to_pdf = *cairo_to_pdf; |
pdf_operators->has_line_style = FALSE; |
} |
cairo_private void |
_cairo_pdf_operators_enable_actual_text (cairo_pdf_operators_t *pdf_operators, |
cairo_bool_t enable) |
{ |
pdf_operators->use_actual_text = enable; |
} |
/* Finish writing out any pending commands to the stream. This |
* function must be called by the surface before emitting anything |
* into the PDF stream. |
* |
* pdf_operators may leave the emitted PDF for some operations |
* unfinished in case subsequent operations can be merged. This |
* function will finish off any incomplete operation so the stream |
* will be in a state where the surface may emit its own PDF |
* operations (eg changing patterns). |
* |
*/ |
cairo_status_t |
_cairo_pdf_operators_flush (cairo_pdf_operators_t *pdf_operators) |
{ |
cairo_status_t status = CAIRO_STATUS_SUCCESS; |
if (pdf_operators->in_text_object) |
status = _cairo_pdf_operators_end_text (pdf_operators); |
return status; |
} |
/* Reset the known graphics state of the PDF consumer. ie no |
* assumptions will be made about the state. The next time a |
* particular graphics state is required (eg line width) the state |
* operator is always emitted and then remembered for subsequent |
* operatations. |
* |
* This should be called when starting a new stream or after emitting |
* the 'Q' operator (where pdf-operators functions were called inside |
* the q/Q pair). |
*/ |
void |
_cairo_pdf_operators_reset (cairo_pdf_operators_t *pdf_operators) |
{ |
pdf_operators->has_line_style = FALSE; |
} |
/* A word wrap stream can be used as a filter to do word wrapping on |
* top of an existing output stream. The word wrapping is quite |
* simple, using isspace to determine characters that separate |
* words. Any word that will cause the column count exceed the given |
* max_column will have a '\n' character emitted before it. |
* |
* The stream is careful to maintain integrity for words that cross |
* the boundary from one call to write to the next. |
* |
* Note: This stream does not guarantee that the output will never |
* exceed max_column. In particular, if a single word is larger than |
* max_column it will not be broken up. |
*/ |
typedef struct _word_wrap_stream { |
cairo_output_stream_t base; |
cairo_output_stream_t *output; |
int max_column; |
int column; |
cairo_bool_t last_write_was_space; |
cairo_bool_t in_hexstring; |
cairo_bool_t empty_hexstring; |
} word_wrap_stream_t; |
static int |
_count_word_up_to (const unsigned char *s, int length) |
{ |
int word = 0; |
while (length--) { |
if (! (_cairo_isspace (*s) || *s == '<')) { |
s++; |
word++; |
} else { |
return word; |
} |
} |
return word; |
} |
/* Count up to either the end of the ASCII hexstring or the number |
* of columns remaining. |
*/ |
static int |
_count_hexstring_up_to (const unsigned char *s, int length, int columns) |
{ |
int word = 0; |
while (length--) { |
if (*s++ != '>') |
word++; |
else |
return word; |
columns--; |
if (columns < 0 && word > 1) |
return word; |
} |
return word; |
} |
static cairo_status_t |
_word_wrap_stream_write (cairo_output_stream_t *base, |
const unsigned char *data, |
unsigned int length) |
{ |
word_wrap_stream_t *stream = (word_wrap_stream_t *) base; |
cairo_bool_t newline; |
int word; |
while (length) { |
if (*data == '<') { |
stream->in_hexstring = TRUE; |
stream->empty_hexstring = TRUE; |
stream->last_write_was_space = FALSE; |
data++; |
length--; |
_cairo_output_stream_printf (stream->output, "<"); |
stream->column++; |
} else if (*data == '>') { |
stream->in_hexstring = FALSE; |
stream->last_write_was_space = FALSE; |
data++; |
length--; |
_cairo_output_stream_printf (stream->output, ">"); |
stream->column++; |
} else if (_cairo_isspace (*data)) { |
newline = (*data == '\n' || *data == '\r'); |
if (! newline && stream->column >= stream->max_column) { |
_cairo_output_stream_printf (stream->output, "\n"); |
stream->column = 0; |
} |
_cairo_output_stream_write (stream->output, data, 1); |
data++; |
length--; |
if (newline) { |
stream->column = 0; |
} |
else |
stream->column++; |
stream->last_write_was_space = TRUE; |
} else { |
if (stream->in_hexstring) { |
word = _count_hexstring_up_to (data, length, |
MAX (stream->max_column - stream->column, 0)); |
} else { |
word = _count_word_up_to (data, length); |
} |
/* Don't wrap if this word is a continuation of a non hex |
* string word from a previous call to write. */ |
if (stream->column + word >= stream->max_column) { |
if (stream->last_write_was_space || |
(stream->in_hexstring && !stream->empty_hexstring)) |
{ |
_cairo_output_stream_printf (stream->output, "\n"); |
stream->column = 0; |
} |
} |
_cairo_output_stream_write (stream->output, data, word); |
data += word; |
length -= word; |
stream->column += word; |
stream->last_write_was_space = FALSE; |
if (stream->in_hexstring) |
stream->empty_hexstring = FALSE; |
} |
} |
return _cairo_output_stream_get_status (stream->output); |
} |
static cairo_status_t |
_word_wrap_stream_close (cairo_output_stream_t *base) |
{ |
word_wrap_stream_t *stream = (word_wrap_stream_t *) base; |
return _cairo_output_stream_get_status (stream->output); |
} |
static cairo_output_stream_t * |
_word_wrap_stream_create (cairo_output_stream_t *output, int max_column) |
{ |
word_wrap_stream_t *stream; |
if (output->status) |
return _cairo_output_stream_create_in_error (output->status); |
stream = malloc (sizeof (word_wrap_stream_t)); |
if (unlikely (stream == NULL)) { |
_cairo_error_throw (CAIRO_STATUS_NO_MEMORY); |
return (cairo_output_stream_t *) &_cairo_output_stream_nil; |
} |
_cairo_output_stream_init (&stream->base, |
_word_wrap_stream_write, |
NULL, |
_word_wrap_stream_close); |
stream->output = output; |
stream->max_column = max_column; |
stream->column = 0; |
stream->last_write_was_space = FALSE; |
stream->in_hexstring = FALSE; |
stream->empty_hexstring = TRUE; |
return &stream->base; |
} |
typedef struct _pdf_path_info { |
cairo_output_stream_t *output; |
cairo_matrix_t *path_transform; |
cairo_line_cap_t line_cap; |
cairo_point_t last_move_to_point; |
cairo_bool_t has_sub_path; |
} pdf_path_info_t; |
static cairo_status_t |
_cairo_pdf_path_move_to (void *closure, |
const cairo_point_t *point) |
{ |
pdf_path_info_t *info = closure; |
double x = _cairo_fixed_to_double (point->x); |
double y = _cairo_fixed_to_double (point->y); |
info->last_move_to_point = *point; |
info->has_sub_path = FALSE; |
cairo_matrix_transform_point (info->path_transform, &x, &y); |
_cairo_output_stream_printf (info->output, |
"%g %g m ", x, y); |
return _cairo_output_stream_get_status (info->output); |
} |
static cairo_status_t |
_cairo_pdf_path_line_to (void *closure, |
const cairo_point_t *point) |
{ |
pdf_path_info_t *info = closure; |
double x = _cairo_fixed_to_double (point->x); |
double y = _cairo_fixed_to_double (point->y); |
if (info->line_cap != CAIRO_LINE_CAP_ROUND && |
! info->has_sub_path && |
point->x == info->last_move_to_point.x && |
point->y == info->last_move_to_point.y) |
{ |
return CAIRO_STATUS_SUCCESS; |
} |
info->has_sub_path = TRUE; |
cairo_matrix_transform_point (info->path_transform, &x, &y); |
_cairo_output_stream_printf (info->output, |
"%g %g l ", x, y); |
return _cairo_output_stream_get_status (info->output); |
} |
static cairo_status_t |
_cairo_pdf_path_curve_to (void *closure, |
const cairo_point_t *b, |
const cairo_point_t *c, |
const cairo_point_t *d) |
{ |
pdf_path_info_t *info = closure; |
double bx = _cairo_fixed_to_double (b->x); |
double by = _cairo_fixed_to_double (b->y); |
double cx = _cairo_fixed_to_double (c->x); |
double cy = _cairo_fixed_to_double (c->y); |
double dx = _cairo_fixed_to_double (d->x); |
double dy = _cairo_fixed_to_double (d->y); |
info->has_sub_path = TRUE; |
cairo_matrix_transform_point (info->path_transform, &bx, &by); |
cairo_matrix_transform_point (info->path_transform, &cx, &cy); |
cairo_matrix_transform_point (info->path_transform, &dx, &dy); |
_cairo_output_stream_printf (info->output, |
"%g %g %g %g %g %g c ", |
bx, by, cx, cy, dx, dy); |
return _cairo_output_stream_get_status (info->output); |
} |
static cairo_status_t |
_cairo_pdf_path_close_path (void *closure) |
{ |
pdf_path_info_t *info = closure; |
if (info->line_cap != CAIRO_LINE_CAP_ROUND && |
! info->has_sub_path) |
{ |
return CAIRO_STATUS_SUCCESS; |
} |
_cairo_output_stream_printf (info->output, |
"h\n"); |
return _cairo_output_stream_get_status (info->output); |
} |
static cairo_status_t |
_cairo_pdf_path_rectangle (pdf_path_info_t *info, cairo_box_t *box) |
{ |
double x1 = _cairo_fixed_to_double (box->p1.x); |
double y1 = _cairo_fixed_to_double (box->p1.y); |
double x2 = _cairo_fixed_to_double (box->p2.x); |
double y2 = _cairo_fixed_to_double (box->p2.y); |
cairo_matrix_transform_point (info->path_transform, &x1, &y1); |
cairo_matrix_transform_point (info->path_transform, &x2, &y2); |
_cairo_output_stream_printf (info->output, |
"%g %g %g %g re ", |
x1, y1, x2 - x1, y2 - y1); |
return _cairo_output_stream_get_status (info->output); |
} |
/* The line cap value is needed to workaround the fact that PostScript |
* and PDF semantics for stroking degenerate sub-paths do not match |
* cairo semantics. (PostScript draws something for any line cap |
* value, while cairo draws something only for round caps). |
* |
* When using this function to emit a path to be filled, rather than |
* stroked, simply pass %CAIRO_LINE_CAP_ROUND which will guarantee that |
* the stroke workaround will not modify the path being emitted. |
*/ |
static cairo_status_t |
_cairo_pdf_operators_emit_path (cairo_pdf_operators_t *pdf_operators, |
cairo_path_fixed_t *path, |
cairo_matrix_t *path_transform, |
cairo_line_cap_t line_cap) |
{ |
cairo_output_stream_t *word_wrap; |
cairo_status_t status, status2; |
pdf_path_info_t info; |
cairo_box_t box; |
word_wrap = _word_wrap_stream_create (pdf_operators->stream, 72); |
status = _cairo_output_stream_get_status (word_wrap); |
if (unlikely (status)) |
return _cairo_output_stream_destroy (word_wrap); |
info.output = word_wrap; |
info.path_transform = path_transform; |
info.line_cap = line_cap; |
if (_cairo_path_fixed_is_rectangle (path, &box)) { |
status = _cairo_pdf_path_rectangle (&info, &box); |
} else { |
status = _cairo_path_fixed_interpret (path, |
CAIRO_DIRECTION_FORWARD, |
_cairo_pdf_path_move_to, |
_cairo_pdf_path_line_to, |
_cairo_pdf_path_curve_to, |
_cairo_pdf_path_close_path, |
&info); |
} |
status2 = _cairo_output_stream_destroy (word_wrap); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
return status; |
} |
cairo_int_status_t |
_cairo_pdf_operators_clip (cairo_pdf_operators_t *pdf_operators, |
cairo_path_fixed_t *path, |
cairo_fill_rule_t fill_rule) |
{ |
const char *pdf_operator; |
cairo_status_t status; |
if (pdf_operators->in_text_object) { |
status = _cairo_pdf_operators_end_text (pdf_operators); |
if (unlikely (status)) |
return status; |
} |
if (! path->has_current_point) { |
/* construct an empty path */ |
_cairo_output_stream_printf (pdf_operators->stream, "0 0 m "); |
} else { |
status = _cairo_pdf_operators_emit_path (pdf_operators, |
path, |
&pdf_operators->cairo_to_pdf, |
CAIRO_LINE_CAP_ROUND); |
if (unlikely (status)) |
return status; |
} |
switch (fill_rule) { |
default: |
ASSERT_NOT_REACHED; |
case CAIRO_FILL_RULE_WINDING: |
pdf_operator = "W"; |
break; |
case CAIRO_FILL_RULE_EVEN_ODD: |
pdf_operator = "W*"; |
break; |
} |
_cairo_output_stream_printf (pdf_operators->stream, |
"%s n\n", |
pdf_operator); |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
static int |
_cairo_pdf_line_cap (cairo_line_cap_t cap) |
{ |
switch (cap) { |
case CAIRO_LINE_CAP_BUTT: |
return 0; |
case CAIRO_LINE_CAP_ROUND: |
return 1; |
case CAIRO_LINE_CAP_SQUARE: |
return 2; |
default: |
ASSERT_NOT_REACHED; |
return 0; |
} |
} |
static int |
_cairo_pdf_line_join (cairo_line_join_t join) |
{ |
switch (join) { |
case CAIRO_LINE_JOIN_MITER: |
return 0; |
case CAIRO_LINE_JOIN_ROUND: |
return 1; |
case CAIRO_LINE_JOIN_BEVEL: |
return 2; |
default: |
ASSERT_NOT_REACHED; |
return 0; |
} |
} |
cairo_int_status_t |
_cairo_pdf_operators_emit_stroke_style (cairo_pdf_operators_t *pdf_operators, |
const cairo_stroke_style_t *style, |
double scale) |
{ |
double *dash = style->dash; |
int num_dashes = style->num_dashes; |
double dash_offset = style->dash_offset; |
double line_width = style->line_width * scale; |
/* PostScript has "special needs" when it comes to zero-length |
* dash segments with butt caps. It apparently (at least |
* according to ghostscript) draws hairlines for this |
* case. That's not what the cairo semantics want, so we first |
* touch up the array to eliminate any 0.0 values that will |
* result in "on" segments. |
*/ |
if (num_dashes && style->line_cap == CAIRO_LINE_CAP_BUTT) { |
int i; |
/* If there's an odd number of dash values they will each get |
* interpreted as both on and off. So we first explicitly |
* expand the array to remove the duplicate usage so that we |
* can modify some of the values. |
*/ |
if (num_dashes % 2) { |
dash = _cairo_malloc_abc (num_dashes, 2, sizeof (double)); |
if (unlikely (dash == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
memcpy (dash, style->dash, num_dashes * sizeof (double)); |
memcpy (dash + num_dashes, style->dash, num_dashes * sizeof (double)); |
num_dashes *= 2; |
} |
for (i = 0; i < num_dashes; i += 2) { |
if (dash[i] == 0.0) { |
/* Do not modify the dashes in-place, as we may need to also |
* replay this stroke to an image fallback. |
*/ |
if (dash == style->dash) { |
dash = _cairo_malloc_ab (num_dashes, sizeof (double)); |
if (unlikely (dash == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
memcpy (dash, style->dash, num_dashes * sizeof (double)); |
} |
/* If we're at the front of the list, we first rotate |
* two elements from the end of the list to the front |
* of the list before folding away the 0.0. Or, if |
* there are only two dash elements, then there is |
* nothing at all to draw. |
*/ |
if (i == 0) { |
double last_two[2]; |
if (num_dashes == 2) { |
free (dash); |
return CAIRO_INT_STATUS_NOTHING_TO_DO; |
} |
/* The cases of num_dashes == 0, 1, or 3 elements |
* cannot exist, so the rotation of 2 elements |
* will always be safe */ |
memcpy (last_two, dash + num_dashes - 2, sizeof (last_two)); |
memmove (dash + 2, dash, (num_dashes - 2) * sizeof (double)); |
memcpy (dash, last_two, sizeof (last_two)); |
dash_offset += dash[0] + dash[1]; |
i = 2; |
} |
dash[i-1] += dash[i+1]; |
num_dashes -= 2; |
memmove (dash + i, dash + i + 2, (num_dashes - i) * sizeof (double)); |
/* If we might have just rotated, it's possible that |
* we rotated a 0.0 value to the front of the list. |
* Set i to -2 so it will get incremented to 0. */ |
if (i == 2) |
i = -2; |
} |
} |
} |
if (!pdf_operators->has_line_style || pdf_operators->line_width != line_width) { |
_cairo_output_stream_printf (pdf_operators->stream, |
"%f w\n", |
line_width); |
pdf_operators->line_width = line_width; |
} |
if (!pdf_operators->has_line_style || pdf_operators->line_cap != style->line_cap) { |
_cairo_output_stream_printf (pdf_operators->stream, |
"%d J\n", |
_cairo_pdf_line_cap (style->line_cap)); |
pdf_operators->line_cap = style->line_cap; |
} |
if (!pdf_operators->has_line_style || pdf_operators->line_join != style->line_join) { |
_cairo_output_stream_printf (pdf_operators->stream, |
"%d j\n", |
_cairo_pdf_line_join (style->line_join)); |
pdf_operators->line_join = style->line_join; |
} |
if (num_dashes) { |
int d; |
_cairo_output_stream_printf (pdf_operators->stream, "["); |
for (d = 0; d < num_dashes; d++) |
_cairo_output_stream_printf (pdf_operators->stream, " %f", dash[d] * scale); |
_cairo_output_stream_printf (pdf_operators->stream, "] %f d\n", |
dash_offset * scale); |
pdf_operators->has_dashes = TRUE; |
} else if (!pdf_operators->has_line_style || pdf_operators->has_dashes) { |
_cairo_output_stream_printf (pdf_operators->stream, "[] 0.0 d\n"); |
pdf_operators->has_dashes = FALSE; |
} |
if (dash != style->dash) |
free (dash); |
if (!pdf_operators->has_line_style || pdf_operators->miter_limit != style->miter_limit) { |
_cairo_output_stream_printf (pdf_operators->stream, |
"%f M ", |
style->miter_limit < 1.0 ? 1.0 : style->miter_limit); |
pdf_operators->miter_limit = style->miter_limit; |
} |
pdf_operators->has_line_style = TRUE; |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
/* Scale the matrix so the largest absolute value of the non |
* translation components is 1.0. Return the scale required to restore |
* the matrix to the original values. |
* |
* eg the matrix [ 100 0 0 50 20 10 ] |
* |
* is rescaled to [ 1 0 0 0.5 0.2 0.1 ] |
* and the scale returned is 100 |
*/ |
static void |
_cairo_matrix_factor_out_scale (cairo_matrix_t *m, double *scale) |
{ |
double s; |
s = fabs (m->xx); |
if (fabs (m->xy) > s) |
s = fabs (m->xy); |
if (fabs (m->yx) > s) |
s = fabs (m->yx); |
if (fabs (m->yy) > s) |
s = fabs (m->yy); |
*scale = s; |
s = 1.0/s; |
cairo_matrix_scale (m, s, s); |
} |
static cairo_int_status_t |
_cairo_pdf_operators_emit_stroke (cairo_pdf_operators_t *pdf_operators, |
cairo_path_fixed_t *path, |
const cairo_stroke_style_t *style, |
const cairo_matrix_t *ctm, |
const cairo_matrix_t *ctm_inverse, |
const char *pdf_operator) |
{ |
cairo_status_t status; |
cairo_matrix_t m, path_transform; |
cairo_bool_t has_ctm = TRUE; |
double scale = 1.0; |
if (pdf_operators->in_text_object) { |
status = _cairo_pdf_operators_end_text (pdf_operators); |
if (unlikely (status)) |
return status; |
} |
/* Optimize away the stroke ctm when it does not affect the |
* stroke. There are other ctm cases that could be optimized |
* however this is the most common. |
*/ |
if (fabs(ctm->xx) == 1.0 && fabs(ctm->yy) == 1.0 && |
fabs(ctm->xy) == 0.0 && fabs(ctm->yx) == 0.0) |
{ |
has_ctm = FALSE; |
} |
/* The PDF CTM is transformed to the user space CTM when stroking |
* so the corect pen shape will be used. This also requires that |
* the path be transformed to user space when emitted. The |
* conversion of path coordinates to user space may cause rounding |
* errors. For example the device space point (1.234, 3.142) when |
* transformed to a user space CTM of [100 0 0 100 0 0] will be |
* emitted as (0.012, 0.031). |
* |
* To avoid the rounding problem we scale the user space CTM |
* matrix so that all the non translation components of the matrix |
* are <= 1. The line width and and dashes are scaled by the |
* inverse of the scale applied to the CTM. This maintains the |
* shape of the stroke pen while keeping the user space CTM within |
* the range that maximizes the precision of the emitted path. |
*/ |
if (has_ctm) { |
m = *ctm; |
/* Zero out the translation since it does not affect the pen |
* shape however it may cause unnecessary digits to be emitted. |
*/ |
m.x0 = 0.0; |
m.y0 = 0.0; |
_cairo_matrix_factor_out_scale (&m, &scale); |
path_transform = m; |
status = cairo_matrix_invert (&path_transform); |
if (unlikely (status)) |
return status; |
cairo_matrix_multiply (&m, &m, &pdf_operators->cairo_to_pdf); |
} |
status = _cairo_pdf_operators_emit_stroke_style (pdf_operators, style, scale); |
if (status == CAIRO_INT_STATUS_NOTHING_TO_DO) |
return CAIRO_STATUS_SUCCESS; |
if (unlikely (status)) |
return status; |
if (has_ctm) { |
_cairo_output_stream_printf (pdf_operators->stream, |
"q %f %f %f %f %f %f cm\n", |
m.xx, m.yx, m.xy, m.yy, |
m.x0, m.y0); |
} else { |
path_transform = pdf_operators->cairo_to_pdf; |
} |
status = _cairo_pdf_operators_emit_path (pdf_operators, |
path, |
&path_transform, |
style->line_cap); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (pdf_operators->stream, "%s", pdf_operator); |
if (has_ctm) |
_cairo_output_stream_printf (pdf_operators->stream, " Q"); |
_cairo_output_stream_printf (pdf_operators->stream, "\n"); |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
cairo_int_status_t |
_cairo_pdf_operators_stroke (cairo_pdf_operators_t *pdf_operators, |
cairo_path_fixed_t *path, |
const cairo_stroke_style_t *style, |
const cairo_matrix_t *ctm, |
const cairo_matrix_t *ctm_inverse) |
{ |
return _cairo_pdf_operators_emit_stroke (pdf_operators, |
path, |
style, |
ctm, |
ctm_inverse, |
"S"); |
} |
cairo_int_status_t |
_cairo_pdf_operators_fill (cairo_pdf_operators_t *pdf_operators, |
cairo_path_fixed_t *path, |
cairo_fill_rule_t fill_rule) |
{ |
const char *pdf_operator; |
cairo_status_t status; |
if (pdf_operators->in_text_object) { |
status = _cairo_pdf_operators_end_text (pdf_operators); |
if (unlikely (status)) |
return status; |
} |
status = _cairo_pdf_operators_emit_path (pdf_operators, |
path, |
&pdf_operators->cairo_to_pdf, |
CAIRO_LINE_CAP_ROUND); |
if (unlikely (status)) |
return status; |
switch (fill_rule) { |
default: |
ASSERT_NOT_REACHED; |
case CAIRO_FILL_RULE_WINDING: |
pdf_operator = "f"; |
break; |
case CAIRO_FILL_RULE_EVEN_ODD: |
pdf_operator = "f*"; |
break; |
} |
_cairo_output_stream_printf (pdf_operators->stream, |
"%s\n", |
pdf_operator); |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
cairo_int_status_t |
_cairo_pdf_operators_fill_stroke (cairo_pdf_operators_t *pdf_operators, |
cairo_path_fixed_t *path, |
cairo_fill_rule_t fill_rule, |
const cairo_stroke_style_t *style, |
const cairo_matrix_t *ctm, |
const cairo_matrix_t *ctm_inverse) |
{ |
const char *operator; |
switch (fill_rule) { |
default: |
ASSERT_NOT_REACHED; |
case CAIRO_FILL_RULE_WINDING: |
operator = "B"; |
break; |
case CAIRO_FILL_RULE_EVEN_ODD: |
operator = "B*"; |
break; |
} |
return _cairo_pdf_operators_emit_stroke (pdf_operators, |
path, |
style, |
ctm, |
ctm_inverse, |
operator); |
} |
#define GLYPH_POSITION_TOLERANCE 0.001 |
/* Emit the string of glyphs using the 'Tj' operator. This requires |
* that the glyphs are positioned at their natural glyph advances. */ |
static cairo_status_t |
_cairo_pdf_operators_emit_glyph_string (cairo_pdf_operators_t *pdf_operators, |
cairo_output_stream_t *stream) |
{ |
int i; |
_cairo_output_stream_printf (stream, "<"); |
for (i = 0; i < pdf_operators->num_glyphs; i++) { |
_cairo_output_stream_printf (stream, |
"%0*x", |
pdf_operators->hex_width, |
pdf_operators->glyphs[i].glyph_index); |
pdf_operators->cur_x += pdf_operators->glyphs[i].x_advance; |
} |
_cairo_output_stream_printf (stream, ">Tj\n"); |
return _cairo_output_stream_get_status (stream); |
} |
/* Emit the string of glyphs using the 'TJ' operator. |
* |
* The TJ operator takes an array of strings of glyphs. Each string of |
* glyphs is displayed using the glyph advances of each glyph to |
* position the glyphs. A relative adjustment to the glyph advance may |
* be specified by including the adjustment between two strings. The |
* adjustment is in units of text space * -1000. |
*/ |
static cairo_status_t |
_cairo_pdf_operators_emit_glyph_string_with_positioning ( |
cairo_pdf_operators_t *pdf_operators, |
cairo_output_stream_t *stream) |
{ |
int i; |
_cairo_output_stream_printf (stream, "[<"); |
for (i = 0; i < pdf_operators->num_glyphs; i++) { |
if (pdf_operators->glyphs[i].x_position != pdf_operators->cur_x) |
{ |
double delta = pdf_operators->glyphs[i].x_position - pdf_operators->cur_x; |
int rounded_delta; |
delta = -1000.0*delta; |
/* As the delta is in 1/1000 of a unit of text space, |
* rounding to an integer should still provide sufficient |
* precision. We round the delta before adding to Tm_x so |
* that we keep track of the accumulated rounding error in |
* the PDF interpreter and compensate for it when |
* calculating subsequent deltas. |
*/ |
rounded_delta = _cairo_lround (delta); |
if (rounded_delta != 0) { |
_cairo_output_stream_printf (stream, |
">%d<", |
rounded_delta); |
} |
/* Convert the rounded delta back to text |
* space before adding to the current text |
* position. */ |
delta = rounded_delta/-1000.0; |
pdf_operators->cur_x += delta; |
} |
_cairo_output_stream_printf (stream, |
"%0*x", |
pdf_operators->hex_width, |
pdf_operators->glyphs[i].glyph_index); |
pdf_operators->cur_x += pdf_operators->glyphs[i].x_advance; |
} |
_cairo_output_stream_printf (stream, ">]TJ\n"); |
return _cairo_output_stream_get_status (stream); |
} |
static cairo_status_t |
_cairo_pdf_operators_flush_glyphs (cairo_pdf_operators_t *pdf_operators) |
{ |
cairo_output_stream_t *word_wrap_stream; |
cairo_status_t status, status2; |
int i; |
double x; |
if (pdf_operators->num_glyphs == 0) |
return CAIRO_STATUS_SUCCESS; |
word_wrap_stream = _word_wrap_stream_create (pdf_operators->stream, 72); |
status = _cairo_output_stream_get_status (word_wrap_stream); |
if (unlikely (status)) |
return _cairo_output_stream_destroy (word_wrap_stream); |
/* Check if glyph advance used to position every glyph */ |
x = pdf_operators->cur_x; |
for (i = 0; i < pdf_operators->num_glyphs; i++) { |
if (fabs(pdf_operators->glyphs[i].x_position - x) > GLYPH_POSITION_TOLERANCE) |
break; |
x += pdf_operators->glyphs[i].x_advance; |
} |
if (i == pdf_operators->num_glyphs) { |
status = _cairo_pdf_operators_emit_glyph_string (pdf_operators, |
word_wrap_stream); |
} else { |
status = _cairo_pdf_operators_emit_glyph_string_with_positioning ( |
pdf_operators, word_wrap_stream); |
} |
pdf_operators->num_glyphs = 0; |
pdf_operators->glyph_buf_x_pos = pdf_operators->cur_x; |
status2 = _cairo_output_stream_destroy (word_wrap_stream); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
return status; |
} |
static cairo_status_t |
_cairo_pdf_operators_add_glyph (cairo_pdf_operators_t *pdf_operators, |
cairo_scaled_font_subsets_glyph_t *glyph, |
double x_position) |
{ |
double x, y; |
x = glyph->x_advance; |
y = glyph->y_advance; |
if (glyph->is_scaled) |
cairo_matrix_transform_distance (&pdf_operators->font_matrix_inverse, &x, &y); |
pdf_operators->glyphs[pdf_operators->num_glyphs].x_position = x_position; |
pdf_operators->glyphs[pdf_operators->num_glyphs].glyph_index = glyph->subset_glyph_index; |
pdf_operators->glyphs[pdf_operators->num_glyphs].x_advance = x; |
pdf_operators->glyph_buf_x_pos += x; |
pdf_operators->num_glyphs++; |
if (pdf_operators->num_glyphs == PDF_GLYPH_BUFFER_SIZE) |
return _cairo_pdf_operators_flush_glyphs (pdf_operators); |
return CAIRO_STATUS_SUCCESS; |
} |
/* Use 'Tm' operator to set the PDF text matrix. */ |
static cairo_status_t |
_cairo_pdf_operators_set_text_matrix (cairo_pdf_operators_t *pdf_operators, |
cairo_matrix_t *matrix) |
{ |
cairo_matrix_t inverse; |
cairo_status_t status; |
/* We require the matrix to be invertable. */ |
inverse = *matrix; |
status = cairo_matrix_invert (&inverse); |
if (unlikely (status)) |
return status; |
pdf_operators->text_matrix = *matrix; |
pdf_operators->cur_x = 0; |
pdf_operators->cur_y = 0; |
pdf_operators->glyph_buf_x_pos = 0; |
_cairo_output_stream_printf (pdf_operators->stream, |
"%f %f %f %f %f %f Tm\n", |
pdf_operators->text_matrix.xx, |
pdf_operators->text_matrix.yx, |
pdf_operators->text_matrix.xy, |
pdf_operators->text_matrix.yy, |
pdf_operators->text_matrix.x0, |
pdf_operators->text_matrix.y0); |
pdf_operators->cairo_to_pdftext = *matrix; |
status = cairo_matrix_invert (&pdf_operators->cairo_to_pdftext); |
assert (status == CAIRO_STATUS_SUCCESS); |
cairo_matrix_multiply (&pdf_operators->cairo_to_pdftext, |
&pdf_operators->cairo_to_pdf, |
&pdf_operators->cairo_to_pdftext); |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
#define TEXT_MATRIX_TOLERANCE 1e-6 |
/* Set the translation components of the PDF text matrix to x, y. The |
* 'Td' operator is used to transform the text matrix. |
*/ |
static cairo_status_t |
_cairo_pdf_operators_set_text_position (cairo_pdf_operators_t *pdf_operators, |
double x, |
double y) |
{ |
cairo_matrix_t translate, inverse; |
cairo_status_t status; |
/* The Td operator transforms the text_matrix with: |
* |
* text_matrix' = T x text_matrix |
* |
* where T is a translation matrix with the translation components |
* set to the Td operands tx and ty. |
*/ |
inverse = pdf_operators->text_matrix; |
status = cairo_matrix_invert (&inverse); |
assert (status == CAIRO_STATUS_SUCCESS); |
pdf_operators->text_matrix.x0 = x; |
pdf_operators->text_matrix.y0 = y; |
cairo_matrix_multiply (&translate, &pdf_operators->text_matrix, &inverse); |
if (fabs(translate.x0) < TEXT_MATRIX_TOLERANCE) |
translate.x0 = 0.0; |
if (fabs(translate.y0) < TEXT_MATRIX_TOLERANCE) |
translate.y0 = 0.0; |
_cairo_output_stream_printf (pdf_operators->stream, |
"%f %f Td\n", |
translate.x0, |
translate.y0); |
pdf_operators->cur_x = 0; |
pdf_operators->cur_y = 0; |
pdf_operators->glyph_buf_x_pos = 0; |
pdf_operators->cairo_to_pdftext = pdf_operators->text_matrix; |
status = cairo_matrix_invert (&pdf_operators->cairo_to_pdftext); |
assert (status == CAIRO_STATUS_SUCCESS); |
cairo_matrix_multiply (&pdf_operators->cairo_to_pdftext, |
&pdf_operators->cairo_to_pdf, |
&pdf_operators->cairo_to_pdftext); |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
/* Select the font using the 'Tf' operator. The font size is set to 1 |
* as we use the 'Tm' operator to set the font scale. |
*/ |
static cairo_status_t |
_cairo_pdf_operators_set_font_subset (cairo_pdf_operators_t *pdf_operators, |
cairo_scaled_font_subsets_glyph_t *subset_glyph) |
{ |
cairo_status_t status; |
_cairo_output_stream_printf (pdf_operators->stream, |
"/f-%d-%d 1 Tf\n", |
subset_glyph->font_id, |
subset_glyph->subset_id); |
if (pdf_operators->use_font_subset) { |
status = pdf_operators->use_font_subset (subset_glyph->font_id, |
subset_glyph->subset_id, |
pdf_operators->use_font_subset_closure); |
if (unlikely (status)) |
return status; |
} |
pdf_operators->font_id = subset_glyph->font_id; |
pdf_operators->subset_id = subset_glyph->subset_id; |
if (subset_glyph->is_composite) |
pdf_operators->hex_width = 4; |
else |
pdf_operators->hex_width = 2; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_pdf_operators_begin_text (cairo_pdf_operators_t *pdf_operators) |
{ |
_cairo_output_stream_printf (pdf_operators->stream, "BT\n"); |
pdf_operators->in_text_object = TRUE; |
pdf_operators->num_glyphs = 0; |
pdf_operators->glyph_buf_x_pos = 0; |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
static cairo_status_t |
_cairo_pdf_operators_end_text (cairo_pdf_operators_t *pdf_operators) |
{ |
cairo_status_t status; |
status = _cairo_pdf_operators_flush_glyphs (pdf_operators); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (pdf_operators->stream, "ET\n"); |
pdf_operators->in_text_object = FALSE; |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
/* Compare the scale components of two matrices. The translation |
* components are ignored. */ |
static cairo_bool_t |
_cairo_matrix_scale_equal (cairo_matrix_t *a, cairo_matrix_t *b) |
{ |
return (a->xx == b->xx && |
a->xy == b->xy && |
a->yx == b->yx && |
a->yy == b->yy); |
} |
static cairo_status_t |
_cairo_pdf_operators_begin_actualtext (cairo_pdf_operators_t *pdf_operators, |
const char *utf8, |
int utf8_len) |
{ |
uint16_t *utf16; |
int utf16_len; |
cairo_status_t status; |
int i; |
_cairo_output_stream_printf (pdf_operators->stream, "/Span << /ActualText <feff"); |
if (utf8_len) { |
status = _cairo_utf8_to_utf16 (utf8, utf8_len, &utf16, &utf16_len); |
if (unlikely (status)) |
return status; |
for (i = 0; i < utf16_len; i++) { |
_cairo_output_stream_printf (pdf_operators->stream, |
"%04x", (int) (utf16[i])); |
} |
free (utf16); |
} |
_cairo_output_stream_printf (pdf_operators->stream, "> >> BDC\n"); |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
static cairo_status_t |
_cairo_pdf_operators_end_actualtext (cairo_pdf_operators_t *pdf_operators) |
{ |
_cairo_output_stream_printf (pdf_operators->stream, "EMC\n"); |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
static cairo_status_t |
_cairo_pdf_operators_emit_glyph (cairo_pdf_operators_t *pdf_operators, |
cairo_glyph_t *glyph, |
cairo_scaled_font_subsets_glyph_t *subset_glyph) |
{ |
double x, y; |
cairo_status_t status; |
if (pdf_operators->is_new_text_object || |
pdf_operators->font_id != subset_glyph->font_id || |
pdf_operators->subset_id != subset_glyph->subset_id) |
{ |
status = _cairo_pdf_operators_flush_glyphs (pdf_operators); |
if (unlikely (status)) |
return status; |
status = _cairo_pdf_operators_set_font_subset (pdf_operators, subset_glyph); |
if (unlikely (status)) |
return status; |
pdf_operators->is_new_text_object = FALSE; |
} |
x = glyph->x; |
y = glyph->y; |
cairo_matrix_transform_point (&pdf_operators->cairo_to_pdftext, &x, &y); |
/* The TJ operator for displaying text strings can only set |
* the horizontal position of the glyphs. If the y position |
* (in text space) changes, use the Td operator to change the |
* current position to the next glyph. We also use the Td |
* operator to move the current position if the horizontal |
* position changes by more than 10 (in text space |
* units). This is becauses the horizontal glyph positioning |
* in the TJ operator is intended for kerning and there may be |
* PDF consumers that do not handle very large position |
* adjustments in TJ. |
*/ |
if (fabs(x - pdf_operators->glyph_buf_x_pos) > 10 || |
fabs(y - pdf_operators->cur_y) > GLYPH_POSITION_TOLERANCE) |
{ |
status = _cairo_pdf_operators_flush_glyphs (pdf_operators); |
if (unlikely (status)) |
return status; |
x = glyph->x; |
y = glyph->y; |
cairo_matrix_transform_point (&pdf_operators->cairo_to_pdf, &x, &y); |
status = _cairo_pdf_operators_set_text_position (pdf_operators, x, y); |
if (unlikely (status)) |
return status; |
x = 0.0; |
y = 0.0; |
} |
status = _cairo_pdf_operators_add_glyph (pdf_operators, |
subset_glyph, |
x); |
return status; |
} |
/* A utf8_len of -1 indicates no unicode text. A utf8_len = 0 is an |
* empty string. |
*/ |
static cairo_int_status_t |
_cairo_pdf_operators_emit_cluster (cairo_pdf_operators_t *pdf_operators, |
const char *utf8, |
int utf8_len, |
cairo_glyph_t *glyphs, |
int num_glyphs, |
cairo_text_cluster_flags_t cluster_flags, |
cairo_scaled_font_t *scaled_font) |
{ |
cairo_scaled_font_subsets_glyph_t subset_glyph; |
cairo_glyph_t *cur_glyph; |
cairo_status_t status = CAIRO_STATUS_SUCCESS; |
int i; |
/* If the cluster maps 1 glyph to 1 or more unicode characters, we |
* first try _map_glyph() with the unicode string to see if it can |
* use toUnicode to map our glyph to the unicode. This will fail |
* if the glyph is already mapped to a different unicode string. |
* |
* We also go through this path if no unicode mapping was |
* supplied (utf8_len < 0). |
* |
* Mapping a glyph to a zero length unicode string requires the |
* use of ActualText. |
*/ |
if (num_glyphs == 1 && utf8_len != 0) { |
status = _cairo_scaled_font_subsets_map_glyph (pdf_operators->font_subsets, |
scaled_font, |
glyphs->index, |
utf8, |
utf8_len, |
&subset_glyph); |
if (unlikely (status)) |
return status; |
if (subset_glyph.utf8_is_mapped || utf8_len < 0) { |
status = _cairo_pdf_operators_emit_glyph (pdf_operators, |
glyphs, |
&subset_glyph); |
if (unlikely (status)) |
return status; |
return CAIRO_STATUS_SUCCESS; |
} |
} |
if (pdf_operators->use_actual_text) { |
/* Fallback to using ActualText to map zero or more glyphs to a |
* unicode string. */ |
status = _cairo_pdf_operators_flush_glyphs (pdf_operators); |
if (unlikely (status)) |
return status; |
status = _cairo_pdf_operators_begin_actualtext (pdf_operators, utf8, utf8_len); |
if (unlikely (status)) |
return status; |
} |
cur_glyph = glyphs; |
/* XXX |
* If no glyphs, we should put *something* here for the text to be selectable. */ |
for (i = 0; i < num_glyphs; i++) { |
status = _cairo_scaled_font_subsets_map_glyph (pdf_operators->font_subsets, |
scaled_font, |
cur_glyph->index, |
NULL, -1, |
&subset_glyph); |
if (unlikely (status)) |
return status; |
status = _cairo_pdf_operators_emit_glyph (pdf_operators, |
cur_glyph, |
&subset_glyph); |
if (unlikely (status)) |
return status; |
if ((cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)) |
cur_glyph--; |
else |
cur_glyph++; |
} |
if (pdf_operators->use_actual_text) { |
status = _cairo_pdf_operators_flush_glyphs (pdf_operators); |
if (unlikely (status)) |
return status; |
status = _cairo_pdf_operators_end_actualtext (pdf_operators); |
} |
return status; |
} |
cairo_int_status_t |
_cairo_pdf_operators_show_text_glyphs (cairo_pdf_operators_t *pdf_operators, |
const char *utf8, |
int utf8_len, |
cairo_glyph_t *glyphs, |
int num_glyphs, |
const cairo_text_cluster_t *clusters, |
int num_clusters, |
cairo_text_cluster_flags_t cluster_flags, |
cairo_scaled_font_t *scaled_font) |
{ |
cairo_status_t status; |
int i; |
cairo_matrix_t text_matrix, invert_y_axis; |
double x, y; |
const char *cur_text; |
cairo_glyph_t *cur_glyph; |
pdf_operators->font_matrix_inverse = scaled_font->font_matrix; |
status = cairo_matrix_invert (&pdf_operators->font_matrix_inverse); |
if (status == CAIRO_STATUS_INVALID_MATRIX) |
return CAIRO_STATUS_SUCCESS; |
assert (status == CAIRO_STATUS_SUCCESS); |
pdf_operators->is_new_text_object = FALSE; |
if (pdf_operators->in_text_object == FALSE) { |
status = _cairo_pdf_operators_begin_text (pdf_operators); |
if (unlikely (status)) |
return status; |
/* Force Tm and Tf to be emitted when starting a new text |
* object.*/ |
pdf_operators->is_new_text_object = TRUE; |
} |
cairo_matrix_init_scale (&invert_y_axis, 1, -1); |
text_matrix = scaled_font->scale; |
/* Invert y axis in font space */ |
cairo_matrix_multiply (&text_matrix, &text_matrix, &invert_y_axis); |
/* Invert y axis in device space */ |
cairo_matrix_multiply (&text_matrix, &invert_y_axis, &text_matrix); |
if (pdf_operators->is_new_text_object || |
! _cairo_matrix_scale_equal (&pdf_operators->text_matrix, &text_matrix)) |
{ |
status = _cairo_pdf_operators_flush_glyphs (pdf_operators); |
if (unlikely (status)) |
return status; |
x = glyphs[0].x; |
y = glyphs[0].y; |
cairo_matrix_transform_point (&pdf_operators->cairo_to_pdf, &x, &y); |
text_matrix.x0 = x; |
text_matrix.y0 = y; |
status = _cairo_pdf_operators_set_text_matrix (pdf_operators, &text_matrix); |
if (status == CAIRO_STATUS_INVALID_MATRIX) |
return CAIRO_STATUS_SUCCESS; |
if (unlikely (status)) |
return status; |
} |
if (num_clusters > 0) { |
cur_text = utf8; |
if ((cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)) |
cur_glyph = glyphs + num_glyphs; |
else |
cur_glyph = glyphs; |
for (i = 0; i < num_clusters; i++) { |
if ((cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)) |
cur_glyph -= clusters[i].num_glyphs; |
status = _cairo_pdf_operators_emit_cluster (pdf_operators, |
cur_text, |
clusters[i].num_bytes, |
cur_glyph, |
clusters[i].num_glyphs, |
cluster_flags, |
scaled_font); |
if (unlikely (status)) |
return status; |
cur_text += clusters[i].num_bytes; |
if (!(cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)) |
cur_glyph += clusters[i].num_glyphs; |
} |
} else { |
for (i = 0; i < num_glyphs; i++) { |
status = _cairo_pdf_operators_emit_cluster (pdf_operators, |
NULL, |
-1, /* no unicode string available */ |
&glyphs[i], |
1, |
FALSE, |
scaled_font); |
if (unlikely (status)) |
return status; |
} |
} |
return _cairo_output_stream_get_status (pdf_operators->stream); |
} |
#endif /* CAIRO_HAS_PDF_OPERATORS */ |
/programs/develop/libraries/cairo/src/cairo-png.c |
---|
0,0 → 1,798 |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2003 University of Southern California |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is University of Southern |
* California. |
* |
* Contributor(s): |
* Carl D. Worth <cworth@cworth.org> |
* Kristian Høgsberg <krh@redhat.com> |
* Chris Wilson <chris@chris-wilson.co.uk> |
*/ |
#include "cairoint.h" |
#include "cairo-error-private.h" |
#include "cairo-output-stream-private.h" |
#include <stdio.h> |
#include <errno.h> |
#include <png.h> |
/** |
* SECTION:cairo-png |
* @Title: PNG Support |
* @Short_Description: Reading and writing PNG images |
* @See_Also: #cairo_surface_t |
* |
* The PNG functions allow reading PNG images into image surfaces, and writing |
* any surface to a PNG file. |
*/ |
/** |
* CAIRO_HAS_PNG_FUNCTIONS: |
* |
* Defined if the PNG functions are available. |
* This macro can be used to conditionally compile code using the cairo |
* PNG functions. |
*/ |
struct png_read_closure_t { |
cairo_read_func_t read_func; |
void *closure; |
cairo_output_stream_t *png_data; |
}; |
/* Unpremultiplies data and converts native endian ARGB => RGBA bytes */ |
static void |
unpremultiply_data (png_structp png, png_row_infop row_info, png_bytep data) |
{ |
unsigned int i; |
for (i = 0; i < row_info->rowbytes; i += 4) { |
uint8_t *b = &data[i]; |
uint32_t pixel; |
uint8_t alpha; |
memcpy (&pixel, b, sizeof (uint32_t)); |
alpha = (pixel & 0xff000000) >> 24; |
if (alpha == 0) { |
b[0] = b[1] = b[2] = b[3] = 0; |
} else { |
b[0] = (((pixel & 0xff0000) >> 16) * 255 + alpha / 2) / alpha; |
b[1] = (((pixel & 0x00ff00) >> 8) * 255 + alpha / 2) / alpha; |
b[2] = (((pixel & 0x0000ff) >> 0) * 255 + alpha / 2) / alpha; |
b[3] = alpha; |
} |
} |
} |
/* Converts native endian xRGB => RGBx bytes */ |
static void |
convert_data_to_bytes (png_structp png, png_row_infop row_info, png_bytep data) |
{ |
unsigned int i; |
for (i = 0; i < row_info->rowbytes; i += 4) { |
uint8_t *b = &data[i]; |
uint32_t pixel; |
memcpy (&pixel, b, sizeof (uint32_t)); |
b[0] = (pixel & 0xff0000) >> 16; |
b[1] = (pixel & 0x00ff00) >> 8; |
b[2] = (pixel & 0x0000ff) >> 0; |
b[3] = 0; |
} |
} |
/* Use a couple of simple error callbacks that do not print anything to |
* stderr and rely on the user to check for errors via the #cairo_status_t |
* return. |
*/ |
static void |
png_simple_error_callback (png_structp png, |
png_const_charp error_msg) |
{ |
cairo_status_t *error = png_get_error_ptr (png); |
/* default to the most likely error */ |
if (*error == CAIRO_STATUS_SUCCESS) |
*error = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
#ifdef PNG_SETJMP_SUPPORTED |
longjmp (png_jmpbuf (png), 1); |
#endif |
/* if we get here, then we have to choice but to abort ... */ |
} |
static void |
png_simple_warning_callback (png_structp png, |
png_const_charp error_msg) |
{ |
cairo_status_t *error = png_get_error_ptr (png); |
/* default to the most likely error */ |
if (*error == CAIRO_STATUS_SUCCESS) |
*error = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
/* png does not expect to abort and will try to tidy up after a warning */ |
} |
/* Starting with libpng-1.2.30, we must explicitly specify an output_flush_fn. |
* Otherwise, we will segfault if we are writing to a stream. */ |
static void |
png_simple_output_flush_fn (png_structp png_ptr) |
{ |
} |
static cairo_status_t |
write_png (cairo_surface_t *surface, |
png_rw_ptr write_func, |
void *closure) |
{ |
int i; |
cairo_status_t status; |
cairo_image_surface_t *image; |
cairo_image_surface_t * volatile clone; |
void *image_extra; |
png_struct *png; |
png_info *info; |
png_byte **volatile rows = NULL; |
png_color_16 white; |
int png_color_type; |
int depth; |
status = _cairo_surface_acquire_source_image (surface, |
&image, |
&image_extra); |
if (status == CAIRO_INT_STATUS_UNSUPPORTED) |
return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); |
else if (unlikely (status)) |
return status; |
/* PNG complains about "Image width or height is zero in IHDR" */ |
if (image->width == 0 || image->height == 0) { |
status = _cairo_error (CAIRO_STATUS_WRITE_ERROR); |
goto BAIL1; |
} |
/* Handle the various fallback formats (e.g. low bit-depth XServers) |
* by coercing them to a simpler format using pixman. |
*/ |
clone = _cairo_image_surface_coerce (image); |
status = clone->base.status; |
if (unlikely (status)) |
goto BAIL1; |
rows = _cairo_malloc_ab (clone->height, sizeof (png_byte*)); |
if (unlikely (rows == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto BAIL2; |
} |
for (i = 0; i < clone->height; i++) |
rows[i] = (png_byte *) clone->data + i * clone->stride; |
png = png_create_write_struct (PNG_LIBPNG_VER_STRING, &status, |
png_simple_error_callback, |
png_simple_warning_callback); |
if (unlikely (png == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto BAIL3; |
} |
info = png_create_info_struct (png); |
if (unlikely (info == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto BAIL4; |
} |
#ifdef PNG_SETJMP_SUPPORTED |
if (setjmp (png_jmpbuf (png))) |
goto BAIL4; |
#endif |
png_set_write_fn (png, closure, write_func, png_simple_output_flush_fn); |
switch (clone->format) { |
case CAIRO_FORMAT_ARGB32: |
depth = 8; |
if (_cairo_image_analyze_transparency (clone) == CAIRO_IMAGE_IS_OPAQUE) |
png_color_type = PNG_COLOR_TYPE_RGB; |
else |
png_color_type = PNG_COLOR_TYPE_RGB_ALPHA; |
break; |
case CAIRO_FORMAT_RGB24: |
depth = 8; |
png_color_type = PNG_COLOR_TYPE_RGB; |
break; |
case CAIRO_FORMAT_A8: |
depth = 8; |
png_color_type = PNG_COLOR_TYPE_GRAY; |
break; |
case CAIRO_FORMAT_A1: |
depth = 1; |
png_color_type = PNG_COLOR_TYPE_GRAY; |
#ifndef WORDS_BIGENDIAN |
png_set_packswap (png); |
#endif |
break; |
case CAIRO_FORMAT_INVALID: |
case CAIRO_FORMAT_RGB16_565: |
default: |
status = _cairo_error (CAIRO_STATUS_INVALID_FORMAT); |
goto BAIL4; |
} |
png_set_IHDR (png, info, |
clone->width, |
clone->height, depth, |
png_color_type, |
PNG_INTERLACE_NONE, |
PNG_COMPRESSION_TYPE_DEFAULT, |
PNG_FILTER_TYPE_DEFAULT); |
white.gray = (1 << depth) - 1; |
white.red = white.blue = white.green = white.gray; |
png_set_bKGD (png, info, &white); |
if (0) { /* XXX extract meta-data from surface (i.e. creation date) */ |
png_time pt; |
png_convert_from_time_t (&pt, time (NULL)); |
png_set_tIME (png, info, &pt); |
} |
/* We have to call png_write_info() before setting up the write |
* transformation, since it stores data internally in 'png' |
* that is needed for the write transformation functions to work. |
*/ |
png_write_info (png, info); |
if (png_color_type == PNG_COLOR_TYPE_RGB_ALPHA) { |
png_set_write_user_transform_fn (png, unpremultiply_data); |
} else if (png_color_type == PNG_COLOR_TYPE_RGB) { |
png_set_write_user_transform_fn (png, convert_data_to_bytes); |
png_set_filler (png, 0, PNG_FILLER_AFTER); |
} |
png_write_image (png, rows); |
png_write_end (png, info); |
BAIL4: |
png_destroy_write_struct (&png, &info); |
BAIL3: |
free (rows); |
BAIL2: |
cairo_surface_destroy (&clone->base); |
BAIL1: |
_cairo_surface_release_source_image (surface, image, image_extra); |
return status; |
} |
static void |
stdio_write_func (png_structp png, png_bytep data, png_size_t size) |
{ |
FILE *fp; |
fp = png_get_io_ptr (png); |
while (size) { |
size_t ret = fwrite (data, 1, size, fp); |
size -= ret; |
data += ret; |
if (size && ferror (fp)) { |
cairo_status_t *error = png_get_error_ptr (png); |
if (*error == CAIRO_STATUS_SUCCESS) |
*error = _cairo_error (CAIRO_STATUS_WRITE_ERROR); |
png_error (png, NULL); |
} |
} |
} |
/** |
* cairo_surface_write_to_png: |
* @surface: a #cairo_surface_t with pixel contents |
* @filename: the name of a file to write to |
* |
* Writes the contents of @surface to a new file @filename as a PNG |
* image. |
* |
* Return value: %CAIRO_STATUS_SUCCESS if the PNG file was written |
* successfully. Otherwise, %CAIRO_STATUS_NO_MEMORY if memory could not |
* be allocated for the operation or |
* %CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface does not have |
* pixel contents, or %CAIRO_STATUS_WRITE_ERROR if an I/O error occurs |
* while attempting to write the file. |
**/ |
cairo_status_t |
cairo_surface_write_to_png (cairo_surface_t *surface, |
const char *filename) |
{ |
FILE *fp; |
cairo_status_t status; |
if (surface->status) |
return surface->status; |
if (surface->finished) |
return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED); |
fp = fopen (filename, "wb"); |
if (fp == NULL) { |
switch (errno) { |
case ENOMEM: |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
default: |
return _cairo_error (CAIRO_STATUS_WRITE_ERROR); |
} |
} |
status = write_png (surface, stdio_write_func, fp); |
if (fclose (fp) && status == CAIRO_STATUS_SUCCESS) |
status = _cairo_error (CAIRO_STATUS_WRITE_ERROR); |
return status; |
} |
struct png_write_closure_t { |
cairo_write_func_t write_func; |
void *closure; |
}; |
static void |
stream_write_func (png_structp png, png_bytep data, png_size_t size) |
{ |
cairo_status_t status; |
struct png_write_closure_t *png_closure; |
png_closure = png_get_io_ptr (png); |
status = png_closure->write_func (png_closure->closure, data, size); |
if (unlikely (status)) { |
cairo_status_t *error = png_get_error_ptr (png); |
if (*error == CAIRO_STATUS_SUCCESS) |
*error = status; |
png_error (png, NULL); |
} |
} |
/** |
* cairo_surface_write_to_png_stream: |
* @surface: a #cairo_surface_t with pixel contents |
* @write_func: a #cairo_write_func_t |
* @closure: closure data for the write function |
* |
* Writes the image surface to the write function. |
* |
* Return value: %CAIRO_STATUS_SUCCESS if the PNG file was written |
* successfully. Otherwise, %CAIRO_STATUS_NO_MEMORY is returned if |
* memory could not be allocated for the operation, |
* %CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface does not have |
* pixel contents. |
**/ |
cairo_status_t |
cairo_surface_write_to_png_stream (cairo_surface_t *surface, |
cairo_write_func_t write_func, |
void *closure) |
{ |
struct png_write_closure_t png_closure; |
if (surface->status) |
return surface->status; |
if (surface->finished) |
return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED); |
png_closure.write_func = write_func; |
png_closure.closure = closure; |
return write_png (surface, stream_write_func, &png_closure); |
} |
slim_hidden_def (cairo_surface_write_to_png_stream); |
static inline int |
multiply_alpha (int alpha, int color) |
{ |
int temp = (alpha * color) + 0x80; |
return ((temp + (temp >> 8)) >> 8); |
} |
/* Premultiplies data and converts RGBA bytes => native endian */ |
static void |
premultiply_data (png_structp png, |
png_row_infop row_info, |
png_bytep data) |
{ |
unsigned int i; |
for (i = 0; i < row_info->rowbytes; i += 4) { |
uint8_t *base = &data[i]; |
uint8_t alpha = base[3]; |
uint32_t p; |
if (alpha == 0) { |
p = 0; |
} else { |
uint8_t red = base[0]; |
uint8_t green = base[1]; |
uint8_t blue = base[2]; |
if (alpha != 0xff) { |
red = multiply_alpha (alpha, red); |
green = multiply_alpha (alpha, green); |
blue = multiply_alpha (alpha, blue); |
} |
p = (alpha << 24) | (red << 16) | (green << 8) | (blue << 0); |
} |
memcpy (base, &p, sizeof (uint32_t)); |
} |
} |
/* Converts RGBx bytes to native endian xRGB */ |
static void |
convert_bytes_to_data (png_structp png, png_row_infop row_info, png_bytep data) |
{ |
unsigned int i; |
for (i = 0; i < row_info->rowbytes; i += 4) { |
uint8_t *base = &data[i]; |
uint8_t red = base[0]; |
uint8_t green = base[1]; |
uint8_t blue = base[2]; |
uint32_t pixel; |
pixel = (0xff << 24) | (red << 16) | (green << 8) | (blue << 0); |
memcpy (base, &pixel, sizeof (uint32_t)); |
} |
} |
static cairo_status_t |
stdio_read_func (void *closure, unsigned char *data, unsigned int size) |
{ |
FILE *file = closure; |
while (size) { |
size_t ret; |
ret = fread (data, 1, size, file); |
size -= ret; |
data += ret; |
if (size && (feof (file) || ferror (file))) |
return _cairo_error (CAIRO_STATUS_READ_ERROR); |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
stream_read_func (png_structp png, png_bytep data, png_size_t size) |
{ |
cairo_status_t status; |
struct png_read_closure_t *png_closure; |
png_closure = png_get_io_ptr (png); |
status = png_closure->read_func (png_closure->closure, data, size); |
if (unlikely (status)) { |
cairo_status_t *error = png_get_error_ptr (png); |
if (*error == CAIRO_STATUS_SUCCESS) |
*error = status; |
png_error (png, NULL); |
} |
_cairo_output_stream_write (png_closure->png_data, data, size); |
} |
static cairo_surface_t * |
read_png (struct png_read_closure_t *png_closure) |
{ |
cairo_surface_t *surface; |
png_struct *png = NULL; |
png_info *info; |
png_byte *data = NULL; |
png_byte **row_pointers = NULL; |
png_uint_32 png_width, png_height; |
int depth, color_type, interlace, stride; |
unsigned int i; |
cairo_format_t format; |
cairo_status_t status; |
unsigned char *mime_data; |
unsigned long mime_data_length; |
png_closure->png_data = _cairo_memory_stream_create (); |
/* XXX: Perhaps we'll want some other error handlers? */ |
png = png_create_read_struct (PNG_LIBPNG_VER_STRING, |
&status, |
png_simple_error_callback, |
png_simple_warning_callback); |
if (unlikely (png == NULL)) { |
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); |
goto BAIL; |
} |
info = png_create_info_struct (png); |
if (unlikely (info == NULL)) { |
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); |
goto BAIL; |
} |
png_set_read_fn (png, png_closure, stream_read_func); |
status = CAIRO_STATUS_SUCCESS; |
#ifdef PNG_SETJMP_SUPPORTED |
if (setjmp (png_jmpbuf (png))) { |
surface = _cairo_surface_create_in_error (status); |
goto BAIL; |
} |
#endif |
png_read_info (png, info); |
png_get_IHDR (png, info, |
&png_width, &png_height, &depth, |
&color_type, &interlace, NULL, NULL); |
if (unlikely (status)) { /* catch any early warnings */ |
surface = _cairo_surface_create_in_error (status); |
goto BAIL; |
} |
/* convert palette/gray image to rgb */ |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
png_set_palette_to_rgb (png); |
/* expand gray bit depth if needed */ |
if (color_type == PNG_COLOR_TYPE_GRAY) { |
#if PNG_LIBPNG_VER >= 10209 |
png_set_expand_gray_1_2_4_to_8 (png); |
#else |
png_set_gray_1_2_4_to_8 (png); |
#endif |
} |
/* transform transparency to alpha */ |
if (png_get_valid (png, info, PNG_INFO_tRNS)) |
png_set_tRNS_to_alpha (png); |
if (depth == 16) |
png_set_strip_16 (png); |
if (depth < 8) |
png_set_packing (png); |
/* convert grayscale to RGB */ |
if (color_type == PNG_COLOR_TYPE_GRAY || |
color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
png_set_gray_to_rgb (png); |
} |
if (interlace != PNG_INTERLACE_NONE) |
png_set_interlace_handling (png); |
png_set_filler (png, 0xff, PNG_FILLER_AFTER); |
/* recheck header after setting EXPAND options */ |
png_read_update_info (png, info); |
png_get_IHDR (png, info, |
&png_width, &png_height, &depth, |
&color_type, &interlace, NULL, NULL); |
if (depth != 8 || |
! (color_type == PNG_COLOR_TYPE_RGB || |
color_type == PNG_COLOR_TYPE_RGB_ALPHA)) |
{ |
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_READ_ERROR)); |
goto BAIL; |
} |
switch (color_type) { |
default: |
ASSERT_NOT_REACHED; |
/* fall-through just in case ;-) */ |
case PNG_COLOR_TYPE_RGB_ALPHA: |
format = CAIRO_FORMAT_ARGB32; |
png_set_read_user_transform_fn (png, premultiply_data); |
break; |
case PNG_COLOR_TYPE_RGB: |
format = CAIRO_FORMAT_RGB24; |
png_set_read_user_transform_fn (png, convert_bytes_to_data); |
break; |
} |
stride = cairo_format_stride_for_width (format, png_width); |
if (stride < 0) { |
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_STRIDE)); |
goto BAIL; |
} |
data = _cairo_malloc_ab (png_height, stride); |
if (unlikely (data == NULL)) { |
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); |
goto BAIL; |
} |
row_pointers = _cairo_malloc_ab (png_height, sizeof (char *)); |
if (unlikely (row_pointers == NULL)) { |
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); |
goto BAIL; |
} |
for (i = 0; i < png_height; i++) |
row_pointers[i] = &data[i * stride]; |
png_read_image (png, row_pointers); |
png_read_end (png, info); |
if (unlikely (status)) { /* catch any late warnings - probably hit an error already */ |
surface = _cairo_surface_create_in_error (status); |
goto BAIL; |
} |
surface = cairo_image_surface_create_for_data (data, format, |
png_width, png_height, |
stride); |
if (surface->status) |
goto BAIL; |
_cairo_image_surface_assume_ownership_of_data ((cairo_image_surface_t*)surface); |
data = NULL; |
_cairo_debug_check_image_surface_is_defined (surface); |
status = _cairo_memory_stream_destroy (png_closure->png_data, |
&mime_data, |
&mime_data_length); |
png_closure->png_data = NULL; |
if (unlikely (status)) { |
cairo_surface_destroy (surface); |
surface = _cairo_surface_create_in_error (status); |
goto BAIL; |
} |
status = cairo_surface_set_mime_data (surface, |
CAIRO_MIME_TYPE_PNG, |
mime_data, |
mime_data_length, |
free, |
mime_data); |
if (unlikely (status)) { |
free (mime_data); |
cairo_surface_destroy (surface); |
surface = _cairo_surface_create_in_error (status); |
goto BAIL; |
} |
BAIL: |
if (row_pointers != NULL) |
free (row_pointers); |
if (data != NULL) |
free (data); |
if (png != NULL) |
png_destroy_read_struct (&png, &info, NULL); |
if (png_closure->png_data != NULL) { |
cairo_status_t status_ignored; |
status_ignored = _cairo_output_stream_destroy (png_closure->png_data); |
} |
return surface; |
} |
/** |
* cairo_image_surface_create_from_png: |
* @filename: name of PNG file to load |
* |
* Creates a new image surface and initializes the contents to the |
* given PNG file. |
* |
* Return value: a new #cairo_surface_t initialized with the contents |
* of the PNG file, or a "nil" surface if any error occurred. A nil |
* surface can be checked for with cairo_surface_status(surface) which |
* may return one of the following values: |
* |
* %CAIRO_STATUS_NO_MEMORY |
* %CAIRO_STATUS_FILE_NOT_FOUND |
* %CAIRO_STATUS_READ_ERROR |
* |
* Alternatively, you can allow errors to propagate through the drawing |
* operations and check the status on the context upon completion |
* using cairo_status(). |
**/ |
cairo_surface_t * |
cairo_image_surface_create_from_png (const char *filename) |
{ |
struct png_read_closure_t png_closure; |
cairo_surface_t *surface; |
png_closure.closure = fopen (filename, "rb"); |
if (png_closure.closure == NULL) { |
cairo_status_t status; |
switch (errno) { |
case ENOMEM: |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
break; |
case ENOENT: |
status = _cairo_error (CAIRO_STATUS_FILE_NOT_FOUND); |
break; |
default: |
status = _cairo_error (CAIRO_STATUS_READ_ERROR); |
break; |
} |
return _cairo_surface_create_in_error (status); |
} |
png_closure.read_func = stdio_read_func; |
surface = read_png (&png_closure); |
fclose (png_closure.closure); |
return surface; |
} |
/** |
* cairo_image_surface_create_from_png_stream: |
* @read_func: function called to read the data of the file |
* @closure: data to pass to @read_func. |
* |
* Creates a new image surface from PNG data read incrementally |
* via the @read_func function. |
* |
* Return value: a new #cairo_surface_t initialized with the contents |
* of the PNG file or a "nil" surface if the data read is not a valid PNG image |
* or memory could not be allocated for the operation. A nil |
* surface can be checked for with cairo_surface_status(surface) which |
* may return one of the following values: |
* |
* %CAIRO_STATUS_NO_MEMORY |
* %CAIRO_STATUS_READ_ERROR |
* |
* Alternatively, you can allow errors to propagate through the drawing |
* operations and check the status on the context upon completion |
* using cairo_status(). |
**/ |
cairo_surface_t * |
cairo_image_surface_create_from_png_stream (cairo_read_func_t read_func, |
void *closure) |
{ |
struct png_read_closure_t png_closure; |
png_closure.read_func = read_func; |
png_closure.closure = closure; |
return read_png (&png_closure); |
} |
/programs/develop/libraries/cairo/src/cairo-scaled-font-subsets.c |
---|
0,0 → 1,1091 |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2003 University of Southern California |
* Copyright © 2005 Red Hat, Inc |
* Copyright © 2006 Keith Packard |
* Copyright © 2006 Red Hat, Inc |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is University of Southern |
* California. |
* |
* Contributor(s): |
* Carl D. Worth <cworth@cworth.org> |
* Kristian Høgsberg <krh@redhat.com> |
* Keith Packard <keithp@keithp.com> |
* Adrian Johnson <ajohnson@redneon.com> |
*/ |
#define _BSD_SOURCE /* for snprintf(), strdup() */ |
#include "cairoint.h" |
#include "cairo-error-private.h" |
#if CAIRO_HAS_FONT_SUBSET |
#include "cairo-scaled-font-subsets-private.h" |
#include "cairo-user-font-private.h" |
#define MAX_GLYPHS_PER_SIMPLE_FONT 256 |
#define MAX_GLYPHS_PER_COMPOSITE_FONT 65536 |
typedef enum { |
CAIRO_SUBSETS_SCALED, |
CAIRO_SUBSETS_SIMPLE, |
CAIRO_SUBSETS_COMPOSITE |
} cairo_subsets_type_t; |
typedef enum { |
CAIRO_SUBSETS_FOREACH_UNSCALED, |
CAIRO_SUBSETS_FOREACH_SCALED, |
CAIRO_SUBSETS_FOREACH_USER |
} cairo_subsets_foreach_type_t; |
typedef struct _cairo_sub_font { |
cairo_hash_entry_t base; |
cairo_bool_t is_scaled; |
cairo_bool_t is_composite; |
cairo_bool_t is_user; |
cairo_scaled_font_subsets_t *parent; |
cairo_scaled_font_t *scaled_font; |
unsigned int font_id; |
int current_subset; |
int num_glyphs_in_current_subset; |
int max_glyphs_per_subset; |
cairo_hash_table_t *sub_font_glyphs; |
struct _cairo_sub_font *next; |
} cairo_sub_font_t; |
struct _cairo_scaled_font_subsets { |
cairo_subsets_type_t type; |
int max_glyphs_per_unscaled_subset_used; |
cairo_hash_table_t *unscaled_sub_fonts; |
cairo_sub_font_t *unscaled_sub_fonts_list; |
cairo_sub_font_t *unscaled_sub_fonts_list_end; |
int max_glyphs_per_scaled_subset_used; |
cairo_hash_table_t *scaled_sub_fonts; |
cairo_sub_font_t *scaled_sub_fonts_list; |
cairo_sub_font_t *scaled_sub_fonts_list_end; |
int num_sub_fonts; |
}; |
typedef struct _cairo_sub_font_glyph { |
cairo_hash_entry_t base; |
unsigned int subset_id; |
unsigned int subset_glyph_index; |
double x_advance; |
double y_advance; |
cairo_bool_t is_mapped; |
uint32_t unicode; |
char *utf8; |
int utf8_len; |
} cairo_sub_font_glyph_t; |
typedef struct _cairo_sub_font_collection { |
unsigned long *glyphs; /* scaled_font_glyph_index */ |
char **utf8; |
unsigned int glyphs_size; |
unsigned int max_glyph; |
unsigned int num_glyphs; |
unsigned int subset_id; |
cairo_status_t status; |
cairo_scaled_font_subset_callback_func_t font_subset_callback; |
void *font_subset_callback_closure; |
} cairo_sub_font_collection_t; |
typedef struct _cairo_string_entry { |
cairo_hash_entry_t base; |
char *string; |
} cairo_string_entry_t; |
static cairo_status_t |
_cairo_sub_font_map_glyph (cairo_sub_font_t *sub_font, |
unsigned long scaled_font_glyph_index, |
const char * utf8, |
int utf8_len, |
cairo_scaled_font_subsets_glyph_t *subset_glyph); |
static void |
_cairo_sub_font_glyph_init_key (cairo_sub_font_glyph_t *sub_font_glyph, |
unsigned long scaled_font_glyph_index) |
{ |
sub_font_glyph->base.hash = scaled_font_glyph_index; |
} |
static cairo_bool_t |
_cairo_sub_font_glyphs_equal (const void *key_a, const void *key_b) |
{ |
const cairo_sub_font_glyph_t *sub_font_glyph_a = key_a; |
const cairo_sub_font_glyph_t *sub_font_glyph_b = key_b; |
return sub_font_glyph_a->base.hash == sub_font_glyph_b->base.hash; |
} |
static cairo_sub_font_glyph_t * |
_cairo_sub_font_glyph_create (unsigned long scaled_font_glyph_index, |
unsigned int subset_id, |
unsigned int subset_glyph_index, |
double x_advance, |
double y_advance) |
{ |
cairo_sub_font_glyph_t *sub_font_glyph; |
sub_font_glyph = malloc (sizeof (cairo_sub_font_glyph_t)); |
if (unlikely (sub_font_glyph == NULL)) { |
_cairo_error_throw (CAIRO_STATUS_NO_MEMORY); |
return NULL; |
} |
_cairo_sub_font_glyph_init_key (sub_font_glyph, scaled_font_glyph_index); |
sub_font_glyph->subset_id = subset_id; |
sub_font_glyph->subset_glyph_index = subset_glyph_index; |
sub_font_glyph->x_advance = x_advance; |
sub_font_glyph->y_advance = y_advance; |
sub_font_glyph->is_mapped = FALSE; |
sub_font_glyph->unicode = -1; |
sub_font_glyph->utf8 = NULL; |
sub_font_glyph->utf8_len = 0; |
return sub_font_glyph; |
} |
static void |
_cairo_sub_font_glyph_destroy (cairo_sub_font_glyph_t *sub_font_glyph) |
{ |
if (sub_font_glyph->utf8 != NULL) |
free (sub_font_glyph->utf8); |
free (sub_font_glyph); |
} |
static void |
_cairo_sub_font_glyph_pluck (void *entry, void *closure) |
{ |
cairo_sub_font_glyph_t *sub_font_glyph = entry; |
cairo_hash_table_t *sub_font_glyphs = closure; |
_cairo_hash_table_remove (sub_font_glyphs, &sub_font_glyph->base); |
_cairo_sub_font_glyph_destroy (sub_font_glyph); |
} |
static void |
_cairo_sub_font_glyph_collect (void *entry, void *closure) |
{ |
cairo_sub_font_glyph_t *sub_font_glyph = entry; |
cairo_sub_font_collection_t *collection = closure; |
unsigned long scaled_font_glyph_index; |
unsigned int subset_glyph_index; |
if (sub_font_glyph->subset_id != collection->subset_id) |
return; |
scaled_font_glyph_index = sub_font_glyph->base.hash; |
subset_glyph_index = sub_font_glyph->subset_glyph_index; |
/* Ensure we don't exceed the allocated bounds. */ |
assert (subset_glyph_index < collection->glyphs_size); |
collection->glyphs[subset_glyph_index] = scaled_font_glyph_index; |
collection->utf8[subset_glyph_index] = sub_font_glyph->utf8; |
if (subset_glyph_index > collection->max_glyph) |
collection->max_glyph = subset_glyph_index; |
collection->num_glyphs++; |
} |
static cairo_bool_t |
_cairo_sub_fonts_equal (const void *key_a, const void *key_b) |
{ |
const cairo_sub_font_t *sub_font_a = key_a; |
const cairo_sub_font_t *sub_font_b = key_b; |
cairo_scaled_font_t *a = sub_font_a->scaled_font; |
cairo_scaled_font_t *b = sub_font_b->scaled_font; |
if (sub_font_a->is_scaled) |
return a == b; |
else |
return a->font_face == b->font_face || a->original_font_face == b->original_font_face; |
} |
static void |
_cairo_sub_font_init_key (cairo_sub_font_t *sub_font, |
cairo_scaled_font_t *scaled_font) |
{ |
if (sub_font->is_scaled) |
{ |
sub_font->base.hash = (unsigned long) scaled_font; |
sub_font->scaled_font = scaled_font; |
} |
else |
{ |
sub_font->base.hash = (unsigned long) scaled_font->font_face; |
sub_font->scaled_font = scaled_font; |
} |
} |
static cairo_status_t |
_cairo_sub_font_create (cairo_scaled_font_subsets_t *parent, |
cairo_scaled_font_t *scaled_font, |
unsigned int font_id, |
int max_glyphs_per_subset, |
cairo_bool_t is_scaled, |
cairo_bool_t is_composite, |
cairo_sub_font_t **sub_font_out) |
{ |
cairo_sub_font_t *sub_font; |
cairo_status_t status; |
cairo_scaled_font_subsets_glyph_t subset_glyph; |
sub_font = malloc (sizeof (cairo_sub_font_t)); |
if (unlikely (sub_font == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
sub_font->is_scaled = is_scaled; |
sub_font->is_composite = is_composite; |
sub_font->is_user = _cairo_font_face_is_user (scaled_font->font_face); |
_cairo_sub_font_init_key (sub_font, scaled_font); |
sub_font->parent = parent; |
sub_font->scaled_font = scaled_font; |
sub_font->font_id = font_id; |
sub_font->current_subset = 0; |
sub_font->num_glyphs_in_current_subset = 0; |
sub_font->max_glyphs_per_subset = max_glyphs_per_subset; |
sub_font->sub_font_glyphs = _cairo_hash_table_create (_cairo_sub_font_glyphs_equal); |
if (unlikely (sub_font->sub_font_glyphs == NULL)) { |
free (sub_font); |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
} |
sub_font->next = NULL; |
/* Reserve first glyph in subset for the .notdef glyph except for |
* Type 3 fonts */ |
if (! is_scaled) { |
status = _cairo_sub_font_map_glyph (sub_font, 0, NULL, -1, &subset_glyph); |
if (unlikely (status)) { |
_cairo_hash_table_destroy (sub_font->sub_font_glyphs); |
free (sub_font); |
return status; |
} |
} |
*sub_font_out = sub_font; |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
_cairo_sub_font_destroy (cairo_sub_font_t *sub_font) |
{ |
_cairo_hash_table_foreach (sub_font->sub_font_glyphs, |
_cairo_sub_font_glyph_pluck, |
sub_font->sub_font_glyphs); |
_cairo_hash_table_destroy (sub_font->sub_font_glyphs); |
cairo_scaled_font_destroy (sub_font->scaled_font); |
free (sub_font); |
} |
static void |
_cairo_sub_font_pluck (void *entry, void *closure) |
{ |
cairo_sub_font_t *sub_font = entry; |
cairo_hash_table_t *sub_fonts = closure; |
_cairo_hash_table_remove (sub_fonts, &sub_font->base); |
_cairo_sub_font_destroy (sub_font); |
} |
static cairo_status_t |
_cairo_sub_font_glyph_lookup_unicode (cairo_sub_font_glyph_t *sub_font_glyph, |
cairo_scaled_font_t *scaled_font, |
unsigned long scaled_font_glyph_index) |
{ |
uint32_t unicode; |
char buf[8]; |
int len; |
cairo_status_t status; |
/* Do a reverse lookup on the glyph index. unicode is -1 if the |
* index could not be mapped to a unicode character. */ |
unicode = -1; |
status = _cairo_truetype_index_to_ucs4 (scaled_font, |
scaled_font_glyph_index, |
&unicode); |
if (_cairo_status_is_error (status)) |
return status; |
if (unicode == (uint32_t)-1 && scaled_font->backend->index_to_ucs4) { |
status = scaled_font->backend->index_to_ucs4 (scaled_font, |
scaled_font_glyph_index, |
&unicode); |
if (unlikely (status)) |
return status; |
} |
sub_font_glyph->unicode = unicode; |
sub_font_glyph->utf8 = NULL; |
sub_font_glyph->utf8_len = 0; |
if (unicode != (uint32_t) -1) { |
len = _cairo_ucs4_to_utf8 (unicode, buf); |
if (len > 0) { |
sub_font_glyph->utf8 = malloc (len + 1); |
if (unlikely (sub_font_glyph->utf8 == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
memcpy (sub_font_glyph->utf8, buf, len); |
sub_font_glyph->utf8[len] = 0; |
sub_font_glyph->utf8_len = len; |
} |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_sub_font_glyph_map_to_unicode (cairo_sub_font_glyph_t *sub_font_glyph, |
const char *utf8, |
int utf8_len, |
cairo_bool_t *is_mapped) |
{ |
*is_mapped = FALSE; |
if (utf8_len < 0) |
return CAIRO_STATUS_SUCCESS; |
if (utf8 != NULL && utf8_len != 0 && utf8[utf8_len - 1] == '\0') |
utf8_len--; |
if (utf8 != NULL && utf8_len != 0) { |
if (sub_font_glyph->utf8 != NULL) { |
if (utf8_len == sub_font_glyph->utf8_len && |
memcmp (utf8, sub_font_glyph->utf8, utf8_len) == 0) |
{ |
/* Requested utf8 mapping matches the existing mapping */ |
*is_mapped = TRUE; |
} |
} else { |
/* No existing mapping. Use the requested mapping */ |
sub_font_glyph->utf8 = malloc (utf8_len + 1); |
if (unlikely (sub_font_glyph->utf8 == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
memcpy (sub_font_glyph->utf8, utf8, utf8_len); |
sub_font_glyph->utf8[utf8_len] = 0; |
sub_font_glyph->utf8_len = utf8_len; |
*is_mapped = TRUE; |
} |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
_cairo_sub_font_lookup_glyph (cairo_sub_font_t *sub_font, |
unsigned long scaled_font_glyph_index, |
const char *utf8, |
int utf8_len, |
cairo_scaled_font_subsets_glyph_t *subset_glyph) |
{ |
cairo_sub_font_glyph_t key, *sub_font_glyph; |
cairo_int_status_t status; |
_cairo_sub_font_glyph_init_key (&key, scaled_font_glyph_index); |
sub_font_glyph = _cairo_hash_table_lookup (sub_font->sub_font_glyphs, |
&key.base); |
if (sub_font_glyph != NULL) { |
subset_glyph->font_id = sub_font->font_id; |
subset_glyph->subset_id = sub_font_glyph->subset_id; |
subset_glyph->subset_glyph_index = sub_font_glyph->subset_glyph_index; |
subset_glyph->is_scaled = sub_font->is_scaled; |
subset_glyph->is_composite = sub_font->is_composite; |
subset_glyph->x_advance = sub_font_glyph->x_advance; |
subset_glyph->y_advance = sub_font_glyph->y_advance; |
status = _cairo_sub_font_glyph_map_to_unicode (sub_font_glyph, |
utf8, utf8_len, |
&subset_glyph->utf8_is_mapped); |
subset_glyph->unicode = sub_font_glyph->unicode; |
return status; |
} |
return CAIRO_INT_STATUS_UNSUPPORTED; |
} |
static cairo_status_t |
_cairo_sub_font_map_glyph (cairo_sub_font_t *sub_font, |
unsigned long scaled_font_glyph_index, |
const char *utf8, |
int utf8_len, |
cairo_scaled_font_subsets_glyph_t *subset_glyph) |
{ |
cairo_sub_font_glyph_t key, *sub_font_glyph; |
cairo_status_t status; |
_cairo_sub_font_glyph_init_key (&key, scaled_font_glyph_index); |
sub_font_glyph = _cairo_hash_table_lookup (sub_font->sub_font_glyphs, |
&key.base); |
if (sub_font_glyph == NULL) { |
cairo_scaled_glyph_t *scaled_glyph; |
if (sub_font->num_glyphs_in_current_subset == sub_font->max_glyphs_per_subset) |
{ |
cairo_scaled_font_subsets_glyph_t tmp_subset_glyph; |
sub_font->current_subset++; |
sub_font->num_glyphs_in_current_subset = 0; |
/* Reserve first glyph in subset for the .notdef glyph |
* except for Type 3 fonts */ |
if (! _cairo_font_face_is_user (sub_font->scaled_font->font_face)) { |
status = _cairo_sub_font_map_glyph (sub_font, 0, NULL, -1, &tmp_subset_glyph); |
if (unlikely (status)) |
return status; |
} |
} |
_cairo_scaled_font_freeze_cache (sub_font->scaled_font); |
status = _cairo_scaled_glyph_lookup (sub_font->scaled_font, |
scaled_font_glyph_index, |
CAIRO_SCALED_GLYPH_INFO_METRICS, |
&scaled_glyph); |
assert (status != CAIRO_INT_STATUS_UNSUPPORTED); |
if (unlikely (status)) { |
_cairo_scaled_font_thaw_cache (sub_font->scaled_font); |
return status; |
} |
sub_font_glyph = _cairo_sub_font_glyph_create (scaled_font_glyph_index, |
sub_font->current_subset, |
sub_font->num_glyphs_in_current_subset, |
scaled_glyph->metrics.x_advance, |
scaled_glyph->metrics.y_advance); |
_cairo_scaled_font_thaw_cache (sub_font->scaled_font); |
if (unlikely (sub_font_glyph == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
status = _cairo_sub_font_glyph_lookup_unicode (sub_font_glyph, |
sub_font->scaled_font, |
scaled_font_glyph_index); |
if (unlikely (status)) { |
_cairo_sub_font_glyph_destroy (sub_font_glyph); |
return status; |
} |
status = _cairo_hash_table_insert (sub_font->sub_font_glyphs, &sub_font_glyph->base); |
if (unlikely (status)) { |
_cairo_sub_font_glyph_destroy (sub_font_glyph); |
return status; |
} |
sub_font->num_glyphs_in_current_subset++; |
if (sub_font->is_scaled) { |
if (sub_font->num_glyphs_in_current_subset > sub_font->parent->max_glyphs_per_scaled_subset_used) |
sub_font->parent->max_glyphs_per_scaled_subset_used = sub_font->num_glyphs_in_current_subset; |
} else { |
if (sub_font->num_glyphs_in_current_subset > sub_font->parent->max_glyphs_per_unscaled_subset_used) |
sub_font->parent->max_glyphs_per_unscaled_subset_used = sub_font->num_glyphs_in_current_subset; |
} |
} |
subset_glyph->font_id = sub_font->font_id; |
subset_glyph->subset_id = sub_font_glyph->subset_id; |
subset_glyph->subset_glyph_index = sub_font_glyph->subset_glyph_index; |
subset_glyph->is_scaled = sub_font->is_scaled; |
subset_glyph->is_composite = sub_font->is_composite; |
subset_glyph->x_advance = sub_font_glyph->x_advance; |
subset_glyph->y_advance = sub_font_glyph->y_advance; |
status = _cairo_sub_font_glyph_map_to_unicode (sub_font_glyph, |
utf8, utf8_len, |
&subset_glyph->utf8_is_mapped); |
subset_glyph->unicode = sub_font_glyph->unicode; |
return status; |
} |
static void |
_cairo_sub_font_collect (void *entry, void *closure) |
{ |
cairo_sub_font_t *sub_font = entry; |
cairo_sub_font_collection_t *collection = closure; |
cairo_scaled_font_subset_t subset; |
int i; |
unsigned int j; |
if (collection->status) |
return; |
collection->status = sub_font->scaled_font->status; |
if (collection->status) |
return; |
for (i = 0; i <= sub_font->current_subset; i++) { |
collection->subset_id = i; |
collection->num_glyphs = 0; |
collection->max_glyph = 0; |
_cairo_hash_table_foreach (sub_font->sub_font_glyphs, |
_cairo_sub_font_glyph_collect, collection); |
if (collection->status) |
break; |
if (collection->num_glyphs == 0) |
continue; |
/* Ensure the resulting array has no uninitialized holes */ |
assert (collection->num_glyphs == collection->max_glyph + 1); |
subset.scaled_font = sub_font->scaled_font; |
subset.is_composite = sub_font->is_composite; |
subset.is_scaled = sub_font->is_scaled; |
subset.font_id = sub_font->font_id; |
subset.subset_id = i; |
subset.glyphs = collection->glyphs; |
subset.utf8 = collection->utf8; |
subset.num_glyphs = collection->num_glyphs; |
subset.glyph_names = NULL; |
/* No need to check for out of memory here. If to_unicode is NULL, the PDF |
* surface does not emit an ToUnicode stream */ |
subset.to_unicode = _cairo_malloc_ab (collection->num_glyphs, sizeof (unsigned long)); |
if (subset.to_unicode) { |
for (j = 0; j < collection->num_glyphs; j++) { |
/* default unicode character required when mapping fails */ |
subset.to_unicode[j] = 0xfffd; |
} |
} |
collection->status = (collection->font_subset_callback) (&subset, |
collection->font_subset_callback_closure); |
if (subset.to_unicode != NULL) |
free (subset.to_unicode); |
if (subset.glyph_names != NULL) { |
for (j = 0; j < collection->num_glyphs; j++) |
free (subset.glyph_names[j]); |
free (subset.glyph_names); |
} |
if (collection->status) |
break; |
} |
} |
static cairo_scaled_font_subsets_t * |
_cairo_scaled_font_subsets_create_internal (cairo_subsets_type_t type) |
{ |
cairo_scaled_font_subsets_t *subsets; |
subsets = malloc (sizeof (cairo_scaled_font_subsets_t)); |
if (unlikely (subsets == NULL)) { |
_cairo_error_throw (CAIRO_STATUS_NO_MEMORY); |
return NULL; |
} |
subsets->type = type; |
subsets->max_glyphs_per_unscaled_subset_used = 0; |
subsets->max_glyphs_per_scaled_subset_used = 0; |
subsets->num_sub_fonts = 0; |
subsets->unscaled_sub_fonts = _cairo_hash_table_create (_cairo_sub_fonts_equal); |
if (! subsets->unscaled_sub_fonts) { |
free (subsets); |
return NULL; |
} |
subsets->unscaled_sub_fonts_list = NULL; |
subsets->unscaled_sub_fonts_list_end = NULL; |
subsets->scaled_sub_fonts = _cairo_hash_table_create (_cairo_sub_fonts_equal); |
if (! subsets->scaled_sub_fonts) { |
_cairo_hash_table_destroy (subsets->unscaled_sub_fonts); |
free (subsets); |
return NULL; |
} |
subsets->scaled_sub_fonts_list = NULL; |
subsets->scaled_sub_fonts_list_end = NULL; |
return subsets; |
} |
cairo_scaled_font_subsets_t * |
_cairo_scaled_font_subsets_create_scaled (void) |
{ |
return _cairo_scaled_font_subsets_create_internal (CAIRO_SUBSETS_SCALED); |
} |
cairo_scaled_font_subsets_t * |
_cairo_scaled_font_subsets_create_simple (void) |
{ |
return _cairo_scaled_font_subsets_create_internal (CAIRO_SUBSETS_SIMPLE); |
} |
cairo_scaled_font_subsets_t * |
_cairo_scaled_font_subsets_create_composite (void) |
{ |
return _cairo_scaled_font_subsets_create_internal (CAIRO_SUBSETS_COMPOSITE); |
} |
void |
_cairo_scaled_font_subsets_destroy (cairo_scaled_font_subsets_t *subsets) |
{ |
_cairo_hash_table_foreach (subsets->scaled_sub_fonts, _cairo_sub_font_pluck, subsets->scaled_sub_fonts); |
_cairo_hash_table_destroy (subsets->scaled_sub_fonts); |
_cairo_hash_table_foreach (subsets->unscaled_sub_fonts, _cairo_sub_font_pluck, subsets->unscaled_sub_fonts); |
_cairo_hash_table_destroy (subsets->unscaled_sub_fonts); |
free (subsets); |
} |
cairo_status_t |
_cairo_scaled_font_subsets_map_glyph (cairo_scaled_font_subsets_t *subsets, |
cairo_scaled_font_t *scaled_font, |
unsigned long scaled_font_glyph_index, |
const char * utf8, |
int utf8_len, |
cairo_scaled_font_subsets_glyph_t *subset_glyph) |
{ |
cairo_sub_font_t key, *sub_font; |
cairo_scaled_glyph_t *scaled_glyph; |
cairo_font_face_t *font_face; |
cairo_matrix_t identity; |
cairo_font_options_t font_options; |
cairo_scaled_font_t *unscaled_font; |
cairo_status_t status; |
int max_glyphs; |
cairo_bool_t type1_font; |
/* Lookup glyph in unscaled subsets */ |
if (subsets->type != CAIRO_SUBSETS_SCALED) { |
key.is_scaled = FALSE; |
_cairo_sub_font_init_key (&key, scaled_font); |
sub_font = _cairo_hash_table_lookup (subsets->unscaled_sub_fonts, |
&key.base); |
if (sub_font != NULL) { |
status = _cairo_sub_font_lookup_glyph (sub_font, |
scaled_font_glyph_index, |
utf8, utf8_len, |
subset_glyph); |
if (status != CAIRO_INT_STATUS_UNSUPPORTED) |
return status; |
} |
} |
/* Lookup glyph in scaled subsets */ |
key.is_scaled = TRUE; |
_cairo_sub_font_init_key (&key, scaled_font); |
sub_font = _cairo_hash_table_lookup (subsets->scaled_sub_fonts, |
&key.base); |
if (sub_font != NULL) { |
status = _cairo_sub_font_lookup_glyph (sub_font, |
scaled_font_glyph_index, |
utf8, utf8_len, |
subset_glyph); |
if (status != CAIRO_INT_STATUS_UNSUPPORTED) |
return status; |
} |
/* Glyph not found. Determine whether the glyph is outline or |
* bitmap and add to the appropriate subset. |
* |
* glyph_index 0 (the .notdef glyph) is a special case. Some fonts |
* will return CAIRO_INT_STATUS_UNSUPPORTED when doing a |
* _scaled_glyph_lookup(_GLYPH_INFO_PATH). Type1-fallback creates |
* empty glyphs in this case so we can put the glyph in a unscaled |
* subset. */ |
if (scaled_font_glyph_index == 0 || |
_cairo_font_face_is_user (scaled_font->font_face)) { |
status = CAIRO_STATUS_SUCCESS; |
} else { |
_cairo_scaled_font_freeze_cache (scaled_font); |
status = _cairo_scaled_glyph_lookup (scaled_font, |
scaled_font_glyph_index, |
CAIRO_SCALED_GLYPH_INFO_PATH, |
&scaled_glyph); |
_cairo_scaled_font_thaw_cache (scaled_font); |
} |
if (_cairo_status_is_error (status)) |
return status; |
if (status == CAIRO_STATUS_SUCCESS && |
subsets->type != CAIRO_SUBSETS_SCALED && |
! _cairo_font_face_is_user (scaled_font->font_face)) |
{ |
/* Path available. Add to unscaled subset. */ |
key.is_scaled = FALSE; |
_cairo_sub_font_init_key (&key, scaled_font); |
sub_font = _cairo_hash_table_lookup (subsets->unscaled_sub_fonts, |
&key.base); |
if (sub_font == NULL) { |
font_face = cairo_scaled_font_get_font_face (scaled_font); |
cairo_matrix_init_identity (&identity); |
_cairo_font_options_init_default (&font_options); |
cairo_font_options_set_hint_style (&font_options, CAIRO_HINT_STYLE_NONE); |
cairo_font_options_set_hint_metrics (&font_options, CAIRO_HINT_METRICS_OFF); |
unscaled_font = cairo_scaled_font_create (font_face, |
&identity, |
&identity, |
&font_options); |
if (unlikely (unscaled_font->status)) |
return unscaled_font->status; |
subset_glyph->is_scaled = FALSE; |
type1_font = FALSE; |
#if CAIRO_HAS_FT_FONT |
type1_font = _cairo_type1_scaled_font_is_type1 (unscaled_font); |
#endif |
if (subsets->type == CAIRO_SUBSETS_COMPOSITE && !type1_font) { |
max_glyphs = MAX_GLYPHS_PER_COMPOSITE_FONT; |
subset_glyph->is_composite = TRUE; |
} else { |
max_glyphs = MAX_GLYPHS_PER_SIMPLE_FONT; |
subset_glyph->is_composite = FALSE; |
} |
status = _cairo_sub_font_create (subsets, |
unscaled_font, |
subsets->num_sub_fonts, |
max_glyphs, |
subset_glyph->is_scaled, |
subset_glyph->is_composite, |
&sub_font); |
if (unlikely (status)) { |
cairo_scaled_font_destroy (unscaled_font); |
return status; |
} |
status = _cairo_hash_table_insert (subsets->unscaled_sub_fonts, |
&sub_font->base); |
if (unlikely (status)) { |
_cairo_sub_font_destroy (sub_font); |
return status; |
} |
if (!subsets->unscaled_sub_fonts_list) |
subsets->unscaled_sub_fonts_list = sub_font; |
else |
subsets->unscaled_sub_fonts_list_end->next = sub_font; |
subsets->unscaled_sub_fonts_list_end = sub_font; |
subsets->num_sub_fonts++; |
} |
} else { |
/* No path available. Add to scaled subset. */ |
key.is_scaled = TRUE; |
_cairo_sub_font_init_key (&key, scaled_font); |
sub_font = _cairo_hash_table_lookup (subsets->scaled_sub_fonts, |
&key.base); |
if (sub_font == NULL) { |
subset_glyph->is_scaled = TRUE; |
subset_glyph->is_composite = FALSE; |
if (subsets->type == CAIRO_SUBSETS_SCALED) |
max_glyphs = INT_MAX; |
else |
max_glyphs = MAX_GLYPHS_PER_SIMPLE_FONT; |
status = _cairo_sub_font_create (subsets, |
cairo_scaled_font_reference (scaled_font), |
subsets->num_sub_fonts, |
max_glyphs, |
subset_glyph->is_scaled, |
subset_glyph->is_composite, |
&sub_font); |
if (unlikely (status)) { |
cairo_scaled_font_destroy (scaled_font); |
return status; |
} |
status = _cairo_hash_table_insert (subsets->scaled_sub_fonts, |
&sub_font->base); |
if (unlikely (status)) { |
_cairo_sub_font_destroy (sub_font); |
return status; |
} |
if (!subsets->scaled_sub_fonts_list) |
subsets->scaled_sub_fonts_list = sub_font; |
else |
subsets->scaled_sub_fonts_list_end->next = sub_font; |
subsets->scaled_sub_fonts_list_end = sub_font; |
subsets->num_sub_fonts++; |
} |
} |
return _cairo_sub_font_map_glyph (sub_font, |
scaled_font_glyph_index, |
utf8, utf8_len, |
subset_glyph); |
} |
static cairo_status_t |
_cairo_scaled_font_subsets_foreach_internal (cairo_scaled_font_subsets_t *font_subsets, |
cairo_scaled_font_subset_callback_func_t font_subset_callback, |
void *closure, |
cairo_subsets_foreach_type_t type) |
{ |
cairo_sub_font_collection_t collection; |
cairo_sub_font_t *sub_font; |
cairo_bool_t is_scaled, is_user; |
is_scaled = FALSE; |
is_user = FALSE; |
if (type == CAIRO_SUBSETS_FOREACH_USER) |
is_user = TRUE; |
if (type == CAIRO_SUBSETS_FOREACH_SCALED || |
type == CAIRO_SUBSETS_FOREACH_USER) |
{ |
is_scaled = TRUE; |
} |
if (is_scaled) |
collection.glyphs_size = font_subsets->max_glyphs_per_scaled_subset_used; |
else |
collection.glyphs_size = font_subsets->max_glyphs_per_unscaled_subset_used; |
if (! collection.glyphs_size) |
return CAIRO_STATUS_SUCCESS; |
collection.glyphs = _cairo_malloc_ab (collection.glyphs_size, sizeof(unsigned long)); |
collection.utf8 = _cairo_malloc_ab (collection.glyphs_size, sizeof(char *)); |
if (unlikely (collection.glyphs == NULL || collection.utf8 == NULL)) { |
if (collection.glyphs != NULL) |
free (collection.glyphs); |
if (collection.utf8 != NULL) |
free (collection.utf8); |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
} |
collection.font_subset_callback = font_subset_callback; |
collection.font_subset_callback_closure = closure; |
collection.status = CAIRO_STATUS_SUCCESS; |
if (is_scaled) |
sub_font = font_subsets->scaled_sub_fonts_list; |
else |
sub_font = font_subsets->unscaled_sub_fonts_list; |
while (sub_font) { |
if (sub_font->is_user == is_user) |
_cairo_sub_font_collect (sub_font, &collection); |
sub_font = sub_font->next; |
} |
free (collection.utf8); |
free (collection.glyphs); |
return collection.status; |
} |
cairo_status_t |
_cairo_scaled_font_subsets_foreach_scaled (cairo_scaled_font_subsets_t *font_subsets, |
cairo_scaled_font_subset_callback_func_t font_subset_callback, |
void *closure) |
{ |
return _cairo_scaled_font_subsets_foreach_internal (font_subsets, |
font_subset_callback, |
closure, |
CAIRO_SUBSETS_FOREACH_SCALED); |
} |
cairo_status_t |
_cairo_scaled_font_subsets_foreach_unscaled (cairo_scaled_font_subsets_t *font_subsets, |
cairo_scaled_font_subset_callback_func_t font_subset_callback, |
void *closure) |
{ |
return _cairo_scaled_font_subsets_foreach_internal (font_subsets, |
font_subset_callback, |
closure, |
CAIRO_SUBSETS_FOREACH_UNSCALED); |
} |
cairo_status_t |
_cairo_scaled_font_subsets_foreach_user (cairo_scaled_font_subsets_t *font_subsets, |
cairo_scaled_font_subset_callback_func_t font_subset_callback, |
void *closure) |
{ |
return _cairo_scaled_font_subsets_foreach_internal (font_subsets, |
font_subset_callback, |
closure, |
CAIRO_SUBSETS_FOREACH_USER); |
} |
static cairo_bool_t |
_cairo_string_equal (const void *key_a, const void *key_b) |
{ |
const cairo_string_entry_t *a = key_a; |
const cairo_string_entry_t *b = key_b; |
if (strcmp (a->string, b->string) == 0) |
return TRUE; |
else |
return FALSE; |
} |
static void |
_cairo_string_init_key (cairo_string_entry_t *key, char *s) |
{ |
unsigned long sum = 0; |
unsigned int i; |
for (i = 0; i < strlen(s); i++) |
sum += s[i]; |
key->base.hash = sum; |
key->string = s; |
} |
static cairo_status_t |
create_string_entry (char *s, cairo_string_entry_t **entry) |
{ |
*entry = malloc (sizeof (cairo_string_entry_t)); |
if (unlikely (*entry == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
_cairo_string_init_key (*entry, s); |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
_pluck_entry (void *entry, void *closure) |
{ |
_cairo_hash_table_remove (closure, entry); |
free (entry); |
} |
cairo_int_status_t |
_cairo_scaled_font_subset_create_glyph_names (cairo_scaled_font_subset_t *subset) |
{ |
unsigned int i; |
cairo_hash_table_t *names; |
cairo_string_entry_t key, *entry; |
char buf[30]; |
char *utf8; |
uint16_t *utf16; |
int utf16_len; |
cairo_status_t status = CAIRO_STATUS_SUCCESS; |
names = _cairo_hash_table_create (_cairo_string_equal); |
if (unlikely (names == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
subset->glyph_names = calloc (subset->num_glyphs, sizeof (char *)); |
if (unlikely (subset->glyph_names == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto CLEANUP_HASH; |
} |
i = 0; |
if (! subset->is_scaled) { |
subset->glyph_names[0] = strdup (".notdef"); |
if (unlikely (subset->glyph_names[0] == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto CLEANUP_HASH; |
} |
status = create_string_entry (subset->glyph_names[0], &entry); |
if (unlikely (status)) |
goto CLEANUP_HASH; |
status = _cairo_hash_table_insert (names, &entry->base); |
if (unlikely (status)) { |
free (entry); |
goto CLEANUP_HASH; |
} |
i++; |
} |
for (; i < subset->num_glyphs; i++) { |
utf8 = subset->utf8[i]; |
utf16 = NULL; |
utf16_len = 0; |
if (utf8 && *utf8) { |
status = _cairo_utf8_to_utf16 (utf8, -1, &utf16, &utf16_len); |
if (unlikely (status)) |
goto CLEANUP_HASH; |
} |
if (utf16_len == 1) { |
snprintf (buf, sizeof (buf), "uni%04X", (int) utf16[0]); |
_cairo_string_init_key (&key, buf); |
entry = _cairo_hash_table_lookup (names, &key.base); |
if (entry != NULL) |
snprintf (buf, sizeof (buf), "g%d", i); |
} else { |
snprintf (buf, sizeof (buf), "g%d", i); |
} |
if (utf16) |
free (utf16); |
subset->glyph_names[i] = strdup (buf); |
if (unlikely (subset->glyph_names[i] == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto CLEANUP_HASH; |
} |
status = create_string_entry (subset->glyph_names[i], &entry); |
if (unlikely (status)) |
goto CLEANUP_HASH; |
status = _cairo_hash_table_insert (names, &entry->base); |
if (unlikely (status)) { |
free (entry); |
goto CLEANUP_HASH; |
} |
} |
CLEANUP_HASH: |
_cairo_hash_table_foreach (names, _pluck_entry, names); |
_cairo_hash_table_destroy (names); |
if (likely (status == CAIRO_STATUS_SUCCESS)) |
return CAIRO_STATUS_SUCCESS; |
if (subset->glyph_names != NULL) { |
for (i = 0; i < subset->num_glyphs; i++) { |
if (subset->glyph_names[i] != NULL) |
free (subset->glyph_names[i]); |
} |
free (subset->glyph_names); |
subset->glyph_names = NULL; |
} |
return status; |
} |
#endif /* CAIRO_HAS_FONT_SUBSET */ |
/programs/develop/libraries/cairo/src/cairo-svg-surface.c |
---|
0,0 → 1,2848 |
/* vim: set sw=4 sts=4: -*- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -*- */ |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2004 Red Hat, Inc |
* Copyright © 2005-2007 Emmanuel Pacaud <emmanuel.pacaud@free.fr> |
* Copyright © 2006 Red Hat, Inc |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is University of Southern |
* California. |
* |
* Contributor(s): |
* Kristian Høgsberg <krh@redhat.com> |
* Emmanuel Pacaud <emmanuel.pacaud@free.fr> |
* Carl Worth <cworth@cworth.org> |
*/ |
#define _BSD_SOURCE /* for snprintf() */ |
#include "cairoint.h" |
#include "cairo-svg.h" |
#include "cairo-analysis-surface-private.h" |
#include "cairo-error-private.h" |
#include "cairo-image-info-private.h" |
#include "cairo-recording-surface-private.h" |
#include "cairo-output-stream-private.h" |
#include "cairo-path-fixed-private.h" |
#include "cairo-paginated-private.h" |
#include "cairo-scaled-font-subsets-private.h" |
#include "cairo-surface-clipper-private.h" |
#include "cairo-svg-surface-private.h" |
/** |
* SECTION:cairo-svg |
* @Title: SVG Surfaces |
* @Short_Description: Rendering SVG documents |
* @See_Also: #cairo_surface_t |
* |
* The SVG surface is used to render cairo graphics to |
* SVG files and is a multi-page vector surface backend. |
*/ |
/** |
* CAIRO_HAS_SVG_SURFACE: |
* |
* Defined if the SVG surface backend is available. |
* This macro can be used to conditionally compile backend-specific code. |
*/ |
typedef struct cairo_svg_page cairo_svg_page_t; |
static const int invalid_pattern_id = -1; |
static const cairo_svg_version_t _cairo_svg_versions[] = |
{ |
CAIRO_SVG_VERSION_1_1, |
CAIRO_SVG_VERSION_1_2 |
}; |
#define CAIRO_SVG_VERSION_LAST ARRAY_LENGTH (_cairo_svg_versions) |
static void |
_cairo_svg_surface_emit_path (cairo_output_stream_t *output, |
cairo_path_fixed_t *path, |
const cairo_matrix_t *ctm_inverse); |
static cairo_bool_t |
_cairo_svg_version_has_page_set_support (cairo_svg_version_t version) |
{ |
return version > CAIRO_SVG_VERSION_1_1; |
} |
static const char * _cairo_svg_version_strings[CAIRO_SVG_VERSION_LAST] = |
{ |
"SVG 1.1", |
"SVG 1.2" |
}; |
static const char * _cairo_svg_internal_version_strings[CAIRO_SVG_VERSION_LAST] = |
{ |
"1.1", |
"1.2" |
}; |
struct cairo_svg_page { |
unsigned int surface_id; |
unsigned int clip_level; |
cairo_output_stream_t *xml_node; |
}; |
struct cairo_svg_document { |
cairo_output_stream_t *output_stream; |
unsigned long refcount; |
cairo_surface_t *owner; |
cairo_bool_t finished; |
double width; |
double height; |
cairo_output_stream_t *xml_node_defs; |
cairo_output_stream_t *xml_node_glyphs; |
unsigned int linear_pattern_id; |
unsigned int radial_pattern_id; |
unsigned int pattern_id; |
unsigned int filter_id; |
unsigned int clip_id; |
unsigned int mask_id; |
cairo_bool_t alpha_filter; |
cairo_svg_version_t svg_version; |
cairo_scaled_font_subsets_t *font_subsets; |
}; |
static cairo_status_t |
_cairo_svg_document_create (cairo_output_stream_t *stream, |
double width, |
double height, |
cairo_svg_version_t version, |
cairo_svg_document_t **document_out); |
static cairo_status_t |
_cairo_svg_document_destroy (cairo_svg_document_t *document); |
static cairo_status_t |
_cairo_svg_document_finish (cairo_svg_document_t *document); |
static cairo_svg_document_t * |
_cairo_svg_document_reference (cairo_svg_document_t *document); |
static unsigned int |
_cairo_svg_document_allocate_mask_id (cairo_svg_document_t *document); |
static cairo_surface_t * |
_cairo_svg_surface_create_for_document (cairo_svg_document_t *document, |
cairo_content_t content, |
double width, |
double height); |
static cairo_surface_t * |
_cairo_svg_surface_create_for_stream_internal (cairo_output_stream_t *stream, |
double width, |
double height, |
cairo_svg_version_t version); |
static const cairo_surface_backend_t cairo_svg_surface_backend; |
static const cairo_paginated_surface_backend_t cairo_svg_surface_paginated_backend; |
/** |
* cairo_svg_surface_create_for_stream: |
* @write_func: a #cairo_write_func_t to accept the output data, may be %NULL |
* to indicate a no-op @write_func. With a no-op @write_func, |
* the surface may be queried or used as a source without |
* generating any temporary files. |
* @closure: the closure argument for @write_func |
* @width_in_points: width of the surface, in points (1 point == 1/72.0 inch) |
* @height_in_points: height of the surface, in points (1 point == 1/72.0 inch) |
* |
* Creates a SVG surface of the specified size in points to be written |
* incrementally to the stream represented by @write_func and @closure. |
* |
* Return value: a pointer to the newly created surface. The caller |
* owns the surface and should call cairo_surface_destroy() when done |
* with it. |
* |
* This function always returns a valid pointer, but it will return a |
* pointer to a "nil" surface if an error such as out of memory |
* occurs. You can use cairo_surface_status() to check for this. |
* |
* Since: 1.2 |
*/ |
cairo_surface_t * |
cairo_svg_surface_create_for_stream (cairo_write_func_t write_func, |
void *closure, |
double width, |
double height) |
{ |
cairo_output_stream_t *stream; |
stream = _cairo_output_stream_create (write_func, NULL, closure); |
if (_cairo_output_stream_get_status (stream)) |
return _cairo_surface_create_in_error (_cairo_output_stream_destroy (stream)); |
return _cairo_svg_surface_create_for_stream_internal (stream, width, height, CAIRO_SVG_VERSION_1_1); |
} |
/** |
* cairo_svg_surface_create: |
* @filename: a filename for the SVG output (must be writable), %NULL may be |
* used to specify no output. This will generate a SVG surface that |
* may be queried and used as a source, without generating a |
* temporary file. |
* @width_in_points: width of the surface, in points (1 point == 1/72.0 inch) |
* @height_in_points: height of the surface, in points (1 point == 1/72.0 inch) |
* |
* Creates a SVG surface of the specified size in points to be written |
* to @filename. |
* |
* The SVG surface backend recognizes the following MIME types for the |
* data attached to a surface (see cairo_surface_set_mime_data()) when |
* it is used as a source pattern for drawing on this surface: |
* %CAIRO_MIME_TYPE_JPEG, %CAIRO_MIME_TYPE_PNG, |
* %CAIRO_MIME_TYPE_URI. If any of them is specified, the SVG backend |
* emits a href with the content of MIME data instead of a surface |
* snapshot (PNG, Base64-encoded) in the corresponding image tag. |
* |
* The unofficial MIME type %CAIRO_MIME_TYPE_URI is examined |
* first. If present, the URI is emitted as is: assuring the |
* correctness of URI is left to the client code. |
* |
* If %CAIRO_MIME_TYPE_URI is not present, but %CAIRO_MIME_TYPE_JPEG |
* or %CAIRO_MIME_TYPE_PNG is specified, the corresponding data is |
* Base64-encoded and emitted. |
* |
* Return value: a pointer to the newly created surface. The caller |
* owns the surface and should call cairo_surface_destroy() when done |
* with it. |
* |
* This function always returns a valid pointer, but it will return a |
* pointer to a "nil" surface if an error such as out of memory |
* occurs. You can use cairo_surface_status() to check for this. |
* |
* Since: 1.2 |
**/ |
cairo_surface_t * |
cairo_svg_surface_create (const char *filename, |
double width, |
double height) |
{ |
cairo_output_stream_t *stream; |
stream = _cairo_output_stream_create_for_filename (filename); |
if (_cairo_output_stream_get_status (stream)) |
return _cairo_surface_create_in_error (_cairo_output_stream_destroy (stream)); |
return _cairo_svg_surface_create_for_stream_internal (stream, width, height, CAIRO_SVG_VERSION_1_1); |
} |
static cairo_bool_t |
_cairo_surface_is_svg (cairo_surface_t *surface) |
{ |
return surface->backend == &cairo_svg_surface_backend; |
} |
/* If the abstract_surface is a paginated surface, and that paginated |
* surface's target is a svg_surface, then set svg_surface to that |
* target. Otherwise return FALSE. |
*/ |
static cairo_bool_t |
_extract_svg_surface (cairo_surface_t *surface, |
cairo_svg_surface_t **svg_surface) |
{ |
cairo_surface_t *target; |
cairo_status_t status_ignored; |
if (surface->status) |
return FALSE; |
if (surface->finished) { |
status_ignored = _cairo_surface_set_error (surface, |
_cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); |
return FALSE; |
} |
if (! _cairo_surface_is_paginated (surface)) { |
status_ignored = _cairo_surface_set_error (surface, |
_cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); |
return FALSE; |
} |
target = _cairo_paginated_surface_get_target (surface); |
if (target->status) { |
status_ignored = _cairo_surface_set_error (surface, |
target->status); |
return FALSE; |
} |
if (target->finished) { |
status_ignored = _cairo_surface_set_error (surface, |
_cairo_error (CAIRO_STATUS_SURFACE_FINISHED)); |
return FALSE; |
} |
if (! _cairo_surface_is_svg (target)) { |
status_ignored = _cairo_surface_set_error (surface, |
_cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH)); |
return FALSE; |
} |
*svg_surface = (cairo_svg_surface_t *) target; |
return TRUE; |
} |
/** |
* cairo_svg_surface_restrict_to_version: |
* @surface: a SVG #cairo_surface_t |
* @version: SVG version |
* |
* Restricts the generated SVG file to @version. See cairo_svg_get_versions() |
* for a list of available version values that can be used here. |
* |
* This function should only be called before any drawing operations |
* have been performed on the given surface. The simplest way to do |
* this is to call this function immediately after creating the |
* surface. |
* |
* Since: 1.2 |
**/ |
void |
cairo_svg_surface_restrict_to_version (cairo_surface_t *abstract_surface, |
cairo_svg_version_t version) |
{ |
cairo_svg_surface_t *surface = NULL; /* hide compiler warning */ |
if (! _extract_svg_surface (abstract_surface, &surface)) |
return; |
if (version < CAIRO_SVG_VERSION_LAST) |
surface->document->svg_version = version; |
} |
/** |
* cairo_svg_get_versions: |
* @versions: supported version list |
* @num_versions: list length |
* |
* Used to retrieve the list of supported versions. See |
* cairo_svg_surface_restrict_to_version(). |
* |
* Since: 1.2 |
**/ |
void |
cairo_svg_get_versions (cairo_svg_version_t const **versions, |
int *num_versions) |
{ |
if (versions != NULL) |
*versions = _cairo_svg_versions; |
if (num_versions != NULL) |
*num_versions = CAIRO_SVG_VERSION_LAST; |
} |
/** |
* cairo_svg_version_to_string: |
* @version: a version id |
* |
* Get the string representation of the given @version id. This function |
* will return %NULL if @version isn't valid. See cairo_svg_get_versions() |
* for a way to get the list of valid version ids. |
* |
* Return value: the string associated to given version. |
* |
* Since: 1.2 |
**/ |
const char * |
cairo_svg_version_to_string (cairo_svg_version_t version) |
{ |
if (version >= CAIRO_SVG_VERSION_LAST) |
return NULL; |
return _cairo_svg_version_strings[version]; |
} |
static cairo_bool_t |
_cliprect_covers_surface (cairo_svg_surface_t *surface, |
cairo_path_fixed_t *path) |
{ |
cairo_box_t box; |
if (_cairo_path_fixed_is_box (path, &box)) { |
if (box.p1.x <= 0 && |
box.p1.y <= 0 && |
_cairo_fixed_to_double (box.p2.x) >= surface->width && |
_cairo_fixed_to_double (box.p2.y) >= surface->height) |
{ |
return TRUE; |
} |
} |
return FALSE; |
} |
static cairo_status_t |
_cairo_svg_surface_clipper_intersect_clip_path (cairo_surface_clipper_t *clipper, |
cairo_path_fixed_t *path, |
cairo_fill_rule_t fill_rule, |
double tolerance, |
cairo_antialias_t antialias) |
{ |
cairo_svg_surface_t *surface = cairo_container_of (clipper, |
cairo_svg_surface_t, |
clipper); |
cairo_svg_document_t *document = surface->document; |
unsigned int i; |
if (path == NULL) { |
for (i = 0; i < surface->clip_level; i++) |
_cairo_output_stream_printf (surface->xml_node, "</g>\n"); |
surface->clip_level = 0; |
return CAIRO_STATUS_SUCCESS; |
} |
/* skip trivial whole-page clips */ |
if (_cliprect_covers_surface (surface, path)) |
return CAIRO_STATUS_SUCCESS; |
_cairo_output_stream_printf (document->xml_node_defs, |
"<clipPath id=\"clip%d\">\n" |
" <path ", |
document->clip_id); |
_cairo_svg_surface_emit_path (document->xml_node_defs, path, NULL); |
_cairo_output_stream_printf (document->xml_node_defs, |
"/>\n" |
"</clipPath>\n"); |
_cairo_output_stream_printf (surface->xml_node, |
"<g clip-path=\"url(#clip%d)\" " |
"clip-rule=\"%s\">\n", |
document->clip_id, |
fill_rule == CAIRO_FILL_RULE_EVEN_ODD ? |
"evenodd" : "nonzero"); |
document->clip_id++; |
surface->clip_level++; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_surface_t * |
_cairo_svg_surface_create_for_document (cairo_svg_document_t *document, |
cairo_content_t content, |
double width, |
double height) |
{ |
cairo_svg_surface_t *surface; |
cairo_surface_t *paginated; |
cairo_status_t status, status_ignored; |
surface = malloc (sizeof (cairo_svg_surface_t)); |
if (unlikely (surface == NULL)) |
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); |
_cairo_surface_init (&surface->base, |
&cairo_svg_surface_backend, |
NULL, /* device */ |
content); |
surface->width = width; |
surface->height = height; |
surface->document = _cairo_svg_document_reference (document); |
surface->clip_level = 0; |
_cairo_surface_clipper_init (&surface->clipper, |
_cairo_svg_surface_clipper_intersect_clip_path); |
surface->base_clip = document->clip_id++; |
surface->is_base_clip_emitted = FALSE; |
surface->xml_node = _cairo_memory_stream_create (); |
status = _cairo_output_stream_get_status (surface->xml_node); |
if (unlikely (status)) |
goto CLEANUP; |
_cairo_array_init (&surface->page_set, sizeof (cairo_svg_page_t)); |
if (content == CAIRO_CONTENT_COLOR) { |
_cairo_output_stream_printf (surface->xml_node, |
"<rect width=\"%f\" height=\"%f\" " |
"style=\"opacity:1;stroke:none;" |
"fill:rgb(0,0,0);\"/>\n", |
width, height); |
status = _cairo_output_stream_get_status (surface->xml_node); |
if (unlikely (status)) |
goto CLEANUP; |
} |
surface->paginated_mode = CAIRO_PAGINATED_MODE_ANALYZE; |
surface->force_fallbacks = FALSE; |
surface->content = content; |
paginated = _cairo_paginated_surface_create (&surface->base, |
surface->content, |
&cairo_svg_surface_paginated_backend); |
status = paginated->status; |
if (status == CAIRO_STATUS_SUCCESS) { |
/* paginated keeps the only reference to surface now, drop ours */ |
cairo_surface_destroy (&surface->base); |
return paginated; |
} |
/* ignore status as we are on the error path */ |
CLEANUP: |
status_ignored = _cairo_output_stream_destroy (surface->xml_node); |
status_ignored = _cairo_svg_document_destroy (document); |
free (surface); |
return _cairo_surface_create_in_error (status); |
} |
static cairo_surface_t * |
_cairo_svg_surface_create_for_stream_internal (cairo_output_stream_t *stream, |
double width, |
double height, |
cairo_svg_version_t version) |
{ |
cairo_svg_document_t *document = NULL; /* silence compiler */ |
cairo_surface_t *surface; |
cairo_status_t status; |
status = _cairo_svg_document_create (stream, |
width, height, version, |
&document); |
if (unlikely (status)) { |
surface = _cairo_surface_create_in_error (status); |
/* consume the output stream on behalf of caller */ |
status = _cairo_output_stream_destroy (stream); |
return surface; |
} |
surface = _cairo_svg_surface_create_for_document (document, CAIRO_CONTENT_COLOR_ALPHA, |
width, height); |
if (surface->status) { |
status = _cairo_svg_document_destroy (document); |
return surface; |
} |
document->owner = surface; |
status = _cairo_svg_document_destroy (document); |
/* the ref count should be 2 at this point */ |
assert (status == CAIRO_STATUS_SUCCESS); |
return surface; |
} |
static cairo_svg_page_t * |
_cairo_svg_surface_store_page (cairo_svg_surface_t *surface) |
{ |
unsigned int i; |
cairo_svg_page_t page; |
cairo_output_stream_t *stream; |
cairo_status_t status; |
stream = _cairo_memory_stream_create (); |
if (_cairo_output_stream_get_status (stream)) { |
status = _cairo_output_stream_destroy (stream); |
return NULL; |
} |
page.surface_id = surface->base.unique_id; |
page.clip_level = surface->clip_level; |
page.xml_node = surface->xml_node; |
if (_cairo_array_append (&surface->page_set, &page)) { |
status = _cairo_output_stream_destroy (stream); |
return NULL; |
} |
surface->xml_node = stream; |
surface->clip_level = 0; |
for (i = 0; i < page.clip_level; i++) |
_cairo_output_stream_printf (page.xml_node, "</g>\n"); |
_cairo_surface_clipper_reset (&surface->clipper); |
return _cairo_array_index (&surface->page_set, |
surface->page_set.num_elements - 1); |
} |
static cairo_int_status_t |
_cairo_svg_surface_copy_page (void *abstract_surface) |
{ |
cairo_svg_surface_t *surface = abstract_surface; |
cairo_svg_page_t *page; |
page = _cairo_svg_surface_store_page (surface); |
if (unlikely (page == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
_cairo_memory_stream_copy (page->xml_node, surface->xml_node); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
_cairo_svg_surface_show_page (void *abstract_surface) |
{ |
cairo_svg_surface_t *surface = abstract_surface; |
if (unlikely (_cairo_svg_surface_store_page (surface) == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
_cairo_svg_surface_emit_transform (cairo_output_stream_t *output, |
char const *attribute_str, |
const cairo_matrix_t *object_matrix, |
const cairo_matrix_t *parent_matrix) |
{ |
cairo_matrix_t matrix = *object_matrix; |
if (parent_matrix != NULL) |
cairo_matrix_multiply (&matrix, &matrix, parent_matrix); |
if (!_cairo_matrix_is_identity (&matrix)) |
_cairo_output_stream_printf (output, |
"%s=\"matrix(%f,%f,%f,%f,%f,%f)\"", |
attribute_str, |
matrix.xx, matrix.yx, |
matrix.xy, matrix.yy, |
matrix.x0, matrix.y0); |
} |
typedef struct { |
cairo_output_stream_t *output; |
const cairo_matrix_t *ctm_inverse; |
} svg_path_info_t; |
static cairo_status_t |
_cairo_svg_path_move_to (void *closure, |
const cairo_point_t *point) |
{ |
svg_path_info_t *info = closure; |
double x = _cairo_fixed_to_double (point->x); |
double y = _cairo_fixed_to_double (point->y); |
if (info->ctm_inverse) |
cairo_matrix_transform_point (info->ctm_inverse, &x, &y); |
_cairo_output_stream_printf (info->output, "M %f %f ", x, y); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_path_line_to (void *closure, |
const cairo_point_t *point) |
{ |
svg_path_info_t *info = closure; |
double x = _cairo_fixed_to_double (point->x); |
double y = _cairo_fixed_to_double (point->y); |
if (info->ctm_inverse) |
cairo_matrix_transform_point (info->ctm_inverse, &x, &y); |
_cairo_output_stream_printf (info->output, "L %f %f ", x, y); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_path_curve_to (void *closure, |
const cairo_point_t *b, |
const cairo_point_t *c, |
const cairo_point_t *d) |
{ |
svg_path_info_t *info = closure; |
double bx = _cairo_fixed_to_double (b->x); |
double by = _cairo_fixed_to_double (b->y); |
double cx = _cairo_fixed_to_double (c->x); |
double cy = _cairo_fixed_to_double (c->y); |
double dx = _cairo_fixed_to_double (d->x); |
double dy = _cairo_fixed_to_double (d->y); |
if (info->ctm_inverse) { |
cairo_matrix_transform_point (info->ctm_inverse, &bx, &by); |
cairo_matrix_transform_point (info->ctm_inverse, &cx, &cy); |
cairo_matrix_transform_point (info->ctm_inverse, &dx, &dy); |
} |
_cairo_output_stream_printf (info->output, |
"C %f %f %f %f %f %f ", |
bx, by, cx, cy, dx, dy); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_path_close_path (void *closure) |
{ |
svg_path_info_t *info = closure; |
_cairo_output_stream_printf (info->output, "Z "); |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
_cairo_svg_surface_emit_path (cairo_output_stream_t *output, |
cairo_path_fixed_t *path, |
const cairo_matrix_t *ctm_inverse) |
{ |
cairo_status_t status; |
svg_path_info_t info; |
_cairo_output_stream_printf (output, "d=\""); |
info.output = output; |
info.ctm_inverse = ctm_inverse; |
status = _cairo_path_fixed_interpret (path, |
CAIRO_DIRECTION_FORWARD, |
_cairo_svg_path_move_to, |
_cairo_svg_path_line_to, |
_cairo_svg_path_curve_to, |
_cairo_svg_path_close_path, |
&info); |
assert (status == CAIRO_STATUS_SUCCESS); |
_cairo_output_stream_printf (output, "\""); |
} |
static cairo_int_status_t |
_cairo_svg_document_emit_outline_glyph_data (cairo_svg_document_t *document, |
cairo_scaled_font_t *scaled_font, |
unsigned long glyph_index) |
{ |
cairo_scaled_glyph_t *scaled_glyph; |
cairo_int_status_t status; |
status = _cairo_scaled_glyph_lookup (scaled_font, |
glyph_index, |
CAIRO_SCALED_GLYPH_INFO_METRICS| |
CAIRO_SCALED_GLYPH_INFO_PATH, |
&scaled_glyph); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (document->xml_node_glyphs, |
"<path style=\"stroke:none;\" "); |
_cairo_svg_surface_emit_path (document->xml_node_glyphs, |
scaled_glyph->path, NULL); |
_cairo_output_stream_printf (document->xml_node_glyphs, |
"/>\n"); |
return status; |
} |
static cairo_int_status_t |
_cairo_svg_document_emit_bitmap_glyph_data (cairo_svg_document_t *document, |
cairo_scaled_font_t *scaled_font, |
unsigned long glyph_index) |
{ |
cairo_scaled_glyph_t *scaled_glyph; |
cairo_image_surface_t *image; |
cairo_status_t status; |
uint8_t *row, *byte; |
int rows, cols; |
int x, y, bit; |
status = _cairo_scaled_glyph_lookup (scaled_font, |
glyph_index, |
CAIRO_SCALED_GLYPH_INFO_METRICS | |
CAIRO_SCALED_GLYPH_INFO_SURFACE, |
&scaled_glyph); |
if (unlikely (status)) |
return status; |
image = _cairo_image_surface_coerce_to_format (scaled_glyph->surface, |
CAIRO_FORMAT_A1); |
status = image->base.status; |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (document->xml_node_glyphs, "<g"); |
_cairo_svg_surface_emit_transform (document->xml_node_glyphs, " transform", |
&image->base.device_transform_inverse, NULL); |
_cairo_output_stream_printf (document->xml_node_glyphs, ">/n"); |
for (y = 0, row = image->data, rows = image->height; rows; row += image->stride, rows--, y++) { |
for (x = 0, byte = row, cols = (image->width + 7) / 8; cols; byte++, cols--) { |
uint8_t output_byte = CAIRO_BITSWAP8_IF_LITTLE_ENDIAN (*byte); |
for (bit = 7; bit >= 0 && x < image->width; bit--, x++) { |
if (output_byte & (1 << bit)) { |
_cairo_output_stream_printf (document->xml_node_glyphs, |
"<rect x=\"%d\" y=\"%d\" width=\"1\" height=\"1\"/>\n", |
x, y); |
} |
} |
} |
} |
_cairo_output_stream_printf (document->xml_node_glyphs, "</g>\n"); |
cairo_surface_destroy (&image->base); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_document_emit_glyph (cairo_svg_document_t *document, |
cairo_scaled_font_t *scaled_font, |
unsigned long scaled_font_glyph_index, |
unsigned int font_id, |
unsigned int subset_glyph_index) |
{ |
cairo_status_t status; |
_cairo_output_stream_printf (document->xml_node_glyphs, |
"<symbol overflow=\"visible\" id=\"glyph%d-%d\">\n", |
font_id, |
subset_glyph_index); |
status = _cairo_svg_document_emit_outline_glyph_data (document, |
scaled_font, |
scaled_font_glyph_index); |
if (status == CAIRO_INT_STATUS_UNSUPPORTED) |
status = _cairo_svg_document_emit_bitmap_glyph_data (document, |
scaled_font, |
scaled_font_glyph_index); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (document->xml_node_glyphs, "</symbol>\n"); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_document_emit_font_subset (cairo_scaled_font_subset_t *font_subset, |
void *closure) |
{ |
cairo_svg_document_t *document = closure; |
unsigned int i; |
cairo_status_t status = CAIRO_STATUS_SUCCESS; |
_cairo_scaled_font_freeze_cache (font_subset->scaled_font); |
for (i = 0; i < font_subset->num_glyphs; i++) { |
status = _cairo_svg_document_emit_glyph (document, |
font_subset->scaled_font, |
font_subset->glyphs[i], |
font_subset->font_id, i); |
if (unlikely (status)) |
break; |
} |
_cairo_scaled_font_thaw_cache (font_subset->scaled_font); |
return status; |
} |
static cairo_status_t |
_cairo_svg_document_emit_font_subsets (cairo_svg_document_t *document) |
{ |
cairo_status_t status; |
status = _cairo_scaled_font_subsets_foreach_scaled (document->font_subsets, |
_cairo_svg_document_emit_font_subset, |
document); |
if (unlikely (status)) |
goto FAIL; |
status = _cairo_scaled_font_subsets_foreach_user (document->font_subsets, |
_cairo_svg_document_emit_font_subset, |
document); |
FAIL: |
_cairo_scaled_font_subsets_destroy (document->font_subsets); |
document->font_subsets = NULL; |
return status; |
} |
static char const * |
_cairo_svg_surface_operators[] = { |
"clear", |
"src", "src-over", "src-in", |
"src-out", "src-atop", |
"dst", "dst-over", "dst-in", |
"dst-out", "dst-atop", |
"xor", "plus", |
"color-dodge", /* FIXME: saturate ? */ |
"multiply", "screen", "overlay", |
"darken", "lighten", |
"color-dodge", "color-burn", |
"hard-light", "soft-light", |
"difference", "exclusion" |
}; |
static cairo_bool_t |
_cairo_svg_surface_analyze_operator (cairo_svg_surface_t *surface, |
cairo_operator_t op) |
{ |
/* guard against newly added operators */ |
if (op >= ARRAY_LENGTH (_cairo_svg_surface_operators)) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
/* allow operators being NULL if they are unsupported */ |
if (_cairo_svg_surface_operators[op] == NULL) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
_cairo_svg_surface_analyze_operation (cairo_svg_surface_t *surface, |
cairo_operator_t op, |
const cairo_pattern_t *pattern) |
{ |
cairo_svg_document_t *document = surface->document; |
if (surface->force_fallbacks && |
surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) |
{ |
return CAIRO_INT_STATUS_UNSUPPORTED; |
} |
/* SVG doesn't support extend reflect for image pattern */ |
if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE && |
pattern->extend == CAIRO_EXTEND_REFLECT) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
if (document->svg_version >= CAIRO_SVG_VERSION_1_2) |
return _cairo_svg_surface_analyze_operator (surface, op); |
if (op == CAIRO_OPERATOR_OVER) |
return CAIRO_STATUS_SUCCESS; |
/* The SOURCE operator is only supported if there is nothing |
* painted underneath. */ |
if (op == CAIRO_OPERATOR_SOURCE) |
return CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY; |
return CAIRO_INT_STATUS_UNSUPPORTED; |
} |
static cairo_int_status_t |
_cairo_svg_surface_operation_supported (cairo_svg_surface_t *surface, |
cairo_operator_t op, |
const cairo_pattern_t *pattern) |
{ |
return _cairo_svg_surface_analyze_operation (surface, op, pattern) != CAIRO_INT_STATUS_UNSUPPORTED; |
} |
static cairo_status_t |
_cairo_svg_surface_finish (void *abstract_surface) |
{ |
cairo_status_t status, status2; |
cairo_svg_surface_t *surface = abstract_surface; |
cairo_svg_document_t *document = surface->document; |
cairo_svg_page_t *page; |
unsigned int i; |
if (_cairo_paginated_surface_get_target (document->owner) == &surface->base) |
status = _cairo_svg_document_finish (document); |
else |
status = CAIRO_STATUS_SUCCESS; |
if (surface->xml_node != NULL) { |
status2 = _cairo_output_stream_destroy (surface->xml_node); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
} |
for (i = 0; i < surface->page_set.num_elements; i++) { |
page = _cairo_array_index (&surface->page_set, i); |
status2 = _cairo_output_stream_destroy (page->xml_node); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
} |
_cairo_array_fini (&surface->page_set); |
_cairo_surface_clipper_reset (&surface->clipper); |
status2 = _cairo_svg_document_destroy (document); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
return status; |
} |
static void |
_cairo_svg_surface_emit_alpha_filter (cairo_svg_document_t *document) |
{ |
if (document->alpha_filter) |
return; |
_cairo_output_stream_printf (document->xml_node_defs, |
"<filter id=\"alpha\" " |
"filterUnits=\"objectBoundingBox\" " |
"x=\"0%%\" y=\"0%%\" " |
"width=\"100%%\" height=\"100%%\">\n" |
" <feColorMatrix type=\"matrix\" " |
"in=\"SourceGraphic\" " |
"values=\"0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0\"/>\n" |
"</filter>\n"); |
document->alpha_filter = TRUE; |
} |
typedef struct { |
cairo_output_stream_t *output; |
unsigned int in_mem; |
unsigned int trailing; |
unsigned char src[3]; |
} base64_write_closure_t; |
static char const base64_table[64] = |
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; |
static cairo_status_t |
base64_write_func (void *closure, |
const unsigned char *data, |
unsigned int length) |
{ |
base64_write_closure_t *info = (base64_write_closure_t *) closure; |
unsigned int i; |
unsigned char *src; |
src = info->src; |
if (info->in_mem + length < 3) { |
for (i = 0; i < length; i++) { |
src[i + info->in_mem] = *data++; |
} |
info->in_mem += length; |
return CAIRO_STATUS_SUCCESS; |
} |
do { |
unsigned char dst[4]; |
for (i = info->in_mem; i < 3; i++) { |
src[i] = *data++; |
length--; |
} |
info->in_mem = 0; |
dst[0] = base64_table[src[0] >> 2]; |
dst[1] = base64_table[(src[0] & 0x03) << 4 | src[1] >> 4]; |
dst[2] = base64_table[(src[1] & 0x0f) << 2 | src[2] >> 6]; |
dst[3] = base64_table[src[2] & 0xfc >> 2]; |
/* Special case for the last missing bits */ |
switch (info->trailing) { |
case 2: |
dst[2] = '='; |
case 1: |
dst[3] = '='; |
default: |
break; |
} |
_cairo_output_stream_write (info->output, dst, 4); |
} while (length >= 3); |
for (i = 0; i < length; i++) { |
src[i] = *data++; |
} |
info->in_mem = length; |
return _cairo_output_stream_get_status (info->output); |
} |
static cairo_int_status_t |
_cairo_surface_base64_encode_jpeg (cairo_surface_t *surface, |
cairo_output_stream_t *output) |
{ |
const unsigned char *mime_data; |
unsigned long mime_data_length; |
cairo_image_info_t image_info; |
base64_write_closure_t info; |
cairo_status_t status; |
cairo_surface_get_mime_data (surface, CAIRO_MIME_TYPE_JPEG, |
&mime_data, &mime_data_length); |
if (mime_data == NULL) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
status = _cairo_image_info_get_jpeg_info (&image_info, mime_data, mime_data_length); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (output, "data:image/jpeg;base64,"); |
info.output = output; |
info.in_mem = 0; |
info.trailing = 0; |
status = base64_write_func (&info, mime_data, mime_data_length); |
if (unlikely (status)) |
return status; |
if (info.in_mem > 0) { |
memset (info.src + info.in_mem, 0, 3 - info.in_mem); |
info.trailing = 3 - info.in_mem; |
info.in_mem = 3; |
status = base64_write_func (&info, NULL, 0); |
} |
return status; |
} |
static cairo_int_status_t |
_cairo_surface_base64_encode_png (cairo_surface_t *surface, |
cairo_output_stream_t *output) |
{ |
const unsigned char *mime_data; |
unsigned long mime_data_length; |
base64_write_closure_t info; |
cairo_status_t status; |
cairo_surface_get_mime_data (surface, CAIRO_MIME_TYPE_PNG, |
&mime_data, &mime_data_length); |
if (unlikely (surface->status)) |
return surface->status; |
if (mime_data == NULL) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
_cairo_output_stream_printf (output, "data:image/png;base64,"); |
info.output = output; |
info.in_mem = 0; |
info.trailing = 0; |
status = base64_write_func (&info, mime_data, mime_data_length); |
if (unlikely (status)) |
return status; |
if (info.in_mem > 0) { |
memset (info.src + info.in_mem, 0, 3 - info.in_mem); |
info.trailing = 3 - info.in_mem; |
info.in_mem = 3; |
status = base64_write_func (&info, NULL, 0); |
} |
return status; |
} |
static cairo_int_status_t |
_cairo_surface_base64_encode (cairo_surface_t *surface, |
cairo_output_stream_t *output) |
{ |
cairo_status_t status; |
base64_write_closure_t info; |
status = _cairo_surface_base64_encode_jpeg (surface, output); |
if (status != CAIRO_INT_STATUS_UNSUPPORTED) |
return status; |
status = _cairo_surface_base64_encode_png (surface, output); |
if (status != CAIRO_INT_STATUS_UNSUPPORTED) |
return status; |
info.output = output; |
info.in_mem = 0; |
info.trailing = 0; |
_cairo_output_stream_printf (info.output, "data:image/png;base64,"); |
status = cairo_surface_write_to_png_stream (surface, base64_write_func, |
(void *) &info); |
if (unlikely (status)) |
return status; |
if (info.in_mem > 0) { |
memset (info.src + info.in_mem, 0, 3 - info.in_mem); |
info.trailing = 3 - info.in_mem; |
info.in_mem = 3; |
status = base64_write_func (&info, NULL, 0); |
} |
return status; |
} |
static void |
_cairo_svg_surface_emit_operator (cairo_output_stream_t *output, |
cairo_svg_surface_t *surface, |
cairo_operator_t op) |
{ |
if (surface->document->svg_version >= CAIRO_SVG_VERSION_1_2 && |
op != CAIRO_OPERATOR_OVER) { |
_cairo_output_stream_printf (output, " comp-op=\"%s\"", _cairo_svg_surface_operators[op]); |
if (!_cairo_operator_bounded_by_source (op)) |
_cairo_output_stream_printf (output, " clip-to-self=\"true\""); |
} |
} |
static void |
_cairo_svg_surface_emit_operator_for_style (cairo_output_stream_t *output, |
cairo_svg_surface_t *surface, |
cairo_operator_t op) |
{ |
if (surface->document->svg_version >= CAIRO_SVG_VERSION_1_2 && |
op != CAIRO_OPERATOR_OVER) { |
_cairo_output_stream_printf (output, "comp-op:%s;", _cairo_svg_surface_operators[op]); |
if (!_cairo_operator_bounded_by_source (op)) |
_cairo_output_stream_printf (output, "clip-to-self:true;"); |
} |
} |
/** |
* _cairo_svg_surface_emit_attr_value: |
* |
* Write the value to output the stream as a sequence of characters, |
* while escaping those which have special meaning in the XML |
* attribute's value context: & and ". |
**/ |
static void |
_cairo_svg_surface_emit_attr_value (cairo_output_stream_t *stream, |
const unsigned char *value, |
unsigned int length) |
{ |
const unsigned char *p; |
const unsigned char *q; |
unsigned int i; |
/* we'll accumulate non-special chars in [q, p) range */ |
p = value; |
q = p; |
for (i = 0; i < length; i++, p++) { |
if (*p == '&' || *p == '"') { |
/* flush what's left before special char */ |
if (p != q) { |
_cairo_output_stream_write (stream, q, p - q); |
q = p + 1; |
} |
if (*p == '&') |
_cairo_output_stream_printf (stream, "&"); |
else // p == '"' |
_cairo_output_stream_printf (stream, """); |
} |
} |
/* flush the trailing chars if any */ |
if (p != q) |
_cairo_output_stream_write (stream, q, p - q); |
} |
static cairo_status_t |
_cairo_svg_surface_emit_surface (cairo_svg_document_t *document, |
cairo_surface_t *surface) |
{ |
cairo_rectangle_int_t extents; |
cairo_bool_t is_bounded; |
cairo_status_t status; |
const unsigned char *uri; |
unsigned long uri_len; |
if (_cairo_user_data_array_get_data (&surface->user_data, |
(cairo_user_data_key_t *) document)) |
{ |
return CAIRO_STATUS_SUCCESS; |
} |
is_bounded = _cairo_surface_get_extents (surface, &extents); |
assert (is_bounded); |
_cairo_output_stream_printf (document->xml_node_defs, |
"<image id=\"image%d\" width=\"%d\" height=\"%d\"", |
surface->unique_id, |
extents.width, extents.height); |
_cairo_output_stream_printf (document->xml_node_defs, " xlink:href=\""); |
cairo_surface_get_mime_data (surface, CAIRO_MIME_TYPE_URI, |
&uri, &uri_len); |
if (uri != NULL) { |
_cairo_svg_surface_emit_attr_value (document->xml_node_defs, |
uri, uri_len); |
} else { |
status = _cairo_surface_base64_encode (surface, |
document->xml_node_defs); |
if (unlikely (status)) |
return status; |
} |
_cairo_output_stream_printf (document->xml_node_defs, "\"/>\n"); |
/* and tag it */ |
return _cairo_user_data_array_set_data (&surface->user_data, |
(cairo_user_data_key_t *) document, |
document, NULL); |
} |
static cairo_status_t |
_cairo_svg_surface_emit_composite_surface_pattern (cairo_output_stream_t *output, |
cairo_svg_surface_t *svg_surface, |
cairo_operator_t op, |
cairo_surface_pattern_t *pattern, |
int pattern_id, |
const cairo_matrix_t *parent_matrix, |
const char *extra_attributes) |
{ |
cairo_status_t status; |
cairo_matrix_t p2u; |
p2u = pattern->base.matrix; |
status = cairo_matrix_invert (&p2u); |
/* cairo_pattern_set_matrix ensures the matrix is invertible */ |
assert (status == CAIRO_STATUS_SUCCESS); |
status = _cairo_svg_surface_emit_surface (svg_surface->document, |
pattern->surface); |
if (unlikely (status)) |
return status; |
if (pattern_id != invalid_pattern_id) { |
cairo_rectangle_int_t extents; |
cairo_bool_t is_bounded; |
is_bounded = _cairo_surface_get_extents (pattern->surface, &extents); |
assert (is_bounded); |
_cairo_output_stream_printf (output, |
"<pattern id=\"pattern%d\" " |
"patternUnits=\"userSpaceOnUse\" " |
"width=\"%d\" height=\"%d\" ", |
pattern_id, |
extents.width, extents.height); |
_cairo_svg_surface_emit_transform (output, |
" patternTransform", |
&p2u, parent_matrix); |
_cairo_output_stream_printf (output, ">\n "); |
} |
_cairo_output_stream_printf (output, |
"<use xlink:href=\"#image%d\"", |
pattern->surface->unique_id); |
if (extra_attributes) |
_cairo_output_stream_printf (output, " %s", extra_attributes); |
if (pattern_id == invalid_pattern_id) { |
_cairo_svg_surface_emit_operator (output, svg_surface, op); |
_cairo_svg_surface_emit_transform (output, |
" transform", |
&p2u, parent_matrix); |
} |
_cairo_output_stream_printf (output, "/>\n"); |
if (pattern_id != invalid_pattern_id) |
_cairo_output_stream_printf (output, "</pattern>\n"); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_surface_emit_recording_surface (cairo_svg_document_t *document, |
cairo_recording_surface_t *source) |
{ |
cairo_status_t status; |
cairo_surface_t *paginated_surface; |
cairo_svg_surface_t *svg_surface; |
cairo_array_t *page_set; |
cairo_output_stream_t *contents; |
if (_cairo_user_data_array_get_data (&source->base.user_data, |
(cairo_user_data_key_t *) document)) |
{ |
return CAIRO_STATUS_SUCCESS; |
} |
paginated_surface = _cairo_svg_surface_create_for_document (document, |
source->content, |
source->extents_pixels.width, |
source->extents_pixels.height); |
if (unlikely (paginated_surface->status)) |
return paginated_surface->status; |
svg_surface = (cairo_svg_surface_t *) |
_cairo_paginated_surface_get_target (paginated_surface); |
cairo_surface_set_fallback_resolution (paginated_surface, |
document->owner->x_fallback_resolution, |
document->owner->y_fallback_resolution); |
cairo_surface_set_device_offset (&svg_surface->base, |
-source->extents_pixels.x, |
-source->extents_pixels.y); |
status = _cairo_recording_surface_replay (&source->base, paginated_surface); |
if (unlikely (status)) { |
cairo_surface_destroy (paginated_surface); |
return status; |
} |
cairo_surface_show_page (paginated_surface); |
status = cairo_surface_status (paginated_surface); |
if (unlikely (status)) { |
cairo_surface_destroy (paginated_surface); |
return status; |
} |
if (! svg_surface->is_base_clip_emitted) { |
svg_surface->is_base_clip_emitted = TRUE; |
_cairo_output_stream_printf (document->xml_node_defs, |
"<clipPath id=\"clip%d\">\n" |
" <rect width=\"%f\" height=\"%f\"/>\n" |
"</clipPath>\n", |
svg_surface->base_clip, |
svg_surface->width, |
svg_surface->height); |
} |
if (source->content == CAIRO_CONTENT_ALPHA) { |
_cairo_svg_surface_emit_alpha_filter (document); |
_cairo_output_stream_printf (document->xml_node_defs, |
"<g id=\"surface%d\" " |
"clip-path=\"url(#clip%d)\" " |
"filter=\"url(#alpha)\">\n", |
source->base.unique_id, |
svg_surface->base_clip); |
} else { |
_cairo_output_stream_printf (document->xml_node_defs, |
"<g id=\"surface%d\" " |
"clip-path=\"url(#clip%d)\">\n", |
source->base.unique_id, |
svg_surface->base_clip); |
} |
contents = svg_surface->xml_node; |
page_set = &svg_surface->page_set; |
if (_cairo_memory_stream_length (contents) > 0) { |
if (unlikely (_cairo_svg_surface_store_page (svg_surface) == NULL)) { |
cairo_surface_destroy (paginated_surface); |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
} |
} |
if (page_set->num_elements > 0) { |
cairo_svg_page_t *page; |
page = _cairo_array_index (page_set, page_set->num_elements - 1); |
_cairo_memory_stream_copy (page->xml_node, document->xml_node_defs); |
} |
_cairo_output_stream_printf (document->xml_node_defs, "</g>\n"); |
status = cairo_surface_status (paginated_surface); |
cairo_surface_destroy (paginated_surface); |
if (unlikely (status)) |
return status; |
/* and tag it */ |
return _cairo_user_data_array_set_data (&source->base.user_data, |
(cairo_user_data_key_t *) document, |
document, NULL); |
} |
static cairo_status_t |
_cairo_svg_surface_emit_composite_recording_pattern (cairo_output_stream_t *output, |
cairo_svg_surface_t *surface, |
cairo_operator_t op, |
cairo_surface_pattern_t *pattern, |
int pattern_id, |
const cairo_matrix_t *parent_matrix, |
const char *extra_attributes) |
{ |
cairo_svg_document_t *document = surface->document; |
cairo_recording_surface_t *recording_surface; |
cairo_matrix_t p2u; |
cairo_status_t status; |
p2u = pattern->base.matrix; |
status = cairo_matrix_invert (&p2u); |
/* cairo_pattern_set_matrix ensures the matrix is invertible */ |
assert (status == CAIRO_STATUS_SUCCESS); |
recording_surface = (cairo_recording_surface_t *) pattern->surface; |
status = _cairo_svg_surface_emit_recording_surface (document, recording_surface); |
if (unlikely (status)) |
return status; |
if (pattern_id != invalid_pattern_id) { |
_cairo_output_stream_printf (output, |
"<pattern id=\"pattern%d\" " |
"patternUnits=\"userSpaceOnUse\" " |
"width=\"%d\" height=\"%d\"", |
pattern_id, |
recording_surface->extents.width, |
recording_surface->extents.height); |
_cairo_svg_surface_emit_transform (output, " patternTransform", &p2u, parent_matrix); |
_cairo_output_stream_printf (output, ">\n"); |
} |
_cairo_output_stream_printf (output, |
"<use xlink:href=\"#surface%d\"", |
recording_surface->base.unique_id); |
if (pattern_id == invalid_pattern_id) { |
_cairo_svg_surface_emit_operator (output, surface, op); |
_cairo_svg_surface_emit_transform (output, " transform", &p2u, parent_matrix); |
} |
if (extra_attributes) |
_cairo_output_stream_printf (output, " %s", extra_attributes); |
_cairo_output_stream_printf (output, "/>\n"); |
if (pattern_id != invalid_pattern_id) |
_cairo_output_stream_printf (output, "</pattern>\n"); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_surface_emit_composite_pattern (cairo_output_stream_t *output, |
cairo_svg_surface_t *surface, |
cairo_operator_t op, |
cairo_surface_pattern_t *pattern, |
int pattern_id, |
const cairo_matrix_t *parent_matrix, |
const char *extra_attributes) |
{ |
if (_cairo_surface_is_recording (pattern->surface)) { |
return _cairo_svg_surface_emit_composite_recording_pattern (output, surface, |
op, pattern, |
pattern_id, |
parent_matrix, |
extra_attributes); |
} |
return _cairo_svg_surface_emit_composite_surface_pattern (output, surface, |
op, pattern, |
pattern_id, |
parent_matrix, |
extra_attributes); |
} |
static cairo_status_t |
_cairo_svg_surface_emit_solid_pattern (cairo_svg_surface_t *surface, |
cairo_solid_pattern_t *pattern, |
cairo_output_stream_t *style, |
cairo_bool_t is_stroke) |
{ |
_cairo_output_stream_printf (style, is_stroke ? |
"stroke:rgb(%f%%,%f%%,%f%%);stroke-opacity:%f;": |
"fill:rgb(%f%%,%f%%,%f%%);fill-opacity:%f;", |
pattern->color.red * 100.0, |
pattern->color.green * 100.0, |
pattern->color.blue * 100.0, |
pattern->color.alpha); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_surface_emit_surface_pattern (cairo_svg_surface_t *surface, |
cairo_surface_pattern_t *pattern, |
cairo_output_stream_t *style, |
cairo_bool_t is_stroke, |
const cairo_matrix_t *parent_matrix) |
{ |
cairo_svg_document_t *document = surface->document; |
cairo_status_t status; |
int pattern_id; |
pattern_id = document->pattern_id++; |
status = _cairo_svg_surface_emit_composite_pattern (document->xml_node_defs, |
surface, CAIRO_OPERATOR_SOURCE, pattern, |
pattern_id, parent_matrix, NULL); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (style, |
"%s:url(#pattern%d);", |
is_stroke ? "stroke" : "fill", |
pattern_id); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_surface_emit_pattern_stops (cairo_output_stream_t *output, |
cairo_gradient_pattern_t const *pattern, |
double start_offset, |
cairo_bool_t reverse_stops, |
cairo_bool_t emulate_reflect) |
{ |
cairo_gradient_stop_t *stops; |
double offset; |
unsigned int n_stops; |
unsigned int i; |
if (pattern->n_stops < 1) |
return CAIRO_STATUS_SUCCESS; |
if (pattern->n_stops == 1) { |
_cairo_output_stream_printf (output, |
"<stop offset=\"%f\" style=\"" |
"stop-color:rgb(%f%%,%f%%,%f%%);" |
"stop-opacity:%f;\"/>\n", |
pattern->stops[0].offset, |
pattern->stops[0].color.red * 100.0, |
pattern->stops[0].color.green * 100.0, |
pattern->stops[0].color.blue * 100.0, |
pattern->stops[0].color.alpha); |
return CAIRO_STATUS_SUCCESS; |
} |
if (emulate_reflect || reverse_stops) { |
n_stops = emulate_reflect ? pattern->n_stops * 2 - 2: pattern->n_stops; |
stops = _cairo_malloc_ab (n_stops, sizeof (cairo_gradient_stop_t)); |
if (unlikely (stops == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
for (i = 0; i < pattern->n_stops; i++) { |
if (reverse_stops) { |
stops[i] = pattern->stops[pattern->n_stops - i - 1]; |
stops[i].offset = 1.0 - stops[i].offset; |
} else |
stops[i] = pattern->stops[i]; |
if (emulate_reflect) { |
stops[i].offset /= 2; |
if (i > 0 && i < (pattern->n_stops - 1)) { |
if (reverse_stops) { |
stops[i + pattern->n_stops - 1] = pattern->stops[i]; |
stops[i + pattern->n_stops - 1].offset = |
0.5 + 0.5 * stops[i + pattern->n_stops - 1].offset; |
} else { |
stops[i + pattern->n_stops - 1] = pattern->stops[pattern->n_stops - i - 1]; |
stops[i + pattern->n_stops - 1].offset = |
1 - 0.5 * stops[i + pattern->n_stops - 1].offset; |
} |
} |
} |
} |
} else { |
n_stops = pattern->n_stops; |
stops = pattern->stops; |
} |
if (start_offset >= 0.0) |
for (i = 0; i < n_stops; i++) { |
offset = start_offset + (1 - start_offset ) * stops[i].offset; |
_cairo_output_stream_printf (output, |
"<stop offset=\"%f\" style=\"" |
"stop-color:rgb(%f%%,%f%%,%f%%);" |
"stop-opacity:%f;\"/>\n", |
offset, |
stops[i].color.red * 100.0, |
stops[i].color.green * 100.0, |
stops[i].color.blue * 100.0, |
stops[i].color.alpha); |
} |
else { |
cairo_bool_t found = FALSE; |
unsigned int offset_index; |
cairo_color_stop_t offset_color_start, offset_color_stop; |
for (i = 0; i < n_stops; i++) { |
if (stops[i].offset >= -start_offset) { |
if (i > 0) { |
if (stops[i].offset != stops[i-1].offset) { |
double x0, x1; |
cairo_color_stop_t *color0, *color1; |
x0 = stops[i-1].offset; |
x1 = stops[i].offset; |
color0 = &stops[i-1].color; |
color1 = &stops[i].color; |
offset_color_start.red = color0->red + (color1->red - color0->red) |
* (-start_offset - x0) / (x1 - x0); |
offset_color_start.green = color0->green + (color1->green - color0->green) |
* (-start_offset - x0) / (x1 - x0); |
offset_color_start.blue = color0->blue + (color1->blue - color0->blue) |
* (-start_offset - x0) / (x1 - x0); |
offset_color_start.alpha = color0->alpha + (color1->alpha - color0->alpha) |
* (-start_offset - x0) / (x1 - x0); |
offset_color_stop = offset_color_start; |
} else { |
offset_color_stop = stops[i-1].color; |
offset_color_start = stops[i].color; |
} |
} else |
offset_color_stop = offset_color_start = stops[i].color; |
offset_index = i; |
found = TRUE; |
break; |
} |
} |
if (!found) { |
offset_index = n_stops - 1; |
offset_color_stop = offset_color_start = stops[offset_index].color; |
} |
_cairo_output_stream_printf (output, |
"<stop offset=\"0\" style=\"" |
"stop-color:rgb(%f%%,%f%%,%f%%);" |
"stop-opacity:%f;\"/>\n", |
offset_color_start.red * 100.0, |
offset_color_start.green * 100.0, |
offset_color_start.blue * 100.0, |
offset_color_start.alpha); |
for (i = offset_index; i < n_stops; i++) { |
_cairo_output_stream_printf (output, |
"<stop offset=\"%f\" style=\"" |
"stop-color:rgb(%f%%,%f%%,%f%%);" |
"stop-opacity:%f;\"/>\n", |
stops[i].offset + start_offset, |
stops[i].color.red * 100.0, |
stops[i].color.green * 100.0, |
stops[i].color.blue * 100.0, |
stops[i].color.alpha); |
} |
for (i = 0; i < offset_index; i++) { |
_cairo_output_stream_printf (output, |
"<stop offset=\"%f\" style=\"" |
"stop-color:rgb(%f%%,%f%%,%f%%);" |
"stop-opacity:%f;\"/>\n", |
1.0 + stops[i].offset + start_offset, |
stops[i].color.red * 100.0, |
stops[i].color.green * 100.0, |
stops[i].color.blue * 100.0, |
stops[i].color.alpha); |
} |
_cairo_output_stream_printf (output, |
"<stop offset=\"1\" style=\"" |
"stop-color:rgb(%f%%,%f%%,%f%%);" |
"stop-opacity:%f;\"/>\n", |
offset_color_stop.red * 100.0, |
offset_color_stop.green * 100.0, |
offset_color_stop.blue * 100.0, |
offset_color_stop.alpha); |
} |
if (reverse_stops || emulate_reflect) |
free (stops); |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
_cairo_svg_surface_emit_pattern_extend (cairo_output_stream_t *output, |
cairo_pattern_t *pattern) |
{ |
switch (pattern->extend) { |
case CAIRO_EXTEND_REPEAT: |
_cairo_output_stream_printf (output, "spreadMethod=\"repeat\" "); |
break; |
case CAIRO_EXTEND_REFLECT: |
_cairo_output_stream_printf (output, "spreadMethod=\"reflect\" "); |
break; |
case CAIRO_EXTEND_NONE: |
case CAIRO_EXTEND_PAD: |
break; |
} |
} |
static cairo_status_t |
_cairo_svg_surface_emit_linear_pattern (cairo_svg_surface_t *surface, |
cairo_linear_pattern_t *pattern, |
cairo_output_stream_t *style, |
cairo_bool_t is_stroke, |
const cairo_matrix_t *parent_matrix) |
{ |
cairo_svg_document_t *document = surface->document; |
double x0, y0, x1, y1; |
cairo_matrix_t p2u; |
cairo_status_t status; |
p2u = pattern->base.base.matrix; |
status = cairo_matrix_invert (&p2u); |
/* cairo_pattern_set_matrix ensures the matrix is invertible */ |
assert (status == CAIRO_STATUS_SUCCESS); |
x0 = _cairo_fixed_to_double (pattern->p1.x); |
y0 = _cairo_fixed_to_double (pattern->p1.y); |
x1 = _cairo_fixed_to_double (pattern->p2.x); |
y1 = _cairo_fixed_to_double (pattern->p2.y); |
_cairo_output_stream_printf (document->xml_node_defs, |
"<linearGradient id=\"linear%d\" " |
"gradientUnits=\"userSpaceOnUse\" " |
"x1=\"%f\" y1=\"%f\" x2=\"%f\" y2=\"%f\" ", |
document->linear_pattern_id, |
x0, y0, x1, y1); |
_cairo_svg_surface_emit_pattern_extend (document->xml_node_defs, &pattern->base.base), |
_cairo_svg_surface_emit_transform (document->xml_node_defs, "gradientTransform", &p2u, parent_matrix); |
_cairo_output_stream_printf (document->xml_node_defs, ">\n"); |
status = _cairo_svg_surface_emit_pattern_stops (document->xml_node_defs, |
&pattern->base, 0.0, |
FALSE, FALSE); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (document->xml_node_defs, |
"</linearGradient>\n"); |
_cairo_output_stream_printf (style, |
"%s:url(#linear%d);", |
is_stroke ? "stroke" : "fill", |
document->linear_pattern_id); |
document->linear_pattern_id++; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_surface_emit_radial_pattern (cairo_svg_surface_t *surface, |
cairo_radial_pattern_t *pattern, |
cairo_output_stream_t *style, |
cairo_bool_t is_stroke, |
const cairo_matrix_t *parent_matrix) |
{ |
cairo_svg_document_t *document = surface->document; |
cairo_matrix_t p2u; |
cairo_extend_t extend; |
double x0, y0, x1, y1, r0, r1; |
double fx, fy; |
cairo_bool_t reverse_stops; |
cairo_status_t status; |
cairo_point_t *c0, *c1; |
cairo_fixed_t radius0, radius1; |
extend = pattern->base.base.extend; |
if (pattern->r1 < pattern->r2) { |
c0 = &pattern->c1; |
c1 = &pattern->c2; |
radius0 = pattern->r1; |
radius1 = pattern->r2; |
reverse_stops = FALSE; |
} else { |
c0 = &pattern->c2; |
c1 = &pattern->c1; |
radius0 = pattern->r2; |
radius1 = pattern->r1; |
reverse_stops = TRUE; |
} |
x0 = _cairo_fixed_to_double (c0->x); |
y0 = _cairo_fixed_to_double (c0->y); |
r0 = _cairo_fixed_to_double (radius0); |
x1 = _cairo_fixed_to_double (c1->x); |
y1 = _cairo_fixed_to_double (c1->y); |
r1 = _cairo_fixed_to_double (radius1); |
p2u = pattern->base.base.matrix; |
status = cairo_matrix_invert (&p2u); |
/* cairo_pattern_set_matrix ensures the matrix is invertible */ |
assert (status == CAIRO_STATUS_SUCCESS); |
if (pattern->r1 == pattern->r2) { |
unsigned int n_stops = pattern->base.n_stops; |
_cairo_output_stream_printf (document->xml_node_defs, |
"<radialGradient id=\"radial%d\" " |
"gradientUnits=\"userSpaceOnUse\" " |
"cx=\"%f\" cy=\"%f\" " |
"fx=\"%f\" fy=\"%f\" r=\"%f\" ", |
document->radial_pattern_id, |
x1, y1, |
x1, y1, r1); |
_cairo_svg_surface_emit_transform (document->xml_node_defs, |
"gradientTransform", |
&p2u, parent_matrix); |
_cairo_output_stream_printf (document->xml_node_defs, ">\n"); |
if (extend == CAIRO_EXTEND_NONE || n_stops < 1) |
_cairo_output_stream_printf (document->xml_node_defs, |
"<stop offset=\"0\" style=\"" |
"stop-color:rgb(0%%,0%%,0%%);" |
"stop-opacity:0;\"/>\n"); |
else { |
_cairo_output_stream_printf (document->xml_node_defs, |
"<stop offset=\"0\" style=\"" |
"stop-color:rgb(%f%%,%f%%,%f%%);" |
"stop-opacity %f;\"/>\n", |
pattern->base.stops[0].color.red * 100.0, |
pattern->base.stops[0].color.green * 100.0, |
pattern->base.stops[0].color.blue * 100.0, |
pattern->base.stops[0].color.alpha); |
if (n_stops > 1) |
_cairo_output_stream_printf (document->xml_node_defs, |
"<stop offset=\"0\" style=\"" |
"stop-color:rgb(%f%%,%f%%,%f%%);" |
"stop-opacity:%f;\"/>\n", |
pattern->base.stops[n_stops - 1].color.red * 100.0, |
pattern->base.stops[n_stops - 1].color.green * 100.0, |
pattern->base.stops[n_stops - 1].color.blue * 100.0, |
pattern->base.stops[n_stops - 1].color.alpha); |
} |
} else { |
double offset, r, x, y; |
cairo_bool_t emulate_reflect = FALSE; |
fx = (r1 * x0 - r0 * x1) / (r1 - r0); |
fy = (r1 * y0 - r0 * y1) / (r1 - r0); |
/* SVG doesn't support the inner circle and use instead a gradient focal. |
* That means we need to emulate the cairo behaviour by processing the |
* cairo gradient stops. |
* The CAIRO_EXTENT_NONE and CAIRO_EXTENT_PAD modes are quite easy to handle, |
* it's just a matter of stop position translation and calculation of |
* the corresponding SVG radial gradient focal. |
* The CAIRO_EXTENT_REFLECT and CAIRO_EXTEND_REPEAT modes require to compute a new |
* radial gradient, with an new outer circle, equal to r1 - r0 in the CAIRO_EXTEND_REPEAT |
* case, and 2 * (r1 - r0) in the CAIRO_EXTENT_REFLECT case, and a new gradient stop |
* list that maps to the original cairo stop list. |
*/ |
if ((extend == CAIRO_EXTEND_REFLECT |
|| extend == CAIRO_EXTEND_REPEAT) |
&& r0 > 0.0) { |
double r_org = r1; |
if (extend == CAIRO_EXTEND_REFLECT) { |
r1 = 2 * r1 - r0; |
emulate_reflect = TRUE; |
} |
offset = fmod (r1, r1 - r0) / (r1 - r0) - 1.0; |
r = r1 - r0; |
/* New position of outer circle. */ |
x = r * (x1 - fx) / r_org + fx; |
y = r * (y1 - fy) / r_org + fy; |
x1 = x; |
y1 = y; |
r1 = r; |
r0 = 0.0; |
} else { |
offset = r0 / r1; |
} |
_cairo_output_stream_printf (document->xml_node_defs, |
"<radialGradient id=\"radial%d\" " |
"gradientUnits=\"userSpaceOnUse\" " |
"cx=\"%f\" cy=\"%f\" " |
"fx=\"%f\" fy=\"%f\" r=\"%f\" ", |
document->radial_pattern_id, |
x1, y1, |
fx, fy, r1); |
if (emulate_reflect) |
_cairo_output_stream_printf (document->xml_node_defs, "spreadMethod=\"repeat\" "); |
else |
_cairo_svg_surface_emit_pattern_extend (document->xml_node_defs, &pattern->base.base); |
_cairo_svg_surface_emit_transform (document->xml_node_defs, "gradientTransform", &p2u, parent_matrix); |
_cairo_output_stream_printf (document->xml_node_defs, ">\n"); |
/* To support cairo's EXTEND_NONE, (for which SVG has no similar |
* notion), we add transparent color stops on either end of the |
* user-provided stops. */ |
if (extend == CAIRO_EXTEND_NONE) { |
_cairo_output_stream_printf (document->xml_node_defs, |
"<stop offset=\"0\" style=\"" |
"stop-color:rgb(0%%,0%%,0%%);" |
"stop-opacity:0;\"/>\n"); |
if (r0 != 0.0) |
_cairo_output_stream_printf (document->xml_node_defs, |
"<stop offset=\"%f\" style=\"" |
"stop-color:rgb(0%%,0%%,0%%);" |
"stop-opacity:0;\"/>\n", |
r0 / r1); |
} |
status = _cairo_svg_surface_emit_pattern_stops (document->xml_node_defs, |
&pattern->base, offset, |
reverse_stops, |
emulate_reflect); |
if (unlikely (status)) |
return status; |
if (pattern->base.base.extend == CAIRO_EXTEND_NONE) |
_cairo_output_stream_printf (document->xml_node_defs, |
"<stop offset=\"1.0\" style=\"" |
"stop-color:rgb(0%%,0%%,0%%);" |
"stop-opacity:0;\"/>\n"); |
} |
_cairo_output_stream_printf (document->xml_node_defs, |
"</radialGradient>\n"); |
_cairo_output_stream_printf (style, |
"%s:url(#radial%d);", |
is_stroke ? "stroke" : "fill", |
document->radial_pattern_id); |
document->radial_pattern_id++; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_cairo_svg_surface_emit_pattern (cairo_svg_surface_t *surface, |
const cairo_pattern_t *pattern, |
cairo_output_stream_t *output, |
cairo_bool_t is_stroke, |
const cairo_matrix_t *parent_matrix) |
{ |
switch (pattern->type) { |
case CAIRO_PATTERN_TYPE_SOLID: |
return _cairo_svg_surface_emit_solid_pattern (surface, (cairo_solid_pattern_t *) pattern, |
output, is_stroke); |
case CAIRO_PATTERN_TYPE_SURFACE: |
return _cairo_svg_surface_emit_surface_pattern (surface, (cairo_surface_pattern_t *) pattern, |
output, is_stroke, parent_matrix); |
case CAIRO_PATTERN_TYPE_LINEAR: |
return _cairo_svg_surface_emit_linear_pattern (surface, (cairo_linear_pattern_t *) pattern, |
output, is_stroke, parent_matrix); |
case CAIRO_PATTERN_TYPE_RADIAL: |
return _cairo_svg_surface_emit_radial_pattern (surface, (cairo_radial_pattern_t *) pattern, |
output, is_stroke, parent_matrix); |
} |
return _cairo_error (CAIRO_STATUS_PATTERN_TYPE_MISMATCH); |
} |
static cairo_status_t |
_cairo_svg_surface_emit_fill_style (cairo_output_stream_t *output, |
cairo_svg_surface_t *surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
cairo_fill_rule_t fill_rule, |
const cairo_matrix_t *parent_matrix) |
{ |
_cairo_output_stream_printf (output, |
"fill-rule:%s;", |
fill_rule == CAIRO_FILL_RULE_EVEN_ODD ? |
"evenodd" : "nonzero"); |
_cairo_svg_surface_emit_operator_for_style (output, surface, op); |
return _cairo_svg_surface_emit_pattern (surface, source, output, FALSE, parent_matrix); |
} |
static cairo_status_t |
_cairo_svg_surface_emit_stroke_style (cairo_output_stream_t *output, |
cairo_svg_surface_t *surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
const cairo_stroke_style_t *stroke_style, |
const cairo_matrix_t *parent_matrix) |
{ |
cairo_status_t status; |
const char *line_cap, *line_join; |
unsigned int i; |
switch (stroke_style->line_cap) { |
case CAIRO_LINE_CAP_BUTT: |
line_cap = "butt"; |
break; |
case CAIRO_LINE_CAP_ROUND: |
line_cap = "round"; |
break; |
case CAIRO_LINE_CAP_SQUARE: |
line_cap = "square"; |
break; |
default: |
ASSERT_NOT_REACHED; |
} |
switch (stroke_style->line_join) { |
case CAIRO_LINE_JOIN_MITER: |
line_join = "miter"; |
break; |
case CAIRO_LINE_JOIN_ROUND: |
line_join = "round"; |
break; |
case CAIRO_LINE_JOIN_BEVEL: |
line_join = "bevel"; |
break; |
default: |
ASSERT_NOT_REACHED; |
} |
_cairo_output_stream_printf (output, |
"stroke-width:%f;" |
"stroke-linecap:%s;" |
"stroke-linejoin:%s;", |
stroke_style->line_width, |
line_cap, |
line_join); |
status = _cairo_svg_surface_emit_pattern (surface, source, output, TRUE, parent_matrix); |
if (unlikely (status)) |
return status; |
_cairo_svg_surface_emit_operator_for_style (output, surface, op); |
if (stroke_style->num_dashes > 0) { |
_cairo_output_stream_printf (output, "stroke-dasharray:"); |
for (i = 0; i < stroke_style->num_dashes; i++) { |
_cairo_output_stream_printf (output, "%f", |
stroke_style->dash[i]); |
if (i + 1 < stroke_style->num_dashes) |
_cairo_output_stream_printf (output, ","); |
else |
_cairo_output_stream_printf (output, ";"); |
} |
if (stroke_style->dash_offset != 0.0) { |
_cairo_output_stream_printf (output, |
"stroke-dashoffset:%f;", |
stroke_style->dash_offset); |
} |
} |
_cairo_output_stream_printf (output, |
"stroke-miterlimit:%f;", |
stroke_style->miter_limit); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
_cairo_svg_surface_fill_stroke (void *abstract_surface, |
cairo_operator_t fill_op, |
const cairo_pattern_t *fill_source, |
cairo_fill_rule_t fill_rule, |
double fill_tolerance, |
cairo_antialias_t fill_antialias, |
cairo_path_fixed_t *path, |
cairo_operator_t stroke_op, |
const cairo_pattern_t *stroke_source, |
const cairo_stroke_style_t *stroke_style, |
const cairo_matrix_t *stroke_ctm, |
const cairo_matrix_t *stroke_ctm_inverse, |
double stroke_tolerance, |
cairo_antialias_t stroke_antialias, |
cairo_clip_t *clip) |
{ |
cairo_svg_surface_t *surface = abstract_surface; |
cairo_status_t status; |
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (surface->xml_node, "<path style=\""); |
status = _cairo_svg_surface_emit_fill_style (surface->xml_node, surface, fill_op, |
fill_source, fill_rule, stroke_ctm_inverse); |
if (unlikely (status)) |
return status; |
status = _cairo_svg_surface_emit_stroke_style (surface->xml_node, surface, stroke_op, |
stroke_source, stroke_style, stroke_ctm_inverse); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (surface->xml_node, "\" "); |
_cairo_svg_surface_emit_path (surface->xml_node, path, stroke_ctm_inverse); |
_cairo_svg_surface_emit_transform (surface->xml_node, " transform", stroke_ctm, NULL); |
_cairo_output_stream_printf (surface->xml_node, "/>\n"); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
_cairo_svg_surface_fill (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
cairo_path_fixed_t *path, |
cairo_fill_rule_t fill_rule, |
double tolerance, |
cairo_antialias_t antialias, |
cairo_clip_t *clip) |
{ |
cairo_svg_surface_t *surface = abstract_surface; |
cairo_status_t status; |
if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) |
return _cairo_svg_surface_analyze_operation (surface, op, source); |
assert (_cairo_svg_surface_operation_supported (surface, op, source)); |
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (surface->xml_node, "<path style=\" stroke:none;"); |
status = _cairo_svg_surface_emit_fill_style (surface->xml_node, surface, op, source, fill_rule, NULL); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (surface->xml_node, "\" "); |
_cairo_svg_surface_emit_path (surface->xml_node, path, NULL); |
_cairo_output_stream_printf (surface->xml_node, "/>\n"); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_bool_t |
_cairo_svg_surface_get_extents (void *abstract_surface, |
cairo_rectangle_int_t *rectangle) |
{ |
cairo_svg_surface_t *surface = abstract_surface; |
rectangle->x = 0; |
rectangle->y = 0; |
/* XXX: The conversion to integers here is pretty bogus, (not to |
* mention the arbitrary limitation of width to a short(!). We |
* may need to come up with a better interface for get_size. |
*/ |
rectangle->width = ceil (surface->width); |
rectangle->height = ceil (surface->height); |
return TRUE; |
} |
static cairo_status_t |
_cairo_svg_surface_emit_paint (cairo_output_stream_t *output, |
cairo_svg_surface_t *surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
const cairo_pattern_t *mask_source, |
const char *extra_attributes) |
{ |
cairo_status_t status; |
if (source->type == CAIRO_PATTERN_TYPE_SURFACE && |
source->extend == CAIRO_EXTEND_NONE) |
return _cairo_svg_surface_emit_composite_pattern (output, |
surface, |
op, |
(cairo_surface_pattern_t *) source, |
invalid_pattern_id, |
mask_source ? &mask_source->matrix :NULL, |
extra_attributes); |
_cairo_output_stream_printf (output, |
"<rect x=\"0\" y=\"0\" " |
"width=\"%f\" height=\"%f\" " |
"style=\"", |
surface->width, surface->height); |
_cairo_svg_surface_emit_operator_for_style (output, surface, op); |
status = _cairo_svg_surface_emit_pattern (surface, source, output, FALSE, NULL); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (output, "stroke:none;\""); |
if (extra_attributes) |
_cairo_output_stream_printf (output, " %s", extra_attributes); |
_cairo_output_stream_printf (output, "/>\n"); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
_cairo_svg_surface_paint (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
cairo_clip_t *clip) |
{ |
cairo_status_t status; |
cairo_svg_surface_t *surface = abstract_surface; |
/* Emulation of clear and source operators, when no clipping region |
* is defined. We just delete existing content of surface root node, |
* and exit early if operator is clear. |
*/ |
if ((op == CAIRO_OPERATOR_CLEAR || op == CAIRO_OPERATOR_SOURCE) && |
clip == NULL) |
{ |
switch (surface->paginated_mode) { |
case CAIRO_PAGINATED_MODE_FALLBACK: |
ASSERT_NOT_REACHED; |
case CAIRO_PAGINATED_MODE_ANALYZE: |
return CAIRO_STATUS_SUCCESS; |
case CAIRO_PAGINATED_MODE_RENDER: |
status = _cairo_output_stream_destroy (surface->xml_node); |
if (unlikely (status)) { |
surface->xml_node = NULL; |
return status; |
} |
surface->xml_node = _cairo_memory_stream_create (); |
if (_cairo_output_stream_get_status (surface->xml_node)) { |
status = _cairo_output_stream_destroy (surface->xml_node); |
surface->xml_node = NULL; |
return status; |
} |
if (op == CAIRO_OPERATOR_CLEAR) { |
if (surface->content == CAIRO_CONTENT_COLOR) { |
_cairo_output_stream_printf (surface->xml_node, |
"<rect " |
"width=\"%f\" height=\"%f\" " |
"style=\"opacity:1;" |
"stroke:none;" |
"fill:rgb(0,0,0);\"/>\n", |
surface->width, surface->height); |
} |
return CAIRO_STATUS_SUCCESS; |
} |
break; |
} |
} else { |
if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) |
return _cairo_svg_surface_analyze_operation (surface, op, source); |
assert (_cairo_svg_surface_operation_supported (surface, op, source)); |
} |
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip); |
if (unlikely (status)) |
return status; |
return _cairo_svg_surface_emit_paint (surface->xml_node, |
surface, op, source, 0, NULL); |
} |
static cairo_int_status_t |
_cairo_svg_surface_mask (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
const cairo_pattern_t *mask, |
cairo_clip_t *clip) |
{ |
cairo_status_t status; |
cairo_svg_surface_t *surface = abstract_surface; |
cairo_svg_document_t *document = surface->document; |
cairo_output_stream_t *mask_stream; |
char buffer[64]; |
cairo_bool_t discard_filter = FALSE; |
unsigned int mask_id; |
if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) { |
cairo_status_t source_status, mask_status; |
source_status = _cairo_svg_surface_analyze_operation (surface, op, source); |
if (_cairo_status_is_error (source_status)) |
return source_status; |
if (mask->has_component_alpha) { |
mask_status = CAIRO_INT_STATUS_UNSUPPORTED; |
} else { |
mask_status = _cairo_svg_surface_analyze_operation (surface, op, mask); |
if (_cairo_status_is_error (mask_status)) |
return mask_status; |
} |
return _cairo_analysis_surface_merge_status (source_status, |
mask_status); |
} |
assert (_cairo_svg_surface_operation_supported (surface, op, source)); |
assert (_cairo_svg_surface_operation_supported (surface, CAIRO_OPERATOR_OVER, mask)); |
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip); |
if (unlikely (status)) |
return status; |
if (mask->type == CAIRO_PATTERN_TYPE_SURFACE) { |
const cairo_surface_pattern_t *surface_pattern = (const cairo_surface_pattern_t*) mask; |
cairo_content_t content = cairo_surface_get_content (surface_pattern->surface); |
if (content == CAIRO_CONTENT_ALPHA) |
discard_filter = TRUE; |
} |
if (!discard_filter) |
_cairo_svg_surface_emit_alpha_filter (document); |
/* _cairo_svg_surface_emit_paint() will output a pattern definition to |
* document->xml_node_defs so we need to write the mask element to |
* a temporary stream and then copy that to xml_node_defs. */ |
mask_stream = _cairo_memory_stream_create (); |
if (_cairo_output_stream_get_status (mask_stream)) |
return _cairo_output_stream_destroy (mask_stream); |
mask_id = _cairo_svg_document_allocate_mask_id (document); |
_cairo_output_stream_printf (mask_stream, |
"<mask id=\"mask%d\">\n" |
"%s", |
mask_id, |
discard_filter ? "" : " <g filter=\"url(#alpha)\">\n"); |
status = _cairo_svg_surface_emit_paint (mask_stream, surface, CAIRO_OPERATOR_OVER, mask, source, NULL); |
if (unlikely (status)) { |
cairo_status_t ignore = _cairo_output_stream_destroy (mask_stream); |
return status; |
(void) ignore; |
} |
_cairo_output_stream_printf (mask_stream, |
"%s" |
"</mask>\n", |
discard_filter ? "" : " </g>\n"); |
_cairo_memory_stream_copy (mask_stream, document->xml_node_defs); |
status = _cairo_output_stream_destroy (mask_stream); |
if (unlikely (status)) |
return status; |
snprintf (buffer, sizeof buffer, "mask=\"url(#mask%d)\"", |
mask_id); |
status = _cairo_svg_surface_emit_paint (surface->xml_node, surface, op, source, 0, buffer); |
if (unlikely (status)) |
return status; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
_cairo_svg_surface_stroke (void *abstract_dst, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
cairo_path_fixed_t *path, |
const cairo_stroke_style_t *stroke_style, |
const cairo_matrix_t *ctm, |
const cairo_matrix_t *ctm_inverse, |
double tolerance, |
cairo_antialias_t antialias, |
cairo_clip_t *clip) |
{ |
cairo_svg_surface_t *surface = abstract_dst; |
cairo_status_t status; |
if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) |
return _cairo_svg_surface_analyze_operation (surface, op, source); |
assert (_cairo_svg_surface_operation_supported (surface, op, source)); |
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (surface->xml_node, "<path style=\"fill:none;"); |
status = _cairo_svg_surface_emit_stroke_style (surface->xml_node, surface, op, |
source, stroke_style, ctm_inverse); |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (surface->xml_node, "\" "); |
_cairo_svg_surface_emit_path (surface->xml_node, path, ctm_inverse); |
_cairo_svg_surface_emit_transform (surface->xml_node, " transform", ctm, NULL); |
_cairo_output_stream_printf (surface->xml_node, "/>\n"); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
_cairo_svg_surface_show_glyphs (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *pattern, |
cairo_glyph_t *glyphs, |
int num_glyphs, |
cairo_scaled_font_t *scaled_font, |
cairo_clip_t *clip, |
int *remaining_glyphs) |
{ |
cairo_svg_surface_t *surface = abstract_surface; |
cairo_svg_document_t *document = surface->document; |
cairo_path_fixed_t path; |
cairo_status_t status; |
cairo_scaled_font_subsets_glyph_t subset_glyph; |
int i; |
if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) |
return _cairo_svg_surface_analyze_operation (surface, op, pattern); |
assert (_cairo_svg_surface_operation_supported (surface, op, pattern)); |
if (num_glyphs <= 0) |
return CAIRO_STATUS_SUCCESS; |
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip); |
if (unlikely (status)) |
return status; |
/* FIXME it's probably possible to apply a pattern of a gradient to |
* a group of symbols, but I don't know how yet. Gradients or patterns |
* are translated by x and y properties of use element. */ |
if (pattern->type != CAIRO_PATTERN_TYPE_SOLID) |
goto FALLBACK; |
_cairo_output_stream_printf (surface->xml_node, "<g style=\""); |
status = _cairo_svg_surface_emit_pattern (surface, pattern, |
surface->xml_node, FALSE, NULL); |
if (unlikely (status)) |
return status; |
_cairo_svg_surface_emit_operator_for_style (surface->xml_node, surface, op); |
_cairo_output_stream_printf (surface->xml_node, "\">\n"); |
for (i = 0; i < num_glyphs; i++) { |
status = _cairo_scaled_font_subsets_map_glyph (document->font_subsets, |
scaled_font, glyphs[i].index, |
NULL, 0, |
&subset_glyph); |
if (status == CAIRO_INT_STATUS_UNSUPPORTED) { |
_cairo_output_stream_printf (surface->xml_node, "</g>\n"); |
glyphs += i; |
num_glyphs -= i; |
goto FALLBACK; |
} |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (surface->xml_node, |
" <use xlink:href=\"#glyph%d-%d\" " |
"x=\"%f\" y=\"%f\"/>\n", |
subset_glyph.font_id, |
subset_glyph.subset_glyph_index, |
glyphs[i].x, glyphs[i].y); |
} |
_cairo_output_stream_printf (surface->xml_node, "</g>\n"); |
return CAIRO_STATUS_SUCCESS; |
FALLBACK: |
_cairo_path_fixed_init (&path); |
status = _cairo_scaled_font_glyph_path (scaled_font, |
(cairo_glyph_t *) glyphs, |
num_glyphs, &path); |
if (unlikely (status)) { |
_cairo_path_fixed_fini (&path); |
return status; |
} |
status = _cairo_svg_surface_fill (abstract_surface, op, pattern, |
&path, CAIRO_FILL_RULE_WINDING, |
0.0, CAIRO_ANTIALIAS_SUBPIXEL, |
clip); |
_cairo_path_fixed_fini (&path); |
return status; |
} |
static void |
_cairo_svg_surface_get_font_options (void *abstract_surface, |
cairo_font_options_t *options) |
{ |
_cairo_font_options_init_default (options); |
cairo_font_options_set_hint_style (options, CAIRO_HINT_STYLE_NONE); |
cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_OFF); |
cairo_font_options_set_antialias (options, CAIRO_ANTIALIAS_GRAY); |
} |
static const cairo_surface_backend_t cairo_svg_surface_backend = { |
CAIRO_SURFACE_TYPE_SVG, |
NULL, /* create_similar: handled by wrapper */ |
_cairo_svg_surface_finish, |
NULL, /* acquire_source_image */ |
NULL, /* release_source_image */ |
NULL, /* acquire_dest_image */ |
NULL, /* release_dest_image */ |
NULL, /* clone_similar */ |
NULL, /* _cairo_svg_surface_composite, */ |
NULL, /* _cairo_svg_surface_fill_rectangles, */ |
NULL, /* _cairo_svg_surface_composite_trapezoids,*/ |
NULL, /* create_span_renderer */ |
NULL, /* check_span_renderer */ |
_cairo_svg_surface_copy_page, |
_cairo_svg_surface_show_page, |
_cairo_svg_surface_get_extents, |
NULL, /* _cairo_svg_surface_old_show_glyphs, */ |
_cairo_svg_surface_get_font_options, |
NULL, /* flush */ |
NULL, /* mark dirty rectangle */ |
NULL, /* scaled font fini */ |
NULL, /* scaled glyph fini */ |
_cairo_svg_surface_paint, |
_cairo_svg_surface_mask, |
_cairo_svg_surface_stroke, |
_cairo_svg_surface_fill, |
_cairo_svg_surface_show_glyphs, |
NULL, /* snapshot */ |
NULL, /* is_similar */ |
_cairo_svg_surface_fill_stroke |
}; |
static cairo_status_t |
_cairo_svg_document_create (cairo_output_stream_t *output_stream, |
double width, |
double height, |
cairo_svg_version_t version, |
cairo_svg_document_t **document_out) |
{ |
cairo_svg_document_t *document; |
cairo_status_t status, status_ignored; |
if (output_stream->status) |
return output_stream->status; |
document = malloc (sizeof (cairo_svg_document_t)); |
if (unlikely (document == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
/* The use of defs for font glyphs imposes no per-subset limit. */ |
document->font_subsets = _cairo_scaled_font_subsets_create_scaled (); |
if (unlikely (document->font_subsets == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto CLEANUP_DOCUMENT; |
} |
document->output_stream = output_stream; |
document->refcount = 1; |
document->owner = NULL; |
document->finished = FALSE; |
document->width = width; |
document->height = height; |
document->linear_pattern_id = 0; |
document->radial_pattern_id = 0; |
document->pattern_id = 0; |
document->filter_id = 0; |
document->clip_id = 0; |
document->mask_id = 0; |
document->xml_node_defs = _cairo_memory_stream_create (); |
status = _cairo_output_stream_get_status (document->xml_node_defs); |
if (unlikely (status)) |
goto CLEANUP_NODE_DEFS; |
document->xml_node_glyphs = _cairo_memory_stream_create (); |
status = _cairo_output_stream_get_status (document->xml_node_glyphs); |
if (unlikely (status)) |
goto CLEANUP_NODE_GLYPHS; |
document->alpha_filter = FALSE; |
document->svg_version = version; |
*document_out = document; |
return CAIRO_STATUS_SUCCESS; |
CLEANUP_NODE_GLYPHS: |
status_ignored = _cairo_output_stream_destroy (document->xml_node_glyphs); |
CLEANUP_NODE_DEFS: |
status_ignored = _cairo_output_stream_destroy (document->xml_node_defs); |
_cairo_scaled_font_subsets_destroy (document->font_subsets); |
CLEANUP_DOCUMENT: |
free (document); |
return status; |
} |
static cairo_svg_document_t * |
_cairo_svg_document_reference (cairo_svg_document_t *document) |
{ |
document->refcount++; |
return document; |
} |
static unsigned int |
_cairo_svg_document_allocate_mask_id (cairo_svg_document_t *document) |
{ |
return document->mask_id++; |
} |
static cairo_status_t |
_cairo_svg_document_destroy (cairo_svg_document_t *document) |
{ |
cairo_status_t status; |
document->refcount--; |
if (document->refcount > 0) |
return CAIRO_STATUS_SUCCESS; |
status = _cairo_svg_document_finish (document); |
free (document); |
return status; |
} |
static cairo_status_t |
_cairo_svg_document_finish (cairo_svg_document_t *document) |
{ |
cairo_status_t status, status2; |
cairo_output_stream_t *output = document->output_stream; |
cairo_svg_page_t *page; |
unsigned int i; |
if (document->finished) |
return CAIRO_STATUS_SUCCESS; |
/* |
* Should we add DOCTYPE? |
* |
* Google says no. |
* |
* http://tech.groups.yahoo.com/group/svg-developers/message/48562: |
* There's a bunch of issues, but just to pick a few: |
* - they'll give false positives. |
* - they'll give false negatives. |
* - they're namespace-unaware. |
* - they don't wildcard. |
* So when they say OK they really haven't checked anything, when |
* they say NOT OK they might be on crack, and like all |
* namespace-unaware things they're a dead branch of the XML tree. |
* |
* http://jwatt.org/svg/authoring/: |
* Unfortunately the SVG DTDs are a source of so many issues that the |
* SVG WG has decided not to write one for the upcoming SVG 1.2 |
* standard. In fact SVG WG members are even telling people not to use |
* a DOCTYPE declaration in SVG 1.0 and 1.1 documents. |
*/ |
_cairo_output_stream_printf (output, |
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" |
"<svg xmlns=\"http://www.w3.org/2000/svg\" " |
"xmlns:xlink=\"http://www.w3.org/1999/xlink\" " |
"width=\"%fpt\" height=\"%fpt\" " |
"viewBox=\"0 0 %f %f\" version=\"%s\">\n", |
document->width, document->height, |
document->width, document->height, |
_cairo_svg_internal_version_strings [document->svg_version]); |
status = _cairo_svg_document_emit_font_subsets (document); |
if (_cairo_memory_stream_length (document->xml_node_glyphs) > 0 || |
_cairo_memory_stream_length (document->xml_node_defs) > 0) { |
_cairo_output_stream_printf (output, "<defs>\n"); |
if (_cairo_memory_stream_length (document->xml_node_glyphs) > 0) { |
_cairo_output_stream_printf (output, "<g>\n"); |
_cairo_memory_stream_copy (document->xml_node_glyphs, output); |
_cairo_output_stream_printf (output, "</g>\n"); |
} |
_cairo_memory_stream_copy (document->xml_node_defs, output); |
_cairo_output_stream_printf (output, "</defs>\n"); |
} |
if (document->owner != NULL) { |
cairo_svg_surface_t *surface; |
surface = (cairo_svg_surface_t *) _cairo_paginated_surface_get_target (document->owner); |
if (surface->xml_node != NULL && |
_cairo_memory_stream_length (surface->xml_node) > 0) { |
if (unlikely (_cairo_svg_surface_store_page (surface) == NULL)) { |
if (status == CAIRO_STATUS_SUCCESS) |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
} |
} |
if (surface->page_set.num_elements > 1 && |
_cairo_svg_version_has_page_set_support (document->svg_version)) { |
_cairo_output_stream_printf (output, "<pageSet>\n"); |
for (i = 0; i < surface->page_set.num_elements; i++) { |
page = _cairo_array_index (&surface->page_set, i); |
_cairo_output_stream_printf (output, "<page>\n"); |
_cairo_output_stream_printf (output, |
"<g id=\"surface%d\">\n", |
page->surface_id); |
_cairo_memory_stream_copy (page->xml_node, output); |
_cairo_output_stream_printf (output, "</g>\n</page>\n"); |
} |
_cairo_output_stream_printf (output, "</pageSet>\n"); |
} else if (surface->page_set.num_elements > 0) { |
page = _cairo_array_index (&surface->page_set, surface->page_set.num_elements - 1); |
_cairo_output_stream_printf (output, |
"<g id=\"surface%d\">\n", |
page->surface_id); |
_cairo_memory_stream_copy (page->xml_node, output); |
_cairo_output_stream_printf (output, "</g>\n"); |
} |
} |
_cairo_output_stream_printf (output, "</svg>\n"); |
status2 = _cairo_output_stream_destroy (document->xml_node_glyphs); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
status2 = _cairo_output_stream_destroy (document->xml_node_defs); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
status2 = _cairo_output_stream_destroy (output); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
document->finished = TRUE; |
return status; |
} |
static void |
_cairo_svg_surface_set_paginated_mode (void *abstract_surface, |
cairo_paginated_mode_t paginated_mode) |
{ |
cairo_svg_surface_t *surface = abstract_surface; |
surface->paginated_mode = paginated_mode; |
} |
static cairo_bool_t |
_cairo_svg_surface_supports_fine_grained_fallbacks (void *abstract_surface) |
{ |
cairo_svg_surface_t *surface = abstract_surface; |
cairo_int_status_t status = CAIRO_INT_STATUS_UNSUPPORTED; |
if (surface->document->svg_version >= CAIRO_SVG_VERSION_1_2) { |
status = _cairo_svg_surface_analyze_operator (surface, |
CAIRO_OPERATOR_SOURCE); |
} |
return status == CAIRO_STATUS_SUCCESS; |
} |
static const cairo_paginated_surface_backend_t cairo_svg_surface_paginated_backend = { |
NULL /*_cairo_svg_surface_start_page*/, |
_cairo_svg_surface_set_paginated_mode, |
NULL, /* _cairo_svg_surface_set_bounding_box */ |
NULL, /* _cairo_svg_surface_set_fallback_images_required */ |
_cairo_svg_surface_supports_fine_grained_fallbacks, |
}; |
/programs/develop/libraries/cairo/src/cairo-truetype-subset.c |
---|
0,0 → 1,1433 |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2004 Red Hat, Inc |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is Red Hat, Inc. |
* |
* Contributor(s): |
* Kristian Høgsberg <krh@redhat.com> |
* Adrian Johnson <ajohnson@redneon.com> |
*/ |
/* |
* Useful links: |
* http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6.html |
* http://www.microsoft.com/typography/specs/default.htm |
*/ |
#define _BSD_SOURCE /* for snprintf(), strdup() */ |
#include "cairoint.h" |
#include "cairo-error-private.h" |
#if CAIRO_HAS_FONT_SUBSET |
#include "cairo-scaled-font-subsets-private.h" |
#include "cairo-truetype-subset-private.h" |
typedef struct subset_glyph subset_glyph_t; |
struct subset_glyph { |
int parent_index; |
unsigned long location; |
}; |
typedef struct _cairo_truetype_font cairo_truetype_font_t; |
typedef struct table table_t; |
struct table { |
unsigned long tag; |
cairo_status_t (*write) (cairo_truetype_font_t *font, unsigned long tag); |
int pos; /* position in the font directory */ |
}; |
struct _cairo_truetype_font { |
cairo_scaled_font_subset_t *scaled_font_subset; |
table_t truetype_tables[10]; |
int num_tables; |
struct { |
char *font_name; |
char *ps_name; |
unsigned int num_glyphs; |
int *widths; |
long x_min, y_min, x_max, y_max; |
long ascent, descent; |
int units_per_em; |
} base; |
subset_glyph_t *glyphs; |
const cairo_scaled_font_backend_t *backend; |
int num_glyphs_in_face; |
int checksum_index; |
cairo_array_t output; |
cairo_array_t string_offsets; |
unsigned long last_offset; |
unsigned long last_boundary; |
int *parent_to_subset; |
cairo_status_t status; |
}; |
/* |
* Test that the structs we define for TrueType tables have the |
* correct size, ie. they are not padded. |
*/ |
#define check(T, S) COMPILE_TIME_ASSERT (sizeof (T) == (S)) |
check (tt_head_t, 54); |
check (tt_hhea_t, 36); |
check (tt_maxp_t, 32); |
check (tt_name_record_t, 12); |
check (tt_name_t, 18); |
check (tt_name_t, 18); |
check (tt_composite_glyph_t, 16); |
check (tt_glyph_data_t, 26); |
#undef check |
static cairo_status_t |
cairo_truetype_font_use_glyph (cairo_truetype_font_t *font, |
unsigned short glyph, |
unsigned short *out); |
#define SFNT_VERSION 0x00010000 |
#define SFNT_STRING_MAX_LENGTH 65535 |
static cairo_status_t |
_cairo_truetype_font_set_error (cairo_truetype_font_t *font, |
cairo_status_t status) |
{ |
if (status == CAIRO_STATUS_SUCCESS || status == CAIRO_INT_STATUS_UNSUPPORTED) |
return status; |
_cairo_status_set_error (&font->status, status); |
return _cairo_error (status); |
} |
static cairo_status_t |
_cairo_truetype_font_create (cairo_scaled_font_subset_t *scaled_font_subset, |
cairo_truetype_font_t **font_return) |
{ |
cairo_status_t status; |
cairo_truetype_font_t *font; |
const cairo_scaled_font_backend_t *backend; |
tt_head_t head; |
tt_hhea_t hhea; |
tt_maxp_t maxp; |
unsigned long size; |
backend = scaled_font_subset->scaled_font->backend; |
if (!backend->load_truetype_table) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
/* FIXME: We should either support subsetting vertical fonts, or fail on |
* vertical. Currently font_options_t doesn't have vertical flag, but |
* it should be added in the future. For now, the freetype backend |
* returns UNSUPPORTED in load_truetype_table if the font is vertical. |
* |
* if (cairo_font_options_get_vertical_layout (scaled_font_subset->scaled_font)) |
* return CAIRO_INT_STATUS_UNSUPPORTED; |
*/ |
size = sizeof (tt_head_t); |
status = backend->load_truetype_table (scaled_font_subset->scaled_font, |
TT_TAG_head, 0, |
(unsigned char *) &head, |
&size); |
if (unlikely (status)) |
return status; |
size = sizeof (tt_maxp_t); |
status = backend->load_truetype_table (scaled_font_subset->scaled_font, |
TT_TAG_maxp, 0, |
(unsigned char *) &maxp, |
&size); |
if (unlikely (status)) |
return status; |
size = sizeof (tt_hhea_t); |
status = backend->load_truetype_table (scaled_font_subset->scaled_font, |
TT_TAG_hhea, 0, |
(unsigned char *) &hhea, |
&size); |
if (unlikely (status)) |
return status; |
font = malloc (sizeof (cairo_truetype_font_t)); |
if (unlikely (font == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
font->backend = backend; |
font->num_glyphs_in_face = be16_to_cpu (maxp.num_glyphs); |
font->scaled_font_subset = scaled_font_subset; |
font->last_offset = 0; |
font->last_boundary = 0; |
_cairo_array_init (&font->output, sizeof (char)); |
status = _cairo_array_grow_by (&font->output, 4096); |
if (unlikely (status)) |
goto fail1; |
font->glyphs = calloc (font->num_glyphs_in_face + 1, sizeof (subset_glyph_t)); |
if (unlikely (font->glyphs == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail1; |
} |
font->parent_to_subset = calloc (font->num_glyphs_in_face, sizeof (int)); |
if (unlikely (font->parent_to_subset == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail2; |
} |
font->base.num_glyphs = 0; |
font->base.x_min = (int16_t) be16_to_cpu (head.x_min); |
font->base.y_min = (int16_t) be16_to_cpu (head.y_min); |
font->base.x_max = (int16_t) be16_to_cpu (head.x_max); |
font->base.y_max = (int16_t) be16_to_cpu (head.y_max); |
font->base.ascent = (int16_t) be16_to_cpu (hhea.ascender); |
font->base.descent = (int16_t) be16_to_cpu (hhea.descender); |
font->base.units_per_em = (int16_t) be16_to_cpu (head.units_per_em); |
if (font->base.units_per_em == 0) |
font->base.units_per_em = 2048; |
font->base.ps_name = NULL; |
font->base.font_name = NULL; |
status = _cairo_truetype_read_font_name (scaled_font_subset->scaled_font, |
&font->base.ps_name, |
&font->base.font_name); |
if (_cairo_status_is_error (status)) |
goto fail3; |
/* If the PS name is not found, create a CairoFont-x-y name. */ |
if (font->base.ps_name == NULL) { |
font->base.ps_name = malloc (30); |
if (unlikely (font->base.ps_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail3; |
} |
snprintf(font->base.ps_name, 30, "CairoFont-%u-%u", |
scaled_font_subset->font_id, |
scaled_font_subset->subset_id); |
} |
font->base.widths = calloc (font->num_glyphs_in_face, sizeof (int)); |
if (unlikely (font->base.widths == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail4; |
} |
_cairo_array_init (&font->string_offsets, sizeof (unsigned long)); |
status = _cairo_array_grow_by (&font->string_offsets, 10); |
if (unlikely (status)) |
goto fail5; |
font->status = CAIRO_STATUS_SUCCESS; |
*font_return = font; |
return CAIRO_STATUS_SUCCESS; |
fail5: |
_cairo_array_fini (&font->string_offsets); |
free (font->base.widths); |
fail4: |
free (font->base.ps_name); |
fail3: |
free (font->parent_to_subset); |
if (font->base.font_name) |
free (font->base.font_name); |
fail2: |
free (font->glyphs); |
fail1: |
_cairo_array_fini (&font->output); |
free (font); |
return status; |
} |
static void |
cairo_truetype_font_destroy (cairo_truetype_font_t *font) |
{ |
_cairo_array_fini (&font->string_offsets); |
free (font->base.widths); |
free (font->base.ps_name); |
if (font->base.font_name) |
free (font->base.font_name); |
free (font->parent_to_subset); |
free (font->glyphs); |
_cairo_array_fini (&font->output); |
free (font); |
} |
static cairo_status_t |
cairo_truetype_font_allocate_write_buffer (cairo_truetype_font_t *font, |
size_t length, |
unsigned char **buffer) |
{ |
cairo_status_t status; |
if (font->status) |
return font->status; |
status = _cairo_array_allocate (&font->output, length, (void **) buffer); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
cairo_truetype_font_write (cairo_truetype_font_t *font, |
const void *data, |
size_t length) |
{ |
cairo_status_t status; |
if (font->status) |
return; |
status = _cairo_array_append_multiple (&font->output, data, length); |
if (unlikely (status)) |
status = _cairo_truetype_font_set_error (font, status); |
} |
static void |
cairo_truetype_font_write_be16 (cairo_truetype_font_t *font, |
uint16_t value) |
{ |
uint16_t be16_value; |
if (font->status) |
return; |
be16_value = cpu_to_be16 (value); |
cairo_truetype_font_write (font, &be16_value, sizeof be16_value); |
} |
static void |
cairo_truetype_font_write_be32 (cairo_truetype_font_t *font, |
uint32_t value) |
{ |
uint32_t be32_value; |
if (font->status) |
return; |
be32_value = cpu_to_be32 (value); |
cairo_truetype_font_write (font, &be32_value, sizeof be32_value); |
} |
static cairo_status_t |
cairo_truetype_font_align_output (cairo_truetype_font_t *font, |
unsigned long *aligned) |
{ |
int length, pad; |
unsigned char *padding; |
length = _cairo_array_num_elements (&font->output); |
*aligned = (length + 3) & ~3; |
pad = *aligned - length; |
if (pad) { |
cairo_status_t status; |
status = cairo_truetype_font_allocate_write_buffer (font, pad, |
&padding); |
if (unlikely (status)) |
return status; |
memset (padding, 0, pad); |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_truetype_font_check_boundary (cairo_truetype_font_t *font, |
unsigned long boundary) |
{ |
cairo_status_t status; |
if (font->status) |
return font->status; |
if (boundary - font->last_offset > SFNT_STRING_MAX_LENGTH) |
{ |
status = _cairo_array_append (&font->string_offsets, |
&font->last_boundary); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
font->last_offset = font->last_boundary; |
} |
font->last_boundary = boundary; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_truetype_font_write_cmap_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
unsigned int i; |
cairo_truetype_font_write_be16 (font, 0); /* Table version */ |
cairo_truetype_font_write_be16 (font, 2); /* Num tables */ |
cairo_truetype_font_write_be16 (font, 3); /* Platform */ |
cairo_truetype_font_write_be16 (font, 0); /* Encoding */ |
cairo_truetype_font_write_be32 (font, 20); /* Offset to start of table */ |
cairo_truetype_font_write_be16 (font, 1); /* Platform */ |
cairo_truetype_font_write_be16 (font, 0); /* Encoding */ |
cairo_truetype_font_write_be32 (font, 52); /* Offset to start of table */ |
/* Output a format 4 encoding table. */ |
cairo_truetype_font_write_be16 (font, 4); /* Format */ |
cairo_truetype_font_write_be16 (font, 32); /* Length */ |
cairo_truetype_font_write_be16 (font, 0); /* Version */ |
cairo_truetype_font_write_be16 (font, 4); /* 2*segcount */ |
cairo_truetype_font_write_be16 (font, 4); /* searchrange */ |
cairo_truetype_font_write_be16 (font, 1); /* entry selector */ |
cairo_truetype_font_write_be16 (font, 0); /* rangeshift */ |
cairo_truetype_font_write_be16 (font, 0xf000 + font->base.num_glyphs - 1); /* end count[0] */ |
cairo_truetype_font_write_be16 (font, 0xffff); /* end count[1] */ |
cairo_truetype_font_write_be16 (font, 0); /* reserved */ |
cairo_truetype_font_write_be16 (font, 0xf000); /* startCode[0] */ |
cairo_truetype_font_write_be16 (font, 0xffff); /* startCode[1] */ |
cairo_truetype_font_write_be16 (font, 0x1000); /* delta[0] */ |
cairo_truetype_font_write_be16 (font, 1); /* delta[1] */ |
cairo_truetype_font_write_be16 (font, 0); /* rangeOffset[0] */ |
cairo_truetype_font_write_be16 (font, 0); /* rangeOffset[1] */ |
/* Output a format 6 encoding table. */ |
cairo_truetype_font_write_be16 (font, 6); |
cairo_truetype_font_write_be16 (font, 10 + 2 * font->base.num_glyphs); |
cairo_truetype_font_write_be16 (font, 0); |
cairo_truetype_font_write_be16 (font, 0); /* First character */ |
cairo_truetype_font_write_be16 (font, font->base.num_glyphs); |
for (i = 0; i < font->base.num_glyphs; i++) |
cairo_truetype_font_write_be16 (font, i); |
return font->status; |
} |
static cairo_status_t |
cairo_truetype_font_write_generic_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
cairo_status_t status; |
unsigned char *buffer; |
unsigned long size; |
if (font->status) |
return font->status; |
size = 0; |
status = font->backend->load_truetype_table(font->scaled_font_subset->scaled_font, |
tag, 0, NULL, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
status = cairo_truetype_font_allocate_write_buffer (font, size, &buffer); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
tag, 0, buffer, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_truetype_font_remap_composite_glyph (cairo_truetype_font_t *font, |
unsigned char *buffer, |
unsigned long size) |
{ |
tt_glyph_data_t *glyph_data; |
tt_composite_glyph_t *composite_glyph; |
int num_args; |
int has_more_components; |
unsigned short flags; |
unsigned short index; |
cairo_status_t status; |
unsigned char *end = buffer + size; |
if (font->status) |
return font->status; |
glyph_data = (tt_glyph_data_t *) buffer; |
if ((unsigned char *)(&glyph_data->data) >= end) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
if ((int16_t)be16_to_cpu (glyph_data->num_contours) >= 0) |
return CAIRO_STATUS_SUCCESS; |
composite_glyph = &glyph_data->glyph; |
do { |
if ((unsigned char *)(&composite_glyph->args[1]) > end) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
flags = be16_to_cpu (composite_glyph->flags); |
has_more_components = flags & TT_MORE_COMPONENTS; |
status = cairo_truetype_font_use_glyph (font, be16_to_cpu (composite_glyph->index), &index); |
if (unlikely (status)) |
return status; |
composite_glyph->index = cpu_to_be16 (index); |
num_args = 1; |
if (flags & TT_ARG_1_AND_2_ARE_WORDS) |
num_args += 1; |
if (flags & TT_WE_HAVE_A_SCALE) |
num_args += 1; |
else if (flags & TT_WE_HAVE_AN_X_AND_Y_SCALE) |
num_args += 2; |
else if (flags & TT_WE_HAVE_A_TWO_BY_TWO) |
num_args += 4; |
composite_glyph = (tt_composite_glyph_t *) &(composite_glyph->args[num_args]); |
} while (has_more_components); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_truetype_font_write_glyf_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
unsigned long start_offset, index, size, next; |
tt_head_t header; |
unsigned long begin, end; |
unsigned char *buffer; |
unsigned int i; |
union { |
unsigned char *bytes; |
uint16_t *short_offsets; |
uint32_t *long_offsets; |
} u; |
cairo_status_t status; |
if (font->status) |
return font->status; |
size = sizeof (tt_head_t); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_head, 0, |
(unsigned char*) &header, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
if (be16_to_cpu (header.index_to_loc_format) == 0) |
size = sizeof (int16_t) * (font->num_glyphs_in_face + 1); |
else |
size = sizeof (int32_t) * (font->num_glyphs_in_face + 1); |
u.bytes = malloc (size); |
if (unlikely (u.bytes == NULL)) |
return _cairo_truetype_font_set_error (font, CAIRO_STATUS_NO_MEMORY); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_loca, 0, u.bytes, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
start_offset = _cairo_array_num_elements (&font->output); |
for (i = 0; i < font->base.num_glyphs; i++) { |
index = font->glyphs[i].parent_index; |
if (be16_to_cpu (header.index_to_loc_format) == 0) { |
begin = be16_to_cpu (u.short_offsets[index]) * 2; |
end = be16_to_cpu (u.short_offsets[index + 1]) * 2; |
} |
else { |
begin = be32_to_cpu (u.long_offsets[index]); |
end = be32_to_cpu (u.long_offsets[index + 1]); |
} |
/* quick sanity check... */ |
if (end < begin) { |
status = CAIRO_INT_STATUS_UNSUPPORTED; |
goto FAIL; |
} |
size = end - begin; |
status = cairo_truetype_font_align_output (font, &next); |
if (unlikely (status)) |
goto FAIL; |
status = cairo_truetype_font_check_boundary (font, next); |
if (unlikely (status)) |
goto FAIL; |
font->glyphs[i].location = next - start_offset; |
status = cairo_truetype_font_allocate_write_buffer (font, size, &buffer); |
if (unlikely (status)) |
goto FAIL; |
if (size != 0) { |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_glyf, begin, buffer, &size); |
if (unlikely (status)) |
goto FAIL; |
status = cairo_truetype_font_remap_composite_glyph (font, buffer, size); |
if (unlikely (status)) |
goto FAIL; |
} |
} |
status = cairo_truetype_font_align_output (font, &next); |
if (unlikely (status)) |
goto FAIL; |
font->glyphs[i].location = next - start_offset; |
status = font->status; |
FAIL: |
free (u.bytes); |
return _cairo_truetype_font_set_error (font, status); |
} |
static cairo_status_t |
cairo_truetype_font_write_head_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
unsigned char *buffer; |
unsigned long size; |
cairo_status_t status; |
if (font->status) |
return font->status; |
size = 0; |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
tag, 0, NULL, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
font->checksum_index = _cairo_array_num_elements (&font->output) + 8; |
status = cairo_truetype_font_allocate_write_buffer (font, size, &buffer); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
tag, 0, buffer, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
/* set checkSumAdjustment to 0 for table checksum calculation */ |
*(uint32_t *)(buffer + 8) = 0; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_truetype_font_write_hhea_table (cairo_truetype_font_t *font, unsigned long tag) |
{ |
tt_hhea_t *hhea; |
unsigned long size; |
cairo_status_t status; |
if (font->status) |
return font->status; |
size = sizeof (tt_hhea_t); |
status = cairo_truetype_font_allocate_write_buffer (font, size, (unsigned char **) &hhea); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
tag, 0, (unsigned char *) hhea, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
hhea->num_hmetrics = cpu_to_be16 ((uint16_t)(font->base.num_glyphs)); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_truetype_font_write_hmtx_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
unsigned long size; |
unsigned long long_entry_size; |
unsigned long short_entry_size; |
short *p; |
unsigned int i; |
tt_hhea_t hhea; |
int num_hmetrics; |
cairo_status_t status; |
if (font->status) |
return font->status; |
size = sizeof (tt_hhea_t); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hhea, 0, |
(unsigned char*) &hhea, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
num_hmetrics = be16_to_cpu(hhea.num_hmetrics); |
for (i = 0; i < font->base.num_glyphs; i++) { |
long_entry_size = 2 * sizeof (int16_t); |
short_entry_size = sizeof (int16_t); |
status = cairo_truetype_font_allocate_write_buffer (font, |
long_entry_size, |
(unsigned char **) &p); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
if (font->glyphs[i].parent_index < num_hmetrics) { |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hmtx, |
font->glyphs[i].parent_index * long_entry_size, |
(unsigned char *) p, &long_entry_size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
} |
else |
{ |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hmtx, |
(num_hmetrics - 1) * long_entry_size, |
(unsigned char *) p, &short_entry_size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_hmtx, |
num_hmetrics * long_entry_size + |
(font->glyphs[i].parent_index - num_hmetrics) * short_entry_size, |
(unsigned char *) (p + 1), &short_entry_size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
} |
font->base.widths[i] = be16_to_cpu (p[0]); |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_truetype_font_write_loca_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
unsigned int i; |
tt_head_t header; |
unsigned long size; |
cairo_status_t status; |
if (font->status) |
return font->status; |
size = sizeof(tt_head_t); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_head, 0, |
(unsigned char*) &header, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
if (be16_to_cpu (header.index_to_loc_format) == 0) |
{ |
for (i = 0; i < font->base.num_glyphs + 1; i++) |
cairo_truetype_font_write_be16 (font, font->glyphs[i].location / 2); |
} else { |
for (i = 0; i < font->base.num_glyphs + 1; i++) |
cairo_truetype_font_write_be32 (font, font->glyphs[i].location); |
} |
return font->status; |
} |
static cairo_status_t |
cairo_truetype_font_write_maxp_table (cairo_truetype_font_t *font, |
unsigned long tag) |
{ |
tt_maxp_t *maxp; |
unsigned long size; |
cairo_status_t status; |
if (font->status) |
return font->status; |
size = sizeof (tt_maxp_t); |
status = cairo_truetype_font_allocate_write_buffer (font, size, (unsigned char **) &maxp); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
status = font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
tag, 0, (unsigned char *) maxp, &size); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
maxp->num_glyphs = cpu_to_be16 (font->base.num_glyphs); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_truetype_font_write_offset_table (cairo_truetype_font_t *font) |
{ |
cairo_status_t status; |
unsigned char *table_buffer; |
size_t table_buffer_length; |
unsigned short search_range, entry_selector, range_shift; |
if (font->status) |
return font->status; |
search_range = 1; |
entry_selector = 0; |
while (search_range * 2 <= font->num_tables) { |
search_range *= 2; |
entry_selector++; |
} |
search_range *= 16; |
range_shift = font->num_tables * 16 - search_range; |
cairo_truetype_font_write_be32 (font, SFNT_VERSION); |
cairo_truetype_font_write_be16 (font, font->num_tables); |
cairo_truetype_font_write_be16 (font, search_range); |
cairo_truetype_font_write_be16 (font, entry_selector); |
cairo_truetype_font_write_be16 (font, range_shift); |
/* Allocate space for the table directory. Each directory entry |
* will be filled in by cairo_truetype_font_update_entry() after |
* the table is written. */ |
table_buffer_length = font->num_tables * 16; |
status = cairo_truetype_font_allocate_write_buffer (font, table_buffer_length, |
&table_buffer); |
if (unlikely (status)) |
return _cairo_truetype_font_set_error (font, status); |
return CAIRO_STATUS_SUCCESS; |
} |
static uint32_t |
cairo_truetype_font_calculate_checksum (cairo_truetype_font_t *font, |
unsigned long start, |
unsigned long end) |
{ |
uint32_t *padded_end; |
uint32_t *p; |
uint32_t checksum; |
char *data; |
checksum = 0; |
data = _cairo_array_index (&font->output, 0); |
p = (uint32_t *) (data + start); |
padded_end = (uint32_t *) (data + ((end + 3) & ~3)); |
while (p < padded_end) |
checksum += be32_to_cpu(*p++); |
return checksum; |
} |
static void |
cairo_truetype_font_update_entry (cairo_truetype_font_t *font, |
int index, |
unsigned long tag, |
unsigned long start, |
unsigned long end) |
{ |
uint32_t *entry; |
entry = _cairo_array_index (&font->output, 12 + 16 * index); |
entry[0] = cpu_to_be32 ((uint32_t)tag); |
entry[1] = cpu_to_be32 (cairo_truetype_font_calculate_checksum (font, start, end)); |
entry[2] = cpu_to_be32 ((uint32_t)start); |
entry[3] = cpu_to_be32 ((uint32_t)(end - start)); |
} |
static cairo_status_t |
cairo_truetype_font_generate (cairo_truetype_font_t *font, |
const char **data, |
unsigned long *length, |
const unsigned long **string_offsets, |
unsigned long *num_strings) |
{ |
cairo_status_t status; |
unsigned long start, end, next; |
uint32_t checksum, *checksum_location; |
int i; |
if (font->status) |
return font->status; |
status = cairo_truetype_font_write_offset_table (font); |
if (unlikely (status)) |
goto FAIL; |
status = cairo_truetype_font_align_output (font, &start); |
if (unlikely (status)) |
goto FAIL; |
end = 0; |
for (i = 0; i < font->num_tables; i++) { |
status = font->truetype_tables[i].write (font, font->truetype_tables[i].tag); |
if (unlikely (status)) |
goto FAIL; |
end = _cairo_array_num_elements (&font->output); |
status = cairo_truetype_font_align_output (font, &next); |
if (unlikely (status)) |
goto FAIL; |
cairo_truetype_font_update_entry (font, font->truetype_tables[i].pos, |
font->truetype_tables[i].tag, start, end); |
status = cairo_truetype_font_check_boundary (font, next); |
if (unlikely (status)) |
goto FAIL; |
start = next; |
} |
checksum = |
0xb1b0afba - cairo_truetype_font_calculate_checksum (font, 0, end); |
checksum_location = _cairo_array_index (&font->output, font->checksum_index); |
*checksum_location = cpu_to_be32 (checksum); |
*data = _cairo_array_index (&font->output, 0); |
*length = _cairo_array_num_elements (&font->output); |
*num_strings = _cairo_array_num_elements (&font->string_offsets); |
if (*num_strings != 0) |
*string_offsets = _cairo_array_index (&font->string_offsets, 0); |
else |
*string_offsets = NULL; |
FAIL: |
return _cairo_truetype_font_set_error (font, status); |
} |
static cairo_status_t |
cairo_truetype_font_use_glyph (cairo_truetype_font_t *font, |
unsigned short glyph, |
unsigned short *out) |
{ |
if (glyph >= font->num_glyphs_in_face) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
if (font->parent_to_subset[glyph] == 0) { |
font->parent_to_subset[glyph] = font->base.num_glyphs; |
font->glyphs[font->base.num_glyphs].parent_index = glyph; |
font->base.num_glyphs++; |
} |
*out = font->parent_to_subset[glyph]; |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
cairo_truetype_font_add_truetype_table (cairo_truetype_font_t *font, |
unsigned long tag, |
cairo_status_t (*write) (cairo_truetype_font_t *font, unsigned long tag), |
int pos) |
{ |
font->truetype_tables[font->num_tables].tag = tag; |
font->truetype_tables[font->num_tables].write = write; |
font->truetype_tables[font->num_tables].pos = pos; |
font->num_tables++; |
} |
/* cairo_truetype_font_create_truetype_table_list() builds the list of |
* truetype tables to be embedded in the subsetted font. Each call to |
* cairo_truetype_font_add_truetype_table() adds a table, the callback |
* for generating the table, and the position in the table directory |
* to the truetype_tables array. |
* |
* As we write out the glyf table we remap composite glyphs. |
* Remapping composite glyphs will reference the sub glyphs the |
* composite glyph is made up of. The "glyf" table callback needs to |
* be called first so we have all the glyphs in the subset before |
* going further. |
* |
* The order in which tables are added to the truetype_table array |
* using cairo_truetype_font_add_truetype_table() specifies the order |
* in which the callback functions will be called. |
* |
* The tables in the table directory must be listed in alphabetical |
* order. The "cvt", "fpgm", and "prep" are optional tables. They |
* will only be embedded in the subset if they exist in the source |
* font. The pos parameter of cairo_truetype_font_add_truetype_table() |
* specifies the position of the table in the table directory. |
*/ |
static void |
cairo_truetype_font_create_truetype_table_list (cairo_truetype_font_t *font) |
{ |
cairo_bool_t has_cvt = FALSE; |
cairo_bool_t has_fpgm = FALSE; |
cairo_bool_t has_prep = FALSE; |
unsigned long size; |
int pos; |
size = 0; |
if (font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_cvt, 0, NULL, |
&size) == CAIRO_STATUS_SUCCESS) |
has_cvt = TRUE; |
size = 0; |
if (font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_fpgm, 0, NULL, |
&size) == CAIRO_STATUS_SUCCESS) |
has_fpgm = TRUE; |
size = 0; |
if (font->backend->load_truetype_table (font->scaled_font_subset->scaled_font, |
TT_TAG_prep, 0, NULL, |
&size) == CAIRO_STATUS_SUCCESS) |
has_prep = TRUE; |
font->num_tables = 0; |
pos = 1; |
if (has_cvt) |
pos++; |
if (has_fpgm) |
pos++; |
cairo_truetype_font_add_truetype_table (font, TT_TAG_glyf, cairo_truetype_font_write_glyf_table, pos); |
pos = 0; |
cairo_truetype_font_add_truetype_table (font, TT_TAG_cmap, cairo_truetype_font_write_cmap_table, pos++); |
if (has_cvt) |
cairo_truetype_font_add_truetype_table (font, TT_TAG_cvt, cairo_truetype_font_write_generic_table, pos++); |
if (has_fpgm) |
cairo_truetype_font_add_truetype_table (font, TT_TAG_fpgm, cairo_truetype_font_write_generic_table, pos++); |
pos++; |
cairo_truetype_font_add_truetype_table (font, TT_TAG_head, cairo_truetype_font_write_head_table, pos++); |
cairo_truetype_font_add_truetype_table (font, TT_TAG_hhea, cairo_truetype_font_write_hhea_table, pos++); |
cairo_truetype_font_add_truetype_table (font, TT_TAG_hmtx, cairo_truetype_font_write_hmtx_table, pos++); |
cairo_truetype_font_add_truetype_table (font, TT_TAG_loca, cairo_truetype_font_write_loca_table, pos++); |
cairo_truetype_font_add_truetype_table (font, TT_TAG_maxp, cairo_truetype_font_write_maxp_table, pos++); |
if (has_prep) |
cairo_truetype_font_add_truetype_table (font, TT_TAG_prep, cairo_truetype_font_write_generic_table, pos); |
} |
cairo_status_t |
_cairo_truetype_subset_init (cairo_truetype_subset_t *truetype_subset, |
cairo_scaled_font_subset_t *font_subset) |
{ |
cairo_truetype_font_t *font = NULL; |
cairo_status_t status; |
const char *data = NULL; /* squelch bogus compiler warning */ |
unsigned long length = 0; /* squelch bogus compiler warning */ |
unsigned long offsets_length; |
unsigned int i; |
const unsigned long *string_offsets = NULL; |
unsigned long num_strings = 0; |
status = _cairo_truetype_font_create (font_subset, &font); |
if (unlikely (status)) |
return status; |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) { |
unsigned short parent_glyph = font->scaled_font_subset->glyphs[i]; |
status = cairo_truetype_font_use_glyph (font, parent_glyph, &parent_glyph); |
if (unlikely (status)) |
goto fail1; |
} |
cairo_truetype_font_create_truetype_table_list (font); |
status = cairo_truetype_font_generate (font, &data, &length, |
&string_offsets, &num_strings); |
if (unlikely (status)) |
goto fail1; |
truetype_subset->ps_name = strdup (font->base.ps_name); |
if (unlikely (truetype_subset->ps_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail1; |
} |
if (font->base.font_name != NULL) { |
truetype_subset->font_name = strdup (font->base.font_name); |
if (unlikely (truetype_subset->font_name == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail2; |
} |
} else { |
truetype_subset->font_name = NULL; |
} |
/* The widths array returned must contain only widths for the |
* glyphs in font_subset. Any subglyphs appended after |
* font_subset->num_glyphs are omitted. */ |
truetype_subset->widths = calloc (sizeof (double), |
font->scaled_font_subset->num_glyphs); |
if (unlikely (truetype_subset->widths == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail3; |
} |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) |
truetype_subset->widths[i] = (double)font->base.widths[i]/font->base.units_per_em; |
truetype_subset->x_min = (double)font->base.x_min/font->base.units_per_em; |
truetype_subset->y_min = (double)font->base.y_min/font->base.units_per_em; |
truetype_subset->x_max = (double)font->base.x_max/font->base.units_per_em; |
truetype_subset->y_max = (double)font->base.y_max/font->base.units_per_em; |
truetype_subset->ascent = (double)font->base.ascent/font->base.units_per_em; |
truetype_subset->descent = (double)font->base.descent/font->base.units_per_em; |
if (length) { |
truetype_subset->data = malloc (length); |
if (unlikely (truetype_subset->data == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail4; |
} |
memcpy (truetype_subset->data, data, length); |
} else |
truetype_subset->data = NULL; |
truetype_subset->data_length = length; |
if (num_strings) { |
offsets_length = num_strings * sizeof (unsigned long); |
truetype_subset->string_offsets = malloc (offsets_length); |
if (unlikely (truetype_subset->string_offsets == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail5; |
} |
memcpy (truetype_subset->string_offsets, string_offsets, offsets_length); |
truetype_subset->num_string_offsets = num_strings; |
} else { |
truetype_subset->string_offsets = NULL; |
truetype_subset->num_string_offsets = 0; |
} |
cairo_truetype_font_destroy (font); |
return CAIRO_STATUS_SUCCESS; |
fail5: |
free (truetype_subset->data); |
fail4: |
free (truetype_subset->widths); |
fail3: |
if (truetype_subset->font_name) |
free (truetype_subset->font_name); |
fail2: |
free (truetype_subset->ps_name); |
fail1: |
cairo_truetype_font_destroy (font); |
return status; |
} |
void |
_cairo_truetype_subset_fini (cairo_truetype_subset_t *subset) |
{ |
free (subset->ps_name); |
if (subset->font_name) |
free (subset->font_name); |
free (subset->widths); |
free (subset->data); |
free (subset->string_offsets); |
} |
static cairo_int_status_t |
_cairo_truetype_reverse_cmap (cairo_scaled_font_t *scaled_font, |
unsigned long table_offset, |
unsigned long index, |
uint32_t *ucs4) |
{ |
cairo_status_t status; |
const cairo_scaled_font_backend_t *backend; |
tt_segment_map_t *map; |
char buf[4]; |
unsigned int num_segments, i; |
unsigned long size; |
uint16_t *start_code; |
uint16_t *end_code; |
uint16_t *delta; |
uint16_t *range_offset; |
uint16_t *glyph_array; |
uint16_t c; |
backend = scaled_font->backend; |
size = 4; |
status = backend->load_truetype_table (scaled_font, |
TT_TAG_cmap, table_offset, |
(unsigned char *) &buf, |
&size); |
if (unlikely (status)) |
return status; |
/* All table formats have the same first two words */ |
map = (tt_segment_map_t *) buf; |
if (be16_to_cpu (map->format) != 4) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
size = be16_to_cpu (map->length); |
map = malloc (size); |
if (unlikely (map == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
status = backend->load_truetype_table (scaled_font, |
TT_TAG_cmap, table_offset, |
(unsigned char *) map, |
&size); |
if (unlikely (status)) |
goto fail; |
num_segments = be16_to_cpu (map->segCountX2)/2; |
/* A Format 4 cmap contains 8 uint16_t numbers and 4 arrays of |
* uint16_t each num_segments long. */ |
if (size < (8 + 4*num_segments)*sizeof(uint16_t)) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
end_code = map->endCount; |
start_code = &(end_code[num_segments + 1]); |
delta = &(start_code[num_segments]); |
range_offset = &(delta[num_segments]); |
glyph_array = &(range_offset[num_segments]); |
/* search for glyph in segments with rangeOffset=0 */ |
for (i = 0; i < num_segments; i++) { |
c = index - be16_to_cpu (delta[i]); |
if (range_offset[i] == 0 && |
c >= be16_to_cpu (start_code[i]) && |
c <= be16_to_cpu (end_code[i])) |
{ |
*ucs4 = c; |
goto found; |
} |
} |
/* search for glyph in segments with rangeOffset=1 */ |
for (i = 0; i < num_segments; i++) { |
if (range_offset[i] != 0) { |
uint16_t *glyph_ids = &range_offset[i] + be16_to_cpu (range_offset[i])/2; |
int range_size = be16_to_cpu (end_code[i]) - be16_to_cpu (start_code[i]) + 1; |
uint16_t g_id_be = cpu_to_be16 (index); |
int j; |
if (range_size > 0) { |
if ((char*)glyph_ids + 2*range_size > (char*)map + size) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
for (j = 0; j < range_size; j++) { |
if (glyph_ids[j] == g_id_be) { |
*ucs4 = be16_to_cpu (start_code[i]) + j; |
goto found; |
} |
} |
} |
} |
} |
/* glyph not found */ |
*ucs4 = -1; |
found: |
status = CAIRO_STATUS_SUCCESS; |
fail: |
free (map); |
return status; |
} |
cairo_int_status_t |
_cairo_truetype_index_to_ucs4 (cairo_scaled_font_t *scaled_font, |
unsigned long index, |
uint32_t *ucs4) |
{ |
cairo_status_t status = CAIRO_INT_STATUS_UNSUPPORTED; |
const cairo_scaled_font_backend_t *backend; |
tt_cmap_t *cmap; |
char buf[4]; |
int num_tables, i; |
unsigned long size; |
backend = scaled_font->backend; |
if (!backend->load_truetype_table) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
size = 4; |
status = backend->load_truetype_table (scaled_font, |
TT_TAG_cmap, 0, |
(unsigned char *) &buf, |
&size); |
if (unlikely (status)) |
return status; |
cmap = (tt_cmap_t *) buf; |
num_tables = be16_to_cpu (cmap->num_tables); |
size = 4 + num_tables*sizeof(tt_cmap_index_t); |
cmap = _cairo_malloc_ab_plus_c (num_tables, sizeof (tt_cmap_index_t), 4); |
if (unlikely (cmap == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
status = backend->load_truetype_table (scaled_font, |
TT_TAG_cmap, 0, |
(unsigned char *) cmap, |
&size); |
if (unlikely (status)) |
goto cleanup; |
/* Find a table with Unicode mapping */ |
for (i = 0; i < num_tables; i++) { |
if (be16_to_cpu (cmap->index[i].platform) == 3 && |
be16_to_cpu (cmap->index[i].encoding) == 1) { |
status = _cairo_truetype_reverse_cmap (scaled_font, |
be32_to_cpu (cmap->index[i].offset), |
index, |
ucs4); |
if (status != CAIRO_INT_STATUS_UNSUPPORTED) |
break; |
} |
} |
cleanup: |
free (cmap); |
return status; |
} |
cairo_int_status_t |
_cairo_truetype_read_font_name (cairo_scaled_font_t *scaled_font, |
char **ps_name_out, |
char **font_name_out) |
{ |
cairo_status_t status; |
const cairo_scaled_font_backend_t *backend; |
tt_name_t *name; |
tt_name_record_t *record; |
unsigned long size; |
int i, j; |
char *ps_name = NULL; |
char *font_name = NULL; |
backend = scaled_font->backend; |
if (!backend->load_truetype_table) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
size = 0; |
status = backend->load_truetype_table (scaled_font, |
TT_TAG_name, 0, |
NULL, |
&size); |
if (status) |
return status; |
name = malloc (size); |
if (name == NULL) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
status = backend->load_truetype_table (scaled_font, |
TT_TAG_name, 0, |
(unsigned char *) name, |
&size); |
if (status) |
goto fail; |
/* Extract the font name and PS name from the name table. At |
* present this just looks for the Mac platform/Roman encoded font |
* name. It should be extended to use any suitable font name in |
* the name table. |
*/ |
for (i = 0; i < be16_to_cpu(name->num_records); i++) { |
record = &(name->records[i]); |
if ((be16_to_cpu (record->platform) == 1) && |
(be16_to_cpu (record->encoding) == 0)) { |
if (be16_to_cpu (record->name) == 4) { |
font_name = malloc (be16_to_cpu(record->length) + 1); |
if (font_name == NULL) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail; |
} |
strncpy(font_name, |
((char*)name) + be16_to_cpu (name->strings_offset) + be16_to_cpu (record->offset), |
be16_to_cpu (record->length)); |
font_name[be16_to_cpu (record->length)] = 0; |
} |
if (be16_to_cpu (record->name) == 6) { |
ps_name = malloc (be16_to_cpu(record->length) + 1); |
if (ps_name == NULL) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail; |
} |
strncpy(ps_name, |
((char*)name) + be16_to_cpu (name->strings_offset) + be16_to_cpu (record->offset), |
be16_to_cpu (record->length)); |
ps_name[be16_to_cpu (record->length)] = 0; |
} |
if (font_name && ps_name) |
break; |
} |
} |
free (name); |
/* Ensure PS name does not contain any spaces */ |
if (ps_name) { |
for (i = 0, j = 0; ps_name[j]; j++) { |
if (ps_name[j] == ' ') |
continue; |
ps_name[i++] = ps_name[j]; |
} |
ps_name[i] = '\0'; |
} |
*ps_name_out = ps_name; |
*font_name_out = font_name; |
return CAIRO_STATUS_SUCCESS; |
fail: |
free (name); |
if (ps_name != NULL) |
free (ps_name); |
if (font_name != NULL) |
free (font_name); |
*ps_name_out = NULL; |
*font_name_out = NULL; |
return status; |
} |
#endif /* CAIRO_HAS_FONT_SUBSET */ |
/programs/develop/libraries/cairo/src/cairo-type1-fallback.c |
---|
0,0 → 1,887 |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2006 Red Hat, Inc |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is Red Hat, Inc. |
* |
* Contributor(s): |
* Adrian Johnson <ajohnson@redneon.com> |
*/ |
#define _BSD_SOURCE /* for snprintf(), strdup() */ |
#include "cairoint.h" |
#include "cairo-error-private.h" |
#if CAIRO_HAS_FONT_SUBSET |
#include "cairo-type1-private.h" |
#include "cairo-scaled-font-subsets-private.h" |
#include "cairo-path-fixed-private.h" |
#include "cairo-output-stream-private.h" |
typedef enum { |
CAIRO_CHARSTRING_TYPE1, |
CAIRO_CHARSTRING_TYPE2 |
} cairo_charstring_type_t; |
typedef struct _cairo_type1_font { |
int *widths; |
cairo_scaled_font_subset_t *scaled_font_subset; |
cairo_scaled_font_t *type1_scaled_font; |
cairo_array_t contents; |
double x_min, y_min, x_max, y_max; |
const char *data; |
unsigned long header_size; |
unsigned long data_size; |
unsigned long trailer_size; |
int bbox_position; |
int bbox_max_chars; |
cairo_output_stream_t *output; |
unsigned short eexec_key; |
cairo_bool_t hex_encode; |
int hex_column; |
} cairo_type1_font_t; |
static cairo_status_t |
cairo_type1_font_create (cairo_scaled_font_subset_t *scaled_font_subset, |
cairo_type1_font_t **subset_return, |
cairo_bool_t hex_encode) |
{ |
cairo_type1_font_t *font; |
cairo_font_face_t *font_face; |
cairo_matrix_t font_matrix; |
cairo_matrix_t ctm; |
cairo_font_options_t font_options; |
cairo_status_t status; |
font = calloc (1, sizeof (cairo_type1_font_t)); |
if (unlikely (font == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
font->widths = calloc (scaled_font_subset->num_glyphs, sizeof (int)); |
if (unlikely (font->widths == NULL)) { |
free (font); |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
} |
font->scaled_font_subset = scaled_font_subset; |
font->hex_encode = hex_encode; |
font_face = cairo_scaled_font_get_font_face (scaled_font_subset->scaled_font); |
cairo_matrix_init_scale (&font_matrix, 1000, -1000); |
cairo_matrix_init_identity (&ctm); |
_cairo_font_options_init_default (&font_options); |
cairo_font_options_set_hint_style (&font_options, CAIRO_HINT_STYLE_NONE); |
cairo_font_options_set_hint_metrics (&font_options, CAIRO_HINT_METRICS_OFF); |
font->type1_scaled_font = cairo_scaled_font_create (font_face, |
&font_matrix, |
&ctm, |
&font_options); |
status = font->type1_scaled_font->status; |
if (unlikely (status)) |
goto fail; |
_cairo_array_init (&font->contents, sizeof (unsigned char)); |
font->output = NULL; |
*subset_return = font; |
return CAIRO_STATUS_SUCCESS; |
fail: |
free (font->widths); |
free (font); |
return status; |
} |
/* Charstring commands. If the high byte is 0 the command is encoded |
* with a single byte. */ |
#define CHARSTRING_sbw 0x0c07 |
#define CHARSTRING_rmoveto 0x0015 |
#define CHARSTRING_rlineto 0x0005 |
#define CHARSTRING_rcurveto 0x0008 |
#define CHARSTRING_closepath 0x0009 |
#define CHARSTRING_endchar 0x000e |
/* Before calling this function, the caller must allocate sufficient |
* space in data (see _cairo_array_grow_by). The maximum number of |
* bytes that will be used is 2. |
*/ |
static void |
charstring_encode_command (cairo_array_t *data, int command) |
{ |
cairo_status_t status; |
int orig_size; |
unsigned char buf[5]; |
unsigned char *p = buf; |
if (command & 0xff00) |
*p++ = command >> 8; |
*p++ = command & 0x00ff; |
/* Ensure the array doesn't grow, which allows this function to |
* have no possibility of failure. */ |
orig_size = _cairo_array_size (data); |
status = _cairo_array_append_multiple (data, buf, p - buf); |
assert (status == CAIRO_STATUS_SUCCESS); |
assert (_cairo_array_size (data) == orig_size); |
} |
/* Before calling this function, the caller must allocate sufficient |
* space in data (see _cairo_array_grow_by). The maximum number of |
* bytes that will be used is 5. |
*/ |
static void |
charstring_encode_integer (cairo_array_t *data, |
int i, |
cairo_charstring_type_t type) |
{ |
cairo_status_t status; |
int orig_size; |
unsigned char buf[10]; |
unsigned char *p = buf; |
if (i >= -107 && i <= 107) { |
*p++ = i + 139; |
} else if (i >= 108 && i <= 1131) { |
i -= 108; |
*p++ = (i >> 8)+ 247; |
*p++ = i & 0xff; |
} else if (i >= -1131 && i <= -108) { |
i = -i - 108; |
*p++ = (i >> 8)+ 251; |
*p++ = i & 0xff; |
} else { |
if (type == CAIRO_CHARSTRING_TYPE1) { |
*p++ = 0xff; |
*p++ = i >> 24; |
*p++ = (i >> 16) & 0xff; |
*p++ = (i >> 8) & 0xff; |
*p++ = i & 0xff; |
} else { |
*p++ = 0xff; |
*p++ = (i >> 8) & 0xff; |
*p++ = i & 0xff; |
*p++ = 0; |
*p++ = 0; |
} |
} |
/* Ensure the array doesn't grow, which allows this function to |
* have no possibility of failure. */ |
orig_size = _cairo_array_size (data); |
status = _cairo_array_append_multiple (data, buf, p - buf); |
assert (status == CAIRO_STATUS_SUCCESS); |
assert (_cairo_array_size (data) == orig_size); |
} |
typedef struct _ps_path_info { |
cairo_array_t *data; |
int current_x, current_y; |
cairo_charstring_type_t type; |
} t1_path_info_t; |
static cairo_status_t |
_charstring_move_to (void *closure, |
const cairo_point_t *point) |
{ |
t1_path_info_t *path_info = (t1_path_info_t *) closure; |
int dx, dy; |
cairo_status_t status; |
status = _cairo_array_grow_by (path_info->data, 12); |
if (unlikely (status)) |
return status; |
dx = _cairo_fixed_integer_part (point->x) - path_info->current_x; |
dy = _cairo_fixed_integer_part (point->y) - path_info->current_y; |
charstring_encode_integer (path_info->data, dx, path_info->type); |
charstring_encode_integer (path_info->data, dy, path_info->type); |
path_info->current_x += dx; |
path_info->current_y += dy; |
charstring_encode_command (path_info->data, CHARSTRING_rmoveto); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_charstring_line_to (void *closure, |
const cairo_point_t *point) |
{ |
t1_path_info_t *path_info = (t1_path_info_t *) closure; |
int dx, dy; |
cairo_status_t status; |
status = _cairo_array_grow_by (path_info->data, 12); |
if (unlikely (status)) |
return status; |
dx = _cairo_fixed_integer_part (point->x) - path_info->current_x; |
dy = _cairo_fixed_integer_part (point->y) - path_info->current_y; |
charstring_encode_integer (path_info->data, dx, path_info->type); |
charstring_encode_integer (path_info->data, dy, path_info->type); |
path_info->current_x += dx; |
path_info->current_y += dy; |
charstring_encode_command (path_info->data, CHARSTRING_rlineto); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_charstring_curve_to (void *closure, |
const cairo_point_t *point1, |
const cairo_point_t *point2, |
const cairo_point_t *point3) |
{ |
t1_path_info_t *path_info = (t1_path_info_t *) closure; |
int dx1, dy1, dx2, dy2, dx3, dy3; |
cairo_status_t status; |
status = _cairo_array_grow_by (path_info->data, 32); |
if (unlikely (status)) |
return status; |
dx1 = _cairo_fixed_integer_part (point1->x) - path_info->current_x; |
dy1 = _cairo_fixed_integer_part (point1->y) - path_info->current_y; |
dx2 = _cairo_fixed_integer_part (point2->x) - path_info->current_x - dx1; |
dy2 = _cairo_fixed_integer_part (point2->y) - path_info->current_y - dy1; |
dx3 = _cairo_fixed_integer_part (point3->x) - path_info->current_x - dx1 - dx2; |
dy3 = _cairo_fixed_integer_part (point3->y) - path_info->current_y - dy1 - dy2; |
charstring_encode_integer (path_info->data, dx1, path_info->type); |
charstring_encode_integer (path_info->data, dy1, path_info->type); |
charstring_encode_integer (path_info->data, dx2, path_info->type); |
charstring_encode_integer (path_info->data, dy2, path_info->type); |
charstring_encode_integer (path_info->data, dx3, path_info->type); |
charstring_encode_integer (path_info->data, dy3, path_info->type); |
path_info->current_x += dx1 + dx2 + dx3; |
path_info->current_y += dy1 + dy2 + dy3; |
charstring_encode_command (path_info->data, CHARSTRING_rcurveto); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
_charstring_close_path (void *closure) |
{ |
cairo_status_t status; |
t1_path_info_t *path_info = (t1_path_info_t *) closure; |
if (path_info->type == CAIRO_CHARSTRING_TYPE2) |
return CAIRO_STATUS_SUCCESS; |
status = _cairo_array_grow_by (path_info->data, 2); |
if (unlikely (status)) |
return status; |
charstring_encode_command (path_info->data, CHARSTRING_closepath); |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
charstring_encrypt (cairo_array_t *data) |
{ |
unsigned char *d, *end; |
uint16_t c, p, r; |
r = CAIRO_TYPE1_CHARSTRING_KEY; |
d = (unsigned char *) _cairo_array_index (data, 0); |
end = d + _cairo_array_num_elements (data); |
while (d < end) { |
p = *d; |
c = p ^ (r >> 8); |
r = (c + r) * CAIRO_TYPE1_ENCRYPT_C1 + CAIRO_TYPE1_ENCRYPT_C2; |
*d++ = c; |
} |
} |
static cairo_int_status_t |
cairo_type1_font_create_charstring (cairo_type1_font_t *font, |
int subset_index, |
int glyph_index, |
cairo_charstring_type_t type, |
cairo_array_t *data) |
{ |
cairo_int_status_t status; |
cairo_scaled_glyph_t *scaled_glyph; |
t1_path_info_t path_info; |
cairo_text_extents_t *metrics; |
cairo_bool_t emit_path = TRUE; |
/* This call may return CAIRO_INT_STATUS_UNSUPPORTED for bitmap fonts. */ |
status = _cairo_scaled_glyph_lookup (font->type1_scaled_font, |
glyph_index, |
CAIRO_SCALED_GLYPH_INFO_METRICS| |
CAIRO_SCALED_GLYPH_INFO_PATH, |
&scaled_glyph); |
/* It is ok for the .notdef glyph to not have a path available. We |
* just need the metrics to emit an empty glyph. */ |
if (glyph_index == 0 && status == CAIRO_INT_STATUS_UNSUPPORTED) { |
emit_path = FALSE; |
status = _cairo_scaled_glyph_lookup (font->type1_scaled_font, |
glyph_index, |
CAIRO_SCALED_GLYPH_INFO_METRICS, |
&scaled_glyph); |
} |
if (unlikely (status)) |
return status; |
metrics = &scaled_glyph->metrics; |
if (subset_index == 0) { |
font->x_min = metrics->x_bearing; |
font->y_min = metrics->y_bearing; |
font->x_max = metrics->x_bearing + metrics->width; |
font->y_max = metrics->y_bearing + metrics->height; |
} else { |
if (metrics->x_bearing < font->x_min) |
font->x_min = metrics->x_bearing; |
if (metrics->y_bearing < font->y_min) |
font->y_min = metrics->y_bearing; |
if (metrics->x_bearing + metrics->width > font->x_max) |
font->x_max = metrics->x_bearing + metrics->width; |
if (metrics->y_bearing + metrics->height > font->y_max) |
font->y_max = metrics->y_bearing + metrics->height; |
} |
font->widths[subset_index] = metrics->x_advance; |
status = _cairo_array_grow_by (data, 30); |
if (unlikely (status)) |
return status; |
if (type == CAIRO_CHARSTRING_TYPE1) { |
charstring_encode_integer (data, (int) scaled_glyph->metrics.x_bearing, type); |
charstring_encode_integer (data, (int) scaled_glyph->metrics.y_bearing, type); |
charstring_encode_integer (data, (int) scaled_glyph->metrics.x_advance, type); |
charstring_encode_integer (data, (int) scaled_glyph->metrics.y_advance, type); |
charstring_encode_command (data, CHARSTRING_sbw); |
path_info.current_x = (int) scaled_glyph->metrics.x_bearing; |
path_info.current_y = (int) scaled_glyph->metrics.y_bearing; |
} else { |
charstring_encode_integer (data, (int) scaled_glyph->metrics.x_advance, type); |
path_info.current_x = 0; |
path_info.current_y = 0; |
} |
path_info.data = data; |
path_info.type = type; |
if (emit_path) { |
status = _cairo_path_fixed_interpret (scaled_glyph->path, |
CAIRO_DIRECTION_FORWARD, |
_charstring_move_to, |
_charstring_line_to, |
_charstring_curve_to, |
_charstring_close_path, |
&path_info); |
if (unlikely (status)) |
return status; |
} |
status = _cairo_array_grow_by (data, 1); |
if (unlikely (status)) |
return status; |
charstring_encode_command (path_info.data, CHARSTRING_endchar); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
cairo_type1_font_write_charstrings (cairo_type1_font_t *font, |
cairo_output_stream_t *encrypted_output) |
{ |
cairo_status_t status; |
unsigned char zeros[] = { 0, 0, 0, 0 }; |
cairo_array_t data; |
unsigned int i; |
int length; |
_cairo_array_init (&data, sizeof (unsigned char)); |
status = _cairo_array_grow_by (&data, 1024); |
if (unlikely (status)) |
goto fail; |
_cairo_output_stream_printf (encrypted_output, |
"2 index /CharStrings %d dict dup begin\n", |
font->scaled_font_subset->num_glyphs + 1); |
_cairo_scaled_font_freeze_cache (font->type1_scaled_font); |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) { |
_cairo_array_truncate (&data, 0); |
/* four "random" bytes required by encryption algorithm */ |
status = _cairo_array_append_multiple (&data, zeros, 4); |
if (unlikely (status)) |
break; |
status = cairo_type1_font_create_charstring (font, i, |
font->scaled_font_subset->glyphs[i], |
CAIRO_CHARSTRING_TYPE1, |
&data); |
if (unlikely (status)) |
break; |
charstring_encrypt (&data); |
length = _cairo_array_num_elements (&data); |
if (font->scaled_font_subset->glyph_names != NULL) { |
_cairo_output_stream_printf (encrypted_output, "/%s %d RD ", |
font->scaled_font_subset->glyph_names[i], |
length); |
} else if (i == 0) { |
_cairo_output_stream_printf (encrypted_output, "/.notdef %d RD ", length); |
} else { |
_cairo_output_stream_printf (encrypted_output, "/g%d %d RD ", i, length); |
} |
_cairo_output_stream_write (encrypted_output, |
_cairo_array_index (&data, 0), |
length); |
_cairo_output_stream_printf (encrypted_output, " ND\n"); |
} |
_cairo_scaled_font_thaw_cache (font->type1_scaled_font); |
fail: |
_cairo_array_fini (&data); |
return status; |
} |
static void |
cairo_type1_font_write_header (cairo_type1_font_t *font, |
const char *name) |
{ |
unsigned int i; |
const char spaces[50] = " "; |
_cairo_output_stream_printf (font->output, |
"%%!FontType1-1.1 %s 1.0\n" |
"11 dict begin\n" |
"/FontName /%s def\n" |
"/PaintType 0 def\n" |
"/FontType 1 def\n" |
"/FontMatrix [0.001 0 0 0.001 0 0] readonly def\n", |
name, |
name); |
/* We don't know the bbox values until after the charstrings have |
* been generated. Reserve some space and fill in the bbox |
* later. */ |
/* Worst case for four signed ints with spaces between each number */ |
font->bbox_max_chars = 50; |
_cairo_output_stream_printf (font->output, "/FontBBox {"); |
font->bbox_position = _cairo_output_stream_get_position (font->output); |
_cairo_output_stream_write (font->output, spaces, font->bbox_max_chars); |
_cairo_output_stream_printf (font->output, |
"} readonly def\n" |
"/Encoding 256 array\n" |
"0 1 255 {1 index exch /.notdef put} for\n"); |
for (i = 1; i < font->scaled_font_subset->num_glyphs; i++) { |
if (font->scaled_font_subset->glyph_names != NULL) { |
_cairo_output_stream_printf (font->output, "dup %d /%s put\n", |
i, font->scaled_font_subset->glyph_names[i]); |
} else { |
_cairo_output_stream_printf (font->output, "dup %d /g%d put\n", i, i); |
} |
} |
_cairo_output_stream_printf (font->output, |
"readonly def\n" |
"currentdict end\n" |
"currentfile eexec\n"); |
} |
static cairo_status_t |
cairo_type1_write_stream_encrypted (void *closure, |
const unsigned char *data, |
unsigned int length) |
{ |
const unsigned char *in, *end; |
uint16_t c, p; |
static const char hex_digits[16] = "0123456789abcdef"; |
char digits[3]; |
cairo_type1_font_t *font = closure; |
in = (const unsigned char *) data; |
end = (const unsigned char *) data + length; |
while (in < end) { |
p = *in++; |
c = p ^ (font->eexec_key >> 8); |
font->eexec_key = (c + font->eexec_key) * CAIRO_TYPE1_ENCRYPT_C1 + CAIRO_TYPE1_ENCRYPT_C2; |
if (font->hex_encode) { |
digits[0] = hex_digits[c >> 4]; |
digits[1] = hex_digits[c & 0x0f]; |
digits[2] = '\n'; |
font->hex_column += 2; |
if (font->hex_column == 78) { |
_cairo_output_stream_write (font->output, digits, 3); |
font->hex_column = 0; |
} else { |
_cairo_output_stream_write (font->output, digits, 2); |
} |
} else { |
digits[0] = c; |
_cairo_output_stream_write (font->output, digits, 1); |
} |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
cairo_type1_font_write_private_dict (cairo_type1_font_t *font, |
const char *name) |
{ |
cairo_int_status_t status; |
cairo_status_t status2; |
cairo_output_stream_t *encrypted_output; |
font->eexec_key = CAIRO_TYPE1_PRIVATE_DICT_KEY; |
font->hex_column = 0; |
encrypted_output = _cairo_output_stream_create ( |
cairo_type1_write_stream_encrypted, |
NULL, |
font); |
if (_cairo_output_stream_get_status (encrypted_output)) |
return _cairo_output_stream_destroy (encrypted_output); |
/* Note: the first four spaces at the start of this private dict |
* are the four "random" bytes of plaintext required by the |
* encryption algorithm */ |
_cairo_output_stream_printf (encrypted_output, |
" dup /Private 9 dict dup begin\n" |
"/RD {string currentfile exch readstring pop}" |
" bind executeonly def\n" |
"/ND {noaccess def} executeonly def\n" |
"/NP {noaccess put} executeonly def\n" |
"/BlueValues [] def\n" |
"/MinFeature {16 16} def\n" |
"/lenIV 4 def\n" |
"/password 5839 def\n"); |
status = cairo_type1_font_write_charstrings (font, encrypted_output); |
if (unlikely (status)) |
goto fail; |
_cairo_output_stream_printf (encrypted_output, |
"end\n" |
"end\n" |
"readonly put\n" |
"noaccess put\n" |
"dup /FontName get exch definefont pop\n" |
"mark currentfile closefile\n"); |
fail: |
status2 = _cairo_output_stream_destroy (encrypted_output); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
return status; |
} |
static void |
cairo_type1_font_write_trailer(cairo_type1_font_t *font) |
{ |
int i; |
static const char zeros[65] = |
"0000000000000000000000000000000000000000000000000000000000000000\n"; |
for (i = 0; i < 8; i++) |
_cairo_output_stream_write (font->output, zeros, sizeof zeros); |
_cairo_output_stream_printf (font->output, "cleartomark\n"); |
} |
static cairo_status_t |
cairo_type1_write_stream (void *closure, |
const unsigned char *data, |
unsigned int length) |
{ |
cairo_type1_font_t *font = closure; |
return _cairo_array_append_multiple (&font->contents, data, length); |
} |
static cairo_int_status_t |
cairo_type1_font_write (cairo_type1_font_t *font, |
const char *name) |
{ |
cairo_int_status_t status; |
cairo_type1_font_write_header (font, name); |
font->header_size = _cairo_output_stream_get_position (font->output); |
status = cairo_type1_font_write_private_dict (font, name); |
if (unlikely (status)) |
return status; |
font->data_size = _cairo_output_stream_get_position (font->output) - |
font->header_size; |
cairo_type1_font_write_trailer (font); |
font->trailer_size = |
_cairo_output_stream_get_position (font->output) - |
font->header_size - font->data_size; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_int_status_t |
cairo_type1_font_generate (cairo_type1_font_t *font, const char *name) |
{ |
cairo_int_status_t status; |
status = _cairo_array_grow_by (&font->contents, 4096); |
if (unlikely (status)) |
return status; |
font->output = _cairo_output_stream_create (cairo_type1_write_stream, NULL, font); |
if (_cairo_output_stream_get_status (font->output)) |
return _cairo_output_stream_destroy (font->output); |
status = cairo_type1_font_write (font, name); |
if (unlikely (status)) |
return status; |
font->data = _cairo_array_index (&font->contents, 0); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_type1_font_destroy (cairo_type1_font_t *font) |
{ |
cairo_status_t status = CAIRO_STATUS_SUCCESS; |
free (font->widths); |
cairo_scaled_font_destroy (font->type1_scaled_font); |
_cairo_array_fini (&font->contents); |
if (font->output) |
status = _cairo_output_stream_destroy (font->output); |
free (font); |
return status; |
} |
static cairo_status_t |
_cairo_type1_fallback_init_internal (cairo_type1_subset_t *type1_subset, |
const char *name, |
cairo_scaled_font_subset_t *scaled_font_subset, |
cairo_bool_t hex_encode) |
{ |
cairo_type1_font_t *font; |
cairo_status_t status; |
unsigned long length; |
unsigned int i, len; |
status = cairo_type1_font_create (scaled_font_subset, &font, hex_encode); |
if (unlikely (status)) |
return status; |
status = cairo_type1_font_generate (font, name); |
if (unlikely (status)) |
goto fail1; |
type1_subset->base_font = strdup (name); |
if (unlikely (type1_subset->base_font == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail1; |
} |
type1_subset->widths = calloc (sizeof (double), font->scaled_font_subset->num_glyphs); |
if (unlikely (type1_subset->widths == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail2; |
} |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) |
type1_subset->widths[i] = (double)font->widths[i]/1000; |
type1_subset->x_min = (double)font->x_min/1000; |
type1_subset->y_min = (double)font->y_min/1000; |
type1_subset->x_max = (double)font->x_max/1000; |
type1_subset->y_max = (double)font->y_max/1000; |
type1_subset->ascent = (double)font->y_max/1000; |
type1_subset->descent = (double)font->y_min/1000; |
length = font->header_size + font->data_size + |
font->trailer_size; |
type1_subset->data = malloc (length); |
if (unlikely (type1_subset->data == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail3; |
} |
memcpy (type1_subset->data, |
_cairo_array_index (&font->contents, 0), length); |
len = snprintf(type1_subset->data + font->bbox_position, |
font->bbox_max_chars, |
"%d %d %d %d", |
(int)font->x_min, |
(int)font->y_min, |
(int)font->x_max, |
(int)font->y_max); |
type1_subset->data[font->bbox_position + len] = ' '; |
type1_subset->header_length = font->header_size; |
type1_subset->data_length = font->data_size; |
type1_subset->trailer_length = font->trailer_size; |
return cairo_type1_font_destroy (font); |
fail3: |
free (type1_subset->widths); |
fail2: |
free (type1_subset->base_font); |
fail1: |
/* status is already set, ignore further errors */ |
cairo_type1_font_destroy (font); |
return status; |
} |
cairo_status_t |
_cairo_type1_fallback_init_binary (cairo_type1_subset_t *type1_subset, |
const char *name, |
cairo_scaled_font_subset_t *scaled_font_subset) |
{ |
return _cairo_type1_fallback_init_internal (type1_subset, |
name, |
scaled_font_subset, FALSE); |
} |
cairo_status_t |
_cairo_type1_fallback_init_hex (cairo_type1_subset_t *type1_subset, |
const char *name, |
cairo_scaled_font_subset_t *scaled_font_subset) |
{ |
return _cairo_type1_fallback_init_internal (type1_subset, |
name, |
scaled_font_subset, TRUE); |
} |
void |
_cairo_type1_fallback_fini (cairo_type1_subset_t *subset) |
{ |
free (subset->base_font); |
free (subset->widths); |
free (subset->data); |
} |
cairo_status_t |
_cairo_type2_charstrings_init (cairo_type2_charstrings_t *type2_subset, |
cairo_scaled_font_subset_t *scaled_font_subset) |
{ |
cairo_type1_font_t *font; |
cairo_status_t status; |
unsigned int i; |
cairo_array_t charstring; |
status = cairo_type1_font_create (scaled_font_subset, &font, FALSE); |
if (unlikely (status)) |
return status; |
_cairo_array_init (&type2_subset->charstrings, sizeof (cairo_array_t)); |
type2_subset->widths = calloc (sizeof (int), font->scaled_font_subset->num_glyphs); |
if (unlikely (type2_subset->widths == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail1; |
} |
_cairo_scaled_font_freeze_cache (font->type1_scaled_font); |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) { |
_cairo_array_init (&charstring, sizeof (unsigned char)); |
status = _cairo_array_grow_by (&charstring, 32); |
if (unlikely (status)) |
goto fail2; |
status = cairo_type1_font_create_charstring (font, i, |
font->scaled_font_subset->glyphs[i], |
CAIRO_CHARSTRING_TYPE2, |
&charstring); |
if (unlikely (status)) |
goto fail2; |
status = _cairo_array_append (&type2_subset->charstrings, &charstring); |
if (unlikely (status)) |
goto fail2; |
} |
_cairo_scaled_font_thaw_cache (font->type1_scaled_font); |
for (i = 0; i < font->scaled_font_subset->num_glyphs; i++) |
type2_subset->widths[i] = font->widths[i]; |
type2_subset->x_min = (int) font->x_min; |
type2_subset->y_min = (int) font->y_min; |
type2_subset->x_max = (int) font->x_max; |
type2_subset->y_max = (int) font->y_max; |
type2_subset->ascent = (int) font->y_max; |
type2_subset->descent = (int) font->y_min; |
return cairo_type1_font_destroy (font); |
fail2: |
_cairo_scaled_font_thaw_cache (font->type1_scaled_font); |
_cairo_array_fini (&charstring); |
_cairo_type2_charstrings_fini (type2_subset); |
fail1: |
cairo_type1_font_destroy (font); |
return status; |
} |
void |
_cairo_type2_charstrings_fini (cairo_type2_charstrings_t *type2_subset) |
{ |
unsigned int i, num_charstrings; |
cairo_array_t *charstring; |
num_charstrings = _cairo_array_num_elements (&type2_subset->charstrings); |
for (i = 0; i < num_charstrings; i++) { |
charstring = _cairo_array_index (&type2_subset->charstrings, i); |
_cairo_array_fini (charstring); |
} |
_cairo_array_fini (&type2_subset->charstrings); |
free (type2_subset->widths); |
} |
#endif /* CAIRO_HAS_FONT_SUBSET */ |
/programs/develop/libraries/cairo/src/cairo-type1-subset.c |
---|
0,0 → 1,1431 |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2006 Red Hat, Inc |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is Red Hat, Inc. |
* |
* Contributor(s): |
* Kristian Høgsberg <krh@redhat.com> |
*/ |
/* |
* Useful links: |
* http://partners.adobe.com/public/developer/en/font/T1_SPEC.PDF |
*/ |
#define _BSD_SOURCE /* for snprintf(), strdup() */ |
#include "cairoint.h" |
#include "cairo-error-private.h" |
#if CAIRO_HAS_FONT_SUBSET |
#include "cairo-type1-private.h" |
#include "cairo-scaled-font-subsets-private.h" |
#include "cairo-output-stream-private.h" |
/* XXX: Eventually, we need to handle other font backends */ |
#if CAIRO_HAS_FT_FONT |
#include "cairo-ft-private.h" |
#include <ft2build.h> |
#include FT_FREETYPE_H |
#include FT_OUTLINE_H |
#include FT_TYPE1_TABLES_H |
#include <ctype.h> |
typedef struct _cairo_type1_font_subset { |
cairo_scaled_font_subset_t *scaled_font_subset; |
struct { |
cairo_unscaled_font_t *unscaled_font; |
unsigned int font_id; |
char *base_font; |
unsigned int num_glyphs; |
double x_min, y_min, x_max, y_max; |
double ascent, descent; |
const char *data; |
unsigned long header_size; |
unsigned long data_size; |
unsigned long trailer_size; |
} base; |
FT_Face face; |
int num_glyphs; |
struct { |
int subset_index; |
double width; |
char *name; |
} *glyphs; |
cairo_output_stream_t *output; |
cairo_array_t contents; |
const char *rd, *nd; |
char *type1_data; |
unsigned int type1_length; |
char *type1_end; |
char *header_segment; |
int header_segment_size; |
char *eexec_segment; |
int eexec_segment_size; |
cairo_bool_t eexec_segment_is_ascii; |
char *cleartext; |
char *cleartext_end; |
int header_size; |
unsigned short eexec_key; |
cairo_bool_t hex_encode; |
int hex_column; |
} cairo_type1_font_subset_t; |
static cairo_status_t |
_cairo_type1_font_subset_init (cairo_type1_font_subset_t *font, |
cairo_unscaled_font_t *unscaled_font, |
cairo_bool_t hex_encode) |
{ |
cairo_ft_unscaled_font_t *ft_unscaled_font; |
cairo_status_t status; |
FT_Face face; |
PS_FontInfoRec font_info; |
int i, j; |
ft_unscaled_font = (cairo_ft_unscaled_font_t *) unscaled_font; |
face = _cairo_ft_unscaled_font_lock_face (ft_unscaled_font); |
if (unlikely (face == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
if (FT_Get_PS_Font_Info(face, &font_info) != 0) { |
status = CAIRO_INT_STATUS_UNSUPPORTED; |
goto fail1; |
} |
/* OpenType/CFF fonts also have a PS_FontInfoRec */ |
#if HAVE_FT_LOAD_SFNT_TABLE |
if (FT_IS_SFNT (face)) { |
status = CAIRO_INT_STATUS_UNSUPPORTED; |
goto fail1; |
} |
#endif |
memset (font, 0, sizeof (*font)); |
font->base.unscaled_font = _cairo_unscaled_font_reference (unscaled_font); |
font->base.num_glyphs = face->num_glyphs; |
font->base.x_min = face->bbox.xMin / (double)face->units_per_EM; |
font->base.y_min = face->bbox.yMin / (double)face->units_per_EM; |
font->base.x_max = face->bbox.xMax / (double)face->units_per_EM; |
font->base.y_max = face->bbox.yMax / (double)face->units_per_EM; |
font->base.ascent = face->ascender / (double)face->units_per_EM; |
font->base.descent = face->descender / (double)face->units_per_EM; |
if (face->family_name) { |
font->base.base_font = strdup (face->family_name); |
if (unlikely (font->base.base_font == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail2; |
} |
for (i = 0, j = 0; font->base.base_font[j]; j++) { |
if (font->base.base_font[j] == ' ') |
continue; |
font->base.base_font[i++] = font->base.base_font[j]; |
} |
font->base.base_font[i] = '\0'; |
} |
font->glyphs = calloc (face->num_glyphs, sizeof font->glyphs[0]); |
if (unlikely (font->glyphs == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail3; |
} |
font->hex_encode = hex_encode; |
font->num_glyphs = 0; |
for (i = 0; i < face->num_glyphs; i++) |
font->glyphs[i].subset_index = -1; |
_cairo_array_init (&font->contents, sizeof (char)); |
_cairo_ft_unscaled_font_unlock_face (ft_unscaled_font); |
return CAIRO_STATUS_SUCCESS; |
fail3: |
if (font->base.base_font) |
free (font->base.base_font); |
fail2: |
_cairo_unscaled_font_destroy (unscaled_font); |
fail1: |
_cairo_ft_unscaled_font_unlock_face (ft_unscaled_font); |
return status; |
} |
static void |
cairo_type1_font_subset_use_glyph (cairo_type1_font_subset_t *font, int glyph) |
{ |
if (font->glyphs[glyph].subset_index >= 0) |
return; |
font->glyphs[glyph].subset_index = font->num_glyphs++; |
} |
static cairo_bool_t |
is_ps_delimiter(int c) |
{ |
static const char delimiters[] = "()[]{}<>/% \t\r\n"; |
return strchr (delimiters, c) != NULL; |
} |
static const char * |
find_token (const char *buffer, const char *end, const char *token) |
{ |
int i, length; |
/* FIXME: find substring really must be find_token */ |
if (buffer == NULL) |
return NULL; |
length = strlen (token); |
for (i = 0; buffer + i < end - length + 1; i++) |
if (memcmp (buffer + i, token, length) == 0) |
if ((i == 0 || token[0] == '/' || is_ps_delimiter(buffer[i - 1])) && |
(buffer + i == end - length || is_ps_delimiter(buffer[i + length]))) |
return buffer + i; |
return NULL; |
} |
static cairo_status_t |
cairo_type1_font_subset_find_segments (cairo_type1_font_subset_t *font) |
{ |
unsigned char *p; |
const char *eexec_token; |
int size, i; |
p = (unsigned char *) font->type1_data; |
font->type1_end = font->type1_data + font->type1_length; |
if (p[0] == 0x80 && p[1] == 0x01) { |
font->header_segment_size = |
p[2] | (p[3] << 8) | (p[4] << 16) | (p[5] << 24); |
font->header_segment = (char *) p + 6; |
p += 6 + font->header_segment_size; |
font->eexec_segment_size = |
p[2] | (p[3] << 8) | (p[4] << 16) | (p[5] << 24); |
font->eexec_segment = (char *) p + 6; |
font->eexec_segment_is_ascii = (p[1] == 1); |
p += 6 + font->eexec_segment_size; |
while (p < (unsigned char *) (font->type1_end) && p[1] != 0x03) { |
size = p[2] | (p[3] << 8) | (p[4] << 16) | (p[5] << 24); |
p += 6 + size; |
} |
font->type1_end = (char *) p; |
} else { |
eexec_token = find_token ((char *) p, font->type1_end, "eexec"); |
if (eexec_token == NULL) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
font->header_segment_size = eexec_token - (char *) p + strlen ("eexec\n"); |
font->header_segment = (char *) p; |
font->eexec_segment_size = font->type1_length - font->header_segment_size; |
font->eexec_segment = (char *) p + font->header_segment_size; |
font->eexec_segment_is_ascii = TRUE; |
for (i = 0; i < 4; i++) { |
if (!isxdigit(font->eexec_segment[i])) |
font->eexec_segment_is_ascii = FALSE; |
} |
} |
return CAIRO_STATUS_SUCCESS; |
} |
/* Search for the definition of key and erase it by overwriting with spaces. |
* This function is looks for definitions of the form: |
* |
* /key1 1234 def |
* /key2 [12 34 56] def |
* |
* ie a key defined as an integer or array of integers. |
* |
*/ |
static void |
cairo_type1_font_erase_dict_key (cairo_type1_font_subset_t *font, |
const char *key) |
{ |
const char *start, *p, *segment_end; |
segment_end = font->header_segment + font->header_segment_size; |
start = font->header_segment; |
do { |
start = find_token (start, segment_end, key); |
if (start) { |
p = start + strlen(key); |
/* skip integers or array of integers */ |
while (p < segment_end && |
(_cairo_isspace(*p) || |
_cairo_isdigit(*p) || |
*p == '[' || |
*p == ']')) |
{ |
p++; |
} |
if (p + 3 < segment_end && memcmp(p, "def", 3) == 0) { |
/* erase definition of the key */ |
memset((char *) start, ' ', p + 3 - start); |
} |
start += strlen(key); |
} |
} while (start); |
} |
static cairo_status_t |
cairo_type1_font_subset_write_header (cairo_type1_font_subset_t *font, |
const char *name) |
{ |
const char *start, *end, *segment_end; |
unsigned int i; |
/* FIXME: |
* This function assumes that /FontName always appears |
* before /Encoding. This appears to always be the case with Type1 |
* fonts. |
* |
* The more recently added code for removing the UniqueID and XUID |
* keys can not make any assumptions about the position of the |
* keys in the dictionary so it is implemented by overwriting the |
* key definition with spaces before we start copying the font to |
* the output. |
* |
* This code should be rewritten to not make any assumptions about |
* the order of dictionary keys. This will allow UniqueID to be |
* stripped out instead of leaving a bunch of spaces in the |
* output. |
*/ |
cairo_type1_font_erase_dict_key (font, "/UniqueID"); |
cairo_type1_font_erase_dict_key (font, "/XUID"); |
segment_end = font->header_segment + font->header_segment_size; |
/* Type 1 fonts created by Fontforge have some PostScript code at |
* the start of the font that skips the font if the printer has a |
* cached copy of the font with the same unique id. This breaks |
* our subsetted font so we disable it by searching for the |
* PostScript operator "known" when used to check for the |
* "/UniqueID" dictionary key. We append " pop false " after it to |
* pop the result of this check off the stack and replace it with |
* "false" to make the PostScript code think "/UniqueID" does not |
* exist. |
*/ |
end = font->header_segment; |
start = find_token (font->header_segment, segment_end, "/UniqueID"); |
if (start) { |
start += 9; |
while (start < segment_end && _cairo_isspace (*start)) |
start++; |
if (start + 5 < segment_end && memcmp(start, "known", 5) == 0) { |
_cairo_output_stream_write (font->output, font->header_segment, |
start + 5 - font->header_segment); |
_cairo_output_stream_printf (font->output, " pop false "); |
end = start + 5; |
} |
} |
start = find_token (end, segment_end, "/FontName"); |
if (start == NULL) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
_cairo_output_stream_write (font->output, end, |
start - end); |
_cairo_output_stream_printf (font->output, "/FontName /%s def", name); |
end = find_token (start, segment_end, "def"); |
if (end == NULL) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
end += 3; |
start = find_token (end, segment_end, "/Encoding"); |
if (start == NULL) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
_cairo_output_stream_write (font->output, end, start - end); |
_cairo_output_stream_printf (font->output, |
"/Encoding 256 array\n" |
"0 1 255 {1 index exch /.notdef put} for\n"); |
for (i = 1; i < font->base.num_glyphs; i++) { |
if (font->glyphs[i].subset_index < 0) |
continue; |
_cairo_output_stream_printf (font->output, |
"dup %d /%s put\n", |
font->glyphs[i].subset_index, |
font->glyphs[i].name); |
} |
_cairo_output_stream_printf (font->output, "readonly def"); |
end = find_token (start, segment_end, "def"); |
if (end == NULL) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
end += 3; |
_cairo_output_stream_write (font->output, end, segment_end - end); |
return font->output->status; |
} |
static int |
hex_to_int (int ch) |
{ |
if (ch <= '9') |
return ch - '0'; |
else if (ch <= 'F') |
return ch - 'A' + 10; |
else |
return ch - 'a' + 10; |
} |
static cairo_status_t |
cairo_type1_font_subset_write_encrypted (cairo_type1_font_subset_t *font, |
const char *data, unsigned int length) |
{ |
const unsigned char *in, *end; |
int c, p; |
static const char hex_digits[16] = "0123456789abcdef"; |
char digits[3]; |
in = (const unsigned char *) data; |
end = (const unsigned char *) data + length; |
while (in < end) { |
p = *in++; |
c = p ^ (font->eexec_key >> 8); |
font->eexec_key = (c + font->eexec_key) * CAIRO_TYPE1_ENCRYPT_C1 + CAIRO_TYPE1_ENCRYPT_C2; |
if (font->hex_encode) { |
digits[0] = hex_digits[c >> 4]; |
digits[1] = hex_digits[c & 0x0f]; |
digits[2] = '\n'; |
font->hex_column += 2; |
if (font->hex_column == 78) { |
_cairo_output_stream_write (font->output, digits, 3); |
font->hex_column = 0; |
} else { |
_cairo_output_stream_write (font->output, digits, 2); |
} |
} else { |
digits[0] = c; |
_cairo_output_stream_write (font->output, digits, 1); |
} |
} |
return font->output->status; |
} |
static cairo_status_t |
cairo_type1_font_subset_decrypt_eexec_segment (cairo_type1_font_subset_t *font) |
{ |
unsigned short r = CAIRO_TYPE1_PRIVATE_DICT_KEY; |
unsigned char *in, *end; |
char *out; |
int c, p; |
int i; |
in = (unsigned char *) font->eexec_segment; |
end = (unsigned char *) in + font->eexec_segment_size; |
font->cleartext = malloc (font->eexec_segment_size); |
if (unlikely (font->cleartext == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
out = font->cleartext; |
while (in < end) { |
if (font->eexec_segment_is_ascii) { |
c = *in++; |
if (_cairo_isspace (c)) |
continue; |
c = (hex_to_int (c) << 4) | hex_to_int (*in++); |
} else { |
c = *in++; |
} |
p = c ^ (r >> 8); |
r = (c + r) * CAIRO_TYPE1_ENCRYPT_C1 + CAIRO_TYPE1_ENCRYPT_C2; |
*out++ = p; |
} |
font->cleartext_end = out; |
/* Overwrite random bytes with spaces. |
* |
* The first 4 bytes of the cleartext are the random bytes |
* required by the encryption algorithm. When encrypting the |
* cleartext, the first ciphertext byte must not be a white space |
* character and the first 4 bytes must not be an ASCII Hex |
* character. Some fonts do not check that their randomly chosen |
* bytes results in ciphertext that complies with this |
* restriction. This may cause problems for some PDF consumers. By |
* replacing the random bytes with spaces, the first four bytes of |
* ciphertext will always be 0xf9, 0x83, 0xef, 0x00 which complies |
* with this restriction. Using spaces also means we don't have to |
* skip over the random bytes when parsing the cleartext. |
*/ |
for (i = 0; i < 4 && i < font->eexec_segment_size; i++) |
font->cleartext[i] = ' '; |
return CAIRO_STATUS_SUCCESS; |
} |
static const char * |
skip_token (const char *p, const char *end) |
{ |
while (p < end && _cairo_isspace(*p)) |
p++; |
while (p < end && !_cairo_isspace(*p)) |
p++; |
if (p == end) |
return NULL; |
return p; |
} |
static int |
cairo_type1_font_subset_lookup_glyph (cairo_type1_font_subset_t *font, |
const char *glyph_name, int length) |
{ |
unsigned int i; |
for (i = 0; i < font->base.num_glyphs; i++) { |
if (font->glyphs[i].name && |
strncmp (font->glyphs[i].name, glyph_name, length) == 0 && |
font->glyphs[i].name[length] == '\0') |
return i; |
} |
return -1; |
} |
static cairo_status_t |
cairo_type1_font_subset_get_glyph_names_and_widths (cairo_type1_font_subset_t *font) |
{ |
unsigned int i; |
char buffer[256]; |
FT_Error error; |
/* Get glyph names and width using the freetype API */ |
for (i = 0; i < font->base.num_glyphs; i++) { |
if (font->glyphs[i].name != NULL) |
continue; |
error = FT_Load_Glyph (font->face, i, |
FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING | |
FT_LOAD_NO_BITMAP | FT_LOAD_IGNORE_TRANSFORM); |
if (error != FT_Err_Ok) { |
/* propagate fatal errors from FreeType */ |
if (error == FT_Err_Out_Of_Memory) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
return CAIRO_INT_STATUS_UNSUPPORTED; |
} |
font->glyphs[i].width = font->face->glyph->metrics.horiAdvance / (double)font->face->units_per_EM; |
error = FT_Get_Glyph_Name(font->face, i, buffer, sizeof buffer); |
if (error != FT_Err_Ok) { |
/* propagate fatal errors from FreeType */ |
if (error == FT_Err_Out_Of_Memory) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
return CAIRO_INT_STATUS_UNSUPPORTED; |
} |
font->glyphs[i].name = strdup (buffer); |
if (unlikely (font->glyphs[i].name == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
} |
return CAIRO_STATUS_SUCCESS; |
} |
static void |
cairo_type1_font_subset_decrypt_charstring (const unsigned char *in, int size, unsigned char *out) |
{ |
unsigned short r = CAIRO_TYPE1_CHARSTRING_KEY; |
int c, p, i; |
for (i = 0; i < size; i++) { |
c = *in++; |
p = c ^ (r >> 8); |
r = (c + r) * CAIRO_TYPE1_ENCRYPT_C1 + CAIRO_TYPE1_ENCRYPT_C2; |
*out++ = p; |
} |
} |
static const unsigned char * |
cairo_type1_font_subset_decode_integer (const unsigned char *p, int *integer) |
{ |
if (*p <= 246) { |
*integer = *p++ - 139; |
} else if (*p <= 250) { |
*integer = (p[0] - 247) * 256 + p[1] + 108; |
p += 2; |
} else if (*p <= 254) { |
*integer = -(p[0] - 251) * 256 - p[1] - 108; |
p += 2; |
} else { |
*integer = (p[1] << 24) | (p[2] << 16) | (p[3] << 8) | p[4]; |
p += 5; |
} |
return p; |
} |
#if 0 |
/* |
* The two tables that follow are generated using this perl code: |
*/ |
@encoding = ( |
/* 0 */ |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
/* 16 */ |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
/* 32 */ |
"space", "exclam", "quotedbl", "numbersign", |
"dollar", "percent", "ampersand", "quoteright", |
"parenleft", "parenright", "asterisk", "plus", |
"comma", "hyphen", "period", "slash", |
/* 48 */ |
"zero", "one", "two", "three", |
"four", "five", "six", "seven", |
"eight", "nine", "colon", "semicolon", |
"less", "equal", "greater", "question", |
/* 64 */ |
"at", "A", "B", "C", |
"D", "E", "F", "G", |
"H", "I", "J", "K", |
"L", "M", "N", "O", |
/* 80 */ |
"P", "Q", "R", "S", |
"T", "U", "V", "W", |
"X", "Y", "Z", "bracketleft", |
"backslash", "bracketright", "asciicircum", "underscore", |
/* 96 */ |
"quoteleft", "a", "b", "c", |
"d", "e", "f", "g", |
"h", "i", "j", "k", |
"l", "m", "n", "o", |
/* 112 */ |
"p", "q", "r", "s", |
"t", "u", "v", "w", |
"x", "y", "z", "braceleft", |
"bar", "braceright", "asciitilde", NULL, |
/* 128 */ |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
/* 144 */ |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
/* 160 */ |
NULL, "exclamdown", "cent", "sterling", |
"fraction", "yen", "florin", "section", |
"currency", "quotesingle", "quotedblleft", "guillemotleft", |
"guilsinglleft","guilsinglright","fi", "fl", |
/* 176 */ |
NULL, "endash", "dagger", "daggerdbl", |
"periodcentered",NULL, "paragraph", "bullet", |
"quotesinglbase","quotedblbase","quotedblright","guillemotright", |
"ellipsis", "perthousand", NULL, "questiondown", |
/* 192 */ |
NULL, "grave", "acute", "circumflex", |
"tilde", "macron", "breve", "dotaccent", |
"dieresis", NULL, "ring", "cedilla", |
NULL, "hungarumlaut", "ogonek", "caron", |
/* 208 */ |
"emdash", NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
NULL, NULL, NULL, NULL, |
/* 224 */ |
NULL, "AE", NULL, "ordfeminine", |
NULL, NULL, NULL, NULL, |
"Lslash", "Oslash", "OE", "ordmasculine", |
NULL, NULL, NULL, NULL, |
/* 240 */ |
NULL, "ae", NULL, NULL, |
NULL, "dotlessi", NULL, NULL, |
"lslash", "oslash", "oe", "germandbls", |
NULL, NULL, NULL, NULL |
); |
print "static const char ps_standard_encoding_symbol[] = {\n"; |
$s = qq( "\\0"); |
for $sym (@encoding) { |
if (! ($sym eq NULL)) { |
$ss = qq( "$sym\\0"); |
if (length($s) + length($ss) > 78) { |
print qq( $s\n); |
$s = ""; |
} |
$s .= $ss; |
} |
} |
print qq( $s\n); |
print "};\n\n"; |
print "static const int16_t ps_standard_encoding_offset[256] = {\n"; |
$offset = 1; |
$s = qq(); |
for $sym (@encoding) { |
if (! ($sym eq NULL)) { |
$ss = qq( $offset/*$sym*/,); |
$offset += length($sym) + 1; |
} else { |
$ss = qq( 0,); |
} |
if (length($s) + length($ss) > 78) { |
print qq( $s\n); |
$s = ""; |
} |
$s .= $ss; |
} |
print qq( $s\n); |
print "};\n"; |
exit; |
#endif |
static const char ps_standard_encoding_symbol[] = { |
"\0" "space\0" "exclam\0" "quotedbl\0" "numbersign\0" "dollar\0" "percent\0" |
"ampersand\0" "quoteright\0" "parenleft\0" "parenright\0" "asterisk\0" |
"plus\0" "comma\0" "hyphen\0" "period\0" "slash\0" "zero\0" "one\0" "two\0" |
"three\0" "four\0" "five\0" "six\0" "seven\0" "eight\0" "nine\0" "colon\0" |
"semicolon\0" "less\0" "equal\0" "greater\0" "question\0" "at\0" "A\0" "B\0" |
"C\0" "D\0" "E\0" "F\0" "G\0" "H\0" "I\0" "J\0" "K\0" "L\0" "M\0" "N\0" "O\0" |
"P\0" "Q\0" "R\0" "S\0" "T\0" "U\0" "V\0" "W\0" "X\0" "Y\0" "Z\0" |
"bracketleft\0" "backslash\0" "bracketright\0" "asciicircum\0" "underscore\0" |
"quoteleft\0" "a\0" "b\0" "c\0" "d\0" "e\0" "f\0" "g\0" "h\0" "i\0" "j\0" |
"k\0" "l\0" "m\0" "n\0" "o\0" "p\0" "q\0" "r\0" "s\0" "t\0" "u\0" "v\0" "w\0" |
"x\0" "y\0" "z\0" "braceleft\0" "bar\0" "braceright\0" "asciitilde\0" |
"exclamdown\0" "cent\0" "sterling\0" "fraction\0" "yen\0" "florin\0" |
"section\0" "currency\0" "quotesingle\0" "quotedblleft\0" "guillemotleft\0" |
"guilsinglleft\0" "guilsinglright\0" "fi\0" "fl\0" "endash\0" "dagger\0" |
"daggerdbl\0" "periodcentered\0" "paragraph\0" "bullet\0" "quotesinglbase\0" |
"quotedblbase\0" "quotedblright\0" "guillemotright\0" "ellipsis\0" |
"perthousand\0" "questiondown\0" "grave\0" "acute\0" "circumflex\0" "tilde\0" |
"macron\0" "breve\0" "dotaccent\0" "dieresis\0" "ring\0" "cedilla\0" |
"hungarumlaut\0" "ogonek\0" "caron\0" "emdash\0" "AE\0" "ordfeminine\0" |
"Lslash\0" "Oslash\0" "OE\0" "ordmasculine\0" "ae\0" "dotlessi\0" "lslash\0" |
"oslash\0" "oe\0" "germandbls\0" |
}; |
static const int16_t ps_standard_encoding_offset[256] = { |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 1/*space*/, 7/*exclam*/, 14/*quotedbl*/, 23/*numbersign*/, |
34/*dollar*/, 41/*percent*/, 49/*ampersand*/, 59/*quoteright*/, |
70/*parenleft*/, 80/*parenright*/, 91/*asterisk*/, 100/*plus*/, 105/*comma*/, |
111/*hyphen*/, 118/*period*/, 125/*slash*/, 131/*zero*/, 136/*one*/, |
140/*two*/, 144/*three*/, 150/*four*/, 155/*five*/, 160/*six*/, 164/*seven*/, |
170/*eight*/, 176/*nine*/, 181/*colon*/, 187/*semicolon*/, 197/*less*/, |
202/*equal*/, 208/*greater*/, 216/*question*/, 225/*at*/, 228/*A*/, 230/*B*/, |
232/*C*/, 234/*D*/, 236/*E*/, 238/*F*/, 240/*G*/, 242/*H*/, 244/*I*/, |
246/*J*/, 248/*K*/, 250/*L*/, 252/*M*/, 254/*N*/, 256/*O*/, 258/*P*/, |
260/*Q*/, 262/*R*/, 264/*S*/, 266/*T*/, 268/*U*/, 270/*V*/, 272/*W*/, |
274/*X*/, 276/*Y*/, 278/*Z*/, 280/*bracketleft*/, 292/*backslash*/, |
302/*bracketright*/, 315/*asciicircum*/, 327/*underscore*/, 338/*quoteleft*/, |
348/*a*/, 350/*b*/, 352/*c*/, 354/*d*/, 356/*e*/, 358/*f*/, 360/*g*/, |
362/*h*/, 364/*i*/, 366/*j*/, 368/*k*/, 370/*l*/, 372/*m*/, 374/*n*/, |
376/*o*/, 378/*p*/, 380/*q*/, 382/*r*/, 384/*s*/, 386/*t*/, 388/*u*/, |
390/*v*/, 392/*w*/, 394/*x*/, 396/*y*/, 398/*z*/, 400/*braceleft*/, |
410/*bar*/, 414/*braceright*/, 425/*asciitilde*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
436/*exclamdown*/, 447/*cent*/, 452/*sterling*/, 461/*fraction*/, 470/*yen*/, |
474/*florin*/, 481/*section*/, 489/*currency*/, 498/*quotesingle*/, |
510/*quotedblleft*/, 523/*guillemotleft*/, 537/*guilsinglleft*/, |
551/*guilsinglright*/, 566/*fi*/, 569/*fl*/, 0, 572/*endash*/, 579/*dagger*/, |
586/*daggerdbl*/, 596/*periodcentered*/, 0, 611/*paragraph*/, 621/*bullet*/, |
628/*quotesinglbase*/, 643/*quotedblbase*/, 656/*quotedblright*/, |
670/*guillemotright*/, 685/*ellipsis*/, 694/*perthousand*/, 0, |
706/*questiondown*/, 0, 719/*grave*/, 725/*acute*/, 731/*circumflex*/, |
742/*tilde*/, 748/*macron*/, 755/*breve*/, 761/*dotaccent*/, 771/*dieresis*/, |
0, 780/*ring*/, 785/*cedilla*/, 0, 793/*hungarumlaut*/, 806/*ogonek*/, |
813/*caron*/, 819/*emdash*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
826/*AE*/, 0, 829/*ordfeminine*/, 0, 0, 0, 0, 841/*Lslash*/, 848/*Oslash*/, |
855/*OE*/, 858/*ordmasculine*/, 0, 0, 0, 0, 0, 871/*ae*/, 0, 0, 0, |
874/*dotlessi*/, 0, 0, 883/*lslash*/, 890/*oslash*/, 897/*oe*/, |
900/*germandbls*/, 0, 0, 0, 0, |
}; |
#define ps_standard_encoding(index) ((index) ? ps_standard_encoding_symbol+ps_standard_encoding_offset[(index)] : NULL) |
static cairo_status_t |
use_standard_encoding_glyph (cairo_type1_font_subset_t *font, int index) |
{ |
const char *glyph_name; |
if (index < 0 || index > 255) |
return CAIRO_STATUS_SUCCESS; |
glyph_name = ps_standard_encoding(index); |
if (glyph_name == NULL) |
return CAIRO_STATUS_SUCCESS; |
index = cairo_type1_font_subset_lookup_glyph (font, |
glyph_name, |
strlen(glyph_name)); |
if (index < 0) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
cairo_type1_font_subset_use_glyph (font, index); |
return CAIRO_STATUS_SUCCESS; |
} |
#define TYPE1_CHARSTRING_COMMAND_ESCAPE (12) |
#define TYPE1_CHARSTRING_COMMAND_SEAC (32 + 6) |
static cairo_status_t |
cairo_type1_font_subset_look_for_seac(cairo_type1_font_subset_t *font, |
const char *name, int name_length, |
const char *encrypted_charstring, int encrypted_charstring_length) |
{ |
cairo_status_t status; |
unsigned char *charstring; |
const unsigned char *end; |
const unsigned char *p; |
int stack[5], sp, value; |
int command; |
charstring = malloc (encrypted_charstring_length); |
if (unlikely (charstring == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
cairo_type1_font_subset_decrypt_charstring ((const unsigned char *) |
encrypted_charstring, |
encrypted_charstring_length, |
charstring); |
end = charstring + encrypted_charstring_length; |
p = charstring + 4; |
sp = 0; |
while (p < end) { |
if (*p < 32) { |
command = *p++; |
if (command == TYPE1_CHARSTRING_COMMAND_ESCAPE) |
command = 32 + *p++; |
switch (command) { |
case TYPE1_CHARSTRING_COMMAND_SEAC: |
/* The seac command takes five integer arguments. The |
* last two are glyph indices into the PS standard |
* encoding give the names of the glyphs that this |
* glyph is composed from. All we need to do is to |
* make sure those glyphs are present in the subset |
* under their standard names. */ |
status = use_standard_encoding_glyph (font, stack[3]); |
if (unlikely (status)) |
return status; |
status = use_standard_encoding_glyph (font, stack[4]); |
if (unlikely (status)) |
return status; |
sp = 0; |
break; |
default: |
sp = 0; |
break; |
} |
} else { |
/* integer argument */ |
p = cairo_type1_font_subset_decode_integer (p, &value); |
if (sp < 5) |
stack[sp++] = value; |
} |
} |
free (charstring); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
write_used_glyphs (cairo_type1_font_subset_t *font, |
const char *name, int name_length, |
const char *charstring, int charstring_length) |
{ |
cairo_status_t status; |
char buffer[256]; |
int length; |
length = snprintf (buffer, sizeof buffer, |
"/%.*s %d %s ", |
name_length, name, charstring_length, font->rd); |
status = cairo_type1_font_subset_write_encrypted (font, buffer, length); |
if (unlikely (status)) |
return status; |
status = cairo_type1_font_subset_write_encrypted (font, |
charstring, |
charstring_length); |
if (unlikely (status)) |
return status; |
length = snprintf (buffer, sizeof buffer, "%s\n", font->nd); |
status = cairo_type1_font_subset_write_encrypted (font, buffer, length); |
if (unlikely (status)) |
return status; |
return CAIRO_STATUS_SUCCESS; |
} |
typedef cairo_status_t (*glyph_func_t) (cairo_type1_font_subset_t *font, |
const char *name, int name_length, |
const char *charstring, int charstring_length); |
static cairo_status_t |
cairo_type1_font_subset_for_each_glyph (cairo_type1_font_subset_t *font, |
const char *dict_start, |
const char *dict_end, |
glyph_func_t func, |
const char **dict_out) |
{ |
int charstring_length, name_length, glyph_index; |
const char *p, *charstring, *name; |
char *end; |
/* We're looking at '/' in the name of the first glyph. The glyph |
* definitions are on the form: |
* |
* /name 23 RD <23 binary bytes> ND |
* |
* or alternatively using -| and |- instead of RD and ND. |
* |
* We parse the glyph name and see if it is in the subset. If it |
* is, we call the specified callback with the glyph name and |
* glyph data, otherwise we just skip it. We need to parse |
* through a glyph definition; we can't just find the next '/', |
* since the binary data could contain a '/'. |
*/ |
p = dict_start; |
while (*p == '/') { |
name = p + 1; |
p = skip_token (p, dict_end); |
name_length = p - name; |
charstring_length = strtol (p, &end, 10); |
if (p == end) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
/* Skip past -| or RD to binary data. There is exactly one space |
* between the -| or RD token and the encrypted data, thus '+ 1'. */ |
charstring = skip_token (end, dict_end) + 1; |
/* Skip binary data and |- or ND token. */ |
p = skip_token (charstring + charstring_length, dict_end); |
while (p < dict_end && _cairo_isspace(*p)) |
p++; |
/* In case any of the skip_token() calls above reached EOF, p will |
* be equal to dict_end. */ |
if (p == dict_end) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
glyph_index = cairo_type1_font_subset_lookup_glyph (font, |
name, name_length); |
if (font->glyphs[glyph_index].subset_index >= 0) { |
cairo_status_t status = func (font, |
name, name_length, |
charstring, charstring_length); |
if (unlikely (status)) |
return status; |
} |
} |
*dict_out = p; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_type1_font_subset_write_private_dict (cairo_type1_font_subset_t *font, |
const char *name) |
{ |
cairo_status_t status; |
const char *p, *charstrings, *dict_start; |
const char *closefile_token; |
char buffer[32], *glyph_count_end; |
int num_charstrings, length; |
/* The private dict holds hint information, common subroutines and |
* the actual glyph definitions (charstrings). |
* |
* FIXME: update this comment. |
* |
* What we do here is scan directly the /CharString token, which |
* marks the beginning of the glyph definitions. Then we parse |
* through the glyph definitions and weed out the glyphs not in |
* our subset. Everything else before and after the glyph |
* definitions is copied verbatim to the output. It might be |
* worthwile to figure out which of the common subroutines are |
* used by the glyphs in the subset and get rid of the rest. */ |
/* FIXME: The /Subrs array contains binary data and could |
* conceivably have "/CharStrings" in it, so we might need to skip |
* this more cleverly. */ |
charstrings = find_token (font->cleartext, font->cleartext_end, "/CharStrings"); |
if (charstrings == NULL) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
/* Scan past /CharStrings and the integer following it. */ |
p = charstrings + strlen ("/CharStrings"); |
num_charstrings = strtol (p, &glyph_count_end, 10); |
if (p == glyph_count_end) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
/* Look for a '/' which marks the beginning of the first glyph |
* definition. */ |
for (p = glyph_count_end; p < font->cleartext_end; p++) |
if (*p == '/') |
break; |
if (p == font->cleartext_end) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
dict_start = p; |
status = cairo_type1_font_subset_get_glyph_names_and_widths (font); |
if (unlikely (status)) |
return status; |
/* Now that we have the private dictionary broken down in |
* sections, do the first pass through the glyph definitions to |
* figure out which subrs and othersubrs are use and which extra |
* glyphs may be required by the seac operator. */ |
status = cairo_type1_font_subset_for_each_glyph (font, |
dict_start, |
font->cleartext_end, |
cairo_type1_font_subset_look_for_seac, |
&p); |
if (unlikely (status)) |
return status; |
closefile_token = find_token (p, font->cleartext_end, "closefile"); |
if (closefile_token == NULL) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
status = cairo_type1_font_subset_get_glyph_names_and_widths (font); |
if (unlikely (status)) |
return status; |
/* We're ready to start outputting. First write the header, |
* i.e. the public part of the font dict.*/ |
status = cairo_type1_font_subset_write_header (font, name); |
if (unlikely (status)) |
return status; |
font->base.header_size = _cairo_output_stream_get_position (font->output); |
/* Start outputting the private dict. First output everything up |
* to the /CharStrings token. */ |
status = cairo_type1_font_subset_write_encrypted (font, font->cleartext, |
charstrings - font->cleartext); |
if (unlikely (status)) |
return status; |
/* Write out new charstring count */ |
length = snprintf (buffer, sizeof buffer, |
"/CharStrings %d", font->num_glyphs); |
status = cairo_type1_font_subset_write_encrypted (font, buffer, length); |
if (unlikely (status)) |
return status; |
/* Write out text between the charstring count and the first |
* charstring definition */ |
status = cairo_type1_font_subset_write_encrypted (font, glyph_count_end, |
dict_start - glyph_count_end); |
if (unlikely (status)) |
return status; |
/* Write out the charstring definitions for each of the glyphs in |
* the subset. */ |
status = cairo_type1_font_subset_for_each_glyph (font, |
dict_start, |
font->cleartext_end, |
write_used_glyphs, |
&p); |
if (unlikely (status)) |
return status; |
/* Output what's left between the end of the glyph definitions and |
* the end of the private dict to the output. */ |
status = cairo_type1_font_subset_write_encrypted (font, p, |
closefile_token - p + strlen ("closefile") + 1); |
if (unlikely (status)) |
return status; |
if (font->hex_encode) |
_cairo_output_stream_write (font->output, "\n", 1); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_type1_font_subset_write_trailer(cairo_type1_font_subset_t *font) |
{ |
const char *cleartomark_token; |
int i; |
static const char zeros[65] = |
"0000000000000000000000000000000000000000000000000000000000000000\n"; |
for (i = 0; i < 8; i++) |
_cairo_output_stream_write (font->output, zeros, sizeof zeros); |
cleartomark_token = find_token (font->type1_data, font->type1_end, "cleartomark"); |
if (cleartomark_token) { |
/* Some fonts have conditional save/restore around the entire |
* font dict, so we need to retain whatever postscript code |
* that may come after 'cleartomark'. */ |
_cairo_output_stream_write (font->output, cleartomark_token, |
font->type1_end - cleartomark_token); |
} else if (!font->eexec_segment_is_ascii) { |
/* Fonts embedded in PDF may omit the fixed-content portion |
* that includes the 'cleartomark' operator. Type 1 in PDF is |
* always binary. */ |
_cairo_output_stream_printf (font->output, "cleartomark"); |
} else { |
return CAIRO_INT_STATUS_UNSUPPORTED; |
} |
/* some fonts do not have a newline at the end of the last line */ |
_cairo_output_stream_printf (font->output, "\n"); |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
type1_font_write (void *closure, const unsigned char *data, unsigned int length) |
{ |
cairo_type1_font_subset_t *font = closure; |
return _cairo_array_append_multiple (&font->contents, data, length); |
} |
static cairo_status_t |
cairo_type1_font_subset_write (cairo_type1_font_subset_t *font, |
const char *name) |
{ |
cairo_status_t status; |
status = cairo_type1_font_subset_find_segments (font); |
if (unlikely (status)) |
return status; |
status = cairo_type1_font_subset_decrypt_eexec_segment (font); |
if (unlikely (status)) |
return status; |
/* Determine which glyph definition delimiters to use. */ |
if (find_token (font->cleartext, font->cleartext_end, "/-|") != NULL) { |
font->rd = "-|"; |
font->nd = "|-"; |
} else if (find_token (font->cleartext, font->cleartext_end, "/RD") != NULL) { |
font->rd = "RD"; |
font->nd = "ND"; |
} else { |
/* Don't know *what* kind of font this is... */ |
return CAIRO_INT_STATUS_UNSUPPORTED; |
} |
font->eexec_key = CAIRO_TYPE1_PRIVATE_DICT_KEY; |
font->hex_column = 0; |
status = cairo_type1_font_subset_write_private_dict (font, name); |
if (unlikely (status)) |
return status; |
font->base.data_size = _cairo_output_stream_get_position (font->output) - |
font->base.header_size; |
status = cairo_type1_font_subset_write_trailer (font); |
if (unlikely (status)) |
return status; |
font->base.trailer_size = |
_cairo_output_stream_get_position (font->output) - |
font->base.header_size - font->base.data_size; |
return CAIRO_STATUS_SUCCESS; |
} |
static cairo_status_t |
cairo_type1_font_subset_generate (void *abstract_font, |
const char *name) |
{ |
cairo_type1_font_subset_t *font = abstract_font; |
cairo_ft_unscaled_font_t *ft_unscaled_font; |
unsigned long ret; |
cairo_status_t status; |
ft_unscaled_font = (cairo_ft_unscaled_font_t *) font->base.unscaled_font; |
font->face = _cairo_ft_unscaled_font_lock_face (ft_unscaled_font); |
if (unlikely (font->face == NULL)) |
return _cairo_error (CAIRO_STATUS_NO_MEMORY); |
font->type1_length = font->face->stream->size; |
font->type1_data = malloc (font->type1_length); |
if (unlikely (font->type1_data == NULL)) { |
status = _cairo_error (CAIRO_STATUS_NO_MEMORY); |
goto fail; |
} |
if (font->face->stream->read != NULL) { |
/* Note that read() may be implemented as a macro, thanks POSIX!, so we |
* need to wrap the following usage in parentheses in order to |
* disambiguate it for the pre-processor - using the verbose function |
* pointer dereference for clarity. |
*/ |
ret = (* font->face->stream->read) (font->face->stream, 0, |
(unsigned char *) font->type1_data, |
font->type1_length); |
if (ret != font->type1_length) { |
status = _cairo_error (CAIRO_STATUS_READ_ERROR); |
goto fail; |
} |
} else { |
memcpy (font->type1_data, |
font->face->stream->base, font->type1_length); |
} |
status = _cairo_array_grow_by (&font->contents, 4096); |
if (unlikely (status)) |
goto fail; |
font->output = _cairo_output_stream_create (type1_font_write, NULL, font); |
if (unlikely ((status = font->output->status))) |
goto fail; |
status = cairo_type1_font_subset_write (font, name); |
if (unlikely (status)) |
goto fail; |
font->base.data = _cairo_array_index (&font->contents, 0); |
fail: |
_cairo_ft_unscaled_font_unlock_face (ft_unscaled_font); |
return status; |
} |
static cairo_status_t |
_cairo_type1_font_subset_fini (cairo_type1_font_subset_t *font) |
{ |
cairo_status_t status = CAIRO_STATUS_SUCCESS; |
unsigned int i; |
/* If the subset generation failed, some of the pointers below may |
* be NULL depending on at which point the error occurred. */ |
_cairo_array_fini (&font->contents); |
free (font->type1_data); |
if (font->glyphs != NULL) { |
for (i = 0; i < font->base.num_glyphs; i++) |
free (font->glyphs[i].name); |
} |
_cairo_unscaled_font_destroy (font->base.unscaled_font); |
if (font->output != NULL) |
status = _cairo_output_stream_destroy (font->output); |
if (font->base.base_font) |
free (font->base.base_font); |
free (font->glyphs); |
return status; |
} |
cairo_status_t |
_cairo_type1_subset_init (cairo_type1_subset_t *type1_subset, |
const char *name, |
cairo_scaled_font_subset_t *scaled_font_subset, |
cairo_bool_t hex_encode) |
{ |
cairo_type1_font_subset_t font; |
cairo_status_t status, status_ignored; |
unsigned long parent_glyph, length; |
unsigned int i; |
cairo_unscaled_font_t *unscaled_font; |
char buf[30]; |
/* XXX: Need to fix this to work with a general cairo_unscaled_font_t. */ |
if (!_cairo_scaled_font_is_ft (scaled_font_subset->scaled_font)) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
if (_cairo_ft_scaled_font_is_vertical (scaled_font_subset->scaled_font)) |
return CAIRO_INT_STATUS_UNSUPPORTED; |
unscaled_font = _cairo_ft_scaled_font_get_unscaled_font (scaled_font_subset->scaled_font); |
status = _cairo_type1_font_subset_init (&font, unscaled_font, hex_encode); |
if (unlikely (status)) |
return status; |
for (i = 0; i < scaled_font_subset->num_glyphs; i++) { |
parent_glyph = scaled_font_subset->glyphs[i]; |
cairo_type1_font_subset_use_glyph (&font, parent_glyph); |
} |
status = cairo_type1_font_subset_generate (&font, name); |
if (unlikely (status)) |
goto fail1; |
if (font.base.base_font) { |
type1_subset->base_font = strdup (font.base.base_font); |
} else { |
snprintf(buf, sizeof (buf), "CairoFont-%u-%u", |
scaled_font_subset->font_id, scaled_font_subset->subset_id); |
type1_subset->base_font = strdup (buf); |
} |
if (unlikely (type1_subset->base_font == NULL)) |
goto fail1; |
type1_subset->widths = calloc (sizeof (double), font.num_glyphs); |
if (unlikely (type1_subset->widths == NULL)) |
goto fail2; |
for (i = 0; i < font.base.num_glyphs; i++) { |
if (font.glyphs[i].subset_index < 0) |
continue; |
type1_subset->widths[font.glyphs[i].subset_index] = |
font.glyphs[i].width; |
} |
type1_subset->x_min = font.base.x_min; |
type1_subset->y_min = font.base.y_min; |
type1_subset->x_max = font.base.x_max; |
type1_subset->y_max = font.base.y_max; |
type1_subset->ascent = font.base.ascent; |
type1_subset->descent = font.base.descent; |
length = font.base.header_size + |
font.base.data_size + |
font.base.trailer_size; |
type1_subset->data = malloc (length); |
if (unlikely (type1_subset->data == NULL)) |
goto fail3; |
memcpy (type1_subset->data, |
_cairo_array_index (&font.contents, 0), length); |
type1_subset->header_length = font.base.header_size; |
type1_subset->data_length = font.base.data_size; |
type1_subset->trailer_length = font.base.trailer_size; |
return _cairo_type1_font_subset_fini (&font); |
fail3: |
free (type1_subset->widths); |
fail2: |
free (type1_subset->base_font); |
fail1: |
status_ignored = _cairo_type1_font_subset_fini (&font); |
return status; |
} |
void |
_cairo_type1_subset_fini (cairo_type1_subset_t *subset) |
{ |
free (subset->base_font); |
free (subset->widths); |
free (subset->data); |
} |
cairo_bool_t |
_cairo_type1_scaled_font_is_type1 (cairo_scaled_font_t *scaled_font) |
{ |
cairo_ft_unscaled_font_t *unscaled; |
FT_Face face; |
PS_FontInfoRec font_info; |
cairo_bool_t is_type1 = FALSE; |
if (!_cairo_scaled_font_is_ft (scaled_font)) |
return FALSE; |
unscaled = (cairo_ft_unscaled_font_t *) _cairo_ft_scaled_font_get_unscaled_font (scaled_font); |
face = _cairo_ft_unscaled_font_lock_face (unscaled); |
if (!face) |
return FALSE; |
if (FT_Get_PS_Font_Info(face, &font_info) == 0) |
is_type1 = TRUE; |
/* OpenType/CFF fonts also have a PS_FontInfoRec */ |
#if HAVE_FT_LOAD_SFNT_TABLE |
if (FT_IS_SFNT (face)) |
is_type1 = FALSE; |
#endif |
_cairo_ft_unscaled_font_unlock_face (unscaled); |
return is_type1; |
} |
#endif /* CAIRO_HAS_FT_FONT */ |
#endif /* CAIRO_HAS_FONT_SUBSET */ |
/programs/develop/libraries/cairo/src/cairo-type3-glyph-surface.c |
---|
0,0 → 1,563 |
/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */ |
/* cairo - a vector graphics library with display and print output |
* |
* Copyright © 2008 Adrian Johnson |
* |
* This library is free software; you can redistribute it and/or |
* modify it either under the terms of the GNU Lesser General Public |
* License version 2.1 as published by the Free Software Foundation |
* (the "LGPL") or, at your option, under the terms of the Mozilla |
* Public License Version 1.1 (the "MPL"). If you do not alter this |
* notice, a recipient may use your version of this file under either |
* the MPL or the LGPL. |
* |
* You should have received a copy of the LGPL along with this library |
* in the file COPYING-LGPL-2.1; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA |
* You should have received a copy of the MPL along with this library |
* in the file COPYING-MPL-1.1 |
* |
* The contents of this file are subject to the Mozilla Public License |
* Version 1.1 (the "License"); you may not use this file except in |
* compliance with the License. You may obtain a copy of the License at |
* http://www.mozilla.org/MPL/ |
* |
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY |
* OF ANY KIND, either express or implied. See the LGPL or the MPL for |
* the specific language governing rights and limitations. |
* |
* The Original Code is the cairo graphics library. |
* |
* The Initial Developer of the Original Code is Adrian Johnson. |
* |
* Contributor(s): |
* Adrian Johnson <ajohnson@redneon.com> |
*/ |
#include "cairoint.h" |
#if CAIRO_HAS_FONT_SUBSET |
#include "cairo-type3-glyph-surface-private.h" |
#include "cairo-output-stream-private.h" |
#include "cairo-recording-surface-private.h" |
#include "cairo-analysis-surface-private.h" |
#include "cairo-error-private.h" |
#include "cairo-surface-clipper-private.h" |
static const cairo_surface_backend_t cairo_type3_glyph_surface_backend; |
static cairo_status_t |
_cairo_type3_glyph_surface_clipper_intersect_clip_path (cairo_surface_clipper_t *clipper, |
cairo_path_fixed_t *path, |
cairo_fill_rule_t fill_rule, |
double tolerance, |
cairo_antialias_t antialias) |
{ |
cairo_type3_glyph_surface_t *surface = cairo_container_of (clipper, |
cairo_type3_glyph_surface_t, |
clipper); |
if (path == NULL) { |
_cairo_output_stream_printf (surface->stream, "Q q\n"); |
return CAIRO_STATUS_SUCCESS; |
} |
return _cairo_pdf_operators_clip (&surface->pdf_operators, |
path, |
fill_rule); |
} |
cairo_surface_t * |
_cairo_type3_glyph_surface_create (cairo_scaled_font_t *scaled_font, |
cairo_output_stream_t *stream, |
cairo_type3_glyph_surface_emit_image_t emit_image, |
cairo_scaled_font_subsets_t *font_subsets) |
{ |
cairo_type3_glyph_surface_t *surface; |
cairo_matrix_t invert_y_axis; |
if (unlikely (stream != NULL && stream->status)) |
return _cairo_surface_create_in_error (stream->status); |
surface = malloc (sizeof (cairo_type3_glyph_surface_t)); |
if (unlikely (surface == NULL)) |
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); |
_cairo_surface_init (&surface->base, |
&cairo_type3_glyph_surface_backend, |
NULL, /* device */ |
CAIRO_CONTENT_COLOR_ALPHA); |
surface->scaled_font = scaled_font; |
surface->stream = stream; |
surface->emit_image = emit_image; |
/* Setup the transform from the user-font device space to Type 3 |
* font space. The Type 3 font space is defined by the FontMatrix |
* entry in the Type 3 dictionary. In the PDF backend this is an |
* identity matrix. */ |
surface->cairo_to_pdf = scaled_font->scale_inverse; |
cairo_matrix_init_scale (&invert_y_axis, 1, -1); |
cairo_matrix_multiply (&surface->cairo_to_pdf, &surface->cairo_to_pdf, &invert_y_axis); |
_cairo_pdf_operators_init (&surface->pdf_operators, |
surface->stream, |
&surface->cairo_to_pdf, |
font_subsets); |
_cairo_surface_clipper_init (&surface->clipper, |
_cairo_type3_glyph_surface_clipper_intersect_clip_path); |
return &surface->base; |
} |
static cairo_status_t |
_cairo_type3_glyph_surface_emit_image (cairo_type3_glyph_surface_t *surface, |
cairo_image_surface_t *image, |
cairo_matrix_t *image_matrix) |
{ |
cairo_status_t status; |
/* The only image type supported by Type 3 fonts are 1-bit masks */ |
image = _cairo_image_surface_coerce_to_format (image, CAIRO_FORMAT_A1); |
status = image->base.status; |
if (unlikely (status)) |
return status; |
_cairo_output_stream_printf (surface->stream, |
"q %f %f %f %f %f %f cm\n", |
image_matrix->xx, |
image_matrix->xy, |
image_matrix->yx, |
image_matrix->yy, |
image_matrix->x0, |
image_matrix->y0); |
status = surface->emit_image (image, surface->stream); |
cairo_surface_destroy (&image->base); |
_cairo_output_stream_printf (surface->stream, |
"Q\n"); |
return status; |
} |
static cairo_status_t |
_cairo_type3_glyph_surface_emit_image_pattern (cairo_type3_glyph_surface_t *surface, |
cairo_image_surface_t *image, |
const cairo_matrix_t *pattern_matrix) |
{ |
cairo_matrix_t mat, upside_down; |
cairo_status_t status; |
if (image->width == 0 || image->height == 0) |
return CAIRO_STATUS_SUCCESS; |
mat = *pattern_matrix; |
/* Get the pattern space to user space matrix */ |
status = cairo_matrix_invert (&mat); |
/* cairo_pattern_set_matrix ensures the matrix is invertible */ |
assert (status == CAIRO_STATUS_SUCCESS); |
/* Make this a pattern space to Type 3 font space matrix */ |
cairo_matrix_multiply (&mat, &mat, &surface->cairo_to_pdf); |
/* PDF images are in a 1 unit by 1 unit image space. Turn the 1 by |
* 1 image upside down to convert to flip the Y-axis going from |
* cairo to PDF. Then scale the image up to the required size. */ |
cairo_matrix_scale (&mat, image->width, image->height); |
cairo_matrix_init (&upside_down, 1, 0, 0, -1, 0, 1); |
cairo_matrix_multiply (&mat, &upside_down, &mat); |
return _cairo_type3_glyph_surface_emit_image (surface, image, &mat); |
} |
static cairo_status_t |
_cairo_type3_glyph_surface_finish (void *abstract_surface) |
{ |
cairo_type3_glyph_surface_t *surface = abstract_surface; |
return _cairo_pdf_operators_fini (&surface->pdf_operators); |
} |
static cairo_int_status_t |
_cairo_type3_glyph_surface_paint (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
cairo_clip_t *clip) |
{ |
cairo_type3_glyph_surface_t *surface = abstract_surface; |
const cairo_surface_pattern_t *pattern; |
cairo_image_surface_t *image; |
void *image_extra; |
cairo_status_t status; |
if (source->type != CAIRO_PATTERN_TYPE_SURFACE) |
return CAIRO_INT_STATUS_IMAGE_FALLBACK; |
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip); |
if (unlikely (status)) |
return status; |
pattern = (const cairo_surface_pattern_t *) source; |
status = _cairo_surface_acquire_source_image (pattern->surface, |
&image, &image_extra); |
if (unlikely (status)) |
goto fail; |
status = _cairo_type3_glyph_surface_emit_image_pattern (surface, |
image, |
&pattern->base.matrix); |
fail: |
_cairo_surface_release_source_image (pattern->surface, image, image_extra); |
return status; |
} |
static cairo_int_status_t |
_cairo_type3_glyph_surface_mask (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
const cairo_pattern_t *mask, |
cairo_clip_t *clip) |
{ |
return _cairo_type3_glyph_surface_paint (abstract_surface, |
op, mask, |
clip); |
} |
static cairo_int_status_t |
_cairo_type3_glyph_surface_stroke (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
cairo_path_fixed_t *path, |
const cairo_stroke_style_t *style, |
const cairo_matrix_t *ctm, |
const cairo_matrix_t *ctm_inverse, |
double tolerance, |
cairo_antialias_t antialias, |
cairo_clip_t *clip) |
{ |
cairo_type3_glyph_surface_t *surface = abstract_surface; |
cairo_int_status_t status; |
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip); |
if (unlikely (status)) |
return status; |
return _cairo_pdf_operators_stroke (&surface->pdf_operators, |
path, |
style, |
ctm, |
ctm_inverse); |
} |
static cairo_int_status_t |
_cairo_type3_glyph_surface_fill (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
cairo_path_fixed_t *path, |
cairo_fill_rule_t fill_rule, |
double tolerance, |
cairo_antialias_t antialias, |
cairo_clip_t *clip) |
{ |
cairo_type3_glyph_surface_t *surface = abstract_surface; |
cairo_int_status_t status; |
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip); |
if (unlikely (status)) |
return status; |
return _cairo_pdf_operators_fill (&surface->pdf_operators, |
path, |
fill_rule); |
} |
static cairo_int_status_t |
_cairo_type3_glyph_surface_show_glyphs (void *abstract_surface, |
cairo_operator_t op, |
const cairo_pattern_t *source, |
cairo_glyph_t *glyphs, |
int num_glyphs, |
cairo_scaled_font_t *scaled_font, |
cairo_clip_t *clip, |
int *remaining_glyphs) |
{ |
cairo_type3_glyph_surface_t *surface = abstract_surface; |
cairo_int_status_t status; |
cairo_scaled_font_t *font; |
cairo_matrix_t new_ctm, invert_y_axis; |
status = _cairo_surface_clipper_set_clip (&surface->clipper, clip); |
if (unlikely (status)) |
return status; |
cairo_matrix_init_scale (&invert_y_axis, 1, -1); |
cairo_matrix_multiply (&new_ctm, &invert_y_axis, &scaled_font->ctm); |
cairo_matrix_multiply (&new_ctm, &surface->cairo_to_pdf, &new_ctm); |
font = cairo_scaled_font_create (scaled_font->font_face, |
&scaled_font->font_matrix, |
&new_ctm, |
&scaled_font->options); |
if (unlikely (font->status)) |
return font->status; |
status = _cairo_pdf_operators_show_text_glyphs (&surface->pdf_operators, |
NULL, 0, |
glyphs, num_glyphs, |
NULL, 0, |
FALSE, |
font); |
cairo_scaled_font_destroy (font); |
return status; |
} |
static const cairo_surface_backend_t cairo_type3_glyph_surface_backend = { |
CAIRO_INTERNAL_SURFACE_TYPE_TYPE3_GLYPH, |
NULL, /* _cairo_type3_glyph_surface_create_similar */ |
_cairo_type3_glyph_surface_finish, |
NULL, /* acquire_source_image */ |
NULL, /* release_source_image */ |
NULL, /* acquire_dest_image */ |
NULL, /* release_dest_image */ |
NULL, /* clone_similar */ |
NULL, /* composite */ |
NULL, /* fill_rectangles */ |
NULL, /* composite_trapezoids */ |
NULL, /* create_span_renderer */ |
NULL, /* check_span_renderer */ |
NULL, /* cairo_type3_glyph_surface_copy_page */ |
NULL, /* _cairo_type3_glyph_surface_show_page */ |
NULL, /* _cairo_type3_glyph_surface_get_extents */ |
NULL, /* old_show_glyphs */ |
NULL, /* _cairo_type3_glyph_surface_get_font_options */ |
NULL, /* flush */ |
NULL, /* mark_dirty_rectangle */ |
NULL, /* scaled_font_fini */ |
NULL, /* scaled_glyph_fini */ |
_cairo_type3_glyph_surface_paint, |
_cairo_type3_glyph_surface_mask, |
_cairo_type3_glyph_surface_stroke, |
_cairo_type3_glyph_surface_fill, |
_cairo_type3_glyph_surface_show_glyphs, |
NULL, /* snapshot */ |
}; |
static void |
_cairo_type3_glyph_surface_set_stream (cairo_type3_glyph_surface_t *surface, |
cairo_output_stream_t *stream) |
{ |
surface->stream = stream; |
_cairo_pdf_operators_set_stream (&surface->pdf_operators, stream); |
} |
static cairo_status_t |
_cairo_type3_glyph_surface_emit_fallback_image (cairo_type3_glyph_surface_t *surface, |
unsigned long glyph_index) |
{ |
cairo_scaled_glyph_t *scaled_glyph; |
cairo_status_t status; |
cairo_image_surface_t *image; |
cairo_matrix_t mat; |
double x, y; |
status = _cairo_scaled_glyph_lookup (surface->scaled_font, |
glyph_index, |
CAIRO_SCALED_GLYPH_INFO_METRICS | |
CAIRO_SCALED_GLYPH_INFO_SURFACE, |
&scaled_glyph); |
if (unlikely (status)) |
return status; |
image = scaled_glyph->surface; |
if (image->width == 0 || image->height == 0) |
return CAIRO_STATUS_SUCCESS; |
x = _cairo_fixed_to_double (scaled_glyph->bbox.p1.x); |
y = _cairo_fixed_to_double (scaled_glyph->bbox.p2.y); |
mat.xx = image->width; |
mat.xy = 0; |
mat.yx = 0; |
mat.yy = image->height; |
mat.x0 = x; |
mat.y0 = y; |
cairo_matrix_multiply (&mat, &mat, &surface->scaled_font->scale_inverse); |
mat.y0 *= -1; |
return _cairo_type3_glyph_surface_emit_image (surface, image, &mat); |
} |
void |
_cairo_type3_glyph_surface_set_font_subsets_callback (void *abstract_surface, |
cairo_pdf_operators_use_font_subset_t use_font_subset, |
void *closure) |
{ |
cairo_type3_glyph_surface_t *surface = abstract_surface; |
if (unlikely (surface->base.status)) |
return; |
_cairo_pdf_operators_set_font_subsets_callback (&surface->pdf_operators, |
use_font_subset, |
closure); |
} |
cairo_status_t |
_cairo_type3_glyph_surface_analyze_glyph (void *abstract_surface, |
unsigned long glyph_index) |
{ |
cairo_type3_glyph_surface_t *surface = abstract_surface; |
cairo_scaled_glyph_t *scaled_glyph; |
cairo_status_t status, status2; |
cairo_output_stream_t *null_stream; |
if (unlikely (surface->base.status)) |
return surface->base.status; |
null_stream = _cairo_null_stream_create (); |
if (unlikely (null_stream->status)) |
return null_stream->status; |
_cairo_type3_glyph_surface_set_stream (surface, null_stream); |
_cairo_scaled_font_freeze_cache (surface->scaled_font); |
status = _cairo_scaled_glyph_lookup (surface->scaled_font, |
glyph_index, |
CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE, |
&scaled_glyph); |
if (_cairo_status_is_error (status)) |
goto cleanup; |
if (status == CAIRO_INT_STATUS_UNSUPPORTED) { |
status = CAIRO_STATUS_SUCCESS; |
goto cleanup; |
} |
status = _cairo_recording_surface_replay (scaled_glyph->recording_surface, |
&surface->base); |
if (unlikely (status)) |
goto cleanup; |
status = _cairo_pdf_operators_flush (&surface->pdf_operators); |
if (status == CAIRO_INT_STATUS_IMAGE_FALLBACK) |
status = CAIRO_STATUS_SUCCESS; |
cleanup: |
_cairo_scaled_font_thaw_cache (surface->scaled_font); |
status2 = _cairo_output_stream_destroy (null_stream); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
return status; |
} |
cairo_status_t |
_cairo_type3_glyph_surface_emit_glyph (void *abstract_surface, |
cairo_output_stream_t *stream, |
unsigned long glyph_index, |
cairo_box_t *bbox, |
double *width) |
{ |
cairo_type3_glyph_surface_t *surface = abstract_surface; |
cairo_scaled_glyph_t *scaled_glyph; |
cairo_status_t status, status2; |
double x_advance, y_advance; |
cairo_matrix_t font_matrix_inverse; |
if (unlikely (surface->base.status)) |
return surface->base.status; |
_cairo_type3_glyph_surface_set_stream (surface, stream); |
_cairo_scaled_font_freeze_cache (surface->scaled_font); |
status = _cairo_scaled_glyph_lookup (surface->scaled_font, |
glyph_index, |
CAIRO_SCALED_GLYPH_INFO_METRICS | |
CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE, |
&scaled_glyph); |
if (status == CAIRO_INT_STATUS_UNSUPPORTED) { |
status = _cairo_scaled_glyph_lookup (surface->scaled_font, |
glyph_index, |
CAIRO_SCALED_GLYPH_INFO_METRICS, |
&scaled_glyph); |
if (status == CAIRO_STATUS_SUCCESS) |
status = CAIRO_INT_STATUS_IMAGE_FALLBACK; |
} |
if (_cairo_status_is_error (status)) { |
_cairo_scaled_font_thaw_cache (surface->scaled_font); |
return status; |
} |
x_advance = scaled_glyph->metrics.x_advance; |
y_advance = scaled_glyph->metrics.y_advance; |
font_matrix_inverse = surface->scaled_font->font_matrix; |
status2 = cairo_matrix_invert (&font_matrix_inverse); |
/* The invertability of font_matrix is tested in |
* pdf_operators_show_glyphs before any glyphs are mapped to the |
* subset. */ |
assert (status2 == CAIRO_STATUS_SUCCESS); |
cairo_matrix_transform_distance (&font_matrix_inverse, &x_advance, &y_advance); |
*width = x_advance; |
*bbox = scaled_glyph->bbox; |
_cairo_matrix_transform_bounding_box_fixed (&surface->scaled_font->scale_inverse, |
bbox, NULL); |
_cairo_output_stream_printf (surface->stream, |
"%f 0 %f %f %f %f d1\n", |
x_advance, |
_cairo_fixed_to_double (bbox->p1.x), |
- _cairo_fixed_to_double (bbox->p2.y), |
_cairo_fixed_to_double (bbox->p2.x), |
- _cairo_fixed_to_double (bbox->p1.y)); |
if (status == CAIRO_STATUS_SUCCESS) { |
cairo_output_stream_t *mem_stream; |
mem_stream = _cairo_memory_stream_create (); |
status = mem_stream->status; |
if (unlikely (status)) |
goto FAIL; |
_cairo_type3_glyph_surface_set_stream (surface, mem_stream); |
_cairo_output_stream_printf (surface->stream, "q\n"); |
status = _cairo_recording_surface_replay (scaled_glyph->recording_surface, |
&surface->base); |
status2 = _cairo_pdf_operators_flush (&surface->pdf_operators); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
_cairo_output_stream_printf (surface->stream, "Q\n"); |
_cairo_type3_glyph_surface_set_stream (surface, stream); |
if (status == CAIRO_STATUS_SUCCESS) |
_cairo_memory_stream_copy (mem_stream, stream); |
status2 = _cairo_output_stream_destroy (mem_stream); |
if (status == CAIRO_STATUS_SUCCESS) |
status = status2; |
} |
if (status == CAIRO_INT_STATUS_IMAGE_FALLBACK) |
status = _cairo_type3_glyph_surface_emit_fallback_image (surface, glyph_index); |
FAIL: |
_cairo_scaled_font_thaw_cache (surface->scaled_font); |
return status; |
} |
#endif /* CAIRO_HAS_FONT_SUBSET */ |
/programs/develop/libraries/libpng/LICENSE |
---|
0,0 → 1,111 |
This copy of the libpng notices is provided for your convenience. In case of |
any discrepancy between this copy and the notices in the file png.h that is |
included in the libpng distribution, the latter shall prevail. |
COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: |
If you modify libpng you may insert additional notices immediately following |
this sentence. |
This code is released under the libpng license. |
libpng versions 1.2.6, August 15, 2004, through 1.5.1, February 3, 2011, are |
Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are |
distributed according to the same disclaimer and license as libpng-1.2.5 |
with the following individual added to the list of Contributing Authors |
Cosmin Truta |
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 Glenn Randers-Pehrson, and are |
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 Open Source is a |
certification mark of the Open Source Initiative. |
Glenn Randers-Pehrson |
glennrp at users.sourceforge.net |
February 3, 2011 |
/programs/develop/libraries/libpng/Makefile |
---|
0,0 → 1,44 |
LIBRARY= libpng |
CC=gcc |
CPP=gcc -E |
AR= ar rc |
CFLAGS = -c -O2 -fomit-frame-pointer |
DEFS = -DHAVE_CONFIG_H |
LIBPNG_DEFINES = -DPNG_CONFIGURE_LIBPNG |
DEFINES= $(DEFS) $(LIBPNG_DEFINES) |
INCLUDES= -I../newlib/include -I../zlib |
SOURCES = png.c pngerror.c pngget.c pngmem.c pngpread.c \ |
pngread.c pngrio.c pngrtran.c pngrutil.c \ |
pngset.c pngtrans.c pngwio.c pngwrite.c \ |
pngwtran.c pngwutil.c png.h pngconf.h \ |
pngdebug.h pnginfo.h pngpriv.h pngstruct.h |
OBJECTS = $(patsubst %.c, %.o, $(SOURCES)) |
# targets |
all:$(LIBRARY).a |
$(LIBRARY).a: $(OBJECTS) Makefile |
ar cvrs $(LIBRARY).a $(OBJECTS) |
%.o : %.c Makefile |
$(CC) $(CFLAGS) $(DEFINES) $(INCLUDES) -o $@ $< |
/programs/develop/libraries/libpng/config.h |
---|
0,0 → 1,87 |
/* config.h. Generated from config.h.in by configure. */ |
/* config.h.in. Generated from configure.ac by autoheader. */ |
/* Define to 1 if you have the <dlfcn.h> header file. */ |
#define HAVE_DLFCN_H 1 |
/* Define to 1 if you have the <inttypes.h> header file. */ |
#define HAVE_INTTYPES_H 1 |
/* Define to 1 if you have the `m' library (-lm). */ |
#define HAVE_LIBM 1 |
/* Define to 1 if you have the `z' library (-lz). */ |
#define HAVE_LIBZ 1 |
/* Define to 1 if you have the <malloc.h> header file. */ |
#define HAVE_MALLOC_H 1 |
/* Define to 1 if you have the <memory.h> header file. */ |
#define HAVE_MEMORY_H 1 |
/* Define to 1 if you have the `memset' function. */ |
#define HAVE_MEMSET 1 |
/* Define to 1 if you have the `pow' function. */ |
/* #undef HAVE_POW */ |
/* Define to 1 if you have the <stdint.h> header file. */ |
#define HAVE_STDINT_H 1 |
/* Define to 1 if you have the <stdlib.h> header file. */ |
#define HAVE_STDLIB_H 1 |
/* Define to 1 if you have the <strings.h> header file. */ |
#define HAVE_STRINGS_H 1 |
/* Define to 1 if you have the <string.h> header file. */ |
#define HAVE_STRING_H 1 |
/* Define to 1 if you have the <sys/stat.h> header file. */ |
#define HAVE_SYS_STAT_H 1 |
/* Define to 1 if you have the <sys/types.h> header file. */ |
#define HAVE_SYS_TYPES_H 1 |
/* Define to 1 if you have the <unistd.h> header file. */ |
#define HAVE_UNISTD_H 1 |
/* Define to the sub-directory in which libtool stores uninstalled libraries. |
*/ |
#define LT_OBJDIR ".libs/" |
/* Name of package */ |
#define PACKAGE "libpng" |
/* Define to the address where bug reports for this package should be sent. */ |
#define PACKAGE_BUGREPORT "png-mng-implement@lists.sourceforge.net" |
/* Define to the full name of this package. */ |
#define PACKAGE_NAME "libpng" |
/* Define to the full name and version of this package. */ |
#define PACKAGE_STRING "libpng 1.5.1" |
/* Define to the one symbol short name of this package. */ |
#define PACKAGE_TARNAME "libpng" |
/* Define to the home page for this package. */ |
#define PACKAGE_URL "" |
/* Define to the version of this package. */ |
#define PACKAGE_VERSION "1.5.1" |
/* Define to 1 if you have the ANSI C header files. */ |
#define STDC_HEADERS 1 |
/* Define to 1 if your <sys/time.h> declares `struct tm'. */ |
/* #undef TM_IN_SYS_TIME */ |
/* Version number of package */ |
#define VERSION "1.5.1" |
/* Define to empty if `const' does not conform to ANSI C. */ |
/* #undef const */ |
/* Define to `unsigned int' if <sys/types.h> does not define. */ |
/* #undef size_t */ |
/programs/develop/libraries/libpng/libpng-manual.txt |
---|
0,0 → 1,4136 |
libpng-manual.txt - A description on how to use and modify libpng |
libpng version 1.5.1 - February 3, 2011 |
Updated and distributed by Glenn Randers-Pehrson |
<glennrp at users.sourceforge.net> |
Copyright (c) 1998-2011 Glenn Randers-Pehrson |
This document is released under the libpng license. |
For conditions of distribution and use, see the disclaimer |
and license in png.h |
Based on: |
libpng versions 0.97, January 1998, through 1.5.1 - February 3, 2011 |
Updated and distributed by Glenn Randers-Pehrson |
Copyright (c) 1998-2011 Glenn Randers-Pehrson |
libpng 1.0 beta 6 version 0.96 May 28, 1997 |
Updated and distributed by Andreas Dilger |
Copyright (c) 1996, 1997 Andreas Dilger |
libpng 1.0 beta 2 - version 0.88 January 26, 1996 |
For conditions of distribution and use, see copyright |
notice in png.h. Copyright (c) 1995, 1996 Guy Eric |
Schalnat, Group 42, Inc. |
Updated/rewritten per request in the libpng FAQ |
Copyright (c) 1995, 1996 Frank J. T. Wojcik |
December 18, 1995 & January 20, 1996 |
I. Introduction |
This file describes how to use and modify the PNG reference library |
(known as libpng) for your own use. There are five sections to this |
file: introduction, structures, reading, writing, and modification and |
configuration notes for various special platforms. In addition to this |
file, example.c is a good starting point for using the library, as |
it is heavily commented and should include everything most people |
will need. We assume that libpng is already installed; see the |
INSTALL file for instructions on how to install libpng. |
For examples of libpng usage, see the files "example.c", "pngtest.c", |
and the files in the "contrib" directory, all of which are included in |
the libpng distribution. |
Libpng was written as a companion to the PNG specification, as a way |
of reducing the amount of time and effort it takes to support the PNG |
file format in application programs. |
The PNG specification (second edition), November 2003, is available as |
a W3C Recommendation and as an ISO Standard (ISO/IEC 15948:2003 (E)) at |
<http://www.w3.org/TR/2003/REC-PNG-20031110/ |
The W3C and ISO documents have identical technical content. |
The PNG-1.2 specification is available at |
<http://www.libpng.org/pub/png/documents/>. It is technically equivalent |
to the PNG specification (second edition) but has some additional material. |
The PNG-1.0 specification is available |
as RFC 2083 <http://www.libpng.org/pub/png/documents/> and as a |
W3C Recommendation <http://www.w3.org/TR/REC.png.html>. |
Some additional chunks are described in the special-purpose public chunks |
documents at <http://www.libpng.org/pub/png/documents/>. |
Other information |
about PNG, and the latest version of libpng, can be found at the PNG home |
page, <http://www.libpng.org/pub/png/>. |
Most users will not have to modify the library significantly; advanced |
users may want to modify it more. All attempts were made to make it as |
complete as possible, while keeping the code easy to understand. |
Currently, this library only supports C. Support for other languages |
is being considered. |
Libpng has been designed to handle multiple sessions at one time, |
to be easily modifiable, to be portable to the vast majority of |
machines (ANSI, K&R, 16-, 32-, and 64-bit) available, and to be easy |
to use. The ultimate goal of libpng is to promote the acceptance of |
the PNG file format in whatever way possible. While there is still |
work to be done (see the TODO file), libpng should cover the |
majority of the needs of its users. |
Libpng uses zlib for its compression and decompression of PNG files. |
Further information about zlib, and the latest version of zlib, can |
be found at the zlib home page, <http://www.info-zip.org/pub/infozip/zlib/>. |
The zlib compression utility is a general purpose utility that is |
useful for more than PNG files, and can be used without libpng. |
See the documentation delivered with zlib for more details. |
You can usually find the source files for the zlib utility wherever you |
find the libpng source files. |
Libpng is thread safe, provided the threads are using different |
instances of the structures. Each thread should have its own |
png_struct and png_info instances, and thus its own image. |
Libpng does not protect itself against two threads using the |
same instance of a structure. |
II. Structures |
There are two main structures that are important to libpng, png_struct |
and png_info. Both are internal structures that are no longer exposed |
in the libpng interface (as of libpng 1.5.0). |
The png_info structure is designed to provide information about the |
PNG file. At one time, the fields of png_info were intended to be |
directly accessible to the user. However, this tended to cause problems |
with applications using dynamically loaded libraries, and as a result |
a set of interface functions for png_info (the png_get_*() and png_set_*() |
functions) was developed. |
The png_struct structure is the object used by the library to decode a |
single image. As of 1.5.0 this structure is also not exposed. |
Almost all libpng APIs require a pointer to a png_struct as the first argument. |
Many (in particular the png_set and png_get APIs) also require a pointer |
to png_info as the second argument. Some application visible macros |
defined in png.h designed for basic data access (reading and writing |
integers in the PNG format) break this rule, but it's almost always safe |
to assume that a (png_struct*) has to be passed to call an API function. |
The png.h header file is an invaluable reference for programming with libpng. |
And while I'm on the topic, make sure you include the libpng header file: |
#include <png.h> |
Types |
The png.h header file defines a number of integral types used by the |
APIs. Most of these are fairly obvious; for example types corresponding |
to integers of particular sizes and types for passing color values. |
One exception is how non-integral numbers are handled. For application |
convenience most APIs that take such numbers have C (double) arguments, |
however internally PNG, and libpng, use 32 bit signed integers and encode |
the value by multiplying by 100,000. As of libpng 1.5.0 a convenience |
macro PNG_FP_1 is defined in png.h along with a type (png_fixed_point) |
which is simply (png_int_32). |
All APIs that take (double) arguments also have an matching API that |
takes the corresponding fixed point integer arguments. The fixed point |
API has the same name as the floating point one with _fixed appended. |
The actual range of values permitted in the APIs is frequently less than |
the full range of (png_fixed_point) (-21474 to +21474). When APIs require |
a non-negative argument the type is recorded as png_uint_32 above. Consult |
the header file and the text below for more information. |
Special care must be take with sCAL chunk handling because the chunk itself |
uses non-integral values encoded as strings containing decimal floating point |
numbers. See the comments in the header file. |
Configuration |
The main header file function declarations are frequently protected by C |
preprocessing directives of the form: |
#ifdef PNG_feature_SUPPORTED |
declare-function |
#endif |
The library can be built without support for these APIs, although a |
standard build will have all implemented APIs. Application programs |
should check the feature macros before using an API for maximum |
portability. From libpng 1.5.0 the feature macros set during the build |
of libpng are recorded in the header file "pnglibconf.h" and this file |
is always included by png.h. |
If you don't need to change the library configuration from the default skip to |
the next section ("Reading"). |
Notice that some of the makefiles in the 'scripts' directory and (in 1.5.0) all |
of the build project files in the 'projects' directory simply copy |
scripts/pnglibconf.h.prebuilt to pnglibconf.h. This means that these build |
systems do not permit easy auto-configuration of the library - they only |
support the default configuration. |
The easiest way to make minor changes to the libpng configuration when |
auto-configuration is supported is to add definitions to the command line |
using (typically) CPPFLAGS. For example: |
CPPFLAGS=-DPNG_NO_FLOATING_ARITHMETIC |
will change the internal libpng math implementation for gamma correction and |
other arithmetic calculations to fixed point, avoiding the need for fast |
floating point support. The result can be seen in the generated pnglibconf.h - |
make sure it contains the changed feature macro setting. |
If you need to make more extensive configuration changes - more than one or two |
feature macro settings - you can either add -DPNG_USER_CONFIG to the build |
command line and put a list of feature macro settings in pngusr.h or you can set |
DFA_XTRA (a makefile variable) to a file containing the same information in the |
form of 'option' settings. |
A. Changing pnglibconf.h |
A variety of methods exist to build libpng. Not all of these support |
reconfiguration of pnglibconf.h. To reconfigure pnglibconf.h it must either be |
rebuilt from scripts/pnglibconf.dfa using awk or it must be edited by hand. |
Hand editing is achieved by copying scripts/pnglibconf.h.prebuilt and changing |
the lines defining the supported features, paying very close attention to the |
'option' information in scripts/pnglibconf.dfa that describes those features and |
their requirements. This is easy to get wrong. |
B. Configuration using DFA_XTRA |
Rebuilding from pnglibconf.dfa is easy if a functioning 'awk', or a later |
variant such as 'nawk' or 'gawk', is available. The configure build will |
automatically find an appropriate awk and build pnglibconf.h. |
scripts/pnglibconf.mak contains a set of make rules for doing the same thing if |
configure is not used, and many of the makefiles in the scripts directory use |
this approach. |
When rebuilding simply write new file containing changed options and set |
DFA_XTRA to the name of this file. This causes the build to append the new file |
to the end of scripts/pnglibconf.dfa. pngusr.dfa should contain lines of the |
following forms: |
everything = off |
This turns all optional features off. Include it at the start of pngusr.dfa to |
make it easier to build a minimal configuration. You will need to turn at least |
some features on afterward to enable either reading or writing code, or both. |
option feature on |
option feature off |
Enable or disable a single feature. This will automatically enable other |
features required by a feature that is turned on or disable other features that |
require a feature which is turned off. Conflicting settings will cause an error |
message to be emitted by awk. |
setting feature default value |
Changes the default value of setting 'feature' to 'value'. There are a small |
number of settings listed at the top of pnglibconf.h, they are documented in the |
source code. Most of these values have performance implications for the library |
but most of them have no visible effect on the API. Some can also be overridden |
from the API. |
C. Configuration using PNG_USR_CONFIG |
If -DPNG_USR_CONFIG is added to the CFLAGS when pnglibconf.h is built the file |
pngusr.h will automatically be included before the options in |
scripts/pnglibconf.dfa are processed. pngusr.h should contain only macro |
definitions turning features on or off or setting settings. |
Apart from the global setting "everything = off" all the options listed above |
can be set using macros in pngusr.h: |
#define PNG_feature_SUPPORTED |
is equivalent to: |
option feature on |
#define PNG_NO_feature |
is equivalent to: |
option feature off |
#define PNG_feature value |
is equivalent to: |
setting feature default value |
Notice that in both cases, pngusr.dfa and pngusr.h, the contents of the |
pngusr file you supply override the contents of scripts/pnglibconf.dfa |
If confusing or incomprehensible behavior results it is possible to |
examine the intermediate file pnglibconf.dfn to find the full set of |
dependency information for each setting and option. Simply locate the |
feature in the file and read the C comments that precede it. |
III. Reading |
We'll now walk you through the possible functions to call when reading |
in a PNG file sequentially, briefly explaining the syntax and purpose |
of each one. See example.c and png.h for more detail. While |
progressive reading is covered in the next section, you will still |
need some of the functions discussed in this section to read a PNG |
file. |
Setup |
You will want to do the I/O initialization(*) before you get into libpng, |
so if it doesn't work, you don't have much to undo. Of course, you |
will also want to insure that you are, in fact, dealing with a PNG |
file. Libpng provides a simple check to see if a file is a PNG file. |
To use it, pass in the first 1 to 8 bytes of the file to the function |
png_sig_cmp(), and it will return 0 (false) if the bytes match the |
corresponding bytes of the PNG signature, or nonzero (true) otherwise. |
Of course, the more bytes you pass in, the greater the accuracy of the |
prediction. |
If you are intending to keep the file pointer open for use in libpng, |
you must ensure you don't read more than 8 bytes from the beginning |
of the file, and you also have to make a call to png_set_sig_bytes_read() |
with the number of bytes you read from the beginning. Libpng will |
then only check the bytes (if any) that your program didn't read. |
(*): If you are not using the standard I/O functions, you will need |
to replace them with custom functions. See the discussion under |
Customizing libpng. |
FILE *fp = fopen(file_name, "rb"); |
if (!fp) |
{ |
return (ERROR); |
} |
fread(header, 1, number, fp); |
is_png = !png_sig_cmp(header, 0, number); |
if (!is_png) |
{ |
return (NOT_PNG); |
} |
Next, png_struct and png_info need to be allocated and initialized. In |
order to ensure that the size of these structures is correct even with a |
dynamically linked libpng, there are functions to initialize and |
allocate the structures. We also pass the library version, optional |
pointers to error handling functions, and a pointer to a data struct for |
use by the error functions, if necessary (the pointer and functions can |
be NULL if the default error handlers are to be used). See the section |
on Changes to Libpng below regarding the old initialization functions. |
The structure allocation functions quietly return NULL if they fail to |
create the structure, so your application should check for that. |
png_structp png_ptr = png_create_read_struct |
(PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, |
user_error_fn, user_warning_fn); |
if (!png_ptr) |
return (ERROR); |
png_infop info_ptr = png_create_info_struct(png_ptr); |
if (!info_ptr) |
{ |
png_destroy_read_struct(&png_ptr, |
(png_infopp)NULL, (png_infopp)NULL); |
return (ERROR); |
} |
png_infop end_info = png_create_info_struct(png_ptr); |
if (!end_info) |
{ |
png_destroy_read_struct(&png_ptr, &info_ptr, |
(png_infopp)NULL); |
return (ERROR); |
} |
If you want to use your own memory allocation routines, |
use a libpng that was built with PNG_USER_MEM_SUPPORTED defined, and use |
png_create_read_struct_2() instead of png_create_read_struct(): |
png_structp png_ptr = png_create_read_struct_2 |
(PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, |
user_error_fn, user_warning_fn, (png_voidp) |
user_mem_ptr, user_malloc_fn, user_free_fn); |
The error handling routines passed to png_create_read_struct() |
and the memory alloc/free routines passed to png_create_struct_2() |
are only necessary if you are not using the libpng supplied error |
handling and memory alloc/free functions. |
When libpng encounters an error, it expects to longjmp back |
to your routine. Therefore, you will need to call setjmp and pass |
your png_jmpbuf(png_ptr). If you read the file from different |
routines, you will need to update the jmpbuf field every time you enter |
a new routine that will call a png_*() function. |
See your documentation of setjmp/longjmp for your compiler for more |
information on setjmp/longjmp. See the discussion on libpng error |
handling in the Customizing Libpng section below for more information |
on the libpng error handling. If an error occurs, and libpng longjmp's |
back to your setjmp, you will want to call png_destroy_read_struct() to |
free any memory. |
if (setjmp(png_jmpbuf(png_ptr))) |
{ |
png_destroy_read_struct(&png_ptr, &info_ptr, |
&end_info); |
fclose(fp); |
return (ERROR); |
} |
If you would rather avoid the complexity of setjmp/longjmp issues, |
you can compile libpng with PNG_NO_SETJMP, in which case |
errors will result in a call to PNG_ABORT() which defaults to abort(). |
You can #define PNG_ABORT() to a function that does something |
more useful than abort(), as long as your function does not |
return. |
Now you need to set up the input code. The default for libpng is to |
use the C function fread(). If you use this, you will need to pass a |
valid FILE * in the function png_init_io(). Be sure that the file is |
opened in binary mode. If you wish to handle reading data in another |
way, you need not call the png_init_io() function, but you must then |
implement the libpng I/O methods discussed in the Customizing Libpng |
section below. |
png_init_io(png_ptr, fp); |
If you had previously opened the file and read any of the signature from |
the beginning in order to see if this was a PNG file, you need to let |
libpng know that there are some bytes missing from the start of the file. |
png_set_sig_bytes(png_ptr, number); |
You can change the zlib compression buffer size to be used while |
reading compressed data with |
png_set_compression_buffer_size(png_ptr, buffer_size); |
where the default size is 8192 bytes. Note that the buffer size |
is changed immediately and the buffer is reallocated immediately, |
instead of setting a flag to be acted upon later. |
If you want CRC errors to be handled in a different manner than |
the default, use |
png_set_crc_action(png_ptr, crit_action, ancil_action); |
The values for png_set_crc_action() say how libpng is 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. |
Choices for (int) crit_action are |
PNG_CRC_DEFAULT 0 error/quit |
PNG_CRC_ERROR_QUIT 1 error/quit |
PNG_CRC_WARN_USE 3 warn/use data |
PNG_CRC_QUIET_USE 4 quiet/use data |
PNG_CRC_NO_CHANGE 5 use the current value |
Choices for (int) ancil_action are |
PNG_CRC_DEFAULT 0 error/quit |
PNG_CRC_ERROR_QUIT 1 error/quit |
PNG_CRC_WARN_DISCARD 2 warn/discard data |
PNG_CRC_WARN_USE 3 warn/use data |
PNG_CRC_QUIET_USE 4 quiet/use data |
PNG_CRC_NO_CHANGE 5 use the current value |
Setting up callback code |
You can set up a callback function to handle any unknown chunks in the |
input stream. You must supply the function |
read_chunk_callback(png_structp png_ptr, |
png_unknown_chunkp chunk); |
{ |
/* The unknown chunk structure contains your |
chunk data, along with similar data for any other |
unknown chunks: */ |
png_byte name[5]; |
png_byte *data; |
png_size_t size; |
/* Note that libpng has already taken care of |
the CRC handling */ |
/* put your code here. Search for your chunk in the |
unknown chunk structure, process it, and return one |
of the following: */ |
return (-n); /* chunk had an error */ |
return (0); /* did not recognize */ |
return (n); /* success */ |
} |
(You can give your function another name that you like instead of |
"read_chunk_callback") |
To inform libpng about your function, use |
png_set_read_user_chunk_fn(png_ptr, user_chunk_ptr, |
read_chunk_callback); |
This names not only the callback function, but also a user pointer that |
you can retrieve with |
png_get_user_chunk_ptr(png_ptr); |
If you call the png_set_read_user_chunk_fn() function, then all unknown |
chunks will be saved when read, in case your callback function will need |
one or more of them. This behavior can be changed with the |
png_set_keep_unknown_chunks() function, described below. |
At this point, you can set up a callback function that will be |
called after each row has been read, which you can use to control |
a progress meter or the like. It's demonstrated in pngtest.c. |
You must supply a function |
void read_row_callback(png_structp png_ptr, |
png_uint_32 row, int pass); |
{ |
/* put your code here */ |
} |
(You can give it another name that you like instead of "read_row_callback") |
To inform libpng about your function, use |
png_set_read_status_fn(png_ptr, read_row_callback); |
Unknown-chunk handling |
Now you get to set the way the library processes unknown chunks in the |
input PNG stream. Both known and unknown chunks will be read. Normal |
behavior is that known chunks will be parsed into information in |
various info_ptr members while unknown chunks will be discarded. This |
behavior can be wasteful if your application will never use some known |
chunk types. To change this, you can call: |
png_set_keep_unknown_chunks(png_ptr, keep, |
chunk_list, num_chunks); |
keep - 0: default unknown chunk handling |
1: ignore; do not keep |
2: keep only if safe-to-copy |
3: keep even if unsafe-to-copy |
You can use these definitions: |
PNG_HANDLE_CHUNK_AS_DEFAULT 0 |
PNG_HANDLE_CHUNK_NEVER 1 |
PNG_HANDLE_CHUNK_IF_SAFE 2 |
PNG_HANDLE_CHUNK_ALWAYS 3 |
chunk_list - list of chunks affected (a byte string, |
five bytes per chunk, NULL or '\0' if |
num_chunks is 0) |
num_chunks - number of chunks affected; if 0, all |
unknown chunks are affected. If nonzero, |
only the chunks in the list are affected |
Unknown chunks declared in this way will be saved as raw data onto a |
list of png_unknown_chunk structures. If a chunk that is normally |
known to libpng is named in the list, it will be handled as unknown, |
according to the "keep" directive. If a chunk is named in successive |
instances of png_set_keep_unknown_chunks(), the final instance will |
take precedence. The IHDR and IEND chunks should not be named in |
chunk_list; if they are, libpng will process them normally anyway. |
Here is an example of the usage of png_set_keep_unknown_chunks(), |
where the private "vpAg" chunk will later be processed by a user chunk |
callback function: |
png_byte vpAg[5]={118, 112, 65, 103, (png_byte) '\0'}; |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
png_byte unused_chunks[]= |
{ |
104, 73, 83, 84, (png_byte) '\0', /* hIST */ |
105, 84, 88, 116, (png_byte) '\0', /* iTXt */ |
112, 67, 65, 76, (png_byte) '\0', /* pCAL */ |
115, 67, 65, 76, (png_byte) '\0', /* sCAL */ |
115, 80, 76, 84, (png_byte) '\0', /* sPLT */ |
116, 73, 77, 69, (png_byte) '\0', /* tIME */ |
}; |
#endif |
... |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) |
/* ignore all unknown chunks: */ |
png_set_keep_unknown_chunks(read_ptr, 1, NULL, 0); |
/* except for vpAg: */ |
png_set_keep_unknown_chunks(read_ptr, 2, vpAg, 1); |
/* also ignore unused known chunks: */ |
png_set_keep_unknown_chunks(read_ptr, 1, unused_chunks, |
(int)sizeof(unused_chunks)/5); |
#endif |
User limits |
The PNG specification allows the width and height of an image to be as |
large as 2^31-1 (0x7fffffff), or about 2.147 billion rows and columns. |
Since very few applications really need to process such large images, |
we have imposed an arbitrary 1-million limit on rows and columns. |
Larger images will be rejected immediately with a png_error() call. If |
you wish to override this limit, you can use |
png_set_user_limits(png_ptr, width_max, height_max); |
to set your own limits, or use width_max = height_max = 0x7fffffffL |
to allow all valid dimensions (libpng may reject some very large images |
anyway because of potential buffer overflow conditions). |
You should put this statement after you create the PNG structure and |
before calling png_read_info(), png_read_png(), or png_process_data(). |
If you need to retrieve the limits that are being applied, use |
width_max = png_get_user_width_max(png_ptr); |
height_max = png_get_user_height_max(png_ptr); |
The PNG specification sets no limit on the number of ancillary chunks |
allowed in a PNG datastream. You can impose a limit on the total number |
of sPLT, tEXt, iTXt, zTXt, and unknown chunks that will be stored, with |
png_set_chunk_cache_max(png_ptr, user_chunk_cache_max); |
where 0x7fffffffL means unlimited. You can retrieve this limit with |
chunk_cache_max = png_get_chunk_cache_max(png_ptr); |
This limit also applies to the number of buffers that can be allocated |
by png_decompress_chunk() while decompressing iTXt, zTXt, and iCCP chunks. |
You can also set a limit on the amount of memory that a compressed chunk |
other than IDAT can occupy, with |
png_set_chunk_malloc_max(png_ptr, user_chunk_malloc_max); |
and you can retrieve the limit with |
chunk_malloc_max = png_get_chunk_malloc_max(png_ptr); |
Any chunks that would cause either of these limits to be exceeded will |
be ignored. |
The high-level read interface |
At this point there are two ways to proceed; through the high-level |
read interface, or through a sequence of low-level read operations. |
You can use the high-level interface if (a) you are willing to read |
the entire image into memory, and (b) the input transformations |
you want to do are limited to the following set: |
PNG_TRANSFORM_IDENTITY No transformation |
PNG_TRANSFORM_STRIP_16 Strip 16-bit samples to |
8 bits |
PNG_TRANSFORM_STRIP_ALPHA Discard the alpha channel |
PNG_TRANSFORM_PACKING Expand 1, 2 and 4-bit |
samples to bytes |
PNG_TRANSFORM_PACKSWAP Change order of packed |
pixels to LSB first |
PNG_TRANSFORM_EXPAND Perform set_expand() |
PNG_TRANSFORM_INVERT_MONO Invert monochrome images |
PNG_TRANSFORM_SHIFT Normalize pixels to the |
sBIT depth |
PNG_TRANSFORM_BGR Flip RGB to BGR, RGBA |
to BGRA |
PNG_TRANSFORM_SWAP_ALPHA Flip RGBA to ARGB or GA |
to AG |
PNG_TRANSFORM_INVERT_ALPHA Change alpha from opacity |
to transparency |
PNG_TRANSFORM_SWAP_ENDIAN Byte-swap 16-bit samples |
PNG_TRANSFORM_GRAY_TO_RGB Expand grayscale samples |
to RGB (or GA to RGBA) |
(This excludes setting a background color, doing gamma transformation, |
quantizing, and setting filler.) If this is the case, simply do this: |
png_read_png(png_ptr, info_ptr, png_transforms, NULL) |
where png_transforms is an integer containing the bitwise OR of some |
set of transformation flags. This call is equivalent to png_read_info(), |
followed the set of transformations indicated by the transform mask, |
then png_read_image(), and finally png_read_end(). |
(The final parameter of this call is not yet used. Someday it might point |
to transformation parameters required by some future input transform.) |
You must use png_transforms and not call any png_set_transform() functions |
when you use png_read_png(). |
After you have called png_read_png(), you can retrieve the image data |
with |
row_pointers = png_get_rows(png_ptr, info_ptr); |
where row_pointers is an array of pointers to the pixel data for each row: |
png_bytep row_pointers[height]; |
If you know your image size and pixel size ahead of time, you can allocate |
row_pointers prior to calling png_read_png() with |
if (height > PNG_UINT_32_MAX/png_sizeof(png_byte)) |
png_error (png_ptr, |
"Image is too tall to process in memory"); |
if (width > PNG_UINT_32_MAX/pixel_size) |
png_error (png_ptr, |
"Image is too wide to process in memory"); |
row_pointers = png_malloc(png_ptr, |
height*png_sizeof(png_bytep)); |
for (int i=0; i<height, i++) |
row_pointers[i]=NULL; /* security precaution */ |
for (int i=0; i<height, i++) |
row_pointers[i]=png_malloc(png_ptr, |
width*pixel_size); |
png_set_rows(png_ptr, info_ptr, &row_pointers); |
Alternatively you could allocate your image in one big block and define |
row_pointers[i] to point into the proper places in your block. |
If you use png_set_rows(), the application is responsible for freeing |
row_pointers (and row_pointers[i], if they were separately allocated). |
If you don't allocate row_pointers ahead of time, png_read_png() will |
do it, and it'll be free'ed by libpng when you call png_destroy_*(). |
The low-level read interface |
If you are going the low-level route, you are now ready to read all |
the file information up to the actual image data. You do this with a |
call to png_read_info(). |
png_read_info(png_ptr, info_ptr); |
This will process all chunks up to but not including the image data. |
Querying the info structure |
Functions are used to get the information from the info_ptr once it |
has been read. Note that these fields may not be completely filled |
in until png_read_end() has read the chunk data following the image. |
png_get_IHDR(png_ptr, info_ptr, &width, &height, |
&bit_depth, &color_type, &interlace_type, |
&compression_type, &filter_method); |
width - holds the width of the image |
in pixels (up to 2^31). |
height - holds the height of the image |
in pixels (up to 2^31). |
bit_depth - holds the bit depth of one of the |
image channels. (valid values are |
1, 2, 4, 8, 16 and depend also on |
the color_type. See also |
significant bits (sBIT) below). |
color_type - describes which color/alpha channels |
are present. |
PNG_COLOR_TYPE_GRAY |
(bit depths 1, 2, 4, 8, 16) |
PNG_COLOR_TYPE_GRAY_ALPHA |
(bit depths 8, 16) |
PNG_COLOR_TYPE_PALETTE |
(bit depths 1, 2, 4, 8) |
PNG_COLOR_TYPE_RGB |
(bit_depths 8, 16) |
PNG_COLOR_TYPE_RGB_ALPHA |
(bit_depths 8, 16) |
PNG_COLOR_MASK_PALETTE |
PNG_COLOR_MASK_COLOR |
PNG_COLOR_MASK_ALPHA |
interlace_type - (PNG_INTERLACE_NONE or |
PNG_INTERLACE_ADAM7) |
compression_type - (must be PNG_COMPRESSION_TYPE_BASE |
for PNG 1.0) |
filter_method - (must be PNG_FILTER_TYPE_BASE |
for PNG 1.0, and can also be |
PNG_INTRAPIXEL_DIFFERENCING if |
the PNG datastream is embedded in |
a MNG-1.0 datastream) |
Any or all of interlace_type, compression_type, or |
filter_method can be NULL if you are |
not interested in their values. |
Note that png_get_IHDR() returns 32-bit data into |
the application's width and height variables. |
This is an unsafe situation if these are 16-bit |
variables. In such situations, the |
png_get_image_width() and png_get_image_height() |
functions described below are safer. |
width = png_get_image_width(png_ptr, |
info_ptr); |
height = png_get_image_height(png_ptr, |
info_ptr); |
bit_depth = png_get_bit_depth(png_ptr, |
info_ptr); |
color_type = png_get_color_type(png_ptr, |
info_ptr); |
interlace_type = png_get_interlace_type(png_ptr, |
info_ptr); |
compression_type = png_get_compression_type(png_ptr, |
info_ptr); |
filter_method = png_get_filter_type(png_ptr, |
info_ptr); |
channels = png_get_channels(png_ptr, info_ptr); |
channels - number of channels of info for the |
color type (valid values are 1 (GRAY, |
PALETTE), 2 (GRAY_ALPHA), 3 (RGB), |
4 (RGB_ALPHA or RGB + filler byte)) |
rowbytes = png_get_rowbytes(png_ptr, info_ptr); |
rowbytes - number of bytes needed to hold a row |
signature = png_get_signature(png_ptr, info_ptr); |
signature - holds the signature read from the |
file (if any). The data is kept in |
the same offset it would be if the |
whole signature were read (i.e. if an |
application had already read in 4 |
bytes of signature before starting |
libpng, the remaining 4 bytes would |
be in signature[4] through signature[7] |
(see png_set_sig_bytes())). |
These are also important, but their validity depends on whether the chunk |
has been read. The png_get_valid(png_ptr, info_ptr, PNG_INFO_<chunk>) and |
png_get_<chunk>(png_ptr, info_ptr, ...) functions return non-zero if the |
data has been read, or zero if it is missing. The parameters to the |
png_get_<chunk> are set directly if they are simple data types, or a |
pointer into the info_ptr is returned for any complex types. |
png_get_PLTE(png_ptr, info_ptr, &palette, |
&num_palette); |
palette - the palette for the file |
(array of png_color) |
num_palette - number of entries in the palette |
png_get_gAMA(png_ptr, info_ptr, &file_gamma); |
png_get_gAMA_fixed(png_ptr, info_ptr, &int_file_gamma); |
file_gamma - the gamma at which the file is |
written (PNG_INFO_gAMA) |
int_file_gamma - 100,000 times the gamma at which the |
file is written |
png_get_sRGB(png_ptr, info_ptr, &srgb_intent); |
file_srgb_intent - the rendering intent (PNG_INFO_sRGB) |
The presence of the sRGB chunk |
means that the pixel data is in the |
sRGB color space. This chunk also |
implies specific values of gAMA and |
cHRM. |
png_get_iCCP(png_ptr, info_ptr, &name, |
&compression_type, &profile, &proflen); |
name - The profile name. |
compression_type - The compression type; always |
PNG_COMPRESSION_TYPE_BASE for PNG 1.0. |
You may give NULL to this argument to |
ignore it. |
profile - International Color Consortium color |
profile data. May contain NULs. |
proflen - length of profile data in bytes. |
png_get_sBIT(png_ptr, info_ptr, &sig_bit); |
sig_bit - the number of significant bits for |
(PNG_INFO_sBIT) each of the gray, |
red, green, and blue channels, |
whichever are appropriate for the |
given color type (png_color_16) |
png_get_tRNS(png_ptr, info_ptr, &trans_alpha, |
&num_trans, &trans_color); |
trans_alpha - array of alpha (transparency) |
entries for palette (PNG_INFO_tRNS) |
num_trans - number of transparent entries |
(PNG_INFO_tRNS) |
trans_color - graylevel or color sample values of |
the single transparent color for |
non-paletted images (PNG_INFO_tRNS) |
png_get_hIST(png_ptr, info_ptr, &hist); |
(PNG_INFO_hIST) |
hist - histogram of palette (array of |
png_uint_16) |
png_get_tIME(png_ptr, info_ptr, &mod_time); |
mod_time - time image was last modified |
(PNG_VALID_tIME) |
png_get_bKGD(png_ptr, info_ptr, &background); |
background - background color (PNG_VALID_bKGD) |
valid 16-bit red, green and blue |
values, regardless of color_type |
num_comments = png_get_text(png_ptr, info_ptr, |
&text_ptr, &num_text); |
num_comments - number of comments |
text_ptr - array of png_text holding image |
comments |
text_ptr[i].compression - type of compression used |
on "text" PNG_TEXT_COMPRESSION_NONE |
PNG_TEXT_COMPRESSION_zTXt |
PNG_ITXT_COMPRESSION_NONE |
PNG_ITXT_COMPRESSION_zTXt |
text_ptr[i].key - keyword for comment. Must contain |
1-79 characters. |
text_ptr[i].text - text comments for current |
keyword. Can be empty. |
text_ptr[i].text_length - length of text string, |
after decompression, 0 for iTXt |
text_ptr[i].itxt_length - length of itxt string, |
after decompression, 0 for tEXt/zTXt |
text_ptr[i].lang - language of comment (empty |
string for unknown). |
text_ptr[i].lang_key - keyword in UTF-8 |
(empty string for unknown). |
Note that the itxt_length, lang, and lang_key |
members of the text_ptr structure only exist |
when the library is built with iTXt chunk support. |
num_text - number of comments (same as |
num_comments; you can put NULL here |
to avoid the duplication) |
Note while png_set_text() will accept text, language, |
and translated keywords that can be 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. |
num_spalettes = png_get_sPLT(png_ptr, info_ptr, |
&palette_ptr); |
num_spalettes - number of sPLT chunks read. |
palette_ptr - array of palette structures holding |
contents of one or more sPLT chunks |
read. |
png_get_oFFs(png_ptr, info_ptr, &offset_x, &offset_y, |
&unit_type); |
offset_x - positive offset from the left edge |
of the screen |
offset_y - positive offset from the top edge |
of the screen |
unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER |
png_get_pHYs(png_ptr, info_ptr, &res_x, &res_y, |
&unit_type); |
res_x - pixels/unit physical resolution in |
x direction |
res_y - pixels/unit physical resolution in |
x direction |
unit_type - PNG_RESOLUTION_UNKNOWN, |
PNG_RESOLUTION_METER |
png_get_sCAL(png_ptr, info_ptr, &unit, &width, |
&height) |
unit - physical scale units (an integer) |
width - width of a pixel in physical scale units |
height - height of a pixel in physical scale units |
(width and height are doubles) |
png_get_sCAL_s(png_ptr, info_ptr, &unit, &width, |
&height) |
unit - physical scale units (an integer) |
width - width of a pixel in physical scale units |
height - height of a pixel in physical scale units |
(width and height are strings like "2.54") |
num_unknown_chunks = png_get_unknown_chunks(png_ptr, |
info_ptr, &unknowns) |
unknowns - array of png_unknown_chunk |
structures holding unknown chunks |
unknowns[i].name - name of unknown chunk |
unknowns[i].data - data of unknown chunk |
unknowns[i].size - size of unknown chunk's data |
unknowns[i].location - position of chunk in file |
The value of "i" corresponds to the order in which the |
chunks were read from the PNG file or inserted with the |
png_set_unknown_chunks() function. |
The data from the pHYs chunk can be retrieved in several convenient |
forms: |
res_x = png_get_x_pixels_per_meter(png_ptr, |
info_ptr) |
res_y = png_get_y_pixels_per_meter(png_ptr, |
info_ptr) |
res_x_and_y = png_get_pixels_per_meter(png_ptr, |
info_ptr) |
res_x = png_get_x_pixels_per_inch(png_ptr, |
info_ptr) |
res_y = png_get_y_pixels_per_inch(png_ptr, |
info_ptr) |
res_x_and_y = png_get_pixels_per_inch(png_ptr, |
info_ptr) |
aspect_ratio = png_get_pixel_aspect_ratio(png_ptr, |
info_ptr) |
Each of these returns 0 [signifying "unknown"] if |
the data is not present or if res_x is 0; |
res_x_and_y is 0 if res_x != res_y |
Note that because of the way the resolutions are |
stored internally, the inch conversions won't |
come out to exactly even number. For example, |
72 dpi is stored as 0.28346 pixels/meter, and |
when this is retrieved it is 71.9988 dpi, so |
be sure to round the returned value appropriately |
if you want to display a reasonable-looking result. |
The data from the oFFs chunk can be retrieved in several convenient |
forms: |
x_offset = png_get_x_offset_microns(png_ptr, info_ptr); |
y_offset = png_get_y_offset_microns(png_ptr, info_ptr); |
x_offset = png_get_x_offset_inches(png_ptr, info_ptr); |
y_offset = png_get_y_offset_inches(png_ptr, info_ptr); |
Each of these returns 0 [signifying "unknown" if both |
x and y are 0] if the data is not present or if the |
chunk is present but the unit is the pixel. The |
remark about inexact inch conversions applies here |
as well, because a value in inches can't always be |
converted to microns and back without some loss |
of precision. |
For more information, see the png_info definition in png.h and the |
PNG specification for chunk contents. Be careful with trusting |
rowbytes, as some of the transformations could increase the space |
needed to hold a row (expand, filler, gray_to_rgb, etc.). |
See png_read_update_info(), below. |
A quick word about text_ptr and num_text. PNG stores comments in |
keyword/text pairs, one pair per chunk, with no limit on the number |
of text chunks, and a 2^31 byte limit on their size. While there are |
suggested keywords, there is no requirement to restrict the use to these |
strings. It is strongly suggested that keywords and text be sensible |
to humans (that's the point), so don't use abbreviations. Non-printing |
symbols are not allowed. See the PNG specification for more details. |
There is also no requirement to have text after the keyword. |
Keywords should be limited to 79 Latin-1 characters without leading or |
trailing spaces, but non-consecutive spaces are allowed within the |
keyword. It is possible to have the same keyword any number of times. |
The text_ptr is an array of png_text structures, each holding a |
pointer to a language string, a pointer to a keyword and a pointer to |
a text string. The text string, language code, and translated |
keyword may be empty or NULL pointers. The keyword/text |
pairs are put into the array in the order that they are received. |
However, some or all of the text chunks may be after the image, so, to |
make sure you have read all the text chunks, don't mess with these |
until after you read the stuff after the image. This will be |
mentioned again below in the discussion that goes with png_read_end(). |
Input transformations |
After you've read the header information, you can set up the library |
to handle any special transformations of the image data. The various |
ways to transform the data will be described in the order that they |
should occur. This is important, as some of these change the color |
type and/or bit depth of the data, and some others only work on |
certain color types and bit depths. Even though each transformation |
checks to see if it has data that it can do something with, you should |
make sure to only enable a transformation if it will be valid for the |
data. For example, don't swap red and blue on grayscale data. |
The colors used for the background and transparency values should be |
supplied in the same format/depth as the current image data. They |
are stored in the same format/depth as the image data in a bKGD or tRNS |
chunk, so this is what libpng expects for this data. The colors are |
transformed to keep in sync with the image data when an application |
calls the png_read_update_info() routine (see below). |
Data will be decoded into the supplied row buffers packed into bytes |
unless the library has been told to transform it into another format. |
For example, 4 bit/pixel paletted or grayscale data will be returned |
2 pixels/byte with the leftmost pixel in the high-order bits of the |
byte, unless png_set_packing() is called. 8-bit RGB data will be stored |
in RGB RGB RGB format unless png_set_filler() or png_set_add_alpha() |
is called to insert filler bytes, either before or after each RGB triplet. |
16-bit RGB data will be returned RRGGBB RRGGBB, with the most significant |
byte of the color value first, unless png_set_strip_16() is called to |
transform it to regular RGB RGB triplets, or png_set_filler() or |
png_set_add alpha() is called to insert filler bytes, either before or |
after each RRGGBB triplet. Similarly, 8-bit or 16-bit grayscale data can |
be modified with |
png_set_filler(), png_set_add_alpha(), or png_set_strip_16(). |
The following code transforms grayscale images of less than 8 to 8 bits, |
changes paletted images to RGB, and adds a full alpha channel if there is |
transparency information in a tRNS chunk. This is most useful on |
grayscale images with bit depths of 2 or 4 or if there is a multiple-image |
viewing application that wishes to treat all images in the same way. |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
png_set_palette_to_rgb(png_ptr); |
if (color_type == PNG_COLOR_TYPE_GRAY && |
bit_depth < 8) png_set_expand_gray_1_2_4_to_8(png_ptr); |
if (png_get_valid(png_ptr, info_ptr, |
PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr); |
These three functions are actually aliases for png_set_expand(), added |
in libpng version 1.0.4, with the function names expanded to improve code |
readability. In some future version they may actually do different |
things. |
As of libpng version 1.2.9, png_set_expand_gray_1_2_4_to_8() was |
added. It expands the sample depth without changing tRNS to alpha. |
As of libpng version 1.5.1, not all possible expansions are supported. |
In the following table, the 01 means grayscale with depth<8, 31 means |
indexed with depth<8, other numerals represent the color type, "T" means |
the tRNS chunk is present, A means an alpha channel is present, and O |
means tRNS or alpha is present but all pixels in the image are opaque. |
FROM 01 31 0 0T 0O 2 2T 2O 3 3T 3O 4A 4O 6A 6O |
TO |
01 - |
31 - |
0 1 - |
0T - |
0O - |
2 GX - |
2T - |
2O - |
3 1 - |
3T - |
3O - |
4A T - |
4O - |
6A GX TX TX - |
6O GX TX - |
Within the matrix, |
"-" means the transformation is not supported. |
"X" means the transformation is obtained by png_set_expand(). |
"1" means the transformation is obtained by |
png_set_expand_gray_1_2_4_to_8 |
"G" means the transformation is obtained by |
png_set_gray_to_rgb(). |
"P" means the transformation is obtained by |
png_set_expand_palette_to_rgb(). |
"T" means the transformation is obtained by |
png_set_tRNS_to_alpha(). |
PNG can have files with 16 bits per channel. If you only can handle |
8 bits per channel, this will strip the pixels down to 8 bit. |
if (bit_depth == 16) |
png_set_strip_16(png_ptr); |
If, for some reason, you don't need the alpha channel on an image, |
and you want to remove it rather than combining it with the background |
(but the image author certainly had in mind that you *would* combine |
it with the background, so that's what you should probably do): |
if (color_type & PNG_COLOR_MASK_ALPHA) |
png_set_strip_alpha(png_ptr); |
In PNG files, the alpha channel in an image |
is the level of opacity. If you need the alpha channel in an image to |
be the level of transparency instead of opacity, you can invert the |
alpha channel (or the tRNS chunk data) after it's read, so that 0 is |
fully opaque and 255 (in 8-bit or paletted images) or 65535 (in 16-bit |
images) is fully transparent, with |
png_set_invert_alpha(png_ptr); |
PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as |
they can, resulting in, for example, 8 pixels per byte for 1 bit |
files. This code expands to 1 pixel per byte without changing the |
values of the pixels: |
if (bit_depth < 8) |
png_set_packing(png_ptr); |
PNG files have possible bit depths of 1, 2, 4, 8, and 16. All pixels |
stored in a PNG image have been "scaled" or "shifted" up to the next |
higher possible bit depth (e.g. from 5 bits/sample in the range [0,31] |
to 8 bits/sample in the range [0, 255]). However, it is also possible |
to convert the PNG pixel data back to the original bit depth of the |
image. This call reduces the pixels back down to the original bit depth: |
png_color_8p sig_bit; |
if (png_get_sBIT(png_ptr, info_ptr, &sig_bit)) |
png_set_shift(png_ptr, sig_bit); |
PNG files store 3-color pixels in red, green, blue order. This code |
changes the storage of the pixels to blue, green, red: |
if (color_type == PNG_COLOR_TYPE_RGB || |
color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
png_set_bgr(png_ptr); |
PNG files store RGB pixels packed into 3 or 6 bytes. This code expands them |
into 4 or 8 bytes for windowing systems that need them in this format: |
if (color_type == PNG_COLOR_TYPE_RGB) |
png_set_filler(png_ptr, filler, PNG_FILLER_BEFORE); |
where "filler" is the 8 or 16-bit number to fill with, and the location is |
either PNG_FILLER_BEFORE or PNG_FILLER_AFTER, depending upon whether |
you want the filler before the RGB or after. This transformation |
does not affect images that already have full alpha channels. To add an |
opaque alpha channel, use filler=0xff or 0xffff and PNG_FILLER_AFTER which |
will generate RGBA pixels. |
Note that png_set_filler() does not change the color type. If you want |
to do that, you can add a true alpha channel with |
if (color_type == PNG_COLOR_TYPE_RGB || |
color_type == PNG_COLOR_TYPE_GRAY) |
png_set_add_alpha(png_ptr, filler, PNG_FILLER_AFTER); |
where "filler" contains the alpha value to assign to each pixel. |
This function was added in libpng-1.2.7. |
If you are reading an image with an alpha channel, and you need the |
data as ARGB instead of the normal PNG format RGBA: |
if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
png_set_swap_alpha(png_ptr); |
For some uses, you may want a grayscale image to be represented as |
RGB. This code will do that conversion: |
if (color_type == PNG_COLOR_TYPE_GRAY || |
color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
png_set_gray_to_rgb(png_ptr); |
Conversely, you can convert an RGB or RGBA image to grayscale or grayscale |
with alpha. |
if (color_type == PNG_COLOR_TYPE_RGB || |
color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
png_set_rgb_to_gray_fixed(png_ptr, error_action, |
int red_weight, int green_weight); |
error_action = 1: silently do the conversion |
error_action = 2: issue a warning if the original |
image has any pixel where |
red != green or red != blue |
error_action = 3: issue an error and abort the |
conversion if the original |
image has any pixel where |
red != green or red != blue |
red_weight: weight of red component times 100000 |
green_weight: weight of green component times 100000 |
If either weight is negative, default |
weights (21268, 71514) are used. |
If you have set error_action = 1 or 2, you can |
later check whether the image really was gray, after processing |
the image rows, with the png_get_rgb_to_gray_status(png_ptr) function. |
It will return a png_byte that is zero if the image was gray or |
1 if there were any non-gray pixels. bKGD and sBIT data |
will be silently converted to grayscale, using the green channel |
data, regardless of the error_action setting. |
With red_weight+green_weight<=100000, |
the normalized graylevel is computed: |
int rw = red_weight * 65536; |
int gw = green_weight * 65536; |
int bw = 65536 - (rw + gw); |
gray = (rw*red + gw*green + bw*blue)/65536; |
The default values approximate those recommended in the Charles |
Poynton's Color FAQ, <http://www.inforamp.net/~poynton/> |
Copyright (c) 1998-01-04 Charles Poynton <poynton at inforamp.net> |
Y = 0.212671 * R + 0.715160 * G + 0.072169 * B |
Libpng approximates this with integers scaled by 32768: |
Y = (6968 * R + 23434 * G + 2366 * B)/32768 |
The calculation is done in a linear colorspace, if the image gamma |
can be determined. |
If you have a grayscale and you are using png_set_expand_depth(), |
png_set_expand(), or png_set_gray_to_rgb to change to truecolor or to |
a higher bit-depth, you must either supply the background color as a gray |
value at the original file bit-depth (need_expand = 1) or else supply the |
background color as an RGB triplet at the final, expanded bit depth |
(need_expand = 0). Similarly, if you are reading a paletted image, you |
must either supply the background color as a palette index (need_expand = 1) |
or as an RGB triplet that may or may not be in the palette (need_expand = 0). |
png_color_16 my_background; |
png_color_16p 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); |
The png_set_background() function tells libpng to composite images |
with alpha or simple transparency against the supplied background |
color. If the PNG file contains a bKGD chunk (PNG_INFO_bKGD valid), |
you may use this color, or supply another color more suitable for |
the current display (e.g., the background color from a web page). You |
need to tell libpng whether the color is in the gamma space of the |
display (PNG_BACKGROUND_GAMMA_SCREEN for colors you supply), the file |
(PNG_BACKGROUND_GAMMA_FILE for colors from the bKGD chunk), or one |
that is neither of these gammas (PNG_BACKGROUND_GAMMA_UNIQUE - I don't |
know why anyone would use this, but it's here). |
To properly display PNG images on any kind of system, the application needs |
to know what the display gamma is. Ideally, the user will know this, and |
the application will allow them to set it. One method of allowing the user |
to set the display gamma separately for each system is to check for a |
SCREEN_GAMMA or DISPLAY_GAMMA environment variable, which will hopefully be |
correctly set. |
Note that display_gamma is the overall gamma correction required to produce |
pleasing results, which depends on the lighting conditions in the surrounding |
environment. In a dim or brightly lit room, no compensation other than |
the physical gamma exponent of the monitor is needed, while in a dark room |
a slightly smaller exponent is better. |
double gamma, screen_gamma; |
if (/* We have a user-defined screen |
gamma value */) |
{ |
screen_gamma = user_defined_screen_gamma; |
} |
/* One way that applications can share the same |
screen gamma value */ |
else if ((gamma_str = getenv("SCREEN_GAMMA")) |
!= NULL) |
{ |
screen_gamma = (double)atof(gamma_str); |
} |
/* If we don't have another value */ |
else |
{ |
screen_gamma = 2.2; /* A good guess for a |
PC monitor in a bright office or a dim room */ |
screen_gamma = 2.0; /* A good guess for a |
PC monitor in a dark room */ |
screen_gamma = 1.7 or 1.0; /* A good |
guess for Mac systems */ |
} |
The functions png_set_gamma() and its fixed point equivalent |
png_set_gamma_fixed() handle gamma transformations of the data. |
Pass both the file gamma and the current screen_gamma. If the file does |
not have a gamma value, you can pass one anyway if you have an idea what |
it is (usually 0.45455 is a good guess for GIF images on PCs). Note |
that file gammas are inverted from screen gammas. See the discussions |
on gamma in the PNG specification for an excellent description of what |
gamma is, and why all applications should support it. It is strongly |
recommended that PNG viewers support gamma correction. |
if (png_get_gAMA(png_ptr, info_ptr, &file_gamma)) |
png_set_gamma(png_ptr, screen_gamma, file_gamma); |
else |
png_set_gamma(png_ptr, screen_gamma, 0.45455); |
If you need to reduce an RGB file to a paletted file, or if a paletted |
file has more entries then will fit on your screen, png_set_quantize() |
will do that. Note that this is a simple match quantization that merely |
finds the closest color available. This should work fairly well with |
optimized palettes, but fairly badly with linear color cubes. If you |
pass a palette that is larger then maximum_colors, the file will |
reduce the number of colors in the palette so it will fit into |
maximum_colors. If there is a histogram, it will use it to make |
more intelligent choices when reducing the palette. If there is no |
histogram, it may not do as good a job. |
if (color_type & PNG_COLOR_MASK_COLOR) |
{ |
if (png_get_valid(png_ptr, info_ptr, |
PNG_INFO_PLTE)) |
{ |
png_uint_16p histogram = NULL; |
png_get_hIST(png_ptr, info_ptr, |
&histogram); |
png_set_quantize(png_ptr, palette, num_palette, |
max_screen_colors, histogram, 1); |
} |
else |
{ |
png_color std_color_cube[MAX_SCREEN_COLORS] = |
{ ... colors ... }; |
png_set_quantize(png_ptr, std_color_cube, |
MAX_SCREEN_COLORS, MAX_SCREEN_COLORS, |
NULL,0); |
} |
} |
PNG files describe monochrome as black being zero and white being one. |
The following code will reverse this (make black be one and white be |
zero): |
if (bit_depth == 1 && color_type == PNG_COLOR_TYPE_GRAY) |
png_set_invert_mono(png_ptr); |
This function can also be used to invert grayscale and gray-alpha images: |
if (color_type == PNG_COLOR_TYPE_GRAY || |
color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
png_set_invert_mono(png_ptr); |
PNG files store 16 bit pixels in network byte order (big-endian, |
ie. most significant bits first). This code changes the storage to the |
other way (little-endian, i.e. least significant bits first, the |
way PCs store them): |
if (bit_depth == 16) |
png_set_swap(png_ptr); |
If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you |
need to change the order the pixels are packed into bytes, you can use: |
if (bit_depth < 8) |
png_set_packswap(png_ptr); |
Finally, you can write your own transformation function if none of |
the existing ones meets your needs. This is done by setting a callback |
with |
png_set_read_user_transform_fn(png_ptr, |
read_transform_fn); |
You must supply the function |
void read_transform_fn(png_structp png_ptr, row_info_ptr |
row_info, png_bytep data) |
See pngtest.c for a working example. Your function will be called |
after all of the other transformations have been processed. Take care with |
interlaced images if you do the interlace yourself - the width of the row is the |
width in 'row_info', not the overall image width. |
If supported libpng provides two information routines that you can use to find |
where you are in processing the image: |
png_get_current_pass_number(png_structp png_ptr); |
png_get_current_row_number(png_structp png_ptr); |
Don't try using these outside a transform callback - firstly they are only |
supported if user transforms are supported, secondly they may well return |
unexpected results unless the row is actually being processed at the moment they |
are called. |
You can also set up a pointer to a user structure for use by your |
callback function, and you can inform libpng that your transform |
function will change the number of channels or bit depth with the |
function |
png_set_user_transform_info(png_ptr, user_ptr, |
user_depth, user_channels); |
The user's application, not libpng, is responsible for allocating and |
freeing any memory required for the user structure. |
You can retrieve the pointer via the function |
png_get_user_transform_ptr(). For example: |
voidp read_user_transform_ptr = |
png_get_user_transform_ptr(png_ptr); |
The last thing to handle is interlacing; this is covered in detail below, |
but you must call the function here if you want libpng to handle expansion |
of the interlaced image. |
number_of_passes = png_set_interlace_handling(png_ptr); |
After setting the transformations, libpng can update your png_info |
structure to reflect any transformations you've requested with this |
call. This is most useful to update the info structure's rowbytes |
field so you can use it to allocate your image memory. This function |
will also update your palette with the correct screen_gamma and |
background if these have been given with the calls above. |
png_read_update_info(png_ptr, info_ptr); |
After you call png_read_update_info(), you can allocate any |
memory you need to hold the image. The row data is simply |
raw byte data for all forms of images. As the actual allocation |
varies among applications, no example will be given. If you |
are allocating one large chunk, you will need to build an |
array of pointers to each row, as it will be needed for some |
of the functions below. |
Remember: Before you call png_read_update_info(), the png_get_ |
functions return the values corresponding to the original PNG image. |
After you call png_read_update_info the values refer to the image |
that libpng will output. Consequently you must call all the png_set_ |
functions before you call png_read_update_info(). This is particularly |
important for png_set_interlace_handling() - if you are going to call |
png_read_update_info() you must call png_set_interlace_handling() before |
it unless you want to receive interlaced output. |
Reading image data |
After you've allocated memory, you can read the image data. |
The simplest way to do this is in one function call. If you are |
allocating enough memory to hold the whole image, you can just |
call png_read_image() and libpng will read in all the image data |
and put it in the memory area supplied. You will need to pass in |
an array of pointers to each row. |
This function automatically handles interlacing, so you don't |
need to call png_set_interlace_handling() (unless you call |
png_read_update_info()) or call this function multiple times, or any |
of that other stuff necessary with png_read_rows(). |
png_read_image(png_ptr, row_pointers); |
where row_pointers is: |
png_bytep row_pointers[height]; |
You can point to void or char or whatever you use for pixels. |
If you don't want to read in the whole image at once, you can |
use png_read_rows() instead. If there is no interlacing (check |
interlace_type == PNG_INTERLACE_NONE), this is simple: |
png_read_rows(png_ptr, row_pointers, NULL, |
number_of_rows); |
where row_pointers is the same as in the png_read_image() call. |
If you are doing this just one row at a time, you can do this with |
a single row_pointer instead of an array of row_pointers: |
png_bytep row_pointer = row; |
png_read_row(png_ptr, row_pointer, NULL); |
If the file is interlaced (interlace_type != 0 in the IHDR chunk), things |
get somewhat harder. The only current (PNG Specification version 1.2) |
interlacing type for PNG is (interlace_type == PNG_INTERLACE_ADAM7); |
a somewhat complicated 2D interlace scheme, known as Adam7, that |
breaks down an image into seven smaller images of varying size, based |
on an 8x8 grid. This number is defined (from libpng 1.5) as |
PNG_INTERLACE_ADAM7_PASSES in png.h |
libpng can fill out those images or it can give them to you "as is". |
It is almost always better to have libpng handle the interlacing for you. |
If you want the images filled out, there are two ways to do that. The one |
mentioned in the PNG specification is to expand each pixel to cover |
those pixels that have not been read yet (the "rectangle" method). |
This results in a blocky image for the first pass, which gradually |
smooths out as more pixels are read. The other method is the "sparkle" |
method, where pixels are drawn only in their final locations, with the |
rest of the image remaining whatever colors they were initialized to |
before the start of the read. The first method usually looks better, |
but tends to be slower, as there are more pixels to put in the rows. |
If, as is likely, you want libpng to expand the images, call this before |
calling png_start_read_image() or png_read_update_info(): |
if (interlace_type == PNG_INTERLACE_ADAM7) |
number_of_passes |
= png_set_interlace_handling(png_ptr); |
This will return the number of passes needed. Currently, this is seven, |
but may change if another interlace type is added. This function can be |
called even if the file is not interlaced, where it will return one pass. |
You then need to read the whole image 'number_of_passes' times. Each time |
will distribute the pixels from the current pass to the correct place in |
the output image, so you need to supply the same rows to png_read_rows in |
each pass. |
If you are not going to display the image after each pass, but are |
going to wait until the entire image is read in, use the sparkle |
effect. This effect is faster and the end result of either method |
is exactly the same. If you are planning on displaying the image |
after each pass, the "rectangle" effect is generally considered the |
better looking one. |
If you only want the "sparkle" effect, just call png_read_rows() as |
normal, with the third parameter NULL. Make sure you make pass over |
the image number_of_passes times, and you don't change the data in the |
rows between calls. You can change the locations of the data, just |
not the data. Each pass only writes the pixels appropriate for that |
pass, and assumes the data from previous passes is still valid. |
png_read_rows(png_ptr, row_pointers, NULL, |
number_of_rows); |
If you only want the first effect (the rectangles), do the same as |
before except pass the row buffer in the third parameter, and leave |
the second parameter NULL. |
png_read_rows(png_ptr, NULL, row_pointers, |
number_of_rows); |
If you don't want libpng to handle the interlacing details, just call |
png_read_rows() PNG_INTERLACE_ADAM7_PASSES times to read in all the images. |
Each of the images is a valid image by itself, however you will almost |
certainly need to distribute the pixels from each sub-image to the |
correct place. This is where everything gets very tricky. |
If you want to retrieve the separate images you must pass the correct |
number of rows to each successive call of png_read_rows(). The calculation |
gets pretty complicated for small images, where some sub-images may |
not even exist because either their width or height ends up zero. |
libpng provides two macros to help you in 1.5 and later versions: |
png_uint_32 width = PNG_PASS_COLS(image_width, pass_number); |
png_uint_32 height = PNG_PASS_ROWS(image_height, pass_number); |
Respectively these tell you the width and height of the sub-image |
corresponding to the numbered pass. 'pass' is in in the range 0 to 6 - |
this can be confusing because the specification refers to the same passes |
as 1 to 7! Be careful, you must check both the width and height before |
calling png_read_rows() and not call it for that pass if either is zero. |
You can, of course, read each sub-image row by row. If you want to |
produce optimal code to make a pixel-by-pixel transformation of an |
interlaced image this is the best approach; read each row of each pass, |
transform it, and write it out to a new interlaced image. |
If you want to de-interlace the image yourself libpng provides further |
macros to help that tell you where to place the pixels in the output image. |
Because the interlacing scheme is rectangular - sub-image pixels are always |
arranged on a rectangular grid - all you need to know for each pass is the |
starting column and row in the output image of the first pixel plus the |
spacing between each pixel. As of libpng 1.5 there are four macros to |
retrieve this information: |
png_uint_32 x = PNG_PASS_START_COL(pass); |
png_uint_32 y = PNG_PASS_START_ROW(pass); |
png_uint_32 xStep = 1U << PNG_PASS_COL_SHIFT(pass); |
png_uint_32 yStep = 1U << PNG_PASS_ROW_SHIFT(pass); |
These allow you to write the obvious loop: |
png_uint_32 input_y = 0; |
png_uint_32 output_y = PNG_PASS_START_ROW(pass); |
while (output_y < output_image_height) |
{ |
png_uint_32 input_x = 0; |
png_uint_32 output_x = PNG_PASS_START_COL(pass); |
while (output_x < output_image_width) |
{ |
image[output_y][output_x] = |
subimage[pass][input_y][input_x++]; |
output_x += xStep; |
} |
++input_y; |
output_y += yStep; |
} |
Notice that the steps between successive output rows and columns are |
returned as shifts. This is possible because the pixels in the subimages |
are always a power of 2 apart - 1, 2, 4 or 8 pixels - in the original |
image. In practice you may need to directly calculate the output coordinate |
given an input coordinate. libpng provides two further macros for this |
purpose: |
png_uint_32 output_x = PNG_COL_FROM_PASS_COL(input_x, pass); |
png_uint_32 output_y = PNG_ROW_FROM_PASS_ROW(input_y, pass); |
Finally a pair of macros are provided to tell you if a particular image |
row or column appears in a given pass: |
int col_in_pass = PNG_COL_IN_INTERLACE_PASS(output_x, pass); |
int row_in_pass = PNG_ROW_IN_INTERLACE_PASS(output_y, pass); |
Bear in mind that you will probably also need to check the width and height |
of the pass in addition to the above to be sure the pass even exists! |
With any luck you are convinced by now that you don't want to do your own |
interlace handling. In reality normally the only good reason for doing this |
is if you are processing PNG files on a pixel-by-pixel basis and don't want |
to load the whole file into memory when it is interlaced. |
libpng includes a test program, pngvalid, that illustrates reading and |
writing of interlaced images. If you can't get interlacing to work in your |
code and don't want to leave it to libpng (the recommended approach) see |
how pngvalid.c does it. |
Finishing a sequential read |
After you are finished reading the image through the |
low-level interface, you can finish reading the file. If you are |
interested in comments or time, which may be stored either before or |
after the image data, you should pass the separate png_info struct if |
you want to keep the comments from before and after the image |
separate. If you are not interested, you can pass NULL. |
png_read_end(png_ptr, end_info); |
When you are done, you can free all memory allocated by libpng like this: |
png_destroy_read_struct(&png_ptr, &info_ptr, |
&end_info); |
It is also possible to individually free the info_ptr members that |
point to libpng-allocated storage with the following function: |
png_free_data(png_ptr, info_ptr, mask, seq) |
mask - identifies data to be freed, a mask |
containing the bitwise OR of one or |
more of |
PNG_FREE_PLTE, PNG_FREE_TRNS, |
PNG_FREE_HIST, PNG_FREE_ICCP, |
PNG_FREE_PCAL, PNG_FREE_ROWS, |
PNG_FREE_SCAL, PNG_FREE_SPLT, |
PNG_FREE_TEXT, PNG_FREE_UNKN, |
or simply PNG_FREE_ALL |
seq - sequence number of item to be freed |
(-1 for all items) |
This function may be safely called when the relevant storage has |
already been freed, or has not yet been allocated, or was allocated |
by the user and not by libpng, and will in those cases do nothing. |
The "seq" parameter is ignored if only one item of the selected data |
type, such as PLTE, is allowed. If "seq" is not -1, and multiple items |
are allowed for the data type identified in the mask, such as text or |
sPLT, only the n'th item in the structure is freed, where n is "seq". |
The default behavior is only to free data that was allocated internally |
by libpng. This can be changed, so that libpng will not free the data, |
or so that it will free data that was allocated by the user with png_malloc() |
or png_zalloc() and passed in via a png_set_*() function, with |
png_data_freer(png_ptr, info_ptr, freer, mask) |
freer - one of |
PNG_DESTROY_WILL_FREE_DATA |
PNG_SET_WILL_FREE_DATA |
PNG_USER_WILL_FREE_DATA |
mask - which data elements are affected |
same choices as in png_free_data() |
This function only affects data that has already been allocated. |
You can call this function after reading the PNG data but before calling |
any png_set_*() functions, to control whether the user or the png_set_*() |
function is responsible for freeing any existing data that might be present, |
and again after the png_set_*() functions to control whether the user |
or png_destroy_*() is supposed to free the data. When the user assumes |
responsibility for libpng-allocated data, the application must use |
png_free() to free it, and when the user transfers responsibility to libpng |
for data that the user has allocated, the user must have used png_malloc() |
or png_zalloc() to allocate it. |
If you allocated your row_pointers in a single block, as suggested above in |
the description of the high level read interface, you must not transfer |
responsibility for freeing it to the png_set_rows or png_read_destroy function, |
because they would also try to free the individual row_pointers[i]. |
If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword |
separately, do not transfer responsibility for freeing text_ptr to libpng, |
because when libpng fills a png_text structure it combines these members with |
the key member, and png_free_data() will free only text_ptr.key. Similarly, |
if you transfer responsibility for free'ing text_ptr from libpng to your |
application, your application must not separately free those members. |
The png_free_data() function will turn off the "valid" flag for anything |
it frees. If you need to turn the flag off for a chunk that was freed by |
your application instead of by libpng, you can use |
png_set_invalid(png_ptr, info_ptr, mask); |
mask - identifies the chunks to be made invalid, |
containing the bitwise OR of one or |
more of |
PNG_INFO_gAMA, PNG_INFO_sBIT, |
PNG_INFO_cHRM, PNG_INFO_PLTE, |
PNG_INFO_tRNS, PNG_INFO_bKGD, |
PNG_INFO_hIST, PNG_INFO_pHYs, |
PNG_INFO_oFFs, PNG_INFO_tIME, |
PNG_INFO_pCAL, PNG_INFO_sRGB, |
PNG_INFO_iCCP, PNG_INFO_sPLT, |
PNG_INFO_sCAL, PNG_INFO_IDAT |
For a more compact example of reading a PNG image, see the file example.c. |
Reading PNG files progressively |
The progressive reader is slightly different then the non-progressive |
reader. Instead of calling png_read_info(), png_read_rows(), and |
png_read_end(), you make one call to png_process_data(), which calls |
callbacks when it has the info, a row, or the end of the image. You |
set up these callbacks with png_set_progressive_read_fn(). You don't |
have to worry about the input/output functions of libpng, as you are |
giving the library the data directly in png_process_data(). I will |
assume that you have read the section on reading PNG files above, |
so I will only highlight the differences (although I will show |
all of the code). |
png_structp png_ptr; |
png_infop info_ptr; |
/* An example code fragment of how you would |
initialize the progressive reader in your |
application. */ |
int |
initialize_png_reader() |
{ |
png_ptr = png_create_read_struct |
(PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, |
user_error_fn, user_warning_fn); |
if (!png_ptr) |
return (ERROR); |
info_ptr = png_create_info_struct(png_ptr); |
if (!info_ptr) |
{ |
png_destroy_read_struct(&png_ptr, |
(png_infopp)NULL, (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 can provide functions |
to be called when the header info is valid, |
when each row is completed, and when the image |
is finished. 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(). You can use |
any struct as the user_ptr (cast to a void pointer |
for the function call), and retrieve the pointer |
from inside the callbacks using the function |
png_get_progressive_ptr(png_ptr); |
which will return a void pointer, which you have |
to cast appropriately. |
*/ |
png_set_progressive_read_fn(png_ptr, (void *)user_ptr, |
info_callback, row_callback, end_callback); |
return 0; |
} |
/* A code fragment that you call as you receive blocks |
of data */ |
int |
process_data(png_bytep buffer, png_uint_32 length) |
{ |
if (setjmp(png_jmpbuf(png_ptr))) |
{ |
png_destroy_read_struct(&png_ptr, &info_ptr, |
(png_infopp)NULL); |
return (ERROR); |
} |
/* This one's new also. Simply give it a chunk |
of data from the file stream (in order, of |
course). On machines with segmented memory |
models 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, I haven't tried less then 256 bytes |
yet). When this function returns, you may |
want to display any rows that were generated |
in the row callback if you don't already do |
so there. |
*/ |
png_process_data(png_ptr, info_ptr, buffer, length); |
/* At this point you can call png_process_data_skip if |
you want to handle data the library will skip yourself; |
it simply returns the number of bytes to skip (and stops |
libpng skipping that number of bytes on the next |
png_process_data call). |
return 0; |
} |
/* This function is called (as set by |
png_set_progressive_read_fn() above) when enough data |
has been supplied so all of the header has been |
read. |
*/ |
void |
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. |
This is where you turn on interlace handling, |
assuming you don't want to do it yourself. |
If you need to you can stop the processing of |
your original input data at this point by calling |
png_process_data_pause. This returns the number |
of unprocessed bytes from the last png_process_data |
call - it is up to you to ensure that the next call |
sees these bytes again. If you don't want to bother |
with this you can get libpng to cache the unread |
bytes by setting the 'save' parameter (see png.h) but |
then libpng will have to copy the data internally. |
*/ |
} |
/* This function is called when each row of image |
data is complete */ |
void |
row_callback(png_structp png_ptr, png_bytep new_row, |
png_uint_32 row_num, int pass) |
{ |
/* If the image is interlaced, and you turned |
on the interlace handler, this function will |
be called for every row in every pass. Some |
of these rows will not be changed from the |
previous pass. When the row is not changed, |
the new_row variable will be NULL. 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. |
If you did not turn on interlace handling then |
the callback is called for each row of each |
sub-image when the image is interlaced. In this |
case 'row_num' is the row in the sub-image, not |
the row in the output image as it is in all other |
cases. |
For the non-NULL rows of interlaced images when |
you have switched on libpng interlace handling, |
you must call png_progressive_combine_row() |
passing in the row and the old row. You can |
call this function for NULL rows (it will just |
return) and for non-interlaced images (it just |
does the memcpy for you) if it will make the |
code easier. Thus, you can just do this for |
all cases if you switch on interlace handling; |
*/ |
png_progressive_combine_row(png_ptr, old_row, |
new_row); |
/* where old_row is what was displayed for |
previously for the row. 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, and the function will combine |
the old row and the new row. |
You can also call png_process_data_pause in this |
callback - see above. |
*/ |
} |
void |
end_callback(png_structp png_ptr, png_infop info) |
{ |
/* This function is called after 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. |
*/ |
} |
IV. Writing |
Much of this is very similar to reading. However, everything of |
importance is repeated here, so you won't have to constantly look |
back up in the reading section to understand writing. |
Setup |
You will want to do the I/O initialization before you get into libpng, |
so if it doesn't work, you don't have anything to undo. If you are not |
using the standard I/O functions, you will need to replace them with |
custom writing functions. See the discussion under Customizing libpng. |
FILE *fp = fopen(file_name, "wb"); |
if (!fp) |
return (ERROR); |
Next, png_struct and png_info need to be allocated and initialized. |
As these can be both relatively large, you may not want to store these |
on the stack, unless you have stack space to spare. Of course, you |
will want to check if they return NULL. If you are also reading, |
you won't want to name your read structure and your write structure |
both "png_ptr"; you can call them anything you like, such as |
"read_ptr" and "write_ptr". Look at pngtest.c, for example. |
png_structp png_ptr = png_create_write_struct |
(PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, |
user_error_fn, user_warning_fn); |
if (!png_ptr) |
return (ERROR); |
png_infop info_ptr = png_create_info_struct(png_ptr); |
if (!info_ptr) |
{ |
png_destroy_write_struct(&png_ptr, |
(png_infopp)NULL); |
return (ERROR); |
} |
If you want to use your own memory allocation routines, |
define PNG_USER_MEM_SUPPORTED and use |
png_create_write_struct_2() instead of png_create_write_struct(): |
png_structp png_ptr = png_create_write_struct_2 |
(PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, |
user_error_fn, user_warning_fn, (png_voidp) |
user_mem_ptr, user_malloc_fn, user_free_fn); |
After you have these structures, you will need to set up the |
error handling. When libpng encounters an error, it expects to |
longjmp() back to your routine. Therefore, you will need to call |
setjmp() and pass the png_jmpbuf(png_ptr). If you |
write the file from different routines, you will need to update |
the png_jmpbuf(png_ptr) every time you enter a new routine that will |
call a png_*() function. See your documentation of setjmp/longjmp |
for your compiler for more information on setjmp/longjmp. See |
the discussion on libpng error handling in the Customizing Libpng |
section below for more information on the libpng error handling. |
if (setjmp(png_jmpbuf(png_ptr))) |
{ |
png_destroy_write_struct(&png_ptr, &info_ptr); |
fclose(fp); |
return (ERROR); |
} |
... |
return; |
If you would rather avoid the complexity of setjmp/longjmp issues, |
you can compile libpng with PNG_NO_SETJMP, in which case |
errors will result in a call to PNG_ABORT() which defaults to abort(). |
You can #define PNG_ABORT() to a function that does something |
more useful than abort(), as long as your function does not |
return. |
Now you need to set up the output code. The default for libpng is to |
use the C function fwrite(). If you use this, you will need to pass a |
valid FILE * in the function png_init_io(). Be sure that the file is |
opened in binary mode. Again, if you wish to handle writing data in |
another way, see the discussion on libpng I/O handling in the Customizing |
Libpng section below. |
png_init_io(png_ptr, fp); |
If you are embedding your PNG into a datastream such as MNG, and don't |
want libpng to write the 8-byte signature, or if you have already |
written the signature in your application, use |
png_set_sig_bytes(png_ptr, 8); |
to inform libpng that it should not write a signature. |
Write callbacks |
At this point, you can set up a callback function that will be |
called after each row has been written, which you can use to control |
a progress meter or the like. It's demonstrated in pngtest.c. |
You must supply a function |
void write_row_callback(png_structp png_ptr, png_uint_32 row, |
int pass); |
{ |
/* put your code here */ |
} |
(You can give it another name that you like instead of "write_row_callback") |
To inform libpng about your function, use |
png_set_write_status_fn(png_ptr, write_row_callback); |
You now have the option of modifying how the compression library will |
run. The following functions are mainly for testing, but may be useful |
in some cases, like if you need to write PNG files extremely fast and |
are willing to give up some compression, or if you want to get the |
maximum possible compression at the expense of slower writing. If you |
have no special needs in this area, let the library do what it wants by |
not calling this function at all, as it has been tuned to deliver a good |
speed/compression ratio. The second parameter to png_set_filter() is |
the filter method, for which the only valid values are 0 (as of the |
July 1999 PNG specification, version 1.2) or 64 (if you are writing |
a PNG datastream that is to be embedded in a MNG datastream). The third |
parameter is a flag that indicates which filter type(s) are to be tested |
for each scanline. See the PNG specification for details on the specific |
filter types. |
/* turn on or off filtering, and/or choose |
specific filters. You can use either a single |
PNG_FILTER_VALUE_NAME or the bitwise OR of one |
or more PNG_FILTER_NAME masks. |
*/ |
png_set_filter(png_ptr, 0, |
PNG_FILTER_NONE | PNG_FILTER_VALUE_NONE | |
PNG_FILTER_SUB | PNG_FILTER_VALUE_SUB | |
PNG_FILTER_UP | PNG_FILTER_VALUE_UP | |
PNG_FILTER_AVG | PNG_FILTER_VALUE_AVG | |
PNG_FILTER_PAETH | PNG_FILTER_VALUE_PAETH| |
PNG_ALL_FILTERS); |
If an application wants to start and stop using particular filters during |
compression, it should start out with all of the filters (to ensure that |
the previous row of pixels will be stored in case it's needed later), |
and then add and remove them after the start of compression. |
If you are writing a PNG datastream that is to be embedded in a MNG |
datastream, the second parameter can be either 0 or 64. |
The png_set_compression_*() functions interface to the zlib compression |
library, and should mostly be ignored unless you really know what you are |
doing. The only generally useful call is png_set_compression_level() |
which changes how much time zlib spends on trying to compress the image |
data. See the Compression Library (zlib.h and algorithm.txt, distributed |
with zlib) for details on the compression levels. |
/* set the zlib compression level */ |
png_set_compression_level(png_ptr, |
Z_BEST_COMPRESSION); |
/* set other zlib parameters */ |
png_set_compression_mem_level(png_ptr, 8); |
png_set_compression_strategy(png_ptr, |
Z_DEFAULT_STRATEGY); |
png_set_compression_window_bits(png_ptr, 15); |
png_set_compression_method(png_ptr, 8); |
png_set_compression_buffer_size(png_ptr, 8192) |
extern PNG_EXPORT(void,png_set_zbuf_size) |
Setting the contents of info for output |
You now need to fill in the png_info structure with all the data you |
wish to write before the actual image. Note that the only thing you |
are allowed to write after the image is the text chunks and the time |
chunk (as of PNG Specification 1.2, anyway). See png_write_end() and |
the latest PNG specification for more information on that. If you |
wish to write them before the image, fill them in now, and flag that |
data as being valid. If you want to wait until after the data, don't |
fill them until png_write_end(). For all the fields in png_info and |
their data types, see png.h. For explanations of what the fields |
contain, see the PNG specification. |
Some of the more important parts of the png_info are: |
png_set_IHDR(png_ptr, info_ptr, width, height, |
bit_depth, color_type, interlace_type, |
compression_type, filter_method) |
width - holds the width of the image |
in pixels (up to 2^31). |
height - holds the height of the image |
in pixels (up to 2^31). |
bit_depth - holds the bit depth of one of the |
image channels. |
(valid values are 1, 2, 4, 8, 16 |
and depend also on the |
color_type. See also significant |
bits (sBIT) below). |
color_type - describes which color/alpha |
channels are present. |
PNG_COLOR_TYPE_GRAY |
(bit depths 1, 2, 4, 8, 16) |
PNG_COLOR_TYPE_GRAY_ALPHA |
(bit depths 8, 16) |
PNG_COLOR_TYPE_PALETTE |
(bit depths 1, 2, 4, 8) |
PNG_COLOR_TYPE_RGB |
(bit_depths 8, 16) |
PNG_COLOR_TYPE_RGB_ALPHA |
(bit_depths 8, 16) |
PNG_COLOR_MASK_PALETTE |
PNG_COLOR_MASK_COLOR |
PNG_COLOR_MASK_ALPHA |
interlace_type - PNG_INTERLACE_NONE or |
PNG_INTERLACE_ADAM7 |
compression_type - (must be |
PNG_COMPRESSION_TYPE_DEFAULT) |
filter_method - (must be PNG_FILTER_TYPE_DEFAULT |
or, if you are writing a PNG to |
be embedded in a MNG datastream, |
can also be |
PNG_INTRAPIXEL_DIFFERENCING) |
If you call png_set_IHDR(), the call must appear before any of the |
other png_set_*() functions, because they might require access to some of |
the IHDR settings. The remaining png_set_*() functions can be called |
in any order. |
If you wish, you can reset the compression_type, interlace_type, or |
filter_method later by calling png_set_IHDR() again; if you do this, the |
width, height, bit_depth, and color_type must be the same in each call. |
png_set_PLTE(png_ptr, info_ptr, palette, |
num_palette); |
palette - the palette for the file |
(array of png_color) |
num_palette - number of entries in the palette |
png_set_gAMA(png_ptr, info_ptr, file_gamma); |
png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma); |
file_gamma - the gamma at which the image was |
created (PNG_INFO_gAMA) |
int_file_gamma - 100,000 times the gamma at which |
the image was created |
png_set_sRGB(png_ptr, info_ptr, srgb_intent); |
srgb_intent - the rendering intent |
(PNG_INFO_sRGB) The presence of |
the sRGB chunk means that the pixel |
data is in the sRGB color space. |
This chunk also implies specific |
values of gAMA and cHRM. Rendering |
intent is the CSS-1 property that |
has been defined by the International |
Color Consortium |
(http://www.color.org). |
It can be one of |
PNG_sRGB_INTENT_SATURATION, |
PNG_sRGB_INTENT_PERCEPTUAL, |
PNG_sRGB_INTENT_ABSOLUTE, or |
PNG_sRGB_INTENT_RELATIVE. |
png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, |
srgb_intent); |
srgb_intent - the rendering intent |
(PNG_INFO_sRGB) The presence of the |
sRGB chunk means that the pixel |
data is in the sRGB color space. |
This function also causes gAMA and |
cHRM chunks with the specific values |
that are consistent with sRGB to be |
written. |
png_set_iCCP(png_ptr, info_ptr, name, compression_type, |
profile, proflen); |
name - The profile name. |
compression_type - The compression type; always |
PNG_COMPRESSION_TYPE_BASE for PNG 1.0. |
You may give NULL to this argument to |
ignore it. |
profile - International Color Consortium color |
profile data. May contain NULs. |
proflen - length of profile data in bytes. |
png_set_sBIT(png_ptr, info_ptr, sig_bit); |
sig_bit - the number of significant bits for |
(PNG_INFO_sBIT) each of the gray, red, |
green, and blue channels, whichever are |
appropriate for the given color type |
(png_color_16) |
png_set_tRNS(png_ptr, info_ptr, trans_alpha, |
num_trans, trans_color); |
trans_alpha - array of alpha (transparency) |
entries for palette (PNG_INFO_tRNS) |
trans_color - graylevel or color sample values |
(in order red, green, blue) of the |
single transparent color for |
non-paletted images (PNG_INFO_tRNS) |
num_trans - number of transparent entries |
(PNG_INFO_tRNS) |
png_set_hIST(png_ptr, info_ptr, hist); |
hist - histogram of palette (array of |
png_uint_16) (PNG_INFO_hIST) |
png_set_tIME(png_ptr, info_ptr, mod_time); |
mod_time - time image was last modified |
(PNG_VALID_tIME) |
png_set_bKGD(png_ptr, info_ptr, background); |
background - background color (PNG_VALID_bKGD) |
png_set_text(png_ptr, info_ptr, text_ptr, num_text); |
text_ptr - array of png_text holding image |
comments |
text_ptr[i].compression - type of compression used |
on "text" PNG_TEXT_COMPRESSION_NONE |
PNG_TEXT_COMPRESSION_zTXt |
PNG_ITXT_COMPRESSION_NONE |
PNG_ITXT_COMPRESSION_zTXt |
text_ptr[i].key - keyword for comment. Must contain |
1-79 characters. |
text_ptr[i].text - text comments for current |
keyword. Can be NULL or empty. |
text_ptr[i].text_length - length of text string, |
after decompression, 0 for iTXt |
text_ptr[i].itxt_length - length of itxt string, |
after decompression, 0 for tEXt/zTXt |
text_ptr[i].lang - language of comment (NULL or |
empty for unknown). |
text_ptr[i].translated_keyword - keyword in UTF-8 (NULL |
or empty for unknown). |
Note that the itxt_length, lang, and lang_key |
members of the text_ptr structure only exist |
when the library is built with iTXt chunk support. |
num_text - number of comments |
png_set_sPLT(png_ptr, info_ptr, &palette_ptr, |
num_spalettes); |
palette_ptr - array of png_sPLT_struct structures |
to be added to the list of palettes |
in the info structure. |
num_spalettes - number of palette structures to be |
added. |
png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, |
unit_type); |
offset_x - positive offset from the left |
edge of the screen |
offset_y - positive offset from the top |
edge of the screen |
unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER |
png_set_pHYs(png_ptr, info_ptr, res_x, res_y, |
unit_type); |
res_x - pixels/unit physical resolution |
in x direction |
res_y - pixels/unit physical resolution |
in y direction |
unit_type - PNG_RESOLUTION_UNKNOWN, |
PNG_RESOLUTION_METER |
png_set_sCAL(png_ptr, info_ptr, unit, width, height) |
unit - physical scale units (an integer) |
width - width of a pixel in physical scale units |
height - height of a pixel in physical scale units |
(width and height are doubles) |
png_set_sCAL_s(png_ptr, info_ptr, unit, width, height) |
unit - physical scale units (an integer) |
width - width of a pixel in physical scale units |
height - height of a pixel in physical scale units |
(width and height are strings like "2.54") |
png_set_unknown_chunks(png_ptr, info_ptr, &unknowns, |
num_unknowns) |
unknowns - array of png_unknown_chunk |
structures holding unknown chunks |
unknowns[i].name - name of unknown chunk |
unknowns[i].data - data of unknown chunk |
unknowns[i].size - size of unknown chunk's data |
unknowns[i].location - position to write chunk in file |
0: do not write chunk |
PNG_HAVE_IHDR: before PLTE |
PNG_HAVE_PLTE: before IDAT |
PNG_AFTER_IDAT: after IDAT |
The "location" member is set automatically according to |
what part of the output file has already been written. |
You can change its value after calling png_set_unknown_chunks() |
as demonstrated in pngtest.c. Within each of the "locations", |
the chunks are sequenced according to their position in the |
structure (that is, the value of "i", which is the order in which |
the chunk was either read from the input file or defined with |
png_set_unknown_chunks). |
A quick word about text and num_text. text is an array of png_text |
structures. num_text is the number of valid structures in the array. |
Each png_text structure holds a language code, a keyword, a text value, |
and a compression type. |
The compression types have the same valid numbers as the compression |
types of the image data. Currently, the only valid number is zero. |
However, you can store text either compressed or uncompressed, unlike |
images, which always have to be compressed. So if you don't want the |
text compressed, set the compression type to PNG_TEXT_COMPRESSION_NONE. |
Because tEXt and zTXt chunks don't have a language field, if you |
specify PNG_TEXT_COMPRESSION_NONE or PNG_TEXT_COMPRESSION_zTXt |
any language code or translated keyword will not be written out. |
Until text gets around 1000 bytes, it is not worth compressing it. |
After the text has been written out to the file, the compression type |
is set to PNG_TEXT_COMPRESSION_NONE_WR or PNG_TEXT_COMPRESSION_zTXt_WR, |
so that it isn't written out again at the end (in case you are calling |
png_write_end() with the same struct). |
The keywords that are given in the PNG Specification are: |
Title Short (one line) title or |
caption for image |
Author Name of image's creator |
Description Description of image (possibly long) |
Copyright Copyright notice |
Creation Time Time of original image creation |
(usually RFC 1123 format, see below) |
Software Software used to create the image |
Disclaimer Legal disclaimer |
Warning Warning of nature of content |
Source Device used to create the image |
Comment Miscellaneous comment; conversion |
from other image format |
The keyword-text pairs work like this. Keywords should be short |
simple descriptions of what the comment is about. Some typical |
keywords are found in the PNG specification, as is some recommendations |
on keywords. You can repeat keywords in a file. You can even write |
some text before the image and some after. For example, you may want |
to put a description of the image before the image, but leave the |
disclaimer until after, so viewers working over modem connections |
don't have to wait for the disclaimer to go over the modem before |
they start seeing the image. Finally, keywords should be full |
words, not abbreviations. Keywords and text are in the ISO 8859-1 |
(Latin-1) character set (a superset of regular ASCII) and can not |
contain NUL characters, and should not contain control or other |
unprintable characters. To make the comments widely readable, stick |
with basic ASCII, and avoid machine specific character set extensions |
like the IBM-PC character set. The keyword must be present, but |
you can leave off the text string on non-compressed pairs. |
Compressed pairs must have a text string, as only the text string |
is compressed anyway, so the compression would be meaningless. |
PNG supports modification time via the png_time structure. Two |
conversion routines are provided, png_convert_from_time_t() for |
time_t and png_convert_from_struct_tm() for struct tm. The |
time_t routine uses gmtime(). You don't have to use either of |
these, but if you wish to fill in the png_time structure directly, |
you should provide the time in universal time (GMT) if possible |
instead of your local time. Note that the year number is the full |
year (e.g. 1998, rather than 98 - PNG is year 2000 compliant!), and |
that months start with 1. |
If you want to store the time of the original image creation, you should |
use a plain tEXt chunk with the "Creation Time" keyword. This is |
necessary because the "creation time" of a PNG image is somewhat vague, |
depending on whether you mean the PNG file, the time the image was |
created in a non-PNG format, a still photo from which the image was |
scanned, or possibly the subject matter itself. In order to facilitate |
machine-readable dates, it is recommended that the "Creation Time" |
tEXt chunk use RFC 1123 format dates (e.g. "22 May 1997 18:07:10 GMT"), |
although this isn't a requirement. Unlike the tIME chunk, the |
"Creation Time" tEXt chunk is not expected to be automatically changed |
by the software. To facilitate the use of RFC 1123 dates, a function |
png_convert_to_rfc1123(png_timep) is provided to convert from PNG |
time to an RFC 1123 format string. |
Writing unknown chunks |
You can use the png_set_unknown_chunks function to queue up chunks |
for writing. You give it a chunk name, raw data, and a size; that's |
all there is to it. The chunks will be written by the next following |
png_write_info_before_PLTE, png_write_info, or png_write_end function. |
Any chunks previously read into the info structure's unknown-chunk |
list will also be written out in a sequence that satisfies the PNG |
specification's ordering rules. |
The high-level write interface |
At this point there are two ways to proceed; through the high-level |
write interface, or through a sequence of low-level write operations. |
You can use the high-level interface if your image data is present |
in the info structure. All defined output |
transformations are permitted, enabled by the following masks. |
PNG_TRANSFORM_IDENTITY No transformation |
PNG_TRANSFORM_PACKING Pack 1, 2 and 4-bit samples |
PNG_TRANSFORM_PACKSWAP Change order of packed |
pixels to LSB first |
PNG_TRANSFORM_INVERT_MONO Invert monochrome images |
PNG_TRANSFORM_SHIFT Normalize pixels to the |
sBIT depth |
PNG_TRANSFORM_BGR Flip RGB to BGR, RGBA |
to BGRA |
PNG_TRANSFORM_SWAP_ALPHA Flip RGBA to ARGB or GA |
to AG |
PNG_TRANSFORM_INVERT_ALPHA Change alpha from opacity |
to transparency |
PNG_TRANSFORM_SWAP_ENDIAN Byte-swap 16-bit samples |
PNG_TRANSFORM_STRIP_FILLER Strip out filler |
bytes (deprecated). |
PNG_TRANSFORM_STRIP_FILLER_BEFORE Strip out leading |
filler bytes |
PNG_TRANSFORM_STRIP_FILLER_AFTER Strip out trailing |
filler bytes |
If you have valid image data in the info structure (you can use |
png_set_rows() to put image data in the info structure), simply do this: |
png_write_png(png_ptr, info_ptr, png_transforms, NULL) |
where png_transforms is an integer containing the bitwise OR of some set of |
transformation flags. This call is equivalent to png_write_info(), |
followed the set of transformations indicated by the transform mask, |
then png_write_image(), and finally png_write_end(). |
(The final parameter of this call is not yet used. Someday it might point |
to transformation parameters required by some future output transform.) |
You must use png_transforms and not call any png_set_transform() functions |
when you use png_write_png(). |
The low-level write interface |
If you are going the low-level route instead, you are now ready to |
write all the file information up to the actual image data. You do |
this with a call to png_write_info(). |
png_write_info(png_ptr, info_ptr); |
Note that there is one transformation you may need to do before |
png_write_info(). In PNG files, the alpha channel in an image is the |
level of opacity. If your data is supplied as a level of transparency, |
you can invert the alpha channel before you write it, so that 0 is |
fully transparent and 255 (in 8-bit or paletted images) or 65535 |
(in 16-bit images) is fully opaque, with |
png_set_invert_alpha(png_ptr); |
This must appear before png_write_info() instead of later with the |
other transformations because in the case of paletted images the tRNS |
chunk data has to be inverted before the tRNS chunk is written. If |
your image is not a paletted image, the tRNS data (which in such cases |
represents a single color to be rendered as transparent) won't need to |
be changed, and you can safely do this transformation after your |
png_write_info() call. |
If you need to write a private chunk that you want to appear before |
the PLTE chunk when PLTE is present, you can write the PNG info in |
two steps, and insert code to write your own chunk between them: |
png_write_info_before_PLTE(png_ptr, info_ptr); |
png_set_unknown_chunks(png_ptr, info_ptr, ...); |
png_write_info(png_ptr, info_ptr); |
After you've written the file information, you can set up the library |
to handle any special transformations of the image data. The various |
ways to transform the data will be described in the order that they |
should occur. This is important, as some of these change the color |
type and/or bit depth of the data, and some others only work on |
certain color types and bit depths. Even though each transformation |
checks to see if it has data that it can do something with, you should |
make sure to only enable a transformation if it will be valid for the |
data. For example, don't swap red and blue on grayscale data. |
PNG files store RGB pixels packed into 3 or 6 bytes. This code tells |
the library to strip input data that has 4 or 8 bytes per pixel down |
to 3 or 6 bytes (or strip 2 or 4-byte grayscale+filler data to 1 or 2 |
bytes per pixel). |
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); |
where the 0 is unused, and the location is either PNG_FILLER_BEFORE or |
PNG_FILLER_AFTER, depending upon whether the filler byte in the pixel |
is stored XRGB or RGBX. |
PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as |
they can, resulting in, for example, 8 pixels per byte for 1 bit files. |
If the data is supplied at 1 pixel per byte, use this code, which will |
correctly pack the pixels into a single byte: |
png_set_packing(png_ptr); |
PNG files reduce possible bit depths to 1, 2, 4, 8, and 16. If your |
data is of another bit depth, you can write an sBIT chunk into the |
file so that decoders can recover the original data if desired. |
/* Set the true bit depth of the image data */ |
if (color_type & PNG_COLOR_MASK_COLOR) |
{ |
sig_bit.red = true_bit_depth; |
sig_bit.green = true_bit_depth; |
sig_bit.blue = true_bit_depth; |
} |
else |
{ |
sig_bit.gray = true_bit_depth; |
} |
if (color_type & PNG_COLOR_MASK_ALPHA) |
{ |
sig_bit.alpha = true_bit_depth; |
} |
png_set_sBIT(png_ptr, info_ptr, &sig_bit); |
If the data is stored in the row buffer in a bit depth other than |
one supported by PNG (e.g. 3 bit data in the range 0-7 for a 4-bit PNG), |
this will scale the values to appear to be the correct bit depth as |
is required by PNG. |
png_set_shift(png_ptr, &sig_bit); |
PNG files store 16 bit pixels in network byte order (big-endian, |
ie. most significant bits first). This code would be used if they are |
supplied the other way (little-endian, i.e. least significant bits |
first, the way PCs store them): |
if (bit_depth > 8) |
png_set_swap(png_ptr); |
If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you |
need to change the order the pixels are packed into bytes, you can use: |
if (bit_depth < 8) |
png_set_packswap(png_ptr); |
PNG files store 3 color pixels in red, green, blue order. This code |
would be used if they are supplied as blue, green, red: |
png_set_bgr(png_ptr); |
PNG files describe monochrome as black being zero and white being |
one. This code would be used if the pixels are supplied with this reversed |
(black being one and white being zero): |
png_set_invert_mono(png_ptr); |
Finally, you can write your own transformation function if none of |
the existing ones meets your needs. This is done by setting a callback |
with |
png_set_write_user_transform_fn(png_ptr, |
write_transform_fn); |
You must supply the function |
void write_transform_fn(png_structp png_ptr ptr, |
row_info_ptr row_info, png_bytep data) |
See pngtest.c for a working example. Your function will be called |
before any of the other transformations are processed. If supported |
libpng also supplies an information routine that may be called from |
your callback: |
png_get_current_row_number(png_ptr); |
This returns the current row passed to the transform. Even with interlaced |
images the value returned is the row in the final output image. |
You can also set up a pointer to a user structure for use by your |
callback function. |
png_set_user_transform_info(png_ptr, user_ptr, 0, 0); |
The user_channels and user_depth parameters of this function are ignored |
when writing; you can set them to zero as shown. |
You can retrieve the pointer via the function png_get_user_transform_ptr(). |
For example: |
voidp write_user_transform_ptr = |
png_get_user_transform_ptr(png_ptr); |
It is possible to have libpng flush any pending output, either manually, |
or automatically after a certain number of lines have been written. To |
flush the output stream a single time call: |
png_write_flush(png_ptr); |
and to have libpng flush the output stream periodically after a certain |
number of scanlines have been written, call: |
png_set_flush(png_ptr, nrows); |
Note that the distance between rows is from the last time png_write_flush() |
was called, or the first row of the image if it has never been called. |
So if you write 50 lines, and then png_set_flush 25, it will flush the |
output on the next scanline, and every 25 lines thereafter, unless |
png_write_flush() is called before 25 more lines have been written. |
If nrows is too small (less than about 10 lines for a 640 pixel wide |
RGB image) the image compression may decrease noticeably (although this |
may be acceptable for real-time applications). Infrequent flushing will |
only degrade the compression performance by a few percent over images |
that do not use flushing. |
Writing the image data |
That's it for the transformations. Now you can write the image data. |
The simplest way to do this is in one function call. If you have the |
whole image in memory, you can just call png_write_image() and libpng |
will write the image. You will need to pass in an array of pointers to |
each row. This function automatically handles interlacing, so you don't |
need to call png_set_interlace_handling() or call this function multiple |
times, or any of that other stuff necessary with png_write_rows(). |
png_write_image(png_ptr, row_pointers); |
where row_pointers is: |
png_byte *row_pointers[height]; |
You can point to void or char or whatever you use for pixels. |
If you don't want to write the whole image at once, you can |
use png_write_rows() instead. If the file is not interlaced, |
this is simple: |
png_write_rows(png_ptr, row_pointers, |
number_of_rows); |
row_pointers is the same as in the png_write_image() call. |
If you are just writing one row at a time, you can do this with |
a single row_pointer instead of an array of row_pointers: |
png_bytep row_pointer = row; |
png_write_row(png_ptr, row_pointer); |
When the file is interlaced, things can get a good deal more complicated. |
The only currently (as of the PNG Specification version 1.2, dated July |
1999) defined interlacing scheme for PNG files is the "Adam7" interlace |
scheme, that breaks down an image into seven smaller images of varying |
size. libpng will build these images for you, or you can do them |
yourself. If you want to build them yourself, see the PNG specification |
for details of which pixels to write when. |
If you don't want libpng to handle the interlacing details, just |
use png_set_interlace_handling() and call png_write_rows() the |
correct number of times to write all the sub-images |
(png_set_interlace_handling() returns the number of sub-images.) |
If you want libpng to build the sub-images, call this before you start |
writing any rows: |
number_of_passes = png_set_interlace_handling(png_ptr); |
This will return the number of passes needed. Currently, this is seven, |
but may change if another interlace type is added. |
Then write the complete image number_of_passes times. |
png_write_rows(png_ptr, row_pointers, number_of_rows); |
Think carefully before you write an interlaced image. Typically code that |
reads such images reads all the image data into memory, uncompressed, before |
doing any processing. Only code that can display an image on the fly can |
take advantage of the interlacing and even then the image has to be exactly |
the correct size for the output device, because scaling an image requires |
adjacent pixels and these are not available until all the passes have been |
read. |
If you do write an interlaced image you will hardly ever need to handle |
the interlacing yourself. Call png_set_interlace_handling() and use the |
approach described above. |
The only time it is conceivable that you will really need to write an |
interlaced image pass-by-pass is when you have read one pass by pass and |
made some pixel-by-pixel transformation to it, as described in the read |
code above. In this case use the PNG_PASS_ROWS and PNG_PASS_COLS macros |
to determine the size of each sub-image in turn and simply write the rows |
you obtained from the read code. |
Finishing a sequential write |
After you are finished writing the image, you should finish writing |
the file. If you are interested in writing comments or time, you should |
pass an appropriately filled png_info pointer. If you are not interested, |
you can pass NULL. |
png_write_end(png_ptr, info_ptr); |
When you are done, you can free all memory used by libpng like this: |
png_destroy_write_struct(&png_ptr, &info_ptr); |
It is also possible to individually free the info_ptr members that |
point to libpng-allocated storage with the following function: |
png_free_data(png_ptr, info_ptr, mask, seq) |
mask - identifies data to be freed, a mask |
containing the bitwise OR of one or |
more of |
PNG_FREE_PLTE, PNG_FREE_TRNS, |
PNG_FREE_HIST, PNG_FREE_ICCP, |
PNG_FREE_PCAL, PNG_FREE_ROWS, |
PNG_FREE_SCAL, PNG_FREE_SPLT, |
PNG_FREE_TEXT, PNG_FREE_UNKN, |
or simply PNG_FREE_ALL |
seq - sequence number of item to be freed |
(-1 for all items) |
This function may be safely called when the relevant storage has |
already been freed, or has not yet been allocated, or was allocated |
by the user and not by libpng, and will in those cases do nothing. |
The "seq" parameter is ignored if only one item of the selected data |
type, such as PLTE, is allowed. If "seq" is not -1, and multiple items |
are allowed for the data type identified in the mask, such as text or |
sPLT, only the n'th item in the structure is freed, where n is "seq". |
If you allocated data such as a palette that you passed in to libpng |
with png_set_*, you must not free it until just before the call to |
png_destroy_write_struct(). |
The default behavior is only to free data that was allocated internally |
by libpng. This can be changed, so that libpng will not free the data, |
or so that it will free data that was allocated by the user with png_malloc() |
or png_zalloc() and passed in via a png_set_*() function, with |
png_data_freer(png_ptr, info_ptr, freer, mask) |
freer - one of |
PNG_DESTROY_WILL_FREE_DATA |
PNG_SET_WILL_FREE_DATA |
PNG_USER_WILL_FREE_DATA |
mask - which data elements are affected |
same choices as in png_free_data() |
For example, to transfer responsibility for some data from a read structure |
to a write structure, you could use |
png_data_freer(read_ptr, read_info_ptr, |
PNG_USER_WILL_FREE_DATA, |
PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST) |
png_data_freer(write_ptr, write_info_ptr, |
PNG_DESTROY_WILL_FREE_DATA, |
PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST) |
thereby briefly reassigning responsibility for freeing to the user but |
immediately afterwards reassigning it once more to the write_destroy |
function. Having done this, it would then be safe to destroy the read |
structure and continue to use the PLTE, tRNS, and hIST data in the write |
structure. |
This function only affects data that has already been allocated. |
You can call this function before calling after the png_set_*() functions |
to control whether the user or png_destroy_*() is supposed to free the data. |
When the user assumes responsibility for libpng-allocated data, the |
application must use |
png_free() to free it, and when the user transfers responsibility to libpng |
for data that the user has allocated, the user must have used png_malloc() |
or png_zalloc() to allocate it. |
If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword |
separately, do not transfer responsibility for freeing text_ptr to libpng, |
because when libpng fills a png_text structure it combines these members with |
the key member, and png_free_data() will free only text_ptr.key. Similarly, |
if you transfer responsibility for free'ing text_ptr from libpng to your |
application, your application must not separately free those members. |
For a more compact example of writing a PNG image, see the file example.c. |
V. Modifying/Customizing libpng: |
There are two issues here. The first is changing how libpng does |
standard things like memory allocation, input/output, and error handling. |
The second deals with more complicated things like adding new chunks, |
adding new transformations, and generally changing how libpng works. |
Both of those are compile-time issues; that is, they are generally |
determined at the time the code is written, and there is rarely a need |
to provide the user with a means of changing them. |
Memory allocation, input/output, and error handling |
All of the memory allocation, input/output, and error handling in libpng |
goes through callbacks that are user-settable. The default routines are |
in pngmem.c, pngrio.c, pngwio.c, and pngerror.c, respectively. To change |
these functions, call the appropriate png_set_*_fn() function. |
Memory allocation is done through the functions png_malloc(), png_calloc(), |
and png_free(). These currently just call the standard C functions. |
png_calloc() calls png_malloc() and then clears the newly |
allocated memory to zero. There is limited support for certain systems |
with segmented memory architectures and the types of pointers declared by |
png.h match this; you will have to use appropriate pointers in your |
application. Since it is |
unlikely that the method of handling memory allocation on a platform |
will change between applications, these functions must be modified in |
the library at compile time. If you prefer to use a different method |
of allocating and freeing data, you can use png_create_read_struct_2() or |
png_create_write_struct_2() to register your own functions as described |
above. These functions also provide a void pointer that can be retrieved |
via |
mem_ptr=png_get_mem_ptr(png_ptr); |
Your replacement memory functions must have prototypes as follows: |
png_voidp malloc_fn(png_structp png_ptr, |
png_alloc_size_t size); |
void free_fn(png_structp png_ptr, png_voidp ptr); |
Your malloc_fn() must return NULL in case of failure. The png_malloc() |
function will normally call png_error() if it receives a NULL from the |
system memory allocator or from your replacement malloc_fn(). |
Your free_fn() will never be called with a NULL ptr, since libpng's |
png_free() checks for NULL before calling free_fn(). |
Input/Output in libpng is done through png_read() and png_write(), |
which currently just call fread() and fwrite(). The FILE * is stored in |
png_struct and is initialized via png_init_io(). If you wish to change |
the method of I/O, the library supplies callbacks that you can set |
through the function png_set_read_fn() and png_set_write_fn() at run |
time, instead of calling the png_init_io() function. These functions |
also provide a void pointer that can be retrieved via the function |
png_get_io_ptr(). For example: |
png_set_read_fn(png_structp read_ptr, |
voidp read_io_ptr, png_rw_ptr read_data_fn) |
png_set_write_fn(png_structp write_ptr, |
voidp write_io_ptr, png_rw_ptr write_data_fn, |
png_flush_ptr output_flush_fn); |
voidp read_io_ptr = png_get_io_ptr(read_ptr); |
voidp write_io_ptr = png_get_io_ptr(write_ptr); |
The replacement I/O functions must have prototypes as follows: |
void user_read_data(png_structp png_ptr, |
png_bytep data, png_size_t length); |
void user_write_data(png_structp png_ptr, |
png_bytep data, png_size_t length); |
void user_flush_data(png_structp png_ptr); |
The user_read_data() function is responsible for detecting and |
handling end-of-data errors. |
Supplying NULL for the read, write, or flush functions sets them back |
to using the default C stream functions, which expect the io_ptr to |
point to a standard *FILE structure. It is probably a mistake |
to use NULL for one of write_data_fn and output_flush_fn but not both |
of them, unless you have built libpng with PNG_NO_WRITE_FLUSH defined. |
It is an error to read from a write stream, and vice versa. |
Error handling in libpng is done through png_error() and png_warning(). |
Errors handled through png_error() are fatal, meaning that png_error() |
should never return to its caller. Currently, this is handled via |
setjmp() and longjmp() (unless you have compiled libpng with |
PNG_NO_SETJMP, in which case it is handled via PNG_ABORT()), |
but you could change this to do things like exit() if you should wish, |
as long as your function does not return. |
On non-fatal errors, png_warning() is called |
to print a warning message, and then control returns to the calling code. |
By default png_error() and png_warning() print a message on stderr via |
fprintf() unless the library is compiled with PNG_NO_CONSOLE_IO defined |
(because you don't want the messages) or PNG_NO_STDIO defined (because |
fprintf() isn't available). If you wish to change the behavior of the error |
functions, you will need to set up your own message callbacks. These |
functions are normally supplied at the time that the png_struct is created. |
It is also possible to redirect errors and warnings to your own replacement |
functions after png_create_*_struct() has been called by calling: |
png_set_error_fn(png_structp png_ptr, |
png_voidp error_ptr, png_error_ptr error_fn, |
png_error_ptr warning_fn); |
png_voidp error_ptr = png_get_error_ptr(png_ptr); |
If NULL is supplied for either error_fn or warning_fn, then the libpng |
default function will be used, calling fprintf() and/or longjmp() if a |
problem is encountered. The replacement error functions should have |
parameters as follows: |
void user_error_fn(png_structp png_ptr, |
png_const_charp error_msg); |
void user_warning_fn(png_structp png_ptr, |
png_const_charp warning_msg); |
The motivation behind using setjmp() and longjmp() is the C++ throw and |
catch exception handling methods. This makes the code much easier to write, |
as there is no need to check every return code of every function call. |
However, there are some uncertainties about the status of local variables |
after a longjmp, so the user may want to be careful about doing anything |
after setjmp returns non-zero besides returning itself. Consult your |
compiler documentation for more details. For an alternative approach, you |
may wish to use the "cexcept" facility (see http://cexcept.sourceforge.net). |
Custom chunks |
If you need to read or write custom chunks, you may need to get deeper |
into the libpng code. The library now has mechanisms for storing |
and writing chunks of unknown type; you can even declare callbacks |
for custom chunks. However, this may not be good enough if the |
library code itself needs to know about interactions between your |
chunk and existing `intrinsic' chunks. |
If you need to write a new intrinsic chunk, first read the PNG |
specification. Acquire a first level of understanding of how it works. |
Pay particular attention to the sections that describe chunk names, |
and look at how other chunks were designed, so you can do things |
similarly. Second, check out the sections of libpng that read and |
write chunks. Try to find a chunk that is similar to yours and use |
it as a template. More details can be found in the comments inside |
the code. It is best to handle unknown chunks in a generic method, |
via callback functions, instead of by modifying libpng functions. |
If you wish to write your own transformation for the data, look through |
the part of the code that does the transformations, and check out some of |
the simpler ones to get an idea of how they work. Try to find a similar |
transformation to the one you want to add and copy off of it. More details |
can be found in the comments inside the code itself. |
Configuring for 16 bit platforms |
You will want to look into zconf.h to tell zlib (and thus libpng) that |
it cannot allocate more then 64K at a time. Even if you can, the memory |
won't be accessible. So limit zlib and libpng to 64K by defining MAXSEG_64K. |
Configuring for DOS |
For DOS users who only have access to the lower 640K, you will |
have to limit zlib's memory usage via a png_set_compression_mem_level() |
call. See zlib.h or zconf.h in the zlib library for more information. |
Configuring for Medium Model |
Libpng's support for medium model has been tested on most of the popular |
compilers. Make sure MAXSEG_64K gets defined, USE_FAR_KEYWORD gets |
defined, and FAR gets defined to far in pngconf.h, and you should be |
all set. Everything in the library (except for zlib's structure) is |
expecting far data. You must use the typedefs with the p or pp on |
the end for pointers (or at least look at them and be careful). Make |
note that the rows of data are defined as png_bytepp, which is an |
unsigned char far * far *. |
Configuring for gui/windowing platforms: |
You will need to write new error and warning functions that use the GUI |
interface, as described previously, and set them to be the error and |
warning functions at the time that png_create_*_struct() is called, |
in order to have them available during the structure initialization. |
They can be changed later via png_set_error_fn(). On some compilers, |
you may also have to change the memory allocators (png_malloc, etc.). |
Configuring for compiler xxx: |
All includes for libpng are in pngconf.h. If you need to add, change |
or delete an include, this is the place to do it. |
The includes that are not needed outside libpng are placed in pngpriv.h, |
which is only used by the routines inside libpng itself. |
The files in libpng proper only include pngpriv.h and png.h, which |
in turn includes pngconf.h. |
Configuring zlib: |
There are special functions to configure the compression. Perhaps the |
most useful one changes the compression level, which currently uses |
input compression values in the range 0 - 9. The library normally |
uses the default compression level (Z_DEFAULT_COMPRESSION = 6). Tests |
have shown that for a large majority of images, compression values in |
the range 3-6 compress nearly as well as higher levels, and do so much |
faster. For online applications it may be desirable to have maximum speed |
(Z_BEST_SPEED = 1). With versions of zlib after v0.99, you can also |
specify no compression (Z_NO_COMPRESSION = 0), but this would create |
files larger than just storing the raw bitmap. You can specify the |
compression level by calling: |
png_set_compression_level(png_ptr, level); |
Another useful one is to reduce the memory level used by the library. |
The memory level defaults to 8, but it can be lowered if you are |
short on memory (running DOS, for example, where you only have 640K). |
Note that the memory level does have an effect on compression; among |
other things, lower levels will result in sections of incompressible |
data being emitted in smaller stored blocks, with a correspondingly |
larger relative overhead of up to 15% in the worst case. |
png_set_compression_mem_level(png_ptr, level); |
The other functions are for configuring zlib. They are not recommended |
for normal use and may result in writing an invalid PNG file. See |
zlib.h for more information on what these mean. |
png_set_compression_strategy(png_ptr, |
strategy); |
png_set_compression_window_bits(png_ptr, |
window_bits); |
png_set_compression_method(png_ptr, method); |
png_set_compression_buffer_size(png_ptr, size); |
Controlling row filtering |
If you want to control whether libpng uses filtering or not, which |
filters are used, and how it goes about picking row filters, you |
can call one of these functions. The selection and configuration |
of row filters can have a significant impact on the size and |
encoding speed and a somewhat lesser impact on the decoding speed |
of an image. Filtering is enabled by default for RGB and grayscale |
images (with and without alpha), but not for paletted images nor |
for any images with bit depths less than 8 bits/pixel. |
The 'method' parameter sets the main filtering method, which is |
currently only '0' in the PNG 1.2 specification. The 'filters' |
parameter sets which filter(s), if any, should be used for each |
scanline. Possible values are PNG_ALL_FILTERS and PNG_NO_FILTERS |
to turn filtering on and off, respectively. |
Individual filter types are PNG_FILTER_NONE, PNG_FILTER_SUB, |
PNG_FILTER_UP, PNG_FILTER_AVG, PNG_FILTER_PAETH, which can be bitwise |
ORed together with '|' to specify one or more filters to use. |
These filters are described in more detail in the PNG specification. |
If you intend to change the filter type during the course of writing |
the image, you should start with flags set for all of the filters |
you intend to use so that libpng can initialize its internal |
structures appropriately for all of the filter types. (Note that this |
means the first row must always be adaptively filtered, because libpng |
currently does not allocate the filter buffers until png_write_row() |
is called for the first time.) |
filters = PNG_FILTER_NONE | PNG_FILTER_SUB |
PNG_FILTER_UP | PNG_FILTER_AVG | |
PNG_FILTER_PAETH | PNG_ALL_FILTERS; |
png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, |
filters); |
The second parameter can also be |
PNG_INTRAPIXEL_DIFFERENCING if you are |
writing a PNG to be embedded in a MNG |
datastream. This parameter must be the |
same as the value of filter_method used |
in png_set_IHDR(). |
It is also possible to influence how libpng chooses from among the |
available filters. This is done in one or both of two ways - by |
telling it how important it is to keep the same filter for successive |
rows, and by telling it the relative computational costs of the filters. |
double weights[3] = {1.5, 1.3, 1.1}, |
costs[PNG_FILTER_VALUE_LAST] = |
{1.0, 1.3, 1.3, 1.5, 1.7}; |
png_set_filter_heuristics(png_ptr, |
PNG_FILTER_HEURISTIC_WEIGHTED, 3, |
weights, costs); |
The weights are multiplying factors that indicate to libpng that the |
row filter should be the same for successive rows unless another row filter |
is that many times better than the previous filter. In the above example, |
if the previous 3 filters were SUB, SUB, NONE, the SUB filter could have a |
"sum of absolute differences" 1.5 x 1.3 times higher than other filters |
and still be chosen, while the NONE filter could have a sum 1.1 times |
higher than other filters and still be chosen. Unspecified weights are |
taken to be 1.0, and the specified weights should probably be declining |
like those above in order to emphasize recent filters over older filters. |
The filter costs specify for each filter type a relative decoding cost |
to be considered when selecting row filters. This means that filters |
with higher costs are less likely to be chosen over filters with lower |
costs, unless their "sum of absolute differences" is that much smaller. |
The costs do not necessarily reflect the exact computational speeds of |
the various filters, since this would unduly influence the final image |
size. |
Note that the numbers above were invented purely for this example and |
are given only to help explain the function usage. Little testing has |
been done to find optimum values for either the costs or the weights. |
Removing unwanted object code |
There are a bunch of #define's in pngconf.h that control what parts of |
libpng are compiled. All the defines end in _SUPPORTED. If you are |
never going to use a capability, you can change the #define to #undef |
before recompiling libpng and save yourself code and data space, or |
you can turn off individual capabilities with defines that begin with |
PNG_NO_. |
In libpng-1.5.0 and later, the #define's are in pnglibconf.h instead. |
You can also turn all of the transforms and ancillary chunk capabilities |
off en masse with compiler directives that define |
PNG_NO_READ[or WRITE]_TRANSFORMS, or PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS, |
or all four, |
along with directives to turn on any of the capabilities that you do |
want. The PNG_NO_READ[or WRITE]_TRANSFORMS directives disable the extra |
transformations but still leave the library fully capable of reading |
and writing PNG files with all known public chunks. Use of the |
PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS directive produces a library |
that is incapable of reading or writing ancillary chunks. If you are |
not using the progressive reading capability, you can turn that off |
with PNG_NO_PROGRESSIVE_READ (don't confuse this with the INTERLACING |
capability, which you'll still have). |
All the reading and writing specific code are in separate files, so the |
linker should only grab the files it needs. However, if you want to |
make sure, or if you are building a stand alone library, all the |
reading files start with pngr and all the writing files start with |
pngw. The files that don't match either (like png.c, pngtrans.c, etc.) |
are used for both reading and writing, and always need to be included. |
The progressive reader is in pngpread.c |
If you are creating or distributing a dynamically linked library (a .so |
or DLL file), you should not remove or disable any parts of the library, |
as this will cause applications linked with different versions of the |
library to fail if they call functions not available in your library. |
The size of the library itself should not be an issue, because only |
those sections that are actually used will be loaded into memory. |
Requesting debug printout |
The macro definition PNG_DEBUG can be used to request debugging |
printout. Set it to an integer value in the range 0 to 3. Higher |
numbers result in increasing amounts of debugging information. The |
information is printed to the "stderr" file, unless another file |
name is specified in the PNG_DEBUG_FILE macro definition. |
When PNG_DEBUG > 0, the following functions (macros) become available: |
png_debug(level, message) |
png_debug1(level, message, p1) |
png_debug2(level, message, p1, p2) |
in which "level" is compared to PNG_DEBUG to decide whether to print |
the message, "message" is the formatted string to be printed, |
and p1 and p2 are parameters that are to be embedded in the string |
according to printf-style formatting directives. For example, |
png_debug1(2, "foo=%d\n", foo); |
is expanded to |
if (PNG_DEBUG > 2) |
fprintf(PNG_DEBUG_FILE, "foo=%d\n", foo); |
When PNG_DEBUG is defined but is zero, the macros aren't defined, but you |
can still use PNG_DEBUG to control your own debugging: |
#ifdef PNG_DEBUG |
fprintf(stderr, ... |
#endif |
When PNG_DEBUG = 1, the macros are defined, but only png_debug statements |
having level = 0 will be printed. There aren't any such statements in |
this version of libpng, but if you insert some they will be printed. |
VI. MNG support |
The MNG specification (available at http://www.libpng.org/pub/mng) allows |
certain extensions to PNG for PNG images that are embedded in MNG datastreams. |
Libpng can support some of these extensions. To enable them, use the |
png_permit_mng_features() function: |
feature_set = png_permit_mng_features(png_ptr, mask) |
mask is a png_uint_32 containing the bitwise OR of the |
features you want to enable. These include |
PNG_FLAG_MNG_EMPTY_PLTE |
PNG_FLAG_MNG_FILTER_64 |
PNG_ALL_MNG_FEATURES |
feature_set is a png_uint_32 that is the bitwise AND of |
your mask with the set of MNG features that is |
supported by the version of libpng that you are using. |
It is an error to use this function when reading or writing a standalone |
PNG file with the PNG 8-byte signature. The PNG datastream must be wrapped |
in a MNG datastream. As a minimum, it must have the MNG 8-byte signature |
and the MHDR and MEND chunks. Libpng does not provide support for these |
or any other MNG chunks; your application must provide its own support for |
them. You may wish to consider using libmng (available at |
http://www.libmng.com) instead. |
VII. Changes to Libpng from version 0.88 |
It should be noted that versions of libpng later than 0.96 are not |
distributed by the original libpng author, Guy Schalnat, nor by |
Andreas Dilger, who had taken over from Guy during 1996 and 1997, and |
distributed versions 0.89 through 0.96, but rather by another member |
of the original PNG Group, Glenn Randers-Pehrson. Guy and Andreas are |
still alive and well, but they have moved on to other things. |
The old libpng functions png_read_init(), png_write_init(), |
png_info_init(), png_read_destroy(), and png_write_destroy() have been |
moved to PNG_INTERNAL in version 0.95 to discourage their use. These |
functions will be removed from libpng version 1.4.0. |
The preferred method of creating and initializing the libpng structures is |
via the png_create_read_struct(), png_create_write_struct(), and |
png_create_info_struct() because they isolate the size of the structures |
from the application, allow version error checking, and also allow the |
use of custom error handling routines during the initialization, which |
the old functions do not. The functions png_read_destroy() and |
png_write_destroy() do not actually free the memory that libpng |
allocated for these structs, but just reset the data structures, so they |
can be used instead of png_destroy_read_struct() and |
png_destroy_write_struct() if you feel there is too much system overhead |
allocating and freeing the png_struct for each image read. |
Setting the error callbacks via png_set_message_fn() before |
png_read_init() as was suggested in libpng-0.88 is no longer supported |
because this caused applications that do not use custom error functions |
to fail if the png_ptr was not initialized to zero. It is still possible |
to set the error callbacks AFTER png_read_init(), or to change them with |
png_set_error_fn(), which is essentially the same function, but with a new |
name to force compilation errors with applications that try to use the old |
method. |
Starting with version 1.0.7, you can find out which version of the library |
you are using at run-time: |
png_uint_32 libpng_vn = png_access_version_number(); |
The number libpng_vn is constructed from the major version, minor |
version with leading zero, and release number with leading zero, |
(e.g., libpng_vn for version 1.0.7 is 10007). |
You can also check which version of png.h you used when compiling your |
application: |
png_uint_32 application_vn = PNG_LIBPNG_VER; |
VIII. Changes to Libpng from version 1.0.x to 1.2.x |
Support for user memory management was enabled by default. To |
accomplish this, the functions png_create_read_struct_2(), |
png_create_write_struct_2(), png_set_mem_fn(), png_get_mem_ptr(), |
png_malloc_default(), and png_free_default() were added. |
Support for the iTXt chunk has been enabled by default as of |
version 1.2.41. |
Support for certain MNG features was enabled. |
Support for numbered error messages was added. However, we never got |
around to actually numbering the error messages. The function |
png_set_strip_error_numbers() was added (Note: the prototype for this |
function was inadvertently removed from png.h in PNG_NO_ASSEMBLER_CODE |
builds of libpng-1.2.15. It was restored in libpng-1.2.36). |
The png_malloc_warn() function was added at libpng-1.2.3. This issues |
a png_warning and returns NULL instead of aborting when it fails to |
acquire the requested memory allocation. |
Support for setting user limits on image width and height was enabled |
by default. The functions png_set_user_limits(), png_get_user_width_max(), |
and png_get_user_height_max() were added at libpng-1.2.6. |
The png_set_add_alpha() function was added at libpng-1.2.7. |
The function png_set_expand_gray_1_2_4_to_8() was added at libpng-1.2.9. |
Unlike png_set_gray_1_2_4_to_8(), the new function does not expand the |
tRNS chunk to alpha. The png_set_gray_1_2_4_to_8() function is |
deprecated. |
A number of macro definitions in support of runtime selection of |
assembler code features (especially Intel MMX code support) were |
added at libpng-1.2.0: |
PNG_ASM_FLAG_MMX_SUPPORT_COMPILED |
PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU |
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 |
PNG_ASM_FLAGS_INITIALIZED |
PNG_MMX_READ_FLAGS |
PNG_MMX_FLAGS |
PNG_MMX_WRITE_FLAGS |
PNG_MMX_FLAGS |
We added the following functions in support of runtime |
selection of assembler code features: |
png_get_mmx_flagmask() |
png_set_mmx_thresholds() |
png_get_asm_flags() |
png_get_mmx_bitdepth_threshold() |
png_get_mmx_rowbytes_threshold() |
png_set_asm_flags() |
We replaced all of these functions with simple stubs in libpng-1.2.20, |
when the Intel assembler code was removed due to a licensing issue. |
These macros are deprecated: |
PNG_READ_TRANSFORMS_NOT_SUPPORTED |
PNG_PROGRESSIVE_READ_NOT_SUPPORTED |
PNG_NO_SEQUENTIAL_READ_SUPPORTED |
PNG_WRITE_TRANSFORMS_NOT_SUPPORTED |
PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED |
PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED |
They have been replaced, respectively, by: |
PNG_NO_READ_TRANSFORMS |
PNG_NO_PROGRESSIVE_READ |
PNG_NO_SEQUENTIAL_READ |
PNG_NO_WRITE_TRANSFORMS |
PNG_NO_READ_ANCILLARY_CHUNKS |
PNG_NO_WRITE_ANCILLARY_CHUNKS |
PNG_MAX_UINT was replaced with PNG_UINT_31_MAX. It has been |
deprecated since libpng-1.0.16 and libpng-1.2.6. |
The function |
png_check_sig(sig, num) |
was replaced with |
!png_sig_cmp(sig, 0, num) |
It has been deprecated since libpng-0.90. |
The function |
png_set_gray_1_2_4_to_8() |
which also expands tRNS to alpha was replaced with |
png_set_expand_gray_1_2_4_to_8() |
which does not. It has been deprecated since libpng-1.0.18 and 1.2.9. |
IX. Changes to Libpng from version 1.0.x/1.2.x to 1.4.x |
Private libpng prototypes and macro definitions were moved from |
png.h and pngconf.h into a new pngpriv.h header file. |
Functions png_set_benign_errors(), png_benign_error(), and |
png_chunk_benign_error() were added. |
Support for setting the maximum amount of memory that the application |
will allocate for reading chunks was added, as a security measure. |
The functions png_set_chunk_cache_max() and png_get_chunk_cache_max() |
were added to the library. |
We implemented support for I/O states by adding png_ptr member io_state |
and functions png_get_io_chunk_name() and png_get_io_state() in pngget.c |
We added PNG_TRANSFORM_GRAY_TO_RGB to the available high-level |
input transforms. |
Checking for and reporting of errors in the IHDR chunk is more thorough. |
Support for global arrays was removed, to improve thread safety. |
Some obsolete/deprecated macros and functions have been removed. |
Typecasted NULL definitions such as |
#define png_voidp_NULL (png_voidp)NULL |
were eliminated. If you used these in your application, just use |
NULL instead. |
The png_struct and info_struct members "trans" and "trans_values" were |
changed to "trans_alpha" and "trans_color", respectively. |
The obsolete, unused pnggccrd.c and pngvcrd.c files and related makefiles |
were removed. |
The PNG_1_0_X and PNG_1_2_X macros were eliminated. |
The PNG_LEGACY_SUPPORTED macro was eliminated. |
Many WIN32_WCE #ifdefs were removed. |
The functions png_read_init(info_ptr), png_write_init(info_ptr), |
png_info_init(info_ptr), png_read_destroy(), and png_write_destroy() |
have been removed. They have been deprecated since libpng-0.95. |
The png_permit_empty_plte() was removed. It has been deprecated |
since libpng-1.0.9. Use png_permit_mng_features() instead. |
We removed the obsolete stub functions png_get_mmx_flagmask(), |
png_set_mmx_thresholds(), png_get_asm_flags(), |
png_get_mmx_bitdepth_threshold(), png_get_mmx_rowbytes_threshold(), |
png_set_asm_flags(), and png_mmx_supported() |
We removed the obsolete png_check_sig(), png_memcpy_check(), and |
png_memset_check() functions. Instead use !png_sig_cmp(), memcpy(), |
and memset(), respectively. |
The function png_set_gray_1_2_4_to_8() was removed. It has been |
deprecated since libpng-1.0.18 and 1.2.9, when it was replaced with |
png_set_expand_gray_1_2_4_to_8() because the former function also |
expanded palette images. |
Macros for png_get_uint_16, png_get_uint_32, and png_get_int_32 |
were added and are used by default instead of the corresponding |
functions. Unfortunately, |
from libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the |
function) incorrectly returned a value of type png_uint_32. |
We changed the prototype for png_malloc() from |
png_malloc(png_structp png_ptr, png_uint_32 size) |
to |
png_malloc(png_structp png_ptr, png_alloc_size_t size) |
This also applies to the prototype for the user replacement malloc_fn(). |
The png_calloc() function was added and is used in place of |
of "png_malloc(); memset();" except in the case in png_read_png() |
where the array consists of pointers; in this case a "for" loop is used |
after the png_malloc() to set the pointers to NULL, to give robust. |
behavior in case the application runs out of memory part-way through |
the process. |
We changed the prototypes of png_get_compression_buffer_size() and |
png_set_compression_buffer_size() to work with png_size_t instead of |
png_uint_32. |
Support for numbered error messages was removed by default, since we |
never got around to actually numbering the error messages. The function |
png_set_strip_error_numbers() was removed from the library by default. |
The png_zalloc() and png_zfree() functions are no longer exported. |
The png_zalloc() function no longer zeroes out the memory that it |
allocates. |
Support for dithering was disabled by default in libpng-1.4.0, because |
been well tested and doesn't actually "dither". The code was not |
removed, however, and could be enabled by building libpng with |
PNG_READ_DITHER_SUPPORTED defined. In libpng-1.4.2, this support |
was reenabled, but the function was renamed png_set_quantize() to |
reflect more accurately what it actually does. At the same time, |
the PNG_DITHER_[RED,GREEN_BLUE]_BITS macros were also renamed to |
PNG_QUANTIZE_[RED,GREEN,BLUE]_BITS, and PNG_READ_DITHER_SUPPORTED |
was renamed to PNG_READ_QUANTIZE_SUPPORTED. |
We removed the trailing '.' from the warning and error messages. |
X. Changes to Libpng from version 1.4.x to 1.5.x |
From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the |
function) incorrectly returned a value of type png_uint_32. |
A. Changes that affect users of libpng |
There are no substantial API changes between the non-deprecated parts of |
the 1.4.5 API and the 1.5.0 API, however the ability to directly access |
the main libpng control structures, png_struct and png_info, deprecated |
in earlier versions of libpng, has been completely removed from |
libpng 1.5. |
We no longer include zlib.h in png.h. Applications that need access |
to information in zlib.h will need to add the '#include "zlib.h"' |
directive. It does not matter whether it is placed prior to or after |
the '"#include png.h"' directive. |
We moved the png_strcpy(), png_strncpy(), png_strlen(), png_memcpy(), |
png_memcmp(), png_sprintf, and png_memcpy() macros into a private |
header file (pngpriv.h) that is not accessible to applications. |
In png_get_iCCP, the type of "profile" was changed from png_charpp |
to png_bytepp, and in png_set_iCCP, from png_charp to png_const_bytep. |
There are changes of form in png.h, including new and changed macros to |
declare |
parts of the API. Some API functions with arguments that are pointers to |
data not modified within the function have been corrected to declare |
these arguments with PNG_CONST. |
Much of the internal use of C macros to control the library build has also |
changed and some of this is visible in the exported header files, in |
particular the use of macros to control data and API elements visible |
during application compilation may require significant revision to |
application code. (It is extremely rare for an application to do this.) |
Any program that compiled against libpng 1.4 and did not use deprecated |
features or access internal library structures should compile and work |
against libpng 1.5. |
libpng 1.5.0 adds PNG_ PASS macros to help in the reading and writing of |
interlaced images. The macros return the number of rows and columns in |
each pass and information that can be used to de-interlace and (if |
absolutely necessary) interlace an image. |
libpng 1.5.0 adds an API png_longjmp(png_ptr, value). This API calls |
the application provided png_longjmp_ptr on the internal, but application |
initialized, jmpbuf. It is provided as a convenience to avoid the need |
to use the png_jmpbuf macro, which had the unnecessary side effect of |
resetting the internal png_longjmp_ptr value. |
libpng 1.5.0 includes a complete fixed point API. By default this is |
present along with the corresponding floating point API. In general the |
fixed point API is faster and smaller than the floating point one because |
the PNG file format used fixed point, not floating point. This applies |
even if the library uses floating point in internal calculations. A new |
macro, PNG_FLOATING_ARITHMETIC_SUPPORTED, reveals whether the library |
uses floating point arithmetic (the default) or fixed point arithmetic |
internally for performance critical calculations such as gamma correction. |
In some cases, the gamma calculations may produce slightly different |
results. This has changed the results in png_rgb_to_gray and in alpha |
composition (png_set_background for example). This applies even if the |
original image was already linear (gamma == 1.0) and, therefore, it is |
not necessary to linearize the image. This is because libpng has *not* |
been changed to optimize that case correctly, yet. |
Fixed point support for the sCAL chunk comes with an important caveat; |
the sCAL specification uses a decimal encoding of floating point values |
and the accuracy of PNG fixed point values is insufficient for |
representation of these values. Consequently a "string" API |
(png_get_sCAL_s and png_set_sCAL_s) is the only reliable way of reading |
arbitrary sCAL chunks in the absence of either the floating point API or |
internal floating point calculations. |
Applications no longer need to include the optional distribution header |
file pngusr.h or define the corresponding macros during application |
build in order to see the correct variant of the libpng API. From 1.5.0 |
application code can check for the corresponding _SUPPORTED macro: |
#ifdef PNG_INCH_CONVERSIONS_SUPPORTED |
/* code that uses the inch conversion APIs. */ |
#endif |
This macro will only be defined if the inch conversion functions have been |
compiled into libpng. The full set of macros, and whether or not support |
has been compiled in, are available in the header file pnglibconf.h. |
This header file is specific to the libpng build. Notice that prior to |
1.5.0 the _SUPPORTED macros would always have the default definition unless |
reset by pngusr.h or by explicit settings on the compiler command line. |
These settings may produce compiler warnings or errors in 1.5.0 because |
of macro redefinition. |
From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the |
function) incorrectly returned a value of type png_uint_32. libpng 1.5.0 |
is consistent with the implementation in 1.4.5 and 1.2.x (where the macro |
did not exist.) |
Applications can now choose whether to use these macros or to call the |
corresponding function by defining PNG_USE_READ_MACROS or |
PNG_NO_USE_READ_MACROS before including png.h. Notice that this is |
only supported from 1.5.0 -defining PNG_NO_USE_READ_MACROS prior to 1.5.0 |
will lead to a link failure. |
B. Changes to the build and configuration of libpng |
Details of internal changes to the library code can be found in the CHANGES |
file. These will be of no concern to the vast majority of library users or |
builders, however the few who configure libpng to a non-default feature |
set may need to change how this is done. |
There should be no need for library builders to alter build scripts if |
these use the distributed build support - configure or the makefiles - |
however users of the makefiles may care to update their build scripts |
to build pnglibconf.h where the corresponding makefile does not do so. |
Building libpng with a non-default configuration has changed completely. |
The old method using pngusr.h should still work correctly even though the |
way pngusr.h is used in the build has been changed, however library |
builders will probably want to examine the changes to take advantage of |
new capabilities and to simplify their build system. |
B.1 Specific changes to library configuration capabilities |
The library now supports a complete fixed point implementation and can |
thus be used on systems which have no floating point support or very |
limited or slow support. Previously gamma correction, an essential part |
of complete PNG support, required reasonably fast floating point. |
As part of this the choice of internal implementation has been made |
independent of the choice of fixed versus floating point APIs and all the |
missing fixed point APIs have been implemented. |
The exact mechanism used to control attributes of API functions has |
changed. A single set of operating system independent macro definitions |
is used and operating system specific directives are defined in |
pnglibconf.h |
As part of this the mechanism used to choose procedure call standards on |
those systems that allow a choice has been changed. At present this only |
affects certain Microsoft (DOS, Windows) and IBM (OS/2) operating systems |
running on Intel processors. As before PNGAPI is defined where required |
to control the exported API functions; however, two new macros, PNGCBAPI |
and PNGCAPI, are used instead for callback functions (PNGCBAPI) and |
(PNGCAPI) for functions that must match a C library prototype (currently |
only png_longjmp_ptr, which must match the C longjmp function.) The new |
approach is documented in pngconf.h |
Despite these changes libpng 1.5.0 only supports the native C function |
calling standard on those platforms tested so far (__cdecl on Microsoft |
Windows). This is because the support requirements for alternative |
calling conventions seem to no longer exist. Developers who find it |
necessary to set PNG_API_RULE to 1 should advise the mailing list |
(png-mng-implement) of this and library builders who use Openwatcom and |
therefore set PNG_API_RULE to 2 should also contact the mailing list. |
A new test program, pngvalid, is provided in addition to pngtest. |
pngvalid validates the arithmetic accuracy of the gamma correction |
calculations and includes a number of validations of the file format. |
A subset of the full range of tests is run when "make check" is done |
(in the 'configure' build.) pngvalid also allows total allocated memory |
usage to be evaluated and performs additional memory overwrite validation. |
Many changes to individual feature macros have been made. The following |
are the changes most likely to be noticed by library builders who |
configure libpng: |
1) All feature macros now have consistent naming: |
#define PNG_NO_feature turns the feature off |
#define PNG_feature_SUPPORTED turns the feature on |
pnglibconf.h contains one line for each feature macro which is either: |
#define PNG_feature_SUPPORTED |
if the feature is supported or: |
/*#undef PNG_feature_SUPPORTED*/ |
if it is not. Library code consistently checks for the 'SUPPORTED' macro. |
It does not, and should not, check for the 'NO' macro which will not |
normally be defined even if the feature is not supported. |
Compatibility with the old names is provided as follows: |
PNG_INCH_CONVERSIONS turns on PNG_INCH_CONVERSIONS_SUPPORTED |
And the following definitions disable the corresponding feature: |
PNG_SETJMP_NOT_SUPPORTED disables SETJMP |
PNG_READ_TRANSFORMS_NOT_SUPPORTED disables READ_TRANSFORMS |
PNG_NO_READ_COMPOSITED_NODIV disables READ_COMPOSITE_NODIV |
PNG_WRITE_TRANSFORMS_NOT_SUPPORTED disables WRITE_TRANSFORMS |
PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED disables READ_ANCILLARY_CHUNKS |
PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED disables WRITE_ANCILLARY_CHUNKS |
Library builders should remove use of the above, inconsistent, names. |
2) Warning and error message formatting was previously conditional on |
the STDIO feature. The library has been changed to use the |
CONSOLE_IO feature instead. This means that if CONSOLE_IO is disabled |
the library no longer uses the printf(3) functions, even though the |
default read/write implementations use (FILE) style stdio.h functions. |
3) Three feature macros now control the fixed/floating point decisions: |
PNG_FLOATING_POINT_SUPPORTED enables the floating point APIs |
PNG_FIXED_POINT_SUPPORTED enables the fixed point APIs; however, in |
practice these are normally required internally anyway (because the PNG |
file format is fixed point), therefore in most cases PNG_NO_FIXED_POINT |
merely stops the function from being exported. |
PNG_FLOATING_ARITHMETIC_SUPPORTED chooses between the internal floating |
point implementation or the fixed point one. Typically the fixed point |
implementation is larger and slower than the floating point implementation |
on a system that supports floating point, however it may be faster on a |
system which lacks floating point hardware and therefore uses a software |
emulation. |
4) Added PNG_{READ,WRITE}_INT_FUNCTIONS_SUPPORTED. This allows the |
functions to read and write ints to be disabled independently of |
PNG_USE_READ_MACROS, which allows libpng to be built with the functions |
even though the default is to use the macros - this allows applications |
to choose at app buildtime whether or not to use macros (previously |
impossible because the functions weren't in the default build.) |
B.2 Changes to the configuration mechanism |
Prior to libpng-1.5.0 library builders who needed to configure libpng |
had either to modify the exported pngconf.h header file to add system |
specific configuration or had to write feature selection macros into |
pngusr.h and cause this to be included into pngconf.h by defining |
PNG_USER_CONFIG. The latter mechanism had the disadvantage that an |
application built without PNG_USER_CONFIG defined would see the |
unmodified, default, libpng API and thus would probably fail to link. |
These mechanisms still work in the configure build and in any makefile |
build that builds pnglibconf.h although the feature selection macros |
have changed somewhat as described above. In 1.5.0, however, pngusr.h is |
processed only once, when the exported header file pnglibconf.h is built. |
pngconf.h no longer includes pngusr.h, therefore it is ignored after the |
build of pnglibconf.h and it is never included in an application build. |
The rarely used alternative of adding a list of feature macros to the |
CFLAGS setting in the build also still works, however the macros will be |
copied to pnglibconf.h and this may produce macro redefinition warnings |
when the individual C files are compiled. |
All configuration now only works if pnglibconf.h is built from |
scripts/pnglibconf.dfa. This requires the program awk. Brian Kernighan |
(the original author of awk) maintains C source code of that awk and this |
and all known later implementations (often called by subtly different |
names - nawk and gawk for example) are adequate to build pnglibconf.h. |
The Sun Microsystems (now Oracle) program 'awk' is an earlier version |
and does not work, this may also apply to other systems that have a |
functioning awk called 'nawk'. |
Configuration options are now documented in scripts/pnglibconf.dfa. This |
file also includes dependency information that ensures a configuration is |
consistent; that is, if a feature is switched off dependent features are |
also removed. As a recommended alternative to using feature macros in |
pngusr.h a system builder may also define equivalent options in pngusr.dfa |
(or, indeed, any file) and add that to the configuration by setting |
DFA_XTRA to the file name. The makefiles in contrib/pngminim illustrate |
how to do this, and a case where pngusr.h is still required. |
XI. Detecting libpng |
The png_get_io_ptr() function has been present since libpng-0.88, has never |
changed, and is unaffected by conditional compilation macros. It is the |
best choice for use in configure scripts for detecting the presence of any |
libpng version since 0.88. In an autoconf "configure.in" you could use |
AC_CHECK_LIB(png, png_get_io_ptr, ... |
XII. Source code repository |
Since about February 2009, version 1.2.34, libpng has been under "git" source |
control. The git repository was built from old libpng-x.y.z.tar.gz files |
going back to version 0.70. You can access the git repository (read only) |
at |
git://libpng.git.sourceforge.net/gitroot/libpng |
or you can browse it via "gitweb" at |
http://libpng.git.sourceforge.net/git/gitweb.cgi?p=libpng |
Patches can be sent to glennrp at users.sourceforge.net or to |
png-mng-implement at lists.sourceforge.net or you can upload them to |
the libpng bug tracker at |
http://libpng.sourceforge.net |
We also accept patches built from the tar or zip distributions, and |
simple verbal discriptions of bug fixes, reported either to the |
SourceForge bug tracker or to the png-mng-implement at lists.sf.net |
mailing list. |
XIII. Coding style |
Our coding style is similar to the "Allman" style, with curly |
braces on separate lines: |
if (condition) |
{ |
action; |
} |
else if (another condition) |
{ |
another action; |
} |
The braces can be omitted from simple one-line actions: |
if (condition) |
return (0); |
We use 3-space indentation, except for continued statements which |
are usually indented the same as the first line of the statement |
plus four more spaces. |
For macro definitions we use 2-space indentation, always leaving the "#" |
in the first column. |
#ifndef PNG_NO_FEATURE |
# ifndef PNG_FEATURE_SUPPORTED |
# define PNG_FEATURE_SUPPORTED |
# endif |
#endif |
Comments appear with the leading "/*" at the same indentation as |
the statement that follows the comment: |
/* Single-line comment */ |
statement; |
/* This is a multiple-line |
* comment. |
*/ |
statement; |
Very short comments can be placed after the end of the statement |
to which they pertain: |
statement; /* comment */ |
We don't use C++ style ("//") comments. We have, however, |
used them in the past in some now-abandoned MMX assembler |
code. |
Functions and their curly braces are not indented, and |
exported functions are marked with PNGAPI: |
/* This is a public function that is visible to |
* application programmers. It does thus-and-so. |
*/ |
void PNGAPI |
png_exported_function(png_ptr, png_info, foo) |
{ |
body; |
} |
The prototypes for all exported functions appear in png.h, |
above the comment that says |
/* Maintainer: Put new public prototypes here ... */ |
We mark all non-exported functions with "/* PRIVATE */"": |
void /* PRIVATE */ |
png_non_exported_function(png_ptr, png_info, foo) |
{ |
body; |
} |
The prototypes for non-exported functions (except for those in |
pngtest) appear in |
pngpriv.h |
above the comment that says |
/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ |
To avoid polluting the global namespace, the names of all exported |
functions and variables begin with "png_", and all publicly visible C |
preprocessor macros begin with "PNG_". We request that applications that |
use libpng *not* begin any of their own symbols with either of these strings. |
We put a space after each comma and after each semicolon |
in "for" statements, and we put spaces before and after each |
C binary operator and after "for" or "while", and before |
"?". We don't put a space between a typecast and the expression |
being cast, nor do we put one between a function name and the |
left parenthesis that follows it: |
for (i = 2; i > 0; --i) |
y[i] = a(x) + (int)b; |
We prefer #ifdef and #ifndef to #if defined() and if !defined() |
when there is only one macro being tested. |
We do not use the TAB character for indentation in the C sources. |
Lines do not exceed 80 characters. |
Other rules can be inferred by inspecting the libpng source. |
XIV. Y2K Compliance in libpng |
February 3, 2011 |
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.5.1 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_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 appear to 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 |
/programs/develop/libraries/libpng/png.c |
---|
0,0 → 1,2362 |
/* png.c - location for general purpose libpng functions |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
*/ |
#include "pngpriv.h" |
/* Generate a compiler error if there is an old png.h in the search path. */ |
typedef png_libpng_version_1_5_1 Your_png_h_is_not_version_1_5_1; |
/* 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. |
*/ |
#ifdef PNG_READ_SUPPORTED |
void PNGAPI |
png_set_sig_bytes(png_structp png_ptr, int num_bytes) |
{ |
png_debug(1, "in png_set_sig_bytes"); |
if (png_ptr == NULL) |
return; |
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_const_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 (-1); |
if (start > 7) |
return (-1); |
if (start + num_to_check > 8) |
num_to_check = 8 - start; |
return ((int)(png_memcmp(&sig[start], &png_signature[start], num_to_check))); |
} |
#endif /* PNG_READ_SUPPORTED */ |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
/* Function to allocate memory for zlib */ |
PNG_FUNCTION(voidpf /* PRIVATE */, |
png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED) |
{ |
png_voidp ptr; |
png_structp p=(png_structp)png_ptr; |
png_uint_32 save_flags=p->flags; |
png_alloc_size_t num_bytes; |
if (png_ptr == NULL) |
return (NULL); |
if (items > PNG_UINT_32_MAX/size) |
{ |
png_warning (p, "Potential overflow in png_zalloc()"); |
return (NULL); |
} |
num_bytes = (png_alloc_size_t)items * size; |
p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; |
ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes); |
p->flags=save_flags; |
return ((voidpf)ptr); |
} |
/* Function to free memory for zlib */ |
void /* PRIVATE */ |
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_const_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(png_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_FUNCTION(png_infop,PNGAPI |
png_create_info_struct,(png_structp png_ptr),PNG_ALLOCATED) |
{ |
png_infop info_ptr; |
png_debug(1, "in png_create_info_struct"); |
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, png_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"); |
if (png_ptr == NULL) |
return; |
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. |
*/ |
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"); |
if (info_ptr == NULL) |
return; |
if (png_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, png_sizeof(png_info)); |
} |
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"); |
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"); |
} |
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"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
#ifdef PNG_TEXT_SUPPORTED |
/* Free text item num or (if num == -1) all text items */ |
if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) |
{ |
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 |
#ifdef PNG_tRNS_SUPPORTED |
/* Free any tRNS entry */ |
if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) |
{ |
png_free(png_ptr, info_ptr->trans_alpha); |
info_ptr->trans_alpha = NULL; |
info_ptr->valid &= ~PNG_INFO_tRNS; |
} |
#endif |
#ifdef PNG_sCAL_SUPPORTED |
/* Free any sCAL entry */ |
if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) |
{ |
#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 |
#ifdef PNG_pCAL_SUPPORTED |
/* Free any pCAL entry */ |
if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) |
{ |
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 |
#ifdef PNG_iCCP_SUPPORTED |
/* Free any iCCP entry */ |
if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) |
{ |
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 |
#ifdef PNG_sPLT_SUPPORTED |
/* Free a given sPLT entry, or (if num == -1) all sPLT entries */ |
if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) |
{ |
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 |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
if (png_ptr->unknown_chunk.data) |
{ |
png_free(png_ptr, png_ptr->unknown_chunk.data); |
png_ptr->unknown_chunk.data = NULL; |
} |
if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) |
{ |
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 < 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 |
#ifdef PNG_hIST_SUPPORTED |
/* Free any hIST entry */ |
if ((mask & PNG_FREE_HIST) & info_ptr->free_me) |
{ |
png_free(png_ptr, info_ptr->hist); |
info_ptr->hist = NULL; |
info_ptr->valid &= ~PNG_INFO_hIST; |
} |
#endif |
/* Free any PLTE entry that was internally allocated */ |
if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) |
{ |
png_zfree(png_ptr, info_ptr->palette); |
info_ptr->palette = NULL; |
info_ptr->valid &= ~PNG_INFO_PLTE; |
info_ptr->num_palette = 0; |
} |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
/* Free any image bits attached to the info structure */ |
if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) |
{ |
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 |
if (num != -1) |
mask &= ~PNG_FREE_MUL; |
info_ptr->free_me &= ~mask; |
} |
/* 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"); |
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
#ifdef PNG_HANDLE_AS_UNKNOWN_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, png_sizeof(png_info)); |
} |
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ |
/* 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) |
{ |
if (png_ptr == NULL) |
return (NULL); |
return (png_ptr->io_ptr); |
} |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
# ifdef PNG_STDIO_SUPPORTED |
/* 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"); |
if (png_ptr == NULL) |
return; |
png_ptr->io_ptr = (png_voidp)fp; |
} |
# endif |
# ifdef 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_const_charp PNGAPI |
png_convert_to_rfc1123(png_structp png_ptr, png_const_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 == NULL) |
return (NULL); |
if (png_ptr->time_buffer == NULL) |
{ |
png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* |
png_sizeof(char))); |
} |
# ifdef USE_FAR_KEYWORD |
{ |
char near_time_buf[29]; |
png_snprintf6(near_time_buf, 29, "%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*png_sizeof(char)); |
} |
# else |
png_snprintf6(png_ptr->time_buffer, 29, "%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 |
return png_ptr->time_buffer; |
} |
# endif /* PNG_TIME_RFC1123_SUPPORTED */ |
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ |
png_const_charp PNGAPI |
png_get_copyright(png_const_structp png_ptr) |
{ |
PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ |
#ifdef PNG_STRING_COPYRIGHT |
return PNG_STRING_COPYRIGHT |
#else |
# ifdef __STDC__ |
return PNG_STRING_NEWLINE \ |
"libpng version 1.5.1 - February 3, 2011" PNG_STRING_NEWLINE \ |
"Copyright (c) 1998-2011 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \ |
"Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \ |
"Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \ |
PNG_STRING_NEWLINE; |
# else |
return "libpng version 1.5.1 - February 3, 2011\ |
Copyright (c) 1998-2011 Glenn Randers-Pehrson\ |
Copyright (c) 1996-1997 Andreas Dilger\ |
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc."; |
# endif |
#endif |
} |
/* 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. |
* Note: now there is no difference between png_get_libpng_ver() and |
* png_get_header_ver(). Due to the version_nn_nn_nn typedef guard, |
* it is guaranteed that png.c uses the correct version of png.h. |
*/ |
png_const_charp PNGAPI |
png_get_libpng_ver(png_const_structp png_ptr) |
{ |
/* Version of *.c files used when building libpng */ |
return png_get_header_ver(png_ptr); |
} |
png_const_charp PNGAPI |
png_get_header_ver(png_const_structp png_ptr) |
{ |
/* Version of *.h files used when building libpng */ |
PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ |
return PNG_LIBPNG_VER_STRING; |
} |
png_const_charp PNGAPI |
png_get_header_version(png_const_structp png_ptr) |
{ |
/* Returns longer string containing both version and date */ |
PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ |
#ifdef __STDC__ |
return PNG_HEADER_VERSION_STRING |
# ifndef PNG_READ_SUPPORTED |
" (NO READ SUPPORT)" |
# endif |
PNG_STRING_NEWLINE; |
#else |
return PNG_HEADER_VERSION_STRING; |
#endif |
} |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
# ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
int PNGAPI |
png_handle_as_unknown(png_structp png_ptr, png_const_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 |
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ |
#ifdef PNG_READ_SUPPORTED |
/* This function, added to libpng-1.0.6g, is untested. */ |
int PNGAPI |
png_reset_zstream(png_structp png_ptr) |
{ |
if (png_ptr == NULL) |
return Z_STREAM_ERROR; |
return (inflateReset(&png_ptr->zstream)); |
} |
#endif /* PNG_READ_SUPPORTED */ |
/* 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)PNG_LIBPNG_VER); |
} |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
# ifdef PNG_SIZE_T |
/* Added at libpng version 1.2.6 */ |
PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); |
png_size_t PNGAPI |
png_convert_size(size_t size) |
{ |
if (size > (png_size_t)-1) |
PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */ |
return ((png_size_t)size); |
} |
# endif /* PNG_SIZE_T */ |
/* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */ |
# ifdef PNG_CHECK_cHRM_SUPPORTED |
int /* PRIVATE */ |
png_check_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) |
{ |
int ret = 1; |
unsigned long xy_hi,xy_lo,yx_hi,yx_lo; |
png_debug(1, "in function png_check_cHRM_fixed"); |
if (png_ptr == NULL) |
return 0; |
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"); |
ret = 0; |
} |
if (white_x > (png_fixed_point)PNG_UINT_31_MAX || |
white_y > (png_fixed_point)PNG_UINT_31_MAX || |
red_x > (png_fixed_point)PNG_UINT_31_MAX || |
red_y > (png_fixed_point)PNG_UINT_31_MAX || |
green_x > (png_fixed_point)PNG_UINT_31_MAX || |
green_y > (png_fixed_point)PNG_UINT_31_MAX || |
blue_x > (png_fixed_point)PNG_UINT_31_MAX || |
blue_y > (png_fixed_point)PNG_UINT_31_MAX ) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set chromaticity value exceeding 21474.83"); |
ret = 0; |
} |
if (white_x > 100000L - white_y) |
{ |
png_warning(png_ptr, "Invalid cHRM white point"); |
ret = 0; |
} |
if (red_x > 100000L - red_y) |
{ |
png_warning(png_ptr, "Invalid cHRM red point"); |
ret = 0; |
} |
if (green_x > 100000L - green_y) |
{ |
png_warning(png_ptr, "Invalid cHRM green point"); |
ret = 0; |
} |
if (blue_x > 100000L - blue_y) |
{ |
png_warning(png_ptr, "Invalid cHRM blue point"); |
ret = 0; |
} |
png_64bit_product(green_x - red_x, blue_y - red_y, &xy_hi, &xy_lo); |
png_64bit_product(green_y - red_y, blue_x - red_x, &yx_hi, &yx_lo); |
if (xy_hi == yx_hi && xy_lo == yx_lo) |
{ |
png_warning(png_ptr, |
"Ignoring attempt to set cHRM RGB triangle with zero area"); |
ret = 0; |
} |
return ret; |
} |
# endif /* PNG_CHECK_cHRM_SUPPORTED */ |
void /* PRIVATE */ |
png_check_IHDR(png_structp png_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 error = 0; |
/* Check for width and height valid values */ |
if (width == 0) |
{ |
png_warning(png_ptr, "Image width is zero in IHDR"); |
error = 1; |
} |
if (height == 0) |
{ |
png_warning(png_ptr, "Image height is zero in IHDR"); |
error = 1; |
} |
# ifdef PNG_SET_USER_LIMITS_SUPPORTED |
if (width > png_ptr->user_width_max || width > PNG_USER_WIDTH_MAX) |
# else |
if (width > PNG_USER_WIDTH_MAX) |
# endif |
{ |
png_warning(png_ptr, "Image width exceeds user limit in IHDR"); |
error = 1; |
} |
# ifdef PNG_SET_USER_LIMITS_SUPPORTED |
if (height > png_ptr->user_height_max || height > PNG_USER_HEIGHT_MAX) |
# else |
if (height > PNG_USER_HEIGHT_MAX) |
# endif |
{ |
png_warning(png_ptr, "Image height exceeds user limit in IHDR"); |
error = 1; |
} |
if (width > PNG_UINT_31_MAX) |
{ |
png_warning(png_ptr, "Invalid image width in IHDR"); |
error = 1; |
} |
if (height > PNG_UINT_31_MAX) |
{ |
png_warning(png_ptr, "Invalid image height in IHDR"); |
error = 1; |
} |
if (width > (PNG_UINT_32_MAX |
>> 3) /* 8-byte RGBA pixels */ |
- 48 /* bigrowbuf hack */ |
- 1 /* filter byte */ |
- 7*8 /* rounding of width to multiple of 8 pixels */ |
- 8) /* extra max_pixel_depth pad */ |
png_warning(png_ptr, "Width is too large for libpng to process pixels"); |
/* Check other values */ |
if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && |
bit_depth != 8 && bit_depth != 16) |
{ |
png_warning(png_ptr, "Invalid bit depth in IHDR"); |
error = 1; |
} |
if (color_type < 0 || color_type == 1 || |
color_type == 5 || color_type > 6) |
{ |
png_warning(png_ptr, "Invalid color type in IHDR"); |
error = 1; |
} |
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_warning(png_ptr, "Invalid color type/bit depth combination in IHDR"); |
error = 1; |
} |
if (interlace_type >= PNG_INTERLACE_LAST) |
{ |
png_warning(png_ptr, "Unknown interlace method in IHDR"); |
error = 1; |
} |
if (compression_type != PNG_COMPRESSION_TYPE_BASE) |
{ |
png_warning(png_ptr, "Unknown compression method in IHDR"); |
error = 1; |
} |
# ifdef 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"); |
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_warning(png_ptr, "Unknown filter method in IHDR"); |
error = 1; |
} |
if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) |
{ |
png_warning(png_ptr, "Invalid filter method in IHDR"); |
error = 1; |
} |
} |
# else |
if (filter_type != PNG_FILTER_TYPE_BASE) |
{ |
png_warning(png_ptr, "Unknown filter method in IHDR"); |
error = 1; |
} |
# endif |
if (error == 1) |
png_error(png_ptr, "Invalid IHDR data"); |
} |
#if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) |
/* ASCII to fp functions */ |
/* Check an ASCII formated floating point value, see the more detailed |
* comments in pngpriv.h |
*/ |
/* The following is used internally to preserve the 'valid' flag */ |
#define png_fp_add(state, flags) ((state) |= (flags)) |
#define png_fp_set(state, value)\ |
((state) = (value) | ((state) & PNG_FP_WAS_VALID)) |
/* Internal type codes: bits above the base state! */ |
#define PNG_FP_SIGN 0 /* [+-] */ |
#define PNG_FP_DOT 4 /* . */ |
#define PNG_FP_DIGIT 8 /* [0123456789] */ |
#define PNG_FP_E 12 /* [Ee] */ |
int /* PRIVATE */ |
png_check_fp_number(png_const_charp string, png_size_t size, int *statep, |
png_size_tp whereami) |
{ |
int state = *statep; |
png_size_t i = *whereami; |
while (i < size) |
{ |
int type; |
/* First find the type of the next character */ |
{ |
char ch = string[i]; |
if (ch >= 48 && ch <= 57) |
type = PNG_FP_DIGIT; |
else switch (ch) |
{ |
case 43: case 45: type = PNG_FP_SIGN; break; |
case 46: type = PNG_FP_DOT; break; |
case 69: case 101: type = PNG_FP_E; break; |
default: goto PNG_FP_End; |
} |
} |
/* Now deal with this type according to the current |
* state, the type is arranged to not overlap the |
* bits of the PNG_FP_STATE. |
*/ |
switch ((state & PNG_FP_STATE) + type) |
{ |
case PNG_FP_INTEGER + PNG_FP_SIGN: |
if (state & PNG_FP_SAW_ANY) |
goto PNG_FP_End; /* not a part of the number */ |
png_fp_add(state, PNG_FP_SAW_SIGN); |
break; |
case PNG_FP_INTEGER + PNG_FP_DOT: |
/* Ok as trailer, ok as lead of fraction. */ |
if (state & PNG_FP_SAW_DOT) /* two dots */ |
goto PNG_FP_End; |
else if (state & PNG_FP_SAW_DIGIT) /* trailing dot? */ |
png_fp_add(state, PNG_FP_SAW_DOT); |
else |
png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT); |
break; |
case PNG_FP_INTEGER + PNG_FP_DIGIT: |
if (state & PNG_FP_SAW_DOT) /* delayed fraction */ |
png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT); |
png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID); |
break; |
case PNG_FP_INTEGER + PNG_FP_E: |
if ((state & PNG_FP_SAW_DIGIT) == 0) |
goto PNG_FP_End; |
png_fp_set(state, PNG_FP_EXPONENT); |
break; |
/* case PNG_FP_FRACTION + PNG_FP_SIGN: |
goto PNG_FP_End; ** no sign in exponent */ |
/* case PNG_FP_FRACTION + PNG_FP_DOT: |
goto PNG_FP_End; ** Because SAW_DOT is always set */ |
case PNG_FP_FRACTION + PNG_FP_DIGIT: |
png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID); |
break; |
case PNG_FP_FRACTION + PNG_FP_E: |
/* This is correct because the trailing '.' on an |
* integer is handled above - so we can only get here |
* with the sequence ".E" (with no preceding digits). |
*/ |
if ((state & PNG_FP_SAW_DIGIT) == 0) |
goto PNG_FP_End; |
png_fp_set(state, PNG_FP_EXPONENT); |
break; |
case PNG_FP_EXPONENT + PNG_FP_SIGN: |
if (state & PNG_FP_SAW_ANY) |
goto PNG_FP_End; /* not a part of the number */ |
png_fp_add(state, PNG_FP_SAW_SIGN); |
break; |
/* case PNG_FP_EXPONENT + PNG_FP_DOT: |
goto PNG_FP_End; */ |
case PNG_FP_EXPONENT + PNG_FP_DIGIT: |
png_fp_add(state, PNG_FP_SAW_DIGIT + PNG_FP_WAS_VALID); |
break; |
/* case PNG_FP_EXPONEXT + PNG_FP_E: |
goto PNG_FP_End; */ |
default: goto PNG_FP_End; /* I.e. break 2 */ |
} |
/* The character seems ok, continue. */ |
++i; |
} |
PNG_FP_End: |
/* Here at the end, update the state and return the correct |
* return code. |
*/ |
*statep = state; |
*whereami = i; |
return (state & PNG_FP_SAW_DIGIT) != 0; |
} |
/* The same but for a complete string. */ |
int |
png_check_fp_string(png_const_charp string, png_size_t size) |
{ |
int state=0; |
png_size_t char_index=0; |
return png_check_fp_number(string, size, &state, &char_index) && |
(char_index == size || string[char_index] == 0); |
} |
#endif /* pCAL or sCAL */ |
#ifdef PNG_READ_sCAL_SUPPORTED |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
/* Utility used below - a simple accurate power of ten from an integral |
* exponent. |
*/ |
static double |
png_pow10(int power) |
{ |
int recip = 0; |
double d = 1; |
/* Handle negative exponent with a reciprocal at the end because |
* 10 is exact whereas .1 is inexact in base 2 |
*/ |
if (power < 0) |
{ |
if (power < DBL_MIN_10_EXP) return 0; |
recip = 1, power = -power; |
} |
if (power > 0) |
{ |
/* Decompose power bitwise. */ |
double mult = 10; |
do |
{ |
if (power & 1) d *= mult; |
mult *= mult; |
power >>= 1; |
} |
while (power > 0); |
if (recip) d = 1/d; |
} |
/* else power is 0 and d is 1 */ |
return d; |
} |
/* Function to format a floating point value in ASCII with a given |
* precision. |
*/ |
void /* PRIVATE */ |
png_ascii_from_fp(png_structp png_ptr, png_charp ascii, png_size_t size, |
double fp, unsigned int precision) |
{ |
/* We use standard functions from math.h, but not printf because |
* that would require stdio. The caller must supply a buffer of |
* sufficient size or we will png_error. The tests on size and |
* the space in ascii[] consumed are indicated below. |
*/ |
if (precision < 1) |
precision = DBL_DIG; |
/* Enforce the limit of the implementation precision too. */ |
if (precision > DBL_DIG+1) |
precision = DBL_DIG+1; |
/* Basic sanity checks */ |
if (size >= precision+5) /* See the requirements below. */ |
{ |
if (fp < 0) |
{ |
fp = -fp; |
*ascii++ = 45; /* '-' PLUS 1 TOTAL 1*/ |
--size; |
} |
if (fp >= DBL_MIN && fp <= DBL_MAX) |
{ |
int exp_b10; /* A base 10 exponent */ |
double base; /* 10^exp_b10 */ |
/* First extract a base 10 exponent of the number, |
* the calculation below rounds down when converting |
* from base 2 to base 10 (multiply by log10(2) - |
* 0.3010, but 77/256 is 0.3008, so exp_b10 needs to |
* be increased. Note that the arithmetic shift |
* performs a floor() unlike C arithmetic - using a |
* C multiply would break the following for negative |
* exponents. |
*/ |
(void)frexp(fp, &exp_b10); /* exponent to base 2 */ |
exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */ |
/* Avoid underflow here. */ |
base = png_pow10(exp_b10); /* May underflow */ |
while (base < DBL_MIN || base < fp) |
{ |
/* And this may overflow. */ |
double test = png_pow10(exp_b10+1); |
if (test <= DBL_MAX) |
++exp_b10, base = test; |
else |
break; |
} |
/* Normalize fp and correct exp_b10, after this fp is in the |
* range [.1,1) and exp_b10 is both the exponent and the digit |
* *before* which the decimal point should be inserted |
* (starting with 0 for the first digit). Note that this |
* works even if 10^exp_b10 is out of range because of the |
* test on DBL_MAX above. |
*/ |
fp /= base; |
while (fp >= 1) fp /= 10, ++exp_b10; |
/* Because of the code above fp may, at this point, be |
* less than .1, this is ok because the code below can |
* handle the leading zeros this generates, so no attempt |
* is made to correct that here. |
*/ |
{ |
int czero, clead, cdigits; |
char exponent[10]; |
/* Allow up to two leading zeros - this will not lengthen |
* the number compared to using E-n. |
*/ |
if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */ |
{ |
czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */ |
exp_b10 = 0; /* Dot added below before first output. */ |
} |
else |
czero = 0; /* No zeros to add */ |
/* Generate the digit list, stripping trailing zeros and |
* inserting a '.' before a digit if the exponent is 0. |
*/ |
clead = czero; /* Count of leading zeros */ |
cdigits = 0; /* Count of digits in list. */ |
do |
{ |
double d; |
fp *= 10; |
/* Use modf here, not floor and subtract, so that |
* the separation is done in one step. At the end |
* of the loop don't break the number into parts so |
* that the final digit is rounded. |
*/ |
if (cdigits+czero-clead+1 < (int)precision) |
fp = modf(fp, &d); |
else |
{ |
d = floor(fp + .5); |
if (d > 9) |
{ |
/* Rounding up to 10, handle that here. */ |
if (czero > 0) |
{ |
--czero, d = 1; |
if (cdigits == 0) --clead; |
} |
else |
{ |
while (cdigits > 0 && d > 9) |
{ |
int ch = *--ascii; |
if (exp_b10 != (-1)) |
++exp_b10; |
else if (ch == 46) |
{ |
ch = *--ascii, ++size; |
/* Advance exp_b10 to '1', so that the |
* decimal point happens after the |
* previous digit. |
*/ |
exp_b10 = 1; |
} |
--cdigits; |
d = ch - 47; /* I.e. 1+(ch-48) */ |
} |
/* Did we reach the beginning? If so adjust the |
* exponent but take into account the leading |
* decimal point. |
*/ |
if (d > 9) /* cdigits == 0 */ |
{ |
if (exp_b10 == (-1)) |
{ |
/* Leading decimal point (plus zeros?), if |
* we lose the decimal point here it must |
* be reentered below. |
*/ |
int ch = *--ascii; |
if (ch == 46) |
++size, exp_b10 = 1; |
/* Else lost a leading zero, so 'exp_b10' is |
* still ok at (-1) |
*/ |
} |
else |
++exp_b10; |
/* In all cases we output a '1' */ |
d = 1; |
} |
} |
} |
fp = 0; /* Guarantees termination below. */ |
} |
if (d == 0) |
{ |
++czero; |
if (cdigits == 0) ++clead; |
} |
else |
{ |
/* Included embedded zeros in the digit count. */ |
cdigits += czero - clead; |
clead = 0; |
while (czero > 0) |
{ |
/* exp_b10 == (-1) means we just output the decimal |
* place - after the DP don't adjust 'exp_b10' any |
* more! |
*/ |
if (exp_b10 != (-1)) |
{ |
if (exp_b10 == 0) *ascii++ = 46, --size; |
/* PLUS 1: TOTAL 4 */ |
--exp_b10; |
} |
*ascii++ = 48, --czero; |
} |
if (exp_b10 != (-1)) |
{ |
if (exp_b10 == 0) *ascii++ = 46, --size; /* counted |
above */ |
--exp_b10; |
} |
*ascii++ = (char)(48 + (int)d), ++cdigits; |
} |
} |
while (cdigits+czero-clead < (int)precision && fp > DBL_MIN); |
/* The total output count (max) is now 4+precision */ |
/* Check for an exponent, if we don't need one we are |
* done and just need to terminate the string. At |
* this point exp_b10==(-1) is effectively if flag - it got |
* to '-1' because of the decrement after outputing |
* the decimal point above (the exponent required is |
* *not* -1!) |
*/ |
if (exp_b10 >= (-1) && exp_b10 <= 2) |
{ |
/* The following only happens if we didn't output the |
* leading zeros above for negative exponent, so this |
* doest add to the digit requirement. Note that the |
* two zeros here can only be output if the two leading |
* zeros were *not* output, so this doesn't increase |
* the output count. |
*/ |
while (--exp_b10 >= 0) *ascii++ = 48; |
*ascii = 0; |
/* Total buffer requirement (including the '\0') is |
* 5+precision - see check at the start. |
*/ |
return; |
} |
/* Here if an exponent is required, adjust size for |
* the digits we output but did not count. The total |
* digit output here so far is at most 1+precision - no |
* decimal point and no leading or trailing zeros have |
* been output. |
*/ |
size -= cdigits; |
*ascii++ = 69, --size; /* 'E': PLUS 1 TOTAL 2+precision*/ |
if (exp_b10 < 0) |
{ |
*ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */ |
exp_b10 = -exp_b10; |
} |
cdigits = 0; |
while (exp_b10 > 0) |
{ |
exponent[cdigits++] = (char)(48 + exp_b10 % 10); |
exp_b10 /= 10; |
} |
/* Need another size check here for the exponent digits, so |
* this need not be considered above. |
*/ |
if ((int)size > cdigits) |
{ |
while (cdigits > 0) *ascii++ = exponent[--cdigits]; |
*ascii = 0; |
return; |
} |
} |
} |
else if (!(fp >= DBL_MIN)) |
{ |
*ascii++ = 48; /* '0' */ |
*ascii = 0; |
return; |
} |
else |
{ |
*ascii++ = 105; /* 'i' */ |
*ascii++ = 110; /* 'n' */ |
*ascii++ = 102; /* 'f' */ |
*ascii = 0; |
return; |
} |
} |
/* Here on buffer too small. */ |
png_error(png_ptr, "ASCII conversion buffer too small"); |
} |
# endif /* FLOATING_POINT */ |
# ifdef PNG_FIXED_POINT_SUPPORTED |
/* Function to format a fixed point value in ASCII. |
*/ |
void /* PRIVATE */ |
png_ascii_from_fixed(png_structp png_ptr, png_charp ascii, png_size_t size, |
png_fixed_point fp) |
{ |
/* Require space for 10 decimal digits, a decimal point, a minus sign and a |
* trailing \0, 13 characters: |
*/ |
if (size > 12) |
{ |
png_uint_32 num; |
/* Avoid overflow here on the minimum integer. */ |
if (fp < 0) |
*ascii++ = 45, --size, num = -fp; |
else |
num = fp; |
if (num <= 0x80000000U) /* else overflowed */ |
{ |
unsigned int ndigits = 0, first = 16/*flag value*/; |
char digits[10]; |
while (num) |
{ |
/* Split the low digit off num: */ |
unsigned int tmp = num/10; |
num -= tmp*10; |
digits[ndigits++] = (char)(48 + num); |
/* Record the first non-zero digit, note that this is a number |
* starting at 1, it's not actually the array index. |
*/ |
if (first == 16 && num > 0) |
first = ndigits; |
num = tmp; |
} |
if (ndigits > 0) |
{ |
while (ndigits > 5) *ascii++ = digits[--ndigits]; |
/* The remaining digits are fractional digits, ndigits is '5' or |
* smaller at this point. It is certainly not zero. Check for a |
* non-zero fractional digit: |
*/ |
if (first <= 5) |
{ |
unsigned int i; |
*ascii++ = 46; /* decimal point */ |
/* ndigits may be <5 for small numbers, output leading zeros |
* then ndigits digits to first: |
*/ |
i = 5; |
while (ndigits < i) *ascii++ = 48, --i; |
while (ndigits >= first) *ascii++ = digits[--ndigits]; |
/* Don't output the trailing zeros! */ |
} |
} |
else |
*ascii++ = 48; |
/* And null terminate the string: */ |
*ascii = 0; |
return; |
} |
} |
/* Here on buffer too small. */ |
png_error(png_ptr, "ASCII conversion buffer too small"); |
} |
# endif /* FIXED_POINT */ |
#endif /* READ_SCAL */ |
#if defined(PNG_FLOATING_POINT_SUPPORTED) && \ |
!defined(PNG_FIXED_POINT_MACRO_SUPPORTED) |
png_fixed_point |
png_fixed(png_structp png_ptr, double fp, png_const_charp text) |
{ |
double r = floor(100000 * fp + .5); |
if (r > 2147483647. || r < -2147483648.) |
png_fixed_error(png_ptr, text); |
return (png_fixed_point)r; |
} |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || \ |
defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG__READ_pHYs_SUPPORTED) |
/* muldiv functions */ |
/* This API takes signed arguments and rounds the result to the nearest |
* integer (or, for a fixed point number - the standard argument - to |
* the nearest .00001). Overflow and divide by zero are signalled in |
* the result, a boolean - true on success, false on overflow. |
*/ |
int |
png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times, |
png_int_32 divisor) |
{ |
/* Return a * times / divisor, rounded. */ |
if (divisor != 0) |
{ |
if (a == 0 || times == 0) |
{ |
*res = 0; |
return 1; |
} |
else |
{ |
#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
double r = a; |
r *= times; |
r /= divisor; |
r = floor(r+.5); |
/* A png_fixed_point is a 32 bit integer. */ |
if (r <= 2147483647. && r >= -2147483648.) |
{ |
*res = (png_fixed_point)r; |
return 1; |
} |
#else |
int negative = 0; |
png_uint_32 A, T, D; |
png_uint_32 s16, s32, s00; |
if (a < 0) |
negative = 1, A = -a; |
else |
A = a; |
if (times < 0) |
negative = !negative, T = -times; |
else |
T = times; |
if (divisor < 0) |
negative = !negative, D = -divisor; |
else |
D = divisor; |
/* Following can't overflow because the arguments only |
* have 31 bits each, however the result may be 32 bits. |
*/ |
s16 = (A >> 16) * (T & 0xffff) + |
(A & 0xffff) * (T >> 16); |
/* Can't overflow because the a*times bit is only 30 |
* bits at most. |
*/ |
s32 = (A >> 16) * (T >> 16) + (s16 >> 16); |
s00 = (A & 0xffff) * (T & 0xffff); |
s16 = (s16 & 0xffff) << 16; |
s00 += s16; |
if (s00 < s16) |
++s32; /* carry */ |
if (s32 < D) /* else overflow */ |
{ |
/* s32.s00 is now the 64 bit product, do a standard |
* division, we know that s32 < D, so the maximum |
* required shift is 31. |
*/ |
int bitshift = 32; |
png_fixed_point result = 0; /* NOTE: signed */ |
while (--bitshift >= 0) |
{ |
png_uint_32 d32, d00; |
if (bitshift > 0) |
d32 = D >> (32-bitshift), d00 = D << bitshift; |
else |
d32 = 0, d00 = D; |
if (s32 > d32) |
{ |
if (s00 < d00) --s32; /* carry */ |
s32 -= d32, s00 -= d00, result += 1<<bitshift; |
} |
else |
if (s32 == d32 && s00 >= d00) |
s32 = 0, s00 -= d00, result += 1<<bitshift; |
} |
/* Handle the rounding. */ |
if (s00 >= (D >> 1)) |
++result; |
if (negative) |
result = -result; |
/* Check for overflow. */ |
if ((negative && result <= 0) || (!negative && result >= 0)) |
{ |
*res = result; |
return 1; |
} |
} |
#endif |
} |
} |
return 0; |
} |
#endif /* READ_GAMMA || INCH_CONVERSIONS */ |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED) |
/* The following is for when the caller doesn't much care about the |
* result. |
*/ |
png_fixed_point |
png_muldiv_warn(png_structp png_ptr, png_fixed_point a, png_int_32 times, |
png_int_32 divisor) |
{ |
png_fixed_point result; |
if (png_muldiv(&result, a, times, divisor)) |
return result; |
png_warning(png_ptr, "fixed point overflow ignored"); |
return 0; |
} |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED /* more fixed point functions for gammma */ |
/* Calculate a reciprocal, return 0 on div-by-zero or overflow. */ |
png_fixed_point |
png_reciprocal(png_fixed_point a) |
{ |
#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
double r = floor(1E10/a+.5); |
if (r <= 2147483647. && r >= -2147483648.) |
return (png_fixed_point)r; |
#else |
png_fixed_point res; |
if (png_muldiv(&res, 100000, 100000, a)) |
return res; |
#endif |
return 0; /* error/overflow */ |
} |
/* A local convenience routine. */ |
static png_fixed_point |
png_product2(png_fixed_point a, png_fixed_point b) |
{ |
/* The required result is 1/a * 1/b; the following preserves accuracy. */ |
#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
double r = a * 1E-5; |
r *= b; |
r = floor(r+.5); |
if (r <= 2147483647. && r >= -2147483648.) |
return (png_fixed_point)r; |
#else |
png_fixed_point res; |
if (png_muldiv(&res, a, b, 100000)) |
return res; |
#endif |
return 0; /* overflow */ |
} |
/* The inverse of the above. */ |
png_fixed_point |
png_reciprocal2(png_fixed_point a, png_fixed_point b) |
{ |
/* The required result is 1/a * 1/b; the following preserves accuracy. */ |
#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
double r = 1E15/a; |
r /= b; |
r = floor(r+.5); |
if (r <= 2147483647. && r >= -2147483648.) |
return (png_fixed_point)r; |
#else |
/* This may overflow because the range of png_fixed_point isn't symmetric, |
* but this API is only used for the product of file and screen gamma so it |
* doesn't matter that the smallest number it can produce is 1/21474, not |
* 1/100000 |
*/ |
png_fixed_point res = png_product2(a, b); |
if (res != 0) |
return png_reciprocal(res); |
#endif |
return 0; /* overflow */ |
} |
#endif /* READ_GAMMA */ |
#ifdef PNG_CHECK_cHRM_SUPPORTED |
/* Added at libpng version 1.2.34 (Dec 8, 2008) and 1.4.0 (Jan 2, |
* 2010: moved from pngset.c) */ |
/* |
* Multiply two 32-bit numbers, V1 and V2, using 32-bit |
* arithmetic, to produce a 64 bit result in the HI/LO words. |
* |
* A B |
* x C D |
* ------ |
* AD || BD |
* AC || CB || 0 |
* |
* where A and B are the high and low 16-bit words of V1, |
* C and D are the 16-bit words of V2, AD is the product of |
* A and D, and X || Y is (X << 16) + Y. |
*/ |
void /* PRIVATE */ |
png_64bit_product (long v1, long v2, unsigned long *hi_product, |
unsigned long *lo_product) |
{ |
int a, b, c, d; |
long lo, hi, x, y; |
a = (v1 >> 16) & 0xffff; |
b = v1 & 0xffff; |
c = (v2 >> 16) & 0xffff; |
d = v2 & 0xffff; |
lo = b * d; /* BD */ |
x = a * d + c * b; /* AD + CB */ |
y = ((lo >> 16) & 0xffff) + x; |
lo = (lo & 0xffff) | ((y & 0xffff) << 16); |
hi = (y >> 16) & 0xffff; |
hi += a * c; /* AC */ |
*hi_product = (unsigned long)hi; |
*lo_product = (unsigned long)lo; |
} |
#endif /* CHECK_cHRM */ |
#ifdef PNG_READ_GAMMA_SUPPORTED /* gamma table code */ |
#ifndef PNG_FLOATING_ARITHMETIC_SUPPORTED |
/* Fixed point gamma. |
* |
* To calculate gamma this code implements fast log() and exp() calls using only |
* fixed point arithmetic. This code has sufficient precision for either 8 or |
* 16 bit sample values. |
* |
* The tables used here were calculated using simple 'bc' programs, but C double |
* precision floating point arithmetic would work fine. The programs are given |
* at the head of each table. |
* |
* 8 bit log table |
* This is a table of -log(value/255)/log(2) for 'value' in the range 128 to |
* 255, so it's the base 2 logarithm of a normalized 8 bit floating point |
* mantissa. The numbers are 32 bit fractions. |
*/ |
static png_uint_32 |
png_8bit_l2[128] = |
{ |
# if PNG_DO_BC |
for (i=128;i<256;++i) { .5 - l(i/255)/l(2)*65536*65536; } |
# endif |
4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U, |
3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U, |
3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U, |
3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U, |
3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U, |
2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U, |
2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U, |
2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U, |
2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U, |
2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U, |
1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U, |
1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U, |
1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U, |
1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U, |
1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U, |
971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U, |
803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U, |
639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U, |
479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U, |
324227938U, 298676034U, 273229066U, 247886176U, 222646516U, 197509248U, |
172473545U, 147538590U, 122703574U, 97967701U, 73330182U, 48790236U, |
24347096U, 0U |
#if 0 |
/* The following are the values for 16 bit tables - these work fine for the 8 |
* bit conversions but produce very slightly larger errors in the 16 bit log |
* (about 1.2 as opposed to 0.7 absolute error in the final value). To use |
* these all the shifts below must be adjusted appropriately. |
*/ |
65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054, |
57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803, |
50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068, |
43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782, |
37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887, |
31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339, |
25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098, |
20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132, |
15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415, |
10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523, |
6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495, |
1119, 744, 372 |
#endif |
}; |
static png_int_32 |
png_log8bit(unsigned int x) |
{ |
unsigned int lg2 = 0; |
/* Each time 'x' is multiplied by 2, 1 must be subtracted off the final log, |
* because the log is actually negate that means adding 1. The final |
* returned value thus has the range 0 (for 255 input) to 7.994 (for 1 |
* input), return 7.99998 for the overflow (log 0) case - so the result is |
* always at most 19 bits. |
*/ |
if ((x &= 0xff) == 0) |
return 0xffffffff; |
if ((x & 0xf0) == 0) |
lg2 = 4, x <<= 4; |
if ((x & 0xc0) == 0) |
lg2 += 2, x <<= 2; |
if ((x & 0x80) == 0) |
lg2 += 1, x <<= 1; |
/* result is at most 19 bits, so this cast is safe: */ |
return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16)); |
} |
/* The above gives exact (to 16 binary places) log2 values for 8 bit images, |
* for 16 bit images we use the most significant 8 bits of the 16 bit value to |
* get an approximation then multiply the approximation by a correction factor |
* determined by the remaining up to 8 bits. This requires an additional step |
* in the 16 bit case. |
* |
* We want log2(value/65535), we have log2(v'/255), where: |
* |
* value = v' * 256 + v'' |
* = v' * f |
* |
* So f is value/v', which is equal to (256+v''/v') since v' is in the range 128 |
* to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less |
* than 258. The final factor also needs to correct for the fact that our 8 bit |
* value is scaled by 255, whereas the 16 bit values must be scaled by 65535. |
* |
* This gives a final formula using a calculated value 'x' which is value/v' and |
* scaling by 65536 to match the above table: |
* |
* log2(x/257) * 65536 |
* |
* Since these numbers are so close to '1' we can use simple linear |
* interpolation between the two end values 256/257 (result -368.61) and 258/257 |
* (result 367.179). The values used below are scaled by a further 64 to give |
* 16 bit precision in the interpolation: |
* |
* Start (256): -23591 |
* Zero (257): 0 |
* End (258): 23499 |
*/ |
static png_int_32 |
png_log16bit(png_uint_32 x) |
{ |
unsigned int lg2 = 0; |
/* As above, but now the input has 16 bits. */ |
if ((x &= 0xffff) == 0) |
return 0xffffffff; |
if ((x & 0xff00) == 0) |
lg2 = 8, x <<= 8; |
if ((x & 0xf000) == 0) |
lg2 += 4, x <<= 4; |
if ((x & 0xc000) == 0) |
lg2 += 2, x <<= 2; |
if ((x & 0x8000) == 0) |
lg2 += 1, x <<= 1; |
/* Calculate the base logarithm from the top 8 bits as a 28 bit fractional |
* value. |
*/ |
lg2 <<= 28; |
lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4; |
/* Now we need to interpolate the factor, this requires a division by the top |
* 8 bits. Do this with maximum precision. |
*/ |
x = ((x << 16) + (x >> 9)) / (x >> 8); |
/* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24, |
* the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly |
* 16 bits to interpolate to get the low bits of the result. Round the |
* answer. Note that the end point values are scaled by 64 to retain overall |
* precision and that 'lg2' is current scaled by an extra 12 bits, so adjust |
* the overall scaling by 6-12. Round at every step. |
*/ |
x -= 1U << 24; |
if (x <= 65536U) /* <= '257' */ |
lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12); |
else |
lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12); |
/* Safe, because the result can't have more than 20 bits: */ |
return (png_int_32)((lg2 + 2048) >> 12); |
} |
/* The 'exp()' case must invert the above, taking a 20 bit fixed point |
* logarithmic value and returning a 16 or 8 bit number as appropriate. In |
* each case only the low 16 bits are relevant - the fraction - since the |
* integer bits (the top 4) simply determine a shift. |
* |
* The worst case is the 16 bit distinction between 65535 and 65534, this |
* requires perhaps spurious accuracty in the decoding of the logarithm to |
* distinguish log2(65535/65534.5) - 10^-5 or 17 bits. There is little chance |
* of getting this accuracy in practice. |
* |
* To deal with this the following exp() function works out the exponent of the |
* frational part of the logarithm by using an accurate 32 bit value from the |
* top four fractional bits then multiplying in the remaining bits. |
*/ |
static png_uint_32 |
png_32bit_exp[16] = |
{ |
# if PNG_DO_BC |
for (i=0;i<16;++i) { .5 + e(-i/16*l(2))*2^32; } |
# endif |
/* NOTE: the first entry is deliberately set to the maximum 32 bit value. */ |
4294967295U, 4112874773U, 3938502376U, 3771522796U, 3611622603U, 3458501653U, |
3311872529U, 3171459999U, 3037000500U, 2908241642U, 2784941738U, 2666869345U, |
2553802834U, 2445529972U, 2341847524U, 2242560872U |
}; |
/* Adjustment table; provided to explain the numbers in the code below. */ |
#if PNG_DO_BC |
for (i=11;i>=0;--i){ print i, " ", (1 - e(-(2^i)/65536*l(2))) * 2^(32-i), "\n"} |
11 44937.64284865548751208448 |
10 45180.98734845585101160448 |
9 45303.31936980687359311872 |
8 45364.65110595323018870784 |
7 45395.35850361789624614912 |
6 45410.72259715102037508096 |
5 45418.40724413220722311168 |
4 45422.25021786898173001728 |
3 45424.17186732298419044352 |
2 45425.13273269940811464704 |
1 45425.61317555035558641664 |
0 45425.85339951654943850496 |
#endif |
static png_uint_32 |
png_exp(png_fixed_point x) |
{ |
if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */ |
{ |
/* Obtain a 4 bit approximation */ |
png_uint_32 e = png_32bit_exp[(x >> 12) & 0xf]; |
/* Incorporate the low 12 bits - these decrease the returned value by |
* multiplying by a number less than 1 if the bit is set. The multiplier |
* is determined by the above table and the shift. Notice that the values |
* converge on 45426 and this is used to allow linear interpolation of the |
* low bits. |
*/ |
if (x & 0x800) |
e -= (((e >> 16) * 44938U) + 16U) >> 5; |
if (x & 0x400) |
e -= (((e >> 16) * 45181U) + 32U) >> 6; |
if (x & 0x200) |
e -= (((e >> 16) * 45303U) + 64U) >> 7; |
if (x & 0x100) |
e -= (((e >> 16) * 45365U) + 128U) >> 8; |
if (x & 0x080) |
e -= (((e >> 16) * 45395U) + 256U) >> 9; |
if (x & 0x040) |
e -= (((e >> 16) * 45410U) + 512U) >> 10; |
/* And handle the low 6 bits in a single block. */ |
e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9; |
/* Handle the upper bits of x. */ |
e >>= x >> 16; |
return e; |
} |
/* Check for overflow */ |
if (x <= 0) |
return png_32bit_exp[0]; |
/* Else underflow */ |
return 0; |
} |
static png_byte |
png_exp8bit(png_fixed_point lg2) |
{ |
/* Get a 32 bit value: */ |
png_uint_32 x = png_exp(lg2); |
/* Convert the 32 bit value to 0..255 by multiplying by 256-1, note that the |
* second, rounding, step can't overflow because of the first, subtraction, |
* step. |
*/ |
x -= x >> 8; |
return (png_byte)((x + 0x7fffffU) >> 24); |
} |
static png_uint_16 |
png_exp16bit(png_fixed_point lg2) |
{ |
/* Get a 32 bit value: */ |
png_uint_32 x = png_exp(lg2); |
/* Convert the 32 bit value to 0..65535 by multiplying by 65536-1: */ |
x -= x >> 16; |
return (png_uint_16)((x + 32767U) >> 16); |
} |
#endif /* FLOATING_ARITHMETIC */ |
png_byte |
png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val) |
{ |
if (value > 0 && value < 255) |
{ |
# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
double r = floor(255*pow(value/255.,gamma_val*.00001)+.5); |
return (png_byte)r; |
# else |
png_int_32 lg2 = png_log8bit(value); |
png_fixed_point res; |
if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1)) |
return png_exp8bit(res); |
/* Overflow. */ |
value = 0; |
# endif |
} |
return (png_byte)value; |
} |
png_uint_16 |
png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val) |
{ |
if (value > 0 && value < 65535) |
{ |
# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
double r = floor(65535*pow(value/65535.,gamma_val*.00001)+.5); |
return (png_uint_16)r; |
# else |
png_int_32 lg2 = png_log16bit(value); |
png_fixed_point res; |
if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1)) |
return png_exp16bit(res); |
/* Overflow. */ |
value = 0; |
# endif |
} |
return (png_uint_16)value; |
} |
/* This does the right thing based on the bit_depth field of the |
* png_struct, interpreting values as 8 or 16 bit. While the result |
* is nominally a 16 bit value if bit depth is 8 then the result is |
* 8 bit (as are the arguments.) |
*/ |
png_uint_16 /* PRIVATE */ |
png_gamma_correct(png_structp png_ptr, unsigned int value, |
png_fixed_point gamma_val) |
{ |
if (png_ptr->bit_depth == 8) |
return png_gamma_8bit_correct(value, gamma_val); |
else |
return png_gamma_16bit_correct(value, gamma_val); |
} |
/* This is the shared test on whether a gamma value is 'significant' - whether |
* it is worth doing gamma correction. |
*/ |
int /* PRIVATE */ |
png_gamma_significant(png_fixed_point gamma_val) |
{ |
return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED || |
gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED; |
} |
/* Internal function to build a single 16 bit table - the table consists of |
* 'num' 256 entry subtables, where 'num' is determined by 'shift' - the amount |
* to shift the input values right (or 16-number_of_signifiant_bits). |
* |
* The caller is responsible for ensuring that the table gets cleaned up on |
* png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument |
* should be somewhere that will be cleaned. |
*/ |
static void |
png_build_16bit_table(png_structp png_ptr, png_uint_16pp *ptable, |
PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val) |
{ |
/* Various values derived from 'shift': */ |
PNG_CONST unsigned int num = 1U << (8U - shift); |
PNG_CONST unsigned int max = (1U << (16U - shift))-1U; |
PNG_CONST unsigned int max_by_2 = 1U << (15U-shift); |
unsigned int i; |
png_uint_16pp table = *ptable = |
(png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p)); |
for (i = 0; i < num; i++) |
{ |
png_uint_16p sub_table = table[i] = |
(png_uint_16p)png_malloc(png_ptr, 256 * png_sizeof(png_uint_16)); |
/* The 'threshold' test is repeated here because it can arise for one of |
* the 16 bit tables even if the others don't hit it. |
*/ |
if (png_gamma_significant(gamma_val)) |
{ |
/* The old code would overflow at the end and this would cause the |
* 'pow' function to return a result >1, resulting in an |
* arithmetic error. This code follows the spec exactly; ig is |
* the recovered input sample, it always has 8-16 bits. |
* |
* We want input * 65535/max, rounded, the arithmetic fits in 32 |
* bits (unsigned) so long as max <= 32767. |
*/ |
unsigned int j; |
for (j = 0; j < 256; j++) |
{ |
png_uint_32 ig = (j << (8-shift)) + i; |
# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
/* Inline the 'max' scaling operation: */ |
double d = floor(65535*pow(ig/(double)max, gamma_val*.00001)+.5); |
sub_table[j] = (png_uint_16)d; |
# else |
if (shift) |
ig = (ig * 65535U + max_by_2)/max; |
sub_table[j] = png_gamma_16bit_correct(ig, gamma_val); |
# endif |
} |
} |
else |
{ |
/* We must still build a table, but do it the fast way. */ |
unsigned int j; |
for (j = 0; j < 256; j++) |
{ |
png_uint_32 ig = (j << (8-shift)) + i; |
if (shift) |
ig = (ig * 65535U + max_by_2)/max; |
sub_table[j] = (png_uint_16)ig; |
} |
} |
} |
} |
/* NOTE: this function expects the *inverse* of the overall gamma transformation |
* required. |
*/ |
static void |
png_build_16to8_table(png_structp png_ptr, png_uint_16pp *ptable, |
PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val) |
{ |
PNG_CONST unsigned int num = 1U << (8U - shift); |
PNG_CONST unsigned int max = (1U << (16U - shift))-1U; |
unsigned int i; |
png_uint_32 last; |
png_uint_16pp table = *ptable = |
(png_uint_16pp)png_calloc(png_ptr, num * png_sizeof(png_uint_16p)); |
/* 'num' is the number of tables and also the number of low bits of low |
* bits of the input 16 bit value used to select a table. Each table is |
* itself index by the high 8 bits of the value. |
*/ |
for (i = 0; i < num; i++) |
table[i] = (png_uint_16p)png_malloc(png_ptr, |
256 * png_sizeof(png_uint_16)); |
/* 'gamma_val' is set to the reciprocal of the value calculated above, so |
* pow(out,g) is an *input* value. 'last' is the last input value set. |
* |
* In the loop 'i' is used to find output values. Since the output is 8 |
* bit there are only 256 possible values. The tables are set up to |
* select the closest possible output value for each input by finding |
* the input value at the boundary between each pair of output values |
* and filling the table up to that boundary with the lower output |
* value. |
* |
* The boundary values are 0.5,1.5..253.5,254.5. Since these are 9 bit |
* values the code below uses a 16 bit value in i; the values start at |
* 128.5 (for 0.5) and step by 257, for a total of 254 values (the last |
* entries are filled with 255). Start i at 128 and fill all 'last' |
* table entries <= 'max' |
*/ |
last = 0; |
for (i = 0; i < 255; ++i) /* 8 bit output value */ |
{ |
/* Find the corresponding maximum input value */ |
png_uint_16 out = (png_uint_16)(i * 257U); /* 16 bit output value */ |
/* Find the boundary value in 16 bits: */ |
png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val); |
/* Adjust (round) to (16-shift) bits: */ |
bound = (bound * max + 32768U)/65535U + 1U; |
while (last < bound) |
{ |
table[last & (0xffU >> shift)][last >> (8U - shift)] = out; |
last++; |
} |
} |
/* And fill in the final entries. */ |
while (last < (num << 8)) |
{ |
table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U; |
last++; |
} |
} |
/* Build a single 8 bit table: same as the 16 bit case but much simpler (and |
* typically much faster). Note that libpng currently does no sBIT processing |
* (apparently contrary to the spec) so a 256 entry table is always generated. |
*/ |
static void |
png_build_8bit_table(png_structp png_ptr, png_bytepp ptable, |
PNG_CONST png_fixed_point gamma_val) |
{ |
unsigned int i; |
png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256); |
if (png_gamma_significant(gamma_val)) for (i=0; i<256; i++) |
table[i] = png_gamma_8bit_correct(i, gamma_val); |
else for (i=0; i<256; ++i) |
table[i] = (png_byte)i; |
} |
/* 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, int bit_depth) |
{ |
png_debug(1, "in png_build_gamma_table"); |
if (bit_depth <= 8) |
{ |
png_build_8bit_table(png_ptr, &png_ptr->gamma_table, |
png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma, |
png_ptr->screen_gamma) : PNG_FP_1); |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY)) |
{ |
png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1, |
png_reciprocal(png_ptr->gamma)); |
png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1, |
png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) : |
png_ptr->gamma/* Probably doing rgb_to_gray */); |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ |
} |
else |
{ |
png_byte shift, sig_bit; |
if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) |
{ |
sig_bit = png_ptr->sig_bit.red; |
if (png_ptr->sig_bit.green > sig_bit) |
sig_bit = png_ptr->sig_bit.green; |
if (png_ptr->sig_bit.blue > sig_bit) |
sig_bit = png_ptr->sig_bit.blue; |
} |
else |
sig_bit = png_ptr->sig_bit.gray; |
/* 16 bit gamma code uses this equation: |
* |
* ov = table[(iv & 0xff) >> gamma_shift][iv >> 8] |
* |
* Where 'iv' is the input color value and 'ov' is the output value - |
* pow(iv, gamma). |
* |
* Thus the gamma table consists of up to 256 256 entry tables. The table |
* is selected by the (8-gamma_shift) most significant of the low 8 bits of |
* the color value then indexed by the upper 8 bits: |
* |
* table[low bits][high 8 bits] |
* |
* So the table 'n' corresponds to all those 'iv' of: |
* |
* <all high 8 bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1> |
* |
*/ |
if (sig_bit > 0 && sig_bit < 16U) |
shift = (png_byte)(16U - sig_bit); /* shift == insignificant bits */ |
else |
shift = 0; /* keep all 16 bits */ |
if (png_ptr->transformations & PNG_16_TO_8) |
{ |
/* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively |
* the significant bits in the *input* when the output will |
* eventually be 8 bits. By default it is 11. |
*/ |
if (shift < (16U - PNG_MAX_GAMMA_8)) |
shift = (16U - PNG_MAX_GAMMA_8); |
} |
if (shift > 8U) |
shift = 8U; /* Guarantees at least one table! */ |
png_ptr->gamma_shift = shift; |
#ifdef PNG_16BIT_SUPPORTED |
if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND)) |
#endif |
png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift, |
png_ptr->screen_gamma > 0 ? png_product2(png_ptr->gamma, |
png_ptr->screen_gamma) : PNG_FP_1); |
#ifdef PNG_16BIT_SUPPORTED |
else |
png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift, |
png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->gamma, |
png_ptr->screen_gamma) : PNG_FP_1); |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ |
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) |
if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY)) |
{ |
png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift, |
png_reciprocal(png_ptr->gamma)); |
/* Notice that the '16 from 1' table should be full precision, however |
* the lookup on this table still uses gamma_shift, so it can't be. |
* TODO: fix this. |
*/ |
png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift, |
png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) : |
png_ptr->gamma/* Probably doing rgb_to_gray */); |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ |
} |
} |
#endif /* READ_GAMMA */ |
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ |
/programs/develop/libraries/libpng/png.h |
---|
0,0 → 1,2280 |
/* png.h - header file for PNG reference library |
* |
* libpng version 1.5.1 - February 3, 2011 |
* Copyright (c) 1998-2011 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 code is released under the libpng license (See LICENSE, below) |
* |
* 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.5.1 - February 3, 2011: 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 |
* 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 |
* 1.0.16 10 10016 10.so.0.1.0.16 |
* 1.2.6 13 10206 12.so.0.1.2.6 |
* 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 |
* 1.0.17rc1 10 10017 12.so.0.1.0.17rc1 |
* 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 |
* 1.0.17 10 10017 12.so.0.1.0.17 |
* 1.2.7 13 10207 12.so.0.1.2.7 |
* 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5 |
* 1.0.18rc1-5 10 10018 12.so.0.1.0.18rc1-5 |
* 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 |
* 1.0.18 10 10018 12.so.0.1.0.18 |
* 1.2.8 13 10208 12.so.0.1.2.8 |
* 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3 |
* 1.2.9beta4-11 13 10209 12.so.0.9[.0] |
* 1.2.9rc1 13 10209 12.so.0.9[.0] |
* 1.2.9 13 10209 12.so.0.9[.0] |
* 1.2.10beta1-7 13 10210 12.so.0.10[.0] |
* 1.2.10rc1-2 13 10210 12.so.0.10[.0] |
* 1.2.10 13 10210 12.so.0.10[.0] |
* 1.4.0beta1-5 14 10400 14.so.0.0[.0] |
* 1.2.11beta1-4 13 10211 12.so.0.11[.0] |
* 1.4.0beta7-8 14 10400 14.so.0.0[.0] |
* 1.2.11 13 10211 12.so.0.11[.0] |
* 1.2.12 13 10212 12.so.0.12[.0] |
* 1.4.0beta9-14 14 10400 14.so.0.0[.0] |
* 1.2.13 13 10213 12.so.0.13[.0] |
* 1.4.0beta15-36 14 10400 14.so.0.0[.0] |
* 1.4.0beta37-87 14 10400 14.so.14.0[.0] |
* 1.4.0rc01 14 10400 14.so.14.0[.0] |
* 1.4.0beta88-109 14 10400 14.so.14.0[.0] |
* 1.4.0rc02-08 14 10400 14.so.14.0[.0] |
* 1.4.0 14 10400 14.so.14.0[.0] |
* 1.4.1beta01-03 14 10401 14.so.14.1[.0] |
* 1.4.1rc01 14 10401 14.so.14.1[.0] |
* 1.4.1beta04-12 14 10401 14.so.14.1[.0] |
* 1.4.1 14 10401 14.so.14.1[.0] |
* 1.4.2 14 10402 14.so.14.2[.0] |
* 1.4.3 14 10403 14.so.14.3[.0] |
* 1.4.4 14 10404 14.so.14.4[.0] |
* 1.5.0beta01-58 15 10500 15.so.15.0[.0] |
* 1.5.0rc01-07 15 10500 15.so.15.0[.0] |
* 1.5.0 15 10500 15.so.15.0[.0] |
* 1.5.1beta01-11 15 10501 15.so.15.1[.0] |
* 1.5.1rc01-02 15 10501 15.so.15.1[.0] |
* 1.5.1 15 10501 15.so.15.1[.0] |
* |
* 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-manual.txt or libpng.3 for more information. The PNG |
* specification is available as a W3C Recommendation and as an ISO |
* Specification, <http://www.w3.org/TR/2003/REC-PNG-20031110/ |
*/ |
/* |
* COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: |
* |
* If you modify libpng you may insert additional notices immediately following |
* this sentence. |
* |
* This code is released under the libpng license. |
* |
* libpng versions 1.2.6, August 15, 2004, through 1.5.1, February 3, 2011, are |
* Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are |
* distributed according to the same disclaimer and license as libpng-1.2.5 |
* with the following individual added to the list of Contributing Authors: |
* |
* Cosmin Truta |
* |
* 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, and are |
* 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: |
* ========================= |
* |
* February 3, 2011 |
* |
* 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.5.1 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-manual.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.5.1" |
#define PNG_HEADER_VERSION_STRING \ |
" libpng version 1.5.1 - February 3, 2011\n" |
#define PNG_LIBPNG_VER_SONUM 15 |
#define PNG_LIBPNG_VER_DLLNUM 15 |
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ |
#define PNG_LIBPNG_VER_MAJOR 1 |
#define PNG_LIBPNG_VER_MINOR 5 |
#define PNG_LIBPNG_VER_RELEASE 1 |
/* 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 |
/* Release Status */ |
#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_RELEASE_STATUS_MASK 7 |
/* Release-Specific Flags */ |
#define PNG_LIBPNG_BUILD_PATCH 8 /* Can be OR'ed with |
PNG_LIBPNG_BUILD_STABLE only */ |
#define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with |
PNG_LIBPNG_BUILD_SPECIAL */ |
#define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with |
PNG_LIBPNG_BUILD_PRIVATE */ |
#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_BETA |
/* 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 10501 /* 1.5.1 */ |
/* Library configuration: these options cannot be changed after |
* the library has been built. |
*/ |
#ifndef PNGLCONF_H |
/* If pnglibconf.h is missing, you can |
* copy scripts/pnglibconf.h.prebuilt to pnglibconf.h |
*/ |
# include "pnglibconf.h" |
#endif |
#ifndef PNG_VERSION_INFO_ONLY |
/* Standard header files (not needed for the version info) */ |
# ifdef PNG_SETJMP_SUPPORTED |
# include <setjmp.h> |
# endif |
/* Need the time information for converting tIME chunks, it |
* defines struct tm: |
*/ |
#ifdef PNG_CONVERT_tIME_SUPPORTED |
/* "time.h" functions are not supported on all operating systems */ |
# include <time.h> |
#endif |
/* Machine specific configuration. */ |
# include "pngconf.h" |
#endif |
/* |
* Added at libpng-1.2.8 |
* |
* Ref MSDN: Private as priority over Special |
* VS_FF_PRIVATEBUILD File *was not* built using standard release |
* procedures. If this value is given, the StringFileInfo block must |
* contain a PrivateBuild string. |
* |
* VS_FF_SPECIALBUILD File *was* built by the original company using |
* standard release procedures but is a variation of the standard |
* file of the same version number. If this value is given, the |
* StringFileInfo block must contain a SpecialBuild string. |
*/ |
#ifdef PNG_USER_PRIVATEBUILD /* From pnglibconf.h */ |
# define PNG_LIBPNG_BUILD_TYPE \ |
(PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE) |
#else |
# ifdef PNG_LIBPNG_SPECIALBUILD |
# define PNG_LIBPNG_BUILD_TYPE \ |
(PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL) |
# else |
# define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE) |
# endif |
#endif |
#ifndef PNG_VERSION_INFO_ONLY |
/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ |
#ifdef __cplusplus |
extern "C" { |
#endif /* __cplusplus */ |
/* Version information for C files, stored in png.c. This had better match |
* the version above. |
*/ |
#define png_libpng_ver png_get_header_ver(NULL) |
/* This file is arranged in several sections: |
* |
* 1. Any configuration options that can be specified by for the application |
* code when it is built. (Build time configuration is in pnglibconf.h) |
* 2. Type definitions (base types are defined in pngconf.h), structure |
* definitions. |
* 3. Exported library functions. |
* |
* The library source code has additional files (principally pngpriv.h) that |
* allow configuration of the library. |
*/ |
/* Section 1: run time configuration |
* See pnglibconf.h for build time configuration |
* |
* Run time configuration allows the application to choose between |
* implementations of certain arithmetic APIs. The default is set |
* at build time and recorded in pnglibconf.h, but it is safe to |
* override these (and only these) settings. Note that this won't |
* change what the library does, only application code, and the |
* settings can (and probably should) be made on a per-file basis |
* by setting the #defines before including png.h |
* |
* Use macros to read integers from PNG data or use the exported |
* functions? |
* PNG_USE_READ_MACROS: use the macros (see below) Note that |
* the macros evaluate their argument multiple times. |
* PNG_NO_USE_READ_MACROS: call the relevant library function. |
* |
* Use the alternative algorithm for compositing alpha samples that |
* does not use division? |
* PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division' |
* algorithm. |
* PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm. |
* |
* How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is |
* false? |
* PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error |
* APIs to png_warning. |
* Otherwise the calls are mapped to png_error. |
*/ |
/* Section 2: type definitions, including structures and compile time |
* constants. |
* See pngconf.h for base types that vary by machine/system |
*/ |
/* This triggers a compiler error in png.c, if png.c and png.h |
* do not agree upon the version number. |
*/ |
typedef char* png_libpng_version_1_5_1; |
/* 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_CONST png_color FAR * png_const_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_CONST png_color_16 FAR * png_const_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_CONST png_color_8 FAR * png_const_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_CONST png_sPLT_entry FAR * png_const_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_CONST png_sPLT_t FAR * png_const_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 */ |
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 */ |
} png_text; |
typedef png_text FAR * png_textp; |
typedef PNG_CONST png_text FAR * png_const_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_CONST png_time FAR * png_const_timep; |
typedef png_time FAR * FAR * png_timepp; |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ |
defined(PNG_HANDLE_AS_UNKNOWN_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_CONST png_unknown_chunk FAR * png_const_unknown_chunkp; |
typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; |
#endif |
typedef struct png_info_def png_info; |
typedef png_info FAR * png_infop; |
typedef PNG_CONST png_info FAR * png_const_infop; |
typedef png_info FAR * FAR * png_infopp; |
/* Maximum positive integer used in PNG is (2^31)-1 */ |
#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL) |
#define PNG_UINT_32_MAX ((png_uint_32)(-1)) |
#define PNG_SIZE_MAX ((png_size_t)(-1)) |
/* These are constants for fixed point values encoded in the |
* PNG specification manner (x100000) |
*/ |
#define PNG_FP_1 100000 |
#define PNG_FP_HALF 50000 |
/* 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_size_t 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. Note that the 'write' function must not |
* modify the buffer it is passed. The 'read' function, on the other hand, is |
* expected to return the read data in the buffer. |
*/ |
typedef struct png_struct_def png_struct; |
typedef PNG_CONST png_struct FAR * png_const_structp; |
typedef png_struct FAR * png_structp; |
typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp), ); |
typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t), ); |
typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp), ); |
typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32, |
int), ); |
typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32, |
int), ); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
typedef PNG_CALLBACK(void, *png_progressive_info_ptr, |
(png_structp, png_infop), ); |
typedef PNG_CALLBACK(void, *png_progressive_end_ptr, |
(png_structp, png_infop), ); |
typedef PNG_CALLBACK(void, *png_progressive_row_ptr, |
(png_structp, png_bytep, png_uint_32, int), ); |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
typedef PNG_CALLBACK(void, *png_user_transform_ptr, |
(png_structp, png_row_infop, png_bytep), ); |
#endif |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp, |
png_unknown_chunkp), ); |
#endif |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp), ); |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* This must match the function definition in <setjmp.h>, and the |
* application must include this before png.h to obtain the definition |
* of jmp_buf. The function is required to be PNG_NORETURN. (Note that |
* PNG_PTR_NORETURN is used here because current versions of the Microsoft |
* C compiler do not support the PNG_NORETURN attribute on a pointer.) |
* |
* If you get a type warning from the compiler when linking against this line |
* then your compiler has 'longjmp' that does not match the requirements of the |
* compiler that built libpng. You will have to write a wrapper function for |
* your compiler's longjmp and call png_set_longjmp_fn directly (not via the |
* png_jmpbuf macro.) |
* |
* If you get a warning here while building the library you will need to make |
* changes to ensure that pnglibconf.h records the calling convention used by |
* your compiler. This may be very difficult - try using a different compiler |
* to build the library! |
*/ |
typedef PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), |
PNG_PTR_NORETURN); |
#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 */ |
/* Added to libpng-1.2.34 */ |
#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER |
#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ |
/* Added to libpng-1.4.0 */ |
#define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read 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 |
/* NOTE: prior to 1.5 these functions had no 'API' style declaration, |
* this allowed the zlib default functions to be used on Windows |
* platforms. In 1.5 the zlib default malloc (which just calls malloc and |
* ignores the first argument) should be completely compatible with the |
* following. |
*/ |
typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp, |
png_alloc_size_t), ); |
typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp), ); |
typedef png_struct FAR * FAR * png_structpp; |
/* Section 3: exported functions |
* Here are the function definitions most commonly used. This is not |
* the place to find out how to use libpng. See libpng-manual.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. |
* |
* The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in |
* pngconf.h and in the *.dfn files in the scripts directory. |
* |
* PNG_EXPORT(ordinal, type, name, (args)); |
* |
* ordinal: ordinal that is used while building |
* *.def files. The ordinal value is only |
* relevant when preprocessing png.h with |
* the *.dfn files for building symbol table |
* entries, and are removed by pngconf.h. |
* type: return type of the function |
* name: function name |
* args: function arguments, with types |
* |
* When we wish to append attributes to a function prototype we use |
* the PNG_EXPORTA() macro instead. |
* |
* PNG_EXPORTA(ordinal, type, name, (args), attributes); |
* |
* ordinal, type, name, and args: same as in PNG_EXPORT(). |
* attributes: function attributes |
*/ |
/* Returns the version number of the library */ |
PNG_EXPORT(1, png_uint_32, png_access_version_number, (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. |
*/ |
PNG_EXPORT(2, void, png_set_sig_bytes, (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). |
*/ |
PNG_EXPORT(3, int, png_sig_cmp, (png_const_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). |
*/ |
#define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n)) |
/* Allocate and initialize png_ptr struct for reading, and any other memory. */ |
PNG_EXPORTA(4, png_structp, png_create_read_struct, |
(png_const_charp user_png_ver, png_voidp error_ptr, |
png_error_ptr error_fn, png_error_ptr warn_fn), |
PNG_ALLOCATED); |
/* Allocate and initialize png_ptr struct for writing, and any other memory */ |
PNG_EXPORTA(5, png_structp, png_create_write_struct, |
(png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, |
png_error_ptr warn_fn), |
PNG_ALLOCATED); |
PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size, |
(png_const_structp png_ptr)); |
PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structp png_ptr, |
png_size_t size)); |
/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp |
* match up. |
*/ |
#ifdef PNG_SETJMP_SUPPORTED |
/* This function returns the jmp_buf built in to *png_ptr. It must be |
* supplied with an appropriate 'longjmp' function to use on that jmp_buf |
* unless the default error function is overridden in which case NULL is |
* acceptable. The size of the jmp_buf is checked against the actual size |
* allocated by the library - the call will return NULL on a mismatch |
* indicating an ABI mismatch. |
*/ |
PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structp png_ptr, |
png_longjmp_ptr longjmp_fn, size_t jmp_buf_size)); |
# define png_jmpbuf(png_ptr) \ |
(*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf))) |
#else |
# define png_jmpbuf(png_ptr) \ |
(LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) |
#endif |
/* This function should be used by libpng applications in place of |
* longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it |
* will use it; otherwise it will call PNG_ABORT(). This function was |
* added in libpng-1.5.0. |
*/ |
PNG_EXPORTA(9, void, png_longjmp, (png_structp png_ptr, int val), |
PNG_NORETURN); |
#ifdef PNG_READ_SUPPORTED |
/* Reset the compression stream */ |
PNG_EXPORT(10, int, png_reset_zstream, (png_structp png_ptr)); |
#endif |
/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ |
#ifdef PNG_USER_MEM_SUPPORTED |
PNG_EXPORTA(11, png_structp, 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), |
PNG_ALLOCATED); |
PNG_EXPORTA(12, png_structp, 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), |
PNG_ALLOCATED); |
#endif |
/* Write the PNG file signature. */ |
PNG_EXPORT(13, void, png_write_sig, (png_structp png_ptr)); |
/* Write a PNG chunk - size, type, (optional) data, CRC. */ |
PNG_EXPORT(14, void, png_write_chunk, (png_structp png_ptr, png_const_bytep |
chunk_name, png_const_bytep data, png_size_t length)); |
/* Write the start of a PNG chunk - length and chunk name. */ |
PNG_EXPORT(15, void, png_write_chunk_start, (png_structp png_ptr, |
png_const_bytep chunk_name, png_uint_32 length)); |
/* Write the data of a PNG chunk started with png_write_chunk_start(). */ |
PNG_EXPORT(16, void, png_write_chunk_data, (png_structp png_ptr, |
png_const_bytep data, png_size_t length)); |
/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ |
PNG_EXPORT(17, void, png_write_chunk_end, (png_structp png_ptr)); |
/* Allocate and initialize the info structure */ |
PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_structp png_ptr), |
PNG_ALLOCATED); |
PNG_EXPORT(19, void, png_info_init_3, (png_infopp info_ptr, |
png_size_t png_info_struct_size)); |
/* Writes all the PNG information before the image. */ |
PNG_EXPORT(20, void, png_write_info_before_PLTE, |
(png_structp png_ptr, png_infop info_ptr)); |
PNG_EXPORT(21, void, png_write_info, |
(png_structp png_ptr, png_infop info_ptr)); |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read the information before the actual image data. */ |
PNG_EXPORT(22, void, png_read_info, |
(png_structp png_ptr, png_infop info_ptr)); |
#endif |
#ifdef PNG_TIME_RFC1123_SUPPORTED |
PNG_EXPORT(23, png_const_charp, png_convert_to_rfc1123, |
(png_structp png_ptr, |
png_const_timep ptime)); |
#endif |
#ifdef PNG_CONVERT_tIME_SUPPORTED |
/* Convert from a struct tm to png_time */ |
PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime, |
PNG_CONST struct tm FAR * ttime)); |
/* Convert from time_t to png_time. Uses gmtime() */ |
PNG_EXPORT(25, void, png_convert_from_time_t, |
(png_timep ptime, time_t ttime)); |
#endif /* PNG_CONVERT_tIME_SUPPORTED */ |
#ifdef PNG_READ_EXPAND_SUPPORTED |
/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ |
PNG_EXPORT(26, void, png_set_expand, (png_structp png_ptr)); |
PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structp png_ptr)); |
PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structp png_ptr)); |
PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) |
/* Use blue, green, red order for pixels. */ |
PNG_EXPORT(30, void, png_set_bgr, (png_structp png_ptr)); |
#endif |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
/* Expand the grayscale to 24-bit RGB if necessary. */ |
PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structp png_ptr)); |
#endif |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
/* Reduce RGB to grayscale. */ |
PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structp png_ptr, |
int error_action, double red, double green)); |
PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structp png_ptr, |
int error_action, png_fixed_point red, png_fixed_point green)); |
PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structp |
png_ptr)); |
#endif |
PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth, |
png_colorp palette)); |
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
PNG_EXPORT(36, void, png_set_strip_alpha, (png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) |
PNG_EXPORT(37, void, png_set_swap_alpha, (png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ |
defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) |
PNG_EXPORT(38, void, png_set_invert_alpha, (png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) |
/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ |
PNG_EXPORT(39, void, png_set_filler, (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 |
/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ |
PNG_EXPORT(40, void, png_set_add_alpha, |
(png_structp png_ptr, png_uint_32 filler, |
int flags)); |
#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. */ |
PNG_EXPORT(41, void, png_set_swap, (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. */ |
PNG_EXPORT(42, void, png_set_packing, (png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ |
defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
/* Swap packing order of pixels in bytes. */ |
PNG_EXPORT(43, void, png_set_packswap, (png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) |
/* Converts files to legal bit depths. */ |
PNG_EXPORT(44, void, png_set_shift, (png_structp png_ptr, png_const_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. |
* MUST be called before png_read_update_info or png_start_read_image, |
* otherwise it will not have the desired effect. Note that it is still |
* necessary to call png_read_row or png_read_rows png_get_image_height |
* times for each pass. |
*/ |
PNG_EXPORT(45, int, png_set_interlace_handling, (png_structp png_ptr)); |
#endif |
#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) |
/* Invert monochrome files */ |
PNG_EXPORT(46, void, png_set_invert_mono, (png_structp png_ptr)); |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
/* Handle alpha and tRNS by replacing with a background color. */ |
PNG_FP_EXPORT(47, void, png_set_background, (png_structp png_ptr, |
png_const_color_16p background_color, int background_gamma_code, |
int need_expand, double background_gamma)); |
PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structp png_ptr, |
png_const_color_16p background_color, int background_gamma_code, |
int need_expand, png_fixed_point background_gamma)); |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
# 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 |
#ifdef PNG_READ_16_TO_8_SUPPORTED |
/* Strip the second byte of information from a 16-bit depth file. */ |
PNG_EXPORT(48, void, png_set_strip_16, (png_structp png_ptr)); |
#endif |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
/* Turn on quantizing, and reduce the palette to the number of colors |
* available. |
*/ |
PNG_EXPORT(49, void, png_set_quantize, |
(png_structp png_ptr, png_colorp palette, |
int num_palette, int maximum_colors, png_const_uint_16p histogram, |
int full_quantize)); |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
/* The threshold on gamma processing is configurable but hard-wired into the |
* library. The following is the floating point variant. |
*/ |
#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001) |
/* Handle gamma correction. Screen_gamma=(display_exponent) */ |
PNG_FP_EXPORT(50, void, png_set_gamma, |
(png_structp png_ptr, double screen_gamma, |
double default_file_gamma)); |
PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structp png_ptr, |
png_fixed_point screen_gamma, png_fixed_point default_file_gamma)); |
#endif |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
/* Set how many lines between output flushes - 0 for no flushing */ |
PNG_EXPORT(51, void, png_set_flush, (png_structp png_ptr, int nrows)); |
/* Flush the current PNG output buffer */ |
PNG_EXPORT(52, void, png_write_flush, (png_structp png_ptr)); |
#endif |
/* Optional update palette with requested transformations */ |
PNG_EXPORT(53, void, png_start_read_image, (png_structp png_ptr)); |
/* Optional call to update the users info structure */ |
PNG_EXPORT(54, void, png_read_update_info, |
(png_structp png_ptr, png_infop info_ptr)); |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read one or more rows of image data. */ |
PNG_EXPORT(55, void, png_read_rows, (png_structp png_ptr, png_bytepp row, |
png_bytepp display_row, png_uint_32 num_rows)); |
#endif |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read a row of data. */ |
PNG_EXPORT(56, void, png_read_row, (png_structp png_ptr, png_bytep row, |
png_bytep display_row)); |
#endif |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read the whole image into memory at once. */ |
PNG_EXPORT(57, void, png_read_image, (png_structp png_ptr, png_bytepp image)); |
#endif |
/* Write a row of image data */ |
PNG_EXPORT(58, void, png_write_row, |
(png_structp png_ptr, png_const_bytep row)); |
/* Write a few rows of image data: (*row) is not written; however, the type |
* is declared as writeable to maintain compatibility with previous versions |
* of libpng and to allow the 'display_row' array from read_rows to be passed |
* unchanged to write_rows. |
*/ |
PNG_EXPORT(59, void, png_write_rows, (png_structp png_ptr, png_bytepp row, |
png_uint_32 num_rows)); |
/* Write the image data */ |
PNG_EXPORT(60, void, png_write_image, |
(png_structp png_ptr, png_bytepp image)); |
/* Write the end of the PNG file. */ |
PNG_EXPORT(61, void, png_write_end, |
(png_structp png_ptr, png_infop info_ptr)); |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* Read the end of the PNG file. */ |
PNG_EXPORT(62, void, png_read_end, (png_structp png_ptr, png_infop info_ptr)); |
#endif |
/* Free any memory associated with the png_info_struct */ |
PNG_EXPORT(63, void, png_destroy_info_struct, (png_structp png_ptr, |
png_infopp info_ptr_ptr)); |
/* Free any memory associated with the png_struct and the png_info_structs */ |
PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr, |
png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); |
/* Free any memory associated with the png_struct and the png_info_structs */ |
PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr, |
png_infopp info_ptr_ptr)); |
/* Set the libpng method of handling chunk CRC errors */ |
PNG_EXPORT(66, void, png_set_crc_action, |
(png_structp png_ptr, int crit_action, int ancil_action)); |
/* Values for png_set_crc_action() 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. |
*/ |
PNG_EXPORT(67, void, png_set_filter, |
(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 |
#ifdef 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. |
*/ |
PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structp png_ptr, |
int heuristic_method, int num_weights, png_const_doublep filter_weights, |
png_const_doublep filter_costs)); |
PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed, |
(png_structp png_ptr, |
int heuristic_method, int num_weights, png_const_fixed_point_p |
filter_weights, png_const_fixed_point_p filter_costs)); |
#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. |
*/ |
PNG_EXPORT(69, void, png_set_compression_level, |
(png_structp png_ptr, int level)); |
PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structp png_ptr, |
int mem_level)); |
PNG_EXPORT(71, void, png_set_compression_strategy, (png_structp png_ptr, |
int strategy)); |
PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structp png_ptr, |
int window_bits)); |
PNG_EXPORT(73, void, png_set_compression_method, (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-manual.txt for |
* more information. |
*/ |
#ifdef PNG_STDIO_SUPPORTED |
/* Initialize the input/output for the PNG file to the default functions. */ |
PNG_EXPORT(74, void, png_init_io, (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. |
*/ |
PNG_EXPORT(75, void, png_set_error_fn, |
(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 */ |
PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_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). |
* It is probably a mistake to use NULL for output_flush_fn if |
* write_data_fn is not also NULL unless you have built libpng with |
* PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's |
* default flush function, which uses the standard *FILE structure, will |
* be used. |
*/ |
PNG_EXPORT(77, void, png_set_write_fn, (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. */ |
PNG_EXPORT(78, void, png_set_read_fn, (png_structp png_ptr, png_voidp io_ptr, |
png_rw_ptr read_data_fn)); |
/* Return the user pointer associated with the I/O functions */ |
PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_structp png_ptr)); |
PNG_EXPORT(80, void, png_set_read_status_fn, (png_structp png_ptr, |
png_read_status_ptr read_row_fn)); |
PNG_EXPORT(81, void, png_set_write_status_fn, (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). */ |
PNG_EXPORT(82, void, png_set_mem_fn, (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 */ |
PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structp png_ptr)); |
#endif |
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED |
PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structp png_ptr, |
png_user_transform_ptr read_user_transform_fn)); |
#endif |
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED |
PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structp png_ptr, |
png_user_transform_ptr write_user_transform_fn)); |
#endif |
#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED |
PNG_EXPORT(86, void, png_set_user_transform_info, (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 */ |
PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr, |
(png_const_structp png_ptr)); |
#endif |
#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED |
/* Return information about the row currently being processed. Note that these |
* APIs do not fail but will return unexpected results if called outside a user |
* transform callback. Also note that when transforming an interlaced image the |
* row number is still the row in the final, de-interlaced, image but the row |
* only contains the data of the current pass - consult png_row_info for the |
* actual width of the row! |
*/ |
PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structp)); |
PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structp)); |
#endif |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structp png_ptr, |
png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); |
PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_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. |
*/ |
PNG_EXPORT(90, void, 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)); |
/* Returns the user pointer associated with the push read functions */ |
PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, (png_const_structp png_ptr)); |
/* Function to be called when data becomes available */ |
PNG_EXPORT(92, void, png_process_data, |
(png_structp png_ptr, png_infop info_ptr, |
png_bytep buffer, png_size_t buffer_size)); |
/* A function which may be called *only* within png_process_data to stop the |
* processing of any more data. The function returns the number of bytes |
* remaining, excluding any that libpng has cached internally. A subsequent |
* call to png_process_data must supply these bytes again. If the argument |
* 'save' is set to true the routine will first save all the pending data and |
* will always return 0. |
*/ |
PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structp, int save)); |
/* A function which may be called *only* outside (after) a call to |
* png_process_data. It returns the number of bytes of data to skip in the |
* input. Normally it will return 0, but if it returns a non-zero value the |
* application must skip than number of bytes of input data and pass the |
* following data to the next call to png_process_data. |
*/ |
PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structp)); |
/* Function that combines rows. 'new_row' is a flag that should come from |
* the callback and be non-NULL if anything needs to be done; the library |
* stores its own version of the new data internally and ignores the passed |
* in value. |
*/ |
PNG_EXPORT(93, void, png_progressive_combine_row, (png_structp png_ptr, |
png_bytep old_row, png_const_bytep new_row)); |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
PNG_EXPORTA(94, png_voidp, png_malloc, |
(png_structp png_ptr, png_alloc_size_t size), |
PNG_ALLOCATED); |
/* Added at libpng version 1.4.0 */ |
PNG_EXPORTA(95, png_voidp, png_calloc, |
(png_structp png_ptr, png_alloc_size_t size), |
PNG_ALLOCATED); |
/* Added at libpng version 1.2.4 */ |
PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_structp png_ptr, |
png_alloc_size_t size), PNG_ALLOCATED); |
/* Frees a pointer allocated by png_malloc() */ |
PNG_EXPORT(97, void, png_free, (png_structp png_ptr, png_voidp ptr)); |
/* Free data that was allocated internally */ |
PNG_EXPORT(98, void, png_free_data, |
(png_structp png_ptr, png_infop info_ptr, png_uint_32 free_me, int num)); |
/* Reassign responsibility for freeing existing data, whether allocated |
* by libpng or by the application */ |
PNG_EXPORT(99, void, png_data_freer, |
(png_structp png_ptr, png_infop info_ptr, int freer, png_uint_32 mask)); |
/* 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 |
PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_structp png_ptr, |
png_alloc_size_t size), PNG_ALLOCATED); |
PNG_EXPORT(101, void, png_free_default, (png_structp png_ptr, png_voidp ptr)); |
#endif |
#ifdef PNG_ERROR_TEXT_SUPPORTED |
/* Fatal error in PNG image of libpng - can't continue */ |
PNG_EXPORTA(102, void, png_error, |
(png_structp png_ptr, png_const_charp error_message), |
PNG_NORETURN); |
/* The same, but the chunk name is prepended to the error string. */ |
PNG_EXPORTA(103, void, png_chunk_error, (png_structp png_ptr, |
png_const_charp error_message), PNG_NORETURN); |
#else |
/* Fatal error in PNG image of libpng - can't continue */ |
PNG_EXPORTA(104, void, png_err, (png_structp png_ptr), PNG_NORETURN); |
#endif |
/* Non-fatal error in libpng. Can continue, but may have a problem. */ |
PNG_EXPORT(105, void, png_warning, (png_structp png_ptr, |
png_const_charp warning_message)); |
/* Non-fatal error in libpng, chunk name is prepended to message. */ |
PNG_EXPORT(106, void, png_chunk_warning, (png_structp png_ptr, |
png_const_charp warning_message)); |
#ifdef PNG_BENIGN_ERRORS_SUPPORTED |
/* Benign error in libpng. Can continue, but may have a problem. |
* User can choose whether to handle as a fatal error or as a warning. */ |
# undef png_benign_error |
PNG_EXPORT(107, void, png_benign_error, (png_structp png_ptr, |
png_const_charp warning_message)); |
/* Same, chunk name is prepended to message. */ |
# undef png_chunk_benign_error |
PNG_EXPORT(108, void, png_chunk_benign_error, (png_structp png_ptr, |
png_const_charp warning_message)); |
PNG_EXPORT(109, void, png_set_benign_errors, |
(png_structp png_ptr, int allowed)); |
#else |
# ifdef PNG_ALLOW_BENIGN_ERRORS |
# define png_benign_error png_warning |
# define png_chunk_benign_error png_chunk_warning |
# else |
# define png_benign_error png_error |
# define png_chunk_benign_error png_chunk_error |
# endif |
#endif |
/* 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. */ |
PNG_EXPORT(110, png_uint_32, png_get_valid, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_uint_32 flag)); |
/* Returns number of bytes needed to hold a transformed row. */ |
PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
/* Returns row_pointers, which is an array of pointers to scanlines that was |
* returned from png_read_png(). |
*/ |
PNG_EXPORT(112, png_bytepp, png_get_rows, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
/* Set row_pointers, which is an array of pointers to scanlines for use |
* by png_write_png(). |
*/ |
PNG_EXPORT(113, void, png_set_rows, (png_structp png_ptr, |
png_infop info_ptr, png_bytepp row_pointers)); |
#endif |
/* Returns number of color channels in image. */ |
PNG_EXPORT(114, png_byte, png_get_channels, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
#ifdef PNG_EASY_ACCESS_SUPPORTED |
/* Returns image width in pixels. */ |
PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
/* Returns image height in pixels. */ |
PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
/* Returns image bit_depth. */ |
PNG_EXPORT(117, png_byte, png_get_bit_depth, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
/* Returns image color_type. */ |
PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
/* Returns image filter_type. */ |
PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
/* Returns image interlace_type. */ |
PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
/* Returns image compression_type. */ |
PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
/* Returns image resolution in pixels per meter, from pHYs chunk data. */ |
PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
/* Returns pixel aspect ratio, computed from pHYs chunk data. */ |
PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ |
PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_EXPORT(128, png_int_32, png_get_x_offset_microns, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_EXPORT(129, png_int_32, png_get_y_offset_microns, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
#endif /* PNG_EASY_ACCESS_SUPPORTED */ |
/* Returns pointer to signature string read from PNG header */ |
PNG_EXPORT(130, png_const_bytep, png_get_signature, |
(png_const_structp png_ptr, png_infop info_ptr)); |
#ifdef PNG_bKGD_SUPPORTED |
PNG_EXPORT(131, png_uint_32, png_get_bKGD, |
(png_const_structp png_ptr, png_infop info_ptr, |
png_color_16p *background)); |
#endif |
#ifdef PNG_bKGD_SUPPORTED |
PNG_EXPORT(132, void, png_set_bKGD, (png_structp png_ptr, png_infop info_ptr, |
png_const_color_16p background)); |
#endif |
#ifdef PNG_cHRM_SUPPORTED |
PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structp png_ptr, |
png_const_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)); |
#ifdef PNG_FIXED_POINT_SUPPORTED /* Otherwise not implemented */ |
PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed, |
(png_const_structp png_ptr, |
png_const_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 |
#ifdef PNG_cHRM_SUPPORTED |
PNG_FP_EXPORT(135, void, 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_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (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 |
#ifdef PNG_gAMA_SUPPORTED |
PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
double *file_gamma)); |
PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_fixed_point *int_file_gamma)); |
#endif |
#ifdef PNG_gAMA_SUPPORTED |
PNG_FP_EXPORT(139, void, png_set_gAMA, (png_structp png_ptr, |
png_infop info_ptr, double file_gamma)); |
PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_structp png_ptr, |
png_infop info_ptr, png_fixed_point int_file_gamma)); |
#endif |
#ifdef PNG_hIST_SUPPORTED |
PNG_EXPORT(141, png_uint_32, png_get_hIST, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_uint_16p *hist)); |
#endif |
#ifdef PNG_hIST_SUPPORTED |
PNG_EXPORT(142, void, png_set_hIST, (png_structp png_ptr, |
png_infop info_ptr, png_const_uint_16p hist)); |
#endif |
PNG_EXPORT(143, png_uint_32, 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_method, int *compression_method, int *filter_method)); |
PNG_EXPORT(144, void, 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_method, int compression_method, int filter_method)); |
#ifdef PNG_oFFs_SUPPORTED |
PNG_EXPORT(145, png_uint_32, png_get_oFFs, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)); |
#endif |
#ifdef PNG_oFFs_SUPPORTED |
PNG_EXPORT(146, void, png_set_oFFs, |
(png_structp png_ptr, png_infop info_ptr, |
png_int_32 offset_x, png_int_32 offset_y, int unit_type)); |
#endif |
#ifdef PNG_pCAL_SUPPORTED |
PNG_EXPORT(147, png_uint_32, png_get_pCAL, |
(png_const_structp png_ptr, png_const_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 |
#ifdef PNG_pCAL_SUPPORTED |
PNG_EXPORT(148, void, png_set_pCAL, (png_structp png_ptr, |
png_infop info_ptr, |
png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type, |
int nparams, png_const_charp units, png_charpp params)); |
#endif |
#ifdef PNG_pHYs_SUPPORTED |
PNG_EXPORT(149, png_uint_32, png_get_pHYs, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); |
#endif |
#ifdef PNG_pHYs_SUPPORTED |
PNG_EXPORT(150, void, png_set_pHYs, |
(png_structp png_ptr, png_infop info_ptr, |
png_uint_32 res_x, png_uint_32 res_y, int unit_type)); |
#endif |
PNG_EXPORT(151, png_uint_32, png_get_PLTE, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_colorp *palette, int *num_palette)); |
PNG_EXPORT(152, void, png_set_PLTE, |
(png_structp png_ptr, png_infop info_ptr, |
png_const_colorp palette, int num_palette)); |
#ifdef PNG_sBIT_SUPPORTED |
PNG_EXPORT(153, png_uint_32, png_get_sBIT, |
(png_const_structp png_ptr, png_infop info_ptr, |
png_color_8p *sig_bit)); |
#endif |
#ifdef PNG_sBIT_SUPPORTED |
PNG_EXPORT(154, void, png_set_sBIT, |
(png_structp png_ptr, png_infop info_ptr, png_const_color_8p sig_bit)); |
#endif |
#ifdef PNG_sRGB_SUPPORTED |
PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structp png_ptr, |
png_const_infop info_ptr, int *file_srgb_intent)); |
#endif |
#ifdef PNG_sRGB_SUPPORTED |
PNG_EXPORT(156, void, png_set_sRGB, |
(png_structp png_ptr, png_infop info_ptr, int srgb_intent)); |
PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_structp png_ptr, |
png_infop info_ptr, int srgb_intent)); |
#endif |
#ifdef PNG_iCCP_SUPPORTED |
PNG_EXPORT(158, png_uint_32, png_get_iCCP, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_charpp name, int *compression_type, png_bytepp profile, |
png_uint_32 *proflen)); |
#endif |
#ifdef PNG_iCCP_SUPPORTED |
PNG_EXPORT(159, void, png_set_iCCP, |
(png_structp png_ptr, png_infop info_ptr, |
png_const_charp name, int compression_type, png_const_bytep profile, |
png_uint_32 proflen)); |
#endif |
#ifdef PNG_sPLT_SUPPORTED |
PNG_EXPORT(160, png_uint_32, png_get_sPLT, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
png_sPLT_tpp entries)); |
#endif |
#ifdef PNG_sPLT_SUPPORTED |
PNG_EXPORT(161, void, png_set_sPLT, |
(png_structp png_ptr, png_infop info_ptr, |
png_const_sPLT_tp entries, int nentries)); |
#endif |
#ifdef PNG_TEXT_SUPPORTED |
/* png_get_text also returns the number of text chunks in *num_text */ |
PNG_EXPORT(162, png_uint_32, png_get_text, |
(png_const_structp png_ptr, png_const_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. |
*/ |
#ifdef PNG_TEXT_SUPPORTED |
PNG_EXPORT(163, void, png_set_text, |
(png_structp png_ptr, png_infop info_ptr, |
png_const_textp text_ptr, int num_text)); |
#endif |
#ifdef PNG_tIME_SUPPORTED |
PNG_EXPORT(164, png_uint_32, png_get_tIME, |
(png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time)); |
#endif |
#ifdef PNG_tIME_SUPPORTED |
PNG_EXPORT(165, void, png_set_tIME, |
(png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time)); |
#endif |
#ifdef PNG_tRNS_SUPPORTED |
PNG_EXPORT(166, png_uint_32, png_get_tRNS, |
(png_const_structp png_ptr, png_infop info_ptr, |
png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)); |
#endif |
#ifdef PNG_tRNS_SUPPORTED |
PNG_EXPORT(167, void, png_set_tRNS, |
(png_structp png_ptr, png_infop info_ptr, |
png_const_bytep trans_alpha, int num_trans, |
png_const_color_16p trans_color)); |
#endif |
#ifdef PNG_sCAL_SUPPORTED |
PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
int *unit, double *width, double *height)); |
#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
/* NOTE: this API is currently implemented using floating point arithmetic, |
* consequently it can only be used on systems with floating point support. |
* In any case the range of values supported by png_fixed_point is small and it |
* is highly recommended that png_get_sCAL_s be used instead. |
*/ |
PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed, |
(png_structp png_ptr, png_const_infop info_ptr, int *unit, |
png_fixed_point *width, |
png_fixed_point *height)); |
#endif |
PNG_EXPORT(169, png_uint_32, png_get_sCAL_s, |
(png_const_structp png_ptr, png_const_infop info_ptr, |
int *unit, png_charpp swidth, png_charpp sheight)); |
PNG_FP_EXPORT(170, void, png_set_sCAL, |
(png_structp png_ptr, png_infop info_ptr, |
int unit, double width, double height)); |
PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_structp png_ptr, |
png_infop info_ptr, int unit, png_fixed_point width, |
png_fixed_point height)); |
PNG_EXPORT(171, void, png_set_sCAL_s, |
(png_structp png_ptr, png_infop info_ptr, |
int unit, png_const_charp swidth, png_const_charp sheight)); |
#endif /* PNG_sCAL_SUPPORTED */ |
#ifdef PNG_HANDLE_AS_UNKNOWN_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 behaviour |
= 1: do not keep |
= 2: keep only if safe-to-copy |
= 3: keep even if unsafe-to-copy |
*/ |
PNG_EXPORT(172, void, png_set_keep_unknown_chunks, |
(png_structp png_ptr, int keep, |
png_const_bytep chunk_list, int num_chunks)); |
PNG_EXPORT(173, int, png_handle_as_unknown, (png_structp png_ptr, |
png_const_bytep chunk_name)); |
#endif |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
PNG_EXPORT(174, void, png_set_unknown_chunks, (png_structp png_ptr, |
png_infop info_ptr, png_const_unknown_chunkp unknowns, |
int num_unknowns)); |
PNG_EXPORT(175, void, png_set_unknown_chunk_location, |
(png_structp png_ptr, png_infop info_ptr, int chunk, int location)); |
PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structp png_ptr, |
png_const_infop info_ptr, png_unknown_chunkpp entries)); |
#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); |
*/ |
PNG_EXPORT(177, void, png_set_invalid, |
(png_structp png_ptr, png_infop info_ptr, int mask)); |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
/* The "params" pointer is currently not used and is for future expansion. */ |
PNG_EXPORT(178, void, png_read_png, (png_structp png_ptr, png_infop info_ptr, |
int transforms, png_voidp params)); |
PNG_EXPORT(179, void, png_write_png, (png_structp png_ptr, png_infop info_ptr, |
int transforms, png_voidp params)); |
#endif |
PNG_EXPORT(180, png_const_charp, png_get_copyright, |
(png_const_structp png_ptr)); |
PNG_EXPORT(181, png_const_charp, png_get_header_ver, |
(png_const_structp png_ptr)); |
PNG_EXPORT(182, png_const_charp, png_get_header_version, |
(png_const_structp png_ptr)); |
PNG_EXPORT(183, png_const_charp, png_get_libpng_ver, |
(png_const_structp png_ptr)); |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structp png_ptr, |
png_uint_32 mng_features_permitted)); |
#endif |
/* For use in png_set_keep_unknown, added to version 1.2.6 */ |
#define PNG_HANDLE_CHUNK_AS_DEFAULT 0 |
#define PNG_HANDLE_CHUNK_NEVER 1 |
#define PNG_HANDLE_CHUNK_IF_SAFE 2 |
#define PNG_HANDLE_CHUNK_ALWAYS 3 |
/* 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 |
PNG_EXPORT(185, void, png_set_strip_error_numbers, |
(png_structp png_ptr, |
png_uint_32 strip_mode)); |
#endif |
/* Added in libpng-1.2.6 */ |
#ifdef PNG_SET_USER_LIMITS_SUPPORTED |
PNG_EXPORT(186, void, png_set_user_limits, (png_structp png_ptr, |
png_uint_32 user_width_max, png_uint_32 user_height_max)); |
PNG_EXPORT(187, png_uint_32, png_get_user_width_max, |
(png_const_structp png_ptr)); |
PNG_EXPORT(188, png_uint_32, png_get_user_height_max, |
(png_const_structp png_ptr)); |
/* Added in libpng-1.4.0 */ |
PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structp png_ptr, |
png_uint_32 user_chunk_cache_max)); |
PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max, |
(png_const_structp png_ptr)); |
/* Added in libpng-1.4.1 */ |
PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structp png_ptr, |
png_alloc_size_t user_chunk_cache_max)); |
PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max, |
(png_const_structp png_ptr)); |
#endif |
#if defined(PNG_INCH_CONVERSIONS_SUPPORTED) |
PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
PNG_FP_EXPORT(196, float, png_get_x_offset_inches, |
(png_const_structp png_ptr, png_const_infop info_ptr)); |
#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ |
PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed, |
(png_structp png_ptr, png_const_infop info_ptr)); |
#endif |
PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structp png_ptr, |
png_const_infop info_ptr)); |
#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ |
PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed, |
(png_structp png_ptr, png_const_infop info_ptr)); |
#endif |
# ifdef PNG_pHYs_SUPPORTED |
PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structp png_ptr, |
png_const_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, |
int *unit_type)); |
# endif /* PNG_pHYs_SUPPORTED */ |
#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */ |
/* Added in libpng-1.4.0 */ |
#ifdef PNG_IO_STATE_SUPPORTED |
PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_structp png_ptr)); |
PNG_EXPORTA(200, png_const_bytep, png_get_io_chunk_name, |
(png_structp png_ptr), PNG_DEPRECATED); |
PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type, |
(png_const_structp png_ptr)); |
/* The flags returned by png_get_io_state() are the following: */ |
# define PNG_IO_NONE 0x0000 /* no I/O at this moment */ |
# define PNG_IO_READING 0x0001 /* currently reading */ |
# define PNG_IO_WRITING 0x0002 /* currently writing */ |
# define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */ |
# define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */ |
# define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */ |
# define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */ |
# define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */ |
# define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */ |
#endif /* ?PNG_IO_STATE_SUPPORTED */ |
/* Interlace support. The following macros are always defined so that if |
* libpng interlace handling is turned off the macros may be used to handle |
* interlaced images within the application. |
*/ |
#define PNG_INTERLACE_ADAM7_PASSES 7 |
/* Two macros to return the first row and first column of the original, |
* full, image which appears in a given pass. 'pass' is in the range 0 |
* to 6 and the result is in the range 0 to 7. |
*/ |
#define PNG_PASS_START_ROW(pass) (((1U&~(pass))<<(3-((pass)>>1)))&7) |
#define PNG_PASS_START_COL(pass) (((1U& (pass))<<(3-(((pass)+1)>>1)))&7) |
/* Two macros to help evaluate the number of rows or columns in each |
* pass. This is expressed as a shift - effectively log2 of the number or |
* rows or columns in each 8x8 tile of the original image. |
*/ |
#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3) |
#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3) |
/* Hence two macros to determine the number of rows or columns in a given |
* pass of an image given its height or width. In fact these macros may |
* return non-zero even though the sub-image is empty, because the other |
* dimension may be empty for a small image. |
*/ |
#define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\ |
-1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass)) |
#define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\ |
-1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass)) |
/* For the progressive reader it is necessary to find the row in the output |
* image given a row in an interlaced image, so two more macros: |
*/ |
#define PNG_ROW_FROM_PASS_ROW(yIn, pass) \ |
(((yIn)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass)) |
#define PNG_COL_FROM_PASS_COL(xIn, pass) \ |
(((xIn)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass)) |
/* Two macros which return a boolean (0 or 1) saying whether the given row |
* or column is in a particular pass. These use a common utility macro that |
* returns a mask for a given pass - the offset 'off' selects the row or |
* column version. The mask has the appropriate bit set for each column in |
* the tile. |
*/ |
#define PNG_PASS_MASK(pass,off) ( \ |
((0x110145AFU>>(((7-(off))-(pass))<<2)) & 0xFU) | \ |
((0x01145AF0U>>(((7-(off))-(pass))<<2)) & 0xF0U)) |
#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \ |
((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1) |
#define PNG_COL_IN_INTERLACE_PASS(x, pass) \ |
((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1) |
#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 */ |
#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED |
PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf)); |
PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf)); |
PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf)); |
#endif |
PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_structp png_ptr, |
png_const_bytep buf)); |
/* No png_get_int_16 -- may be added if there's a real need for it. */ |
/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */ |
#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED |
PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i)); |
#endif |
#ifdef PNG_SAVE_INT_32_SUPPORTED |
PNG_EXPORT(206, void, png_save_int_32, (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. |
*/ |
#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED |
PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i)); |
/* No png_save_int_16 -- may be added if there's a real need for it. */ |
#endif |
#ifdef PNG_USE_READ_MACROS |
/* Inline macros to do direct reads of bytes from the input buffer. |
* The png_get_int_32() routine assumes we are using two's complement |
* format for negative values, which is almost certainly true. |
*/ |
# define png_get_uint_32(buf) \ |
(((png_uint_32)(*(buf)) << 24) + \ |
((png_uint_32)(*((buf) + 1)) << 16) + \ |
((png_uint_32)(*((buf) + 2)) << 8) + \ |
((png_uint_32)(*((buf) + 3)))) |
/* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the |
* function) incorrectly returned a value of type png_uint_32. |
*/ |
# define png_get_uint_16(buf) \ |
((png_uint_16) \ |
(((unsigned int)(*(buf)) << 8) + \ |
((unsigned int)(*((buf) + 1))))) |
# define png_get_int_32(buf) \ |
((png_int_32)((*(buf) & 0x80) \ |
? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \ |
: (png_int_32)png_get_uint_32(buf))) |
#endif |
/* Maintainer: Put new public prototypes here ^, in libpng.3, and project |
* defs |
*/ |
/* The last ordinal number (this is the *last* one already used; the next |
* one to use is one more than this.) Maintainer, remember to add an entry to |
* scripts/symbols.def as well. |
*/ |
#ifdef PNG_EXPORT_LAST_ORDINAL |
PNG_EXPORT_LAST_ORDINAL(220); |
#endif |
#ifdef __cplusplus |
} |
#endif |
#endif /* PNG_VERSION_INFO_ONLY */ |
/* Do not put anything past this line */ |
#endif /* PNG_H */ |
/programs/develop/libraries/libpng/pngconf.h |
---|
0,0 → 1,632 |
/* pngconf.h - machine configurable file for libpng |
* |
* libpng version 1.5.1 - February 3, 2011 |
* |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
* |
*/ |
/* 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 |
/* PNG_NO_LIMITS_H may be used to turn off the use of the standard C |
* definition file for machine specific limits, this may impact the |
* correctness of the definitons below (see uses of INT_MAX). |
*/ |
#ifndef PNG_NO_LIMITS_H |
# include <limits.h> |
#endif |
/* For the memory copy APIs (i.e. the standard definitions of these), |
* because this file defines png_memcpy and so on the base APIs must |
* be defined here. |
*/ |
#ifdef BSD |
# include <strings.h> |
#else |
# include <string.h> |
#endif |
/* For png_FILE_p - this provides the standard definition of a |
* FILE |
*/ |
#ifdef PNG_STDIO_SUPPORTED |
# include <stdio.h> |
#endif |
/* This controls optimization of the reading of 16 and 32 bit values |
* from PNG files. It can be set on a per-app-file basis - it |
* just changes whether a macro is used to the function is called. |
* The library builder sets the default, if read functions are not |
* built into the library the macro implementation is forced on. |
*/ |
#ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED |
# define PNG_USE_READ_MACROS |
#endif |
#if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS) |
# if PNG_DEFAULT_READ_MACROS |
# define PNG_USE_READ_MACROS |
# endif |
#endif |
/* COMPILER SPECIFIC OPTIONS. |
* |
* These options are provided so that a variety of difficult compilers |
* can be used. Some are fixed at build time (e.g. PNG_API_RULE |
* below) but still have compiler specific implementations, others |
* may be changed on a per-file basis when compiling against libpng. |
*/ |
/* The PNGARG 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) () |
# else |
# define PNGARG(arglist) arglist |
# endif /* _NO_PROTO */ |
# endif /* OF */ |
#endif /* PNGARG */ |
/* Function calling conventions. |
* ============================= |
* Normally it is not necessary to specify to the compiler how to call |
* a function - it just does it - however on x86 systems derived from |
* Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems |
* and some others) there are multiple ways to call a function and the |
* default can be changed on the compiler command line. For this reason |
* libpng specifies the calling convention of every exported function and |
* every function called via a user supplied function pointer. This is |
* done in this file by defining the following macros: |
* |
* PNGAPI Calling convention for exported functions. |
* PNGCBAPI Calling convention for user provided (callback) functions. |
* PNGCAPI Calling convention used by the ANSI-C library (required |
* for longjmp callbacks and sometimes used internally to |
* specify the calling convention for zlib). |
* |
* These macros should never be overridden. If it is necessary to |
* change calling convention in a private build this can be done |
* by setting PNG_API_RULE (which defaults to 0) to one of the values |
* below to select the correct 'API' variants. |
* |
* PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout. |
* This is correct in every known environment. |
* PNG_API_RULE=1 Use the operating system convention for PNGAPI and |
* the 'C' calling convention (from PNGCAPI) for |
* callbacks (PNGCBAPI). This is no longer required |
* in any known environment - if it has to be used |
* please post an explanation of the problem to the |
* libpng mailing list. |
* |
* These cases only differ if the operating system does not use the C |
* calling convention, at present this just means the above cases |
* (x86 DOS/Windows sytems) and, even then, this does not apply to |
* Cygwin running on those systems. |
* |
* Note that the value must be defined in pnglibconf.h so that what |
* the application uses to call the library matches the conventions |
* set when building the library. |
*/ |
/* Symbol export |
* ============= |
* When building a shared library it is almost always necessary to tell |
* the compiler which symbols to export. The png.h macro 'PNG_EXPORT' |
* is used to mark the symbols. On some systems these symbols can be |
* extracted at link time and need no special processing by the compiler, |
* on other systems the symbols are flagged by the compiler and just |
* the declaration requires a special tag applied (unfortunately) in a |
* compiler dependent way. Some systems can do either. |
* |
* A small number of older systems also require a symbol from a DLL to |
* be flagged to the program that calls it. This is a problem because |
* we do not know in the header file included by application code that |
* the symbol will come from a shared library, as opposed to a statically |
* linked one. For this reason the application must tell us by setting |
* the magic flag PNG_USE_DLL to turn on the special processing before |
* it includes png.h. |
* |
* Four additional macros are used to make this happen: |
* |
* PNG_IMPEXP The magic (if any) to cause a symbol to be exported from |
* the build or imported if PNG_USE_DLL is set - compiler |
* and system specific. |
* |
* PNG_EXPORT_TYPE(type) A macro that pre or appends PNG_IMPEXP to |
* 'type', compiler specific. |
* |
* PNG_DLL_EXPORT Set to the magic to use during a libpng build to |
* make a symbol exported from the DLL. |
* |
* PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come |
* from a DLL - used to define PNG_IMPEXP when |
* PNG_USE_DLL is set. |
*/ |
/* System specific discovery. |
* ========================== |
* This code is used at build time to find PNG_IMPEXP, the API settings |
* and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL |
* import processing is possible. On Windows/x86 systems it also sets |
* compiler-specific macros to the values required to change the calling |
* conventions of the various functions. |
*/ |
#if ( defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\ |
defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) ) &&\ |
( defined(_X86_) || defined(_X64_) || defined(_M_IX86) ||\ |
defined(_M_X64) || defined(_M_IA64) ) |
/* Windows system (DOS doesn't support DLLs) running on x86/x64. Includes |
* builds under Cygwin or MinGW. Also includes Watcom builds but these need |
* special treatment because they are not compatible with GCC or Visual C |
* because of different calling conventions. |
*/ |
# if PNG_API_RULE == 2 |
/* If this line results in an error, either because __watcall is not |
* understood or because of a redefine just below you cannot use *this* |
* build of the library with the compiler you are using. *This* build was |
* build using Watcom and applications must also be built using Watcom! |
*/ |
# define PNGCAPI __watcall |
# endif |
# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) |
# define PNGCAPI __cdecl |
# if PNG_API_RULE == 1 |
# define PNGAPI __stdcall |
# endif |
# else |
/* An older compiler, or one not detected (erroneously) above, |
* if necessary override on the command line to get the correct |
* variants for the compiler. |
*/ |
# ifndef PNGCAPI |
# define PNGCAPI _cdecl |
# endif |
# if PNG_API_RULE == 1 && !defined(PNGAPI) |
# define PNGAPI _stdcall |
# endif |
# endif /* compiler/api */ |
/* NOTE: PNGCBAPI always defaults to PNGCAPI. */ |
# if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD) |
ERROR: PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed |
# endif |
# if (defined(_MSC_VER) && _MSC_VER < 800) ||\ |
(defined(__BORLANDC__) && __BORLANDC__ < 0x500) |
/* older Borland and MSC |
* compilers used '__export' and required this to be after |
* the type. |
*/ |
# ifndef PNG_EXPORT_TYPE |
# define PNG_EXPORT_TYPE(type) type PNG_IMPEXP |
# endif |
# define PNG_DLL_EXPORT __export |
# else /* newer compiler */ |
# define PNG_DLL_EXPORT __declspec(dllexport) |
# ifndef PNG_DLL_IMPORT |
# define PNG_DLL_IMPORT __declspec(dllimport) |
# endif |
# endif /* compiler */ |
#else /* !Windows/x86 */ |
# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) |
# define PNGAPI _System |
# else /* !Windows/x86 && !OS/2 */ |
/* Use the defaults, or define PNG*API on the command line (but |
* this will have to be done for every compile!) |
*/ |
# endif /* other system, !OS/2 */ |
#endif /* !Windows/x86 */ |
/* Now do all the defaulting . */ |
#ifndef PNGCAPI |
# define PNGCAPI |
#endif |
#ifndef PNGCBAPI |
# define PNGCBAPI PNGCAPI |
#endif |
#ifndef PNGAPI |
# define PNGAPI PNGCAPI |
#endif |
/* The default for PNG_IMPEXP depends on whether the library is |
* being built or used. |
*/ |
#ifndef PNG_IMPEXP |
# ifdef PNGLIB_BUILD |
/* Building the library */ |
# if (defined(DLL_EXPORT)/*from libtool*/ ||\ |
defined(_WINDLL) || defined(_DLL) || defined(__DLL__) ||\ |
defined(_USRDLL) ||\ |
defined(PNG_BUILD_DLL)) && defined(PNG_DLL_EXPORT) |
/* Building a DLL. */ |
# define PNG_IMPEXP PNG_DLL_EXPORT |
# endif /* DLL */ |
# else |
/* Using the library */ |
# if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT) |
/* This forces use of a DLL, disallowing static linking */ |
# define PNG_IMPEXP PNG_DLL_IMPORT |
# endif |
# endif |
# ifndef PNG_IMPEXP |
# define PNG_IMPEXP |
# endif |
#endif |
/* THe following complexity is concerned with getting the 'attributes' of the |
* declared function in the correct place. This potentially requires a separate |
* PNG_EXPORT function for every compiler. |
*/ |
#ifndef PNG_FUNCTION |
# ifdef __GNUC__ |
# define PNG_FUNCTION(type, name, args, attributes)\ |
attributes type name args |
# else /* !GNUC */ |
# ifdef _MSC_VER |
# define PNG_FUNCTION(type, name, args, attributes)\ |
attributes type name args |
# else /* !MSC */ |
# define PNG_FUNCTION(type, name, args, attributes)\ |
type name args |
# endif |
# endif |
#endif |
#ifndef PNG_EXPORT_TYPE |
# define PNG_EXPORT_TYPE(type) PNG_IMPEXP type |
#endif |
/* The ordinal value is only relevant when preprocessing png.h for symbol |
* table entries, so we discard it here. See the .dfn files in the |
* scripts directory. |
*/ |
#ifndef PNG_EXPORTA |
# define PNG_EXPORTA(ordinal, type, name, args, attributes)\ |
extern PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args),\ |
attributes) |
#endif |
#define PNG_EXPORT(ordinal, type, name, args)\ |
PNG_EXPORTA(ordinal, type, name, args, ) |
/* Use PNG_REMOVED to comment out a removed interface. */ |
#ifndef PNG_REMOVED |
# define PNG_REMOVED(ordinal, type, name, args, attributes) |
#endif |
#ifndef PNG_CALLBACK |
# define PNG_CALLBACK(type, name, args, attributes)\ |
type (PNGCBAPI name) PNGARG(args) attributes |
#endif |
/* Support for compiler specific function attributes. These are used |
* so that where compiler support is available incorrect use of API |
* functions in png.h will generate compiler warnings. |
* |
* Added at libpng-1.2.41. |
*/ |
#ifndef PNG_NO_PEDANTIC_WARNINGS |
# ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED |
# define PNG_PEDANTIC_WARNINGS_SUPPORTED |
# endif |
#endif |
#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED |
/* Support for compiler specific function attributes. These are used |
* so that where compiler support is available incorrect use of API |
* functions in png.h will generate compiler warnings. Added at libpng |
* version 1.2.41. |
*/ |
# ifdef __GNUC__ |
# ifndef PNG_USE_RESULT |
# define PNG_USE_RESULT __attribute__((__warn_unused_result__)) |
# endif |
# ifndef PNG_NORETURN |
# define PNG_NORETURN __attribute__((__noreturn__)) |
# endif |
# ifndef PNG_PTR_NORETURN |
# define PNG_PTR_NORETURN __attribute__((__noreturn__)) |
# endif |
# ifndef PNG_ALLOCATED |
# define PNG_ALLOCATED __attribute__((__malloc__)) |
# endif |
/* This specifically protects structure members that should only be |
* accessed from within the library, therefore should be empty during |
* a library build. |
*/ |
# ifndef PNGLIB_BUILD |
# ifndef PNG_DEPRECATED |
# define PNG_DEPRECATED __attribute__((__deprecated__)) |
# endif |
# ifndef PNG_DEPSTRUCT |
# define PNG_DEPSTRUCT __attribute__((__deprecated__)) |
# endif |
# ifndef PNG_PRIVATE |
# if 0 /* Doesn't work so we use deprecated instead*/ |
# define PNG_PRIVATE \ |
__attribute__((warning("This function is not exported by libpng."))) |
# else |
# define PNG_PRIVATE \ |
__attribute__((__deprecated__)) |
# endif |
# endif /* PNG_PRIVATE */ |
# endif /* PNGLIB_BUILD */ |
# endif /* __GNUC__ */ |
# ifdef _MSC_VER /* may need to check value */ |
# ifndef PNG_USE_RESULT |
# define PNG_USE_RESULT /*not supported*/ |
# endif |
# ifndef PNG_NORETURN |
# define PNG_NORETURN __declspec(noreturn) |
# endif |
# ifndef PNG_PTR_NORETURN |
# define PNG_PTR_NORETURN /*not supported*/ |
# endif |
# ifndef PNG_ALLOCATED |
# define PNG_ALLOCATED __declspec(restrict) |
# endif |
/* This specifically protects structure members that should only be |
* accessed from within the library, therefore should be empty during |
* a library build. |
*/ |
# ifndef PNGLIB_BUILD |
# ifndef PNG_DEPRECATED |
# define PNG_DEPRECATED __declspec(deprecated) |
# endif |
# ifndef PNG_DEPSTRUCT |
# define PNG_DEPSTRUCT __declspec(deprecated) |
# endif |
# ifndef PNG_PRIVATE |
# define PNG_PRIVATE __declspec(deprecated) |
# endif /* PNG_PRIVATE */ |
# endif /* PNGLIB_BUILD */ |
# endif /* __GNUC__ */ |
#endif /* PNG_PEDANTIC_WARNINGS */ |
#ifndef PNG_DEPRECATED |
# define PNG_DEPRECATED /* Use of this function is deprecated */ |
#endif |
#ifndef PNG_USE_RESULT |
# define PNG_USE_RESULT /* The result of this function must be checked */ |
#endif |
#ifndef PNG_NORETURN |
# define PNG_NORETURN /* This function does not return */ |
#endif |
#ifndef PNG_ALLOCATED |
# define PNG_ALLOCATED /* The result of the function is new memory */ |
#endif |
#ifndef PNG_DEPSTRUCT |
# define PNG_DEPSTRUCT /* Access to this struct member is deprecated */ |
#endif |
#ifndef PNG_PRIVATE |
# define PNG_PRIVATE /* This is a private libpng function */ |
#endif |
#ifndef PNG_FP_EXPORT /* A floating point API. */ |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
# define PNG_FP_EXPORT(ordinal, type, name, args)\ |
PNG_EXPORT(ordinal, type, name, args) |
# else /* No floating point APIs */ |
# define PNG_FP_EXPORT(ordinal, type, name, args) |
# endif |
#endif |
#ifndef PNG_FIXED_EXPORT /* A fixed point API. */ |
# ifdef PNG_FIXED_POINT_SUPPORTED |
# define PNG_FIXED_EXPORT(ordinal, type, name, args)\ |
PNG_EXPORT(ordinal, type, name, args) |
# else /* No fixed point APIs */ |
# define PNG_FIXED_EXPORT(ordinal, type, name, args) |
# endif |
#endif |
/* 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. |
* |
* This should not change how the APIs are called, so it can be done |
* on a per-file basis in the application. |
*/ |
#ifndef PNG_CONST |
# ifndef PNG_NO_CONST |
# define PNG_CONST const |
# else |
# define PNG_CONST |
# 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. |
*/ |
#if defined(INT_MAX) && (INT_MAX > 0x7ffffffeL) |
typedef unsigned int png_uint_32; |
typedef int png_int_32; |
#else |
typedef unsigned long png_uint_32; |
typedef long png_int_32; |
#endif |
typedef unsigned short png_uint_16; |
typedef short png_int_16; |
typedef unsigned char png_byte; |
#ifdef PNG_NO_SIZE_T |
typedef unsigned int png_size_t; |
#else |
typedef size_t png_size_t; |
#endif |
#define png_sizeof(x) (sizeof (x)) |
/* The following is needed for medium model support. It cannot be in the |
* pngpriv.h header. 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 /* only used in build */ |
# 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 */ |
#ifdef FAR |
# ifdef 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., gamma |
*/ |
typedef png_int_32 png_fixed_point; |
/* Add typedefs for pointers */ |
typedef void FAR * png_voidp; |
typedef PNG_CONST void FAR * png_const_voidp; |
typedef png_byte FAR * png_bytep; |
typedef PNG_CONST png_byte FAR * png_const_bytep; |
typedef png_uint_32 FAR * png_uint_32p; |
typedef PNG_CONST png_uint_32 FAR * png_const_uint_32p; |
typedef png_int_32 FAR * png_int_32p; |
typedef PNG_CONST png_int_32 FAR * png_const_int_32p; |
typedef png_uint_16 FAR * png_uint_16p; |
typedef PNG_CONST png_uint_16 FAR * png_const_uint_16p; |
typedef png_int_16 FAR * png_int_16p; |
typedef PNG_CONST png_int_16 FAR * png_const_int_16p; |
typedef char FAR * png_charp; |
typedef PNG_CONST char FAR * png_const_charp; |
typedef png_fixed_point FAR * png_fixed_point_p; |
typedef PNG_CONST png_fixed_point FAR * png_const_fixed_point_p; |
typedef png_size_t FAR * png_size_tp; |
typedef PNG_CONST png_size_t FAR * png_const_size_tp; |
#ifdef PNG_STDIO_SUPPORTED |
typedef FILE * png_FILE_p; |
#endif |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
typedef double FAR * png_doublep; |
typedef PNG_CONST double FAR * png_const_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; |
/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, |
* and no smaller than png_uint_32. Casts from png_size_t or png_uint_32 |
* to png_alloc_size_t are not necessary; in fact, it is recommended |
* not to use them at all so that the compiler can complain when something |
* turns out to be problematic. |
* Casts in the other direction (from png_alloc_size_t to png_size_t or |
* png_uint_32) should be explicitly applied; however, we do not expect |
* to encounter practical situations that require such conversions. |
*/ |
#if defined(__TURBOC__) && !defined(__FLAT__) |
typedef unsigned long png_alloc_size_t; |
#else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
typedef unsigned long png_alloc_size_t; |
# else |
/* This is an attempt to detect an old Windows system where (int) is |
* actually 16 bits, in that case png_malloc must have an argument with a |
* bigger size to accomodate the requirements of the library. |
*/ |
# if (defined(_Windows) || defined(_WINDOWS) || defined(_WINDOWS_)) && \ |
(!defined(INT_MAX) || INT_MAX <= 0x7ffffffeL) |
typedef DWORD png_alloc_size_t; |
# else |
typedef png_size_t png_alloc_size_t; |
# endif |
# endif |
#endif |
#endif /* PNGCONF_H */ |
/programs/develop/libraries/libpng/pngdebug.h |
---|
0,0 → 1,157 |
/* pngdebug.h - Debugging macros for libpng, also used in pngtest.c |
* |
* Copyright (c) 1998-2011 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.) |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* |
* This code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
*/ |
/* 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. |
* |
* png_debug[1-2]?(level, message ,arg{0-2}) |
* Expands to a statement (either a simple expression or a compound |
* do..while(0) statement) that outputs a message with parameter |
* substitution if PNG_DEBUG is defined to 2 or more. If PNG_DEBUG |
* is undefined, 0 or 1 every png_debug expands to a simple expression |
* (actually ((void)0)). |
* |
* level: level of detail of message, starting at 0. A level 'n' |
* message is preceded by 'n' tab characters (not implemented |
* on Microsoft compilers unless PNG_DEBUG_FILE is also |
* defined, to allow debug DLL compilation with no standard IO). |
* message: a printf(3) style text string. A trailing '\n' is added |
* to the message. |
* arg: 0 to 2 arguments for printf(3) style substitution in message. |
*/ |
#ifndef PNGDEBUG_H |
#define PNGDEBUG_H |
/* These settings control the formatting of messages in png.c and pngerror.c */ |
/* Moved to pngdebug.h at 1.5.0 */ |
# ifndef PNG_LITERAL_SHARP |
# define PNG_LITERAL_SHARP 0x23 |
# endif |
# ifndef PNG_LITERAL_LEFT_SQUARE_BRACKET |
# define PNG_LITERAL_LEFT_SQUARE_BRACKET 0x5b |
# endif |
# ifndef PNG_LITERAL_RIGHT_SQUARE_BRACKET |
# define PNG_LITERAL_RIGHT_SQUARE_BRACKET 0x5d |
# endif |
# ifndef PNG_STRING_NEWLINE |
# define PNG_STRING_NEWLINE "\n" |
# endif |
#ifdef PNG_DEBUG |
# if (PNG_DEBUG > 0) |
# if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) |
# include <crtdbg.h> |
# if (PNG_DEBUG > 1) |
# ifndef _DEBUG |
# define _DEBUG |
# endif |
# ifndef png_debug |
# define png_debug(l,m) _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE) |
# endif |
# ifndef png_debug1 |
# define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1) |
# endif |
# ifndef png_debug2 |
# define png_debug2(l,m,p1,p2) \ |
_RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2) |
# endif |
# endif |
# else /* PNG_DEBUG_FILE || !_MSC_VER */ |
# ifndef PNG_STDIO_SUPPORTED |
# include <stdio.h> /* not included yet */ |
# endif |
# ifndef PNG_DEBUG_FILE |
# define PNG_DEBUG_FILE stderr |
# endif /* PNG_DEBUG_FILE */ |
# if (PNG_DEBUG > 1) |
/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on |
* non-ISO compilers |
*/ |
# ifdef __STDC__ |
# ifndef png_debug |
# define png_debug(l,m) \ |
do { \ |
int num_tabs=l; \ |
fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ |
} while (0) |
# endif |
# ifndef png_debug1 |
# define png_debug1(l,m,p1) \ |
do { \ |
int num_tabs=l; \ |
fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ |
} while (0) |
# endif |
# ifndef png_debug2 |
# define png_debug2(l,m,p1,p2) \ |
do { \ |
int num_tabs=l; \ |
fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ |
} while (0) |
# endif |
# else /* __STDC __ */ |
# ifndef png_debug |
# define png_debug(l,m) \ |
do { \ |
int num_tabs=l; \ |
char format[256]; \ |
snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ |
m,PNG_STRING_NEWLINE); \ |
fprintf(PNG_DEBUG_FILE,format); \ |
} while (0) |
# endif |
# ifndef png_debug1 |
# define png_debug1(l,m,p1) \ |
do { \ |
int num_tabs=l; \ |
char format[256]; \ |
snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ |
m,PNG_STRING_NEWLINE); \ |
fprintf(PNG_DEBUG_FILE,format,p1); \ |
} while (0) |
# endif |
# ifndef png_debug2 |
# define png_debug2(l,m,p1,p2) \ |
do { \ |
int num_tabs=l; \ |
char format[256]; \ |
snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ |
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ |
m,PNG_STRING_NEWLINE); \ |
fprintf(PNG_DEBUG_FILE,format,p1,p2); \ |
} while (0) |
# endif |
# endif /* __STDC __ */ |
# endif /* (PNG_DEBUG > 1) */ |
# endif /* _MSC_VER */ |
# endif /* (PNG_DEBUG > 0) */ |
#endif /* PNG_DEBUG */ |
#ifndef png_debug |
# define png_debug(l, m) ((void)0) |
#endif |
#ifndef png_debug1 |
# define png_debug1(l, m, p1) ((void)0) |
#endif |
#ifndef png_debug2 |
# define png_debug2(l, m, p1, p2) ((void)0) |
#endif |
#endif /* PNGDEBUG_H */ |
/programs/develop/libraries/libpng/pngerror.c |
---|
0,0 → 1,447 |
/* pngerror.c - stub functions for i/o and memory allocation |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
* |
* 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. |
*/ |
#include "pngpriv.h" |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
static PNG_FUNCTION(void, png_default_error,PNGARG((png_structp png_ptr, |
png_const_charp error_message)),PNG_NORETURN); |
#ifdef PNG_WARNINGS_SUPPORTED |
static void /* PRIVATE */ |
png_default_warning PNGARG((png_structp png_ptr, |
png_const_charp warning_message)); |
#endif /* PNG_WARNINGS_SUPPORTED */ |
/* 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. |
*/ |
#ifdef PNG_ERROR_TEXT_SUPPORTED |
PNG_FUNCTION(void,PNGAPI |
png_error,(png_structp png_ptr, png_const_charp error_message),PNG_NORETURN) |
{ |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
char msg[16]; |
if (png_ptr != NULL) |
{ |
if (png_ptr->flags& |
(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) |
{ |
if (*error_message == PNG_LITERAL_SHARP) |
{ |
/* Strip "#nnnn " from beginning of error message. */ |
int offset; |
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 - 1] = '\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 != NULL && png_ptr->error_fn != NULL) |
(*(png_ptr->error_fn))(png_ptr, error_message); |
/* If the custom handler doesn't exist, or if it returns, |
use the default handler, which will not return. */ |
png_default_error(png_ptr, error_message); |
} |
#else |
PNG_FUNCTION(void,PNGAPI |
png_err,(png_structp png_ptr),PNG_NORETURN) |
{ |
if (png_ptr != NULL && png_ptr->error_fn != NULL) |
(*(png_ptr->error_fn))(png_ptr, '\0'); |
/* If the custom handler doesn't exist, or if it returns, |
use the default handler, which will not return. */ |
png_default_error(png_ptr, '\0'); |
} |
#endif /* PNG_ERROR_TEXT_SUPPORTED */ |
#ifdef PNG_WARNINGS_SUPPORTED |
/* 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; |
if (png_ptr != NULL) |
{ |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
if (png_ptr->flags& |
(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) |
#endif |
{ |
if (*warning_message == PNG_LITERAL_SHARP) |
{ |
for (offset = 1; offset < 15; offset++) |
if (warning_message[offset] == ' ') |
break; |
} |
} |
} |
if (png_ptr != NULL && png_ptr->warning_fn != NULL) |
(*(png_ptr->warning_fn))(png_ptr, warning_message + offset); |
else |
png_default_warning(png_ptr, warning_message + offset); |
} |
#endif /* PNG_WARNINGS_SUPPORTED */ |
#ifdef PNG_BENIGN_ERRORS_SUPPORTED |
void PNGAPI |
png_benign_error(png_structp png_ptr, png_const_charp error_message) |
{ |
if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) |
png_warning(png_ptr, error_message); |
else |
png_error(png_ptr, error_message); |
} |
#endif |
/* 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) < 65 || (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' |
}; |
#define PNG_MAX_ERROR_TEXT 64 |
#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED) |
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++] = PNG_LITERAL_LEFT_SQUARE_BRACKET; |
buffer[iout++] = png_digit[(c & 0xf0) >> 4]; |
buffer[iout++] = png_digit[c & 0x0f]; |
buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET; |
} |
else |
{ |
buffer[iout++] = (png_byte)c; |
} |
} |
if (error_message == NULL) |
buffer[iout] = '\0'; |
else |
{ |
buffer[iout++] = ':'; |
buffer[iout++] = ' '; |
png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT); |
buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0'; |
} |
} |
#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */ |
#if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) |
PNG_FUNCTION(void,PNGAPI |
png_chunk_error,(png_structp png_ptr, png_const_charp error_message), |
PNG_NORETURN) |
{ |
char msg[18+PNG_MAX_ERROR_TEXT]; |
if (png_ptr == NULL) |
png_error(png_ptr, error_message); |
else |
{ |
png_format_buffer(png_ptr, msg, error_message); |
png_error(png_ptr, msg); |
} |
} |
#endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */ |
#ifdef PNG_WARNINGS_SUPPORTED |
void PNGAPI |
png_chunk_warning(png_structp png_ptr, png_const_charp warning_message) |
{ |
char msg[18+PNG_MAX_ERROR_TEXT]; |
if (png_ptr == NULL) |
png_warning(png_ptr, warning_message); |
else |
{ |
png_format_buffer(png_ptr, msg, warning_message); |
png_warning(png_ptr, msg); |
} |
} |
#endif /* PNG_WARNINGS_SUPPORTED */ |
#ifdef PNG_READ_SUPPORTED |
#ifdef PNG_BENIGN_ERRORS_SUPPORTED |
void PNGAPI |
png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message) |
{ |
if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) |
png_chunk_warning(png_ptr, error_message); |
else |
png_chunk_error(png_ptr, error_message); |
} |
#endif |
#endif /* PNG_READ_SUPPORTED */ |
#ifdef PNG_ERROR_TEXT_SUPPORTED |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
PNG_FUNCTION(void, |
png_fixed_error,(png_structp png_ptr, png_const_charp name),PNG_NORETURN) |
{ |
# define fixed_message "fixed point overflow in " |
# define fixed_message_ln ((sizeof fixed_message)-1) |
int iin; |
char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT]; |
png_memcpy(msg, fixed_message, fixed_message_ln); |
iin = 0; |
if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0) |
{ |
msg[fixed_message_ln + iin] = name[iin]; |
++iin; |
} |
msg[fixed_message_ln + iin] = 0; |
png_error(png_ptr, msg); |
} |
#endif |
#endif |
#ifdef PNG_SETJMP_SUPPORTED |
/* This API only exists if ANSI-C style error handling is used, |
* otherwise it is necessary for png_default_error to be overridden. |
*/ |
jmp_buf* PNGAPI |
png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn, |
size_t jmp_buf_size) |
{ |
if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf)) |
return NULL; |
png_ptr->longjmp_fn = longjmp_fn; |
return &png_ptr->png_jmpbuf; |
} |
#endif |
/* 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 PNG_FUNCTION(void /* PRIVATE */, |
png_default_error,(png_structp png_ptr, png_const_charp error_message), |
PNG_NORETURN) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
if (*error_message == PNG_LITERAL_SHARP) |
{ |
/* Strip "#nnnn " from beginning of 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'; |
fprintf(stderr, "libpng error no. %s: %s", |
error_number, error_message + offset + 1); |
fprintf(stderr, PNG_STRING_NEWLINE); |
} |
else |
{ |
fprintf(stderr, "libpng error: %s, offset=%d", |
error_message, offset); |
fprintf(stderr, PNG_STRING_NEWLINE); |
} |
} |
else |
#endif |
{ |
fprintf(stderr, "libpng error: %s", error_message); |
fprintf(stderr, PNG_STRING_NEWLINE); |
} |
#endif |
#ifndef PNG_CONSOLE_IO_SUPPORTED |
PNG_UNUSED(error_message) /* Make compiler happy */ |
#endif |
png_longjmp(png_ptr, 1); |
} |
PNG_FUNCTION(void,PNGAPI |
png_longjmp,(png_structp png_ptr, int val),PNG_NORETURN) |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
if (png_ptr && png_ptr->longjmp_fn) |
{ |
# ifdef USE_FAR_KEYWORD |
{ |
jmp_buf png_jmpbuf; |
png_memcpy(png_jmpbuf, png_ptr->png_jmpbuf, png_sizeof(jmp_buf)); |
png_ptr->longjmp_fn(png_jmpbuf, val); |
} |
# else |
png_ptr->longjmp_fn(png_ptr->png_jmpbuf, val); |
# endif |
} |
#endif |
/* Here if not setjmp support or if png_ptr is null. */ |
PNG_ABORT(); |
} |
#ifdef PNG_WARNINGS_SUPPORTED |
/* 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) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
# ifdef PNG_ERROR_NUMBERS_SUPPORTED |
if (*warning_message == PNG_LITERAL_SHARP) |
{ |
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'; |
fprintf(stderr, "libpng warning no. %s: %s", |
warning_number, warning_message + offset); |
fprintf(stderr, PNG_STRING_NEWLINE); |
} |
else |
{ |
fprintf(stderr, "libpng warning: %s", |
warning_message); |
fprintf(stderr, PNG_STRING_NEWLINE); |
} |
} |
else |
# endif |
{ |
fprintf(stderr, "libpng warning: %s", warning_message); |
fprintf(stderr, PNG_STRING_NEWLINE); |
} |
#else |
PNG_UNUSED(warning_message) /* Make compiler happy */ |
#endif |
PNG_UNUSED(png_ptr) /* Make compiler happy */ |
} |
#endif /* PNG_WARNINGS_SUPPORTED */ |
/* 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->png_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) |
{ |
if (png_ptr == NULL) |
return; |
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_const_structp png_ptr) |
{ |
if (png_ptr == NULL) |
return NULL; |
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 |
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngget.c |
---|
0,0 → 1,1032 |
/* pngget.c - retrieval of values from info struct |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
* |
*/ |
#include "pngpriv.h" |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
png_uint_32 PNGAPI |
png_get_valid(png_const_structp png_ptr, png_const_infop info_ptr, |
png_uint_32 flag) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->valid & flag); |
return(0); |
} |
png_size_t PNGAPI |
png_get_rowbytes(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->rowbytes); |
return(0); |
} |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
png_bytepp PNGAPI |
png_get_rows(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->row_pointers); |
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_const_structp png_ptr, png_const_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_const_structp png_ptr, png_const_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return info_ptr->height; |
return (0); |
} |
png_byte PNGAPI |
png_get_bit_depth(png_const_structp png_ptr, png_const_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_const_structp png_ptr, png_const_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_const_structp png_ptr, png_const_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_const_structp png_ptr, png_const_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_const_structp png_ptr, png_const_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_const_structp png_ptr, png_const_infop info_ptr) |
{ |
#ifdef PNG_pHYs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_debug1(1, "in %s retrieval function", |
"png_get_x_pixels_per_meter"); |
if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) |
return (info_ptr->x_pixels_per_unit); |
} |
#endif |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_y_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
#ifdef PNG_pHYs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_debug1(1, "in %s retrieval function", |
"png_get_y_pixels_per_meter"); |
if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) |
return (info_ptr->y_pixels_per_unit); |
} |
#endif |
return (0); |
} |
png_uint_32 PNGAPI |
png_get_pixels_per_meter(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
#ifdef PNG_pHYs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_debug1(1, "in %s retrieval function", "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 (info_ptr->x_pixels_per_unit); |
} |
#endif |
return (0); |
} |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float PNGAPI |
png_get_pixel_aspect_ratio(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
#ifdef PNG_READ_pHYs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs)) |
{ |
png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio"); |
if (info_ptr->x_pixels_per_unit != 0) |
return ((float)((float)info_ptr->y_pixels_per_unit |
/(float)info_ptr->x_pixels_per_unit)); |
} |
#endif |
return ((float)0.0); |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_fixed_point PNGAPI |
png_get_pixel_aspect_ratio_fixed(png_const_structp png_ptr, |
png_const_infop info_ptr) |
{ |
#ifdef PNG_READ_pHYs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs) |
&& info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 |
&& info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX |
&& info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX) |
{ |
png_fixed_point res; |
png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed"); |
/* The following casts work because a PNG 4 byte integer only has a valid |
* range of 0..2^31-1; otherwise the cast might overflow. |
*/ |
if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1, |
(png_int_32)info_ptr->x_pixels_per_unit)) |
return res; |
} |
#endif |
return 0; |
} |
#endif |
png_int_32 PNGAPI |
png_get_x_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
#ifdef PNG_oFFs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
{ |
png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns"); |
if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER) |
return (info_ptr->x_offset); |
} |
#endif |
return (0); |
} |
png_int_32 PNGAPI |
png_get_y_offset_microns(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
#ifdef PNG_oFFs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
{ |
png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns"); |
if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER) |
return (info_ptr->y_offset); |
} |
#endif |
return (0); |
} |
png_int_32 PNGAPI |
png_get_x_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
#ifdef PNG_oFFs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
{ |
png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels"); |
if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL) |
return (info_ptr->x_offset); |
} |
#endif |
return (0); |
} |
png_int_32 PNGAPI |
png_get_y_offset_pixels(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
#ifdef PNG_oFFs_SUPPORTED |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs)) |
{ |
png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels"); |
if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL) |
return (info_ptr->y_offset); |
} |
#endif |
return (0); |
} |
#ifdef PNG_INCH_CONVERSIONS_SUPPORTED |
static png_uint_32 |
ppi_from_ppm(png_uint_32 ppm) |
{ |
#if 0 |
/* The conversion is *(2.54/100), in binary (32 digits): |
* .00000110100000001001110101001001 |
*/ |
png_uint_32 t1001, t1101; |
ppm >>= 1; /* .1 */ |
t1001 = ppm + (ppm >> 3); /* .1001 */ |
t1101 = t1001 + (ppm >> 1); /* .1101 */ |
ppm >>= 20; /* .000000000000000000001 */ |
t1101 += t1101 >> 15; /* .1101000000000001101 */ |
t1001 >>= 11; /* .000000000001001 */ |
t1001 += t1001 >> 12; /* .000000000001001000000001001 */ |
ppm += t1001; /* .000000000001001000001001001 */ |
ppm += t1101; /* .110100000001001110101001001 */ |
return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */ |
#else |
/* The argument is a PNG unsigned integer, so it is not permitted |
* to be bigger than 2^31. |
*/ |
png_fixed_point result; |
if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127, |
5000)) |
return result; |
/* Overflow. */ |
return 0; |
#endif |
} |
png_uint_32 PNGAPI |
png_get_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr)); |
} |
png_uint_32 PNGAPI |
png_get_x_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr)); |
} |
png_uint_32 PNGAPI |
png_get_y_pixels_per_inch(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr)); |
} |
#ifdef PNG_FIXED_POINT_SUPPORTED |
static png_fixed_point |
png_fixed_inches_from_microns(png_structp png_ptr, png_int_32 microns) |
{ |
/* Convert from metres * 1,000,000 to inches * 100,000, meters to |
* inches is simply *(100/2.54), so we want *(10/2.54) == 500/127. |
* Notice that this can overflow - a warning is output and 0 is |
* returned. |
*/ |
return png_muldiv_warn(png_ptr, microns, 500, 127); |
} |
png_fixed_point PNGAPI |
png_get_x_offset_inches_fixed(png_structp png_ptr, |
png_const_infop info_ptr) |
{ |
return png_fixed_inches_from_microns(png_ptr, |
png_get_x_offset_microns(png_ptr, info_ptr)); |
} |
#endif |
#ifdef PNG_FIXED_POINT_SUPPORTED |
png_fixed_point PNGAPI |
png_get_y_offset_inches_fixed(png_structp png_ptr, |
png_const_infop info_ptr) |
{ |
return png_fixed_inches_from_microns(png_ptr, |
png_get_y_offset_microns(png_ptr, info_ptr)); |
} |
#endif |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float PNGAPI |
png_get_x_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
/* To avoid the overflow do the conversion directly in floating |
* point. |
*/ |
return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937); |
} |
#endif |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
float PNGAPI |
png_get_y_offset_inches(png_const_structp png_ptr, png_const_infop info_ptr) |
{ |
/* To avoid the overflow do the conversion directly in floating |
* point. |
*/ |
return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937); |
} |
#endif |
#ifdef PNG_pHYs_SUPPORTED |
png_uint_32 PNGAPI |
png_get_pHYs_dpi(png_const_structp png_ptr, png_const_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", "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_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_const_structp png_ptr, png_const_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->channels); |
return (0); |
} |
png_const_bytep PNGAPI |
png_get_signature(png_const_structp png_ptr, png_infop info_ptr) |
{ |
if (png_ptr != NULL && info_ptr != NULL) |
return(info_ptr->signature); |
return (NULL); |
} |
#ifdef PNG_bKGD_SUPPORTED |
png_uint_32 PNGAPI |
png_get_bKGD(png_const_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", "bKGD"); |
*background = &(info_ptr->background); |
return (PNG_INFO_bKGD); |
} |
return (0); |
} |
#endif |
#ifdef PNG_cHRM_SUPPORTED |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_cHRM(png_const_structp png_ptr, png_const_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", "cHRM"); |
if (white_x != NULL) |
*white_x = png_float(png_ptr, info_ptr->x_white, "cHRM white X"); |
if (white_y != NULL) |
*white_y = png_float(png_ptr, info_ptr->y_white, "cHRM white Y"); |
if (red_x != NULL) |
*red_x = png_float(png_ptr, info_ptr->x_red, "cHRM red X"); |
if (red_y != NULL) |
*red_y = png_float(png_ptr, info_ptr->y_red, "cHRM red Y"); |
if (green_x != NULL) |
*green_x = png_float(png_ptr, info_ptr->x_green, "cHRM green X"); |
if (green_y != NULL) |
*green_y = png_float(png_ptr, info_ptr->y_green, "cHRM green Y"); |
if (blue_x != NULL) |
*blue_x = png_float(png_ptr, info_ptr->x_blue, "cHRM blue X"); |
if (blue_y != NULL) |
*blue_y = png_float(png_ptr, info_ptr->y_blue, "cHRM blue Y"); |
return (PNG_INFO_cHRM); |
} |
return (0); |
} |
# endif |
# ifdef PNG_FIXED_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_cHRM_fixed(png_const_structp png_ptr, png_const_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 retrieval function", "cHRM"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) |
{ |
if (white_x != NULL) |
*white_x = info_ptr->x_white; |
if (white_y != NULL) |
*white_y = info_ptr->y_white; |
if (red_x != NULL) |
*red_x = info_ptr->x_red; |
if (red_y != NULL) |
*red_y = info_ptr->y_red; |
if (green_x != NULL) |
*green_x = info_ptr->x_green; |
if (green_y != NULL) |
*green_y = info_ptr->y_green; |
if (blue_x != NULL) |
*blue_x = info_ptr->x_blue; |
if (blue_y != NULL) |
*blue_y = info_ptr->y_blue; |
return (PNG_INFO_cHRM); |
} |
return (0); |
} |
# endif |
#endif |
#ifdef PNG_gAMA_SUPPORTED |
png_uint_32 PNGFAPI |
png_get_gAMA_fixed(png_const_structp png_ptr, png_const_infop info_ptr, |
png_fixed_point *file_gamma) |
{ |
png_debug1(1, "in %s retrieval function", "gAMA"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
&& file_gamma != NULL) |
{ |
*file_gamma = info_ptr->gamma; |
return (PNG_INFO_gAMA); |
} |
return (0); |
} |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_gAMA(png_const_structp png_ptr, png_const_infop info_ptr, |
double *file_gamma) |
{ |
png_fixed_point igamma; |
png_uint_32 ok = png_get_gAMA_fixed(png_ptr, info_ptr, &igamma); |
if (ok) |
*file_gamma = png_float(png_ptr, igamma, "png_get_gAMA"); |
return ok; |
} |
# endif |
#endif |
#ifdef PNG_sRGB_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sRGB(png_const_structp png_ptr, png_const_infop info_ptr, |
int *file_srgb_intent) |
{ |
png_debug1(1, "in %s retrieval function", "sRGB"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB) |
&& file_srgb_intent != NULL) |
{ |
*file_srgb_intent = (int)info_ptr->srgb_intent; |
return (PNG_INFO_sRGB); |
} |
return (0); |
} |
#endif |
#ifdef PNG_iCCP_SUPPORTED |
png_uint_32 PNGAPI |
png_get_iCCP(png_const_structp png_ptr, png_const_infop info_ptr, |
png_charpp name, int *compression_type, |
png_bytepp profile, png_uint_32 *proflen) |
{ |
png_debug1(1, "in %s retrieval function", "iCCP"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_iCCP) |
&& name != NULL && profile != NULL && proflen != NULL) |
{ |
*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 |
#ifdef PNG_sPLT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sPLT(png_const_structp png_ptr, png_const_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); |
} |
return (0); |
} |
#endif |
#ifdef PNG_hIST_SUPPORTED |
png_uint_32 PNGAPI |
png_get_hIST(png_const_structp png_ptr, png_const_infop info_ptr, |
png_uint_16p *hist) |
{ |
png_debug1(1, "in %s retrieval function", "hIST"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) |
&& hist != NULL) |
{ |
*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) |
{ |
png_debug1(1, "in %s retrieval function", "IHDR"); |
if (png_ptr == NULL || info_ptr == NULL || width == NULL || |
height == NULL || bit_depth == NULL || color_type == NULL) |
return (0); |
*width = info_ptr->width; |
*height = info_ptr->height; |
*bit_depth = info_ptr->bit_depth; |
*color_type = info_ptr->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; |
/* This is redundant if we can be sure that the info_ptr values were all |
* assigned in png_set_IHDR(). We do the check anyhow in case an |
* application has ignored our advice not to mess with the members |
* of info_ptr directly. |
*/ |
png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height, |
info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type, |
info_ptr->compression_type, info_ptr->filter_type); |
return (1); |
} |
#ifdef PNG_oFFs_SUPPORTED |
png_uint_32 PNGAPI |
png_get_oFFs(png_const_structp png_ptr, png_const_infop info_ptr, |
png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) |
{ |
png_debug1(1, "in %s retrieval function", "oFFs"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs) |
&& offset_x != NULL && offset_y != NULL && unit_type != NULL) |
{ |
*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 |
#ifdef PNG_pCAL_SUPPORTED |
png_uint_32 PNGAPI |
png_get_pCAL(png_const_structp png_ptr, png_const_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_debug1(1, "in %s retrieval function", "pCAL"); |
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) |
{ |
*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 |
#ifdef PNG_sCAL_SUPPORTED |
# ifdef PNG_FIXED_POINT_SUPPORTED |
# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sCAL_fixed(png_structp png_ptr, png_const_infop info_ptr, |
int *unit, png_fixed_point *width, png_fixed_point *height) |
{ |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->valid & PNG_INFO_sCAL)) |
{ |
*unit = info_ptr->scal_unit; |
/*TODO: make this work without FP support */ |
*width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width"); |
*height = png_fixed(png_ptr, atof(info_ptr->scal_s_height), |
"sCAL height"); |
return (PNG_INFO_sCAL); |
} |
return(0); |
} |
# endif /* FLOATING_ARITHMETIC */ |
# endif /* FIXED_POINT */ |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sCAL(png_const_structp png_ptr, png_const_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 = atof(info_ptr->scal_s_width); |
*height = atof(info_ptr->scal_s_height); |
return (PNG_INFO_sCAL); |
} |
return(0); |
} |
# endif /* FLOATING POINT */ |
png_uint_32 PNGAPI |
png_get_sCAL_s(png_const_structp png_ptr, png_const_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 /* sCAL */ |
#ifdef PNG_pHYs_SUPPORTED |
png_uint_32 PNGAPI |
png_get_pHYs(png_const_structp png_ptr, png_const_infop info_ptr, |
png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) |
{ |
png_uint_32 retval = 0; |
png_debug1(1, "in %s retrieval function", "pHYs"); |
if (png_ptr != NULL && info_ptr != NULL && |
(info_ptr->valid & PNG_INFO_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 /* pHYs */ |
png_uint_32 PNGAPI |
png_get_PLTE(png_const_structp png_ptr, png_const_infop info_ptr, |
png_colorp *palette, int *num_palette) |
{ |
png_debug1(1, "in %s retrieval function", "PLTE"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_PLTE) |
&& palette != NULL) |
{ |
*palette = info_ptr->palette; |
*num_palette = info_ptr->num_palette; |
png_debug1(3, "num_palette = %d", *num_palette); |
return (PNG_INFO_PLTE); |
} |
return (0); |
} |
#ifdef PNG_sBIT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_sBIT(png_const_structp png_ptr, png_infop info_ptr, |
png_color_8p *sig_bit) |
{ |
png_debug1(1, "in %s retrieval function", "sBIT"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) |
&& sig_bit != NULL) |
{ |
*sig_bit = &(info_ptr->sig_bit); |
return (PNG_INFO_sBIT); |
} |
return (0); |
} |
#endif |
#ifdef PNG_TEXT_SUPPORTED |
png_uint_32 PNGAPI |
png_get_text(png_const_structp png_ptr, png_const_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", |
(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 |
#ifdef PNG_tIME_SUPPORTED |
png_uint_32 PNGAPI |
png_get_tIME(png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time) |
{ |
png_debug1(1, "in %s retrieval function", "tIME"); |
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME) |
&& mod_time != NULL) |
{ |
*mod_time = &(info_ptr->mod_time); |
return (PNG_INFO_tIME); |
} |
return (0); |
} |
#endif |
#ifdef PNG_tRNS_SUPPORTED |
png_uint_32 PNGAPI |
png_get_tRNS(png_const_structp png_ptr, png_infop info_ptr, |
png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color) |
{ |
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", "tRNS"); |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (trans_alpha != NULL) |
{ |
*trans_alpha = info_ptr->trans_alpha; |
retval |= PNG_INFO_tRNS; |
} |
if (trans_color != NULL) |
*trans_color = &(info_ptr->trans_color); |
} |
else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ |
{ |
if (trans_color != NULL) |
{ |
*trans_color = &(info_ptr->trans_color); |
retval |= PNG_INFO_tRNS; |
} |
if (trans_alpha != NULL) |
*trans_alpha = NULL; |
} |
if (num_trans != NULL) |
{ |
*num_trans = info_ptr->num_trans; |
retval |= PNG_INFO_tRNS; |
} |
} |
return (retval); |
} |
#endif |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
int PNGAPI |
png_get_unknown_chunks(png_const_structp png_ptr, png_const_infop info_ptr, |
png_unknown_chunkpp unknowns) |
{ |
if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL) |
{ |
*unknowns = info_ptr->unknown_chunks; |
return info_ptr->unknown_chunks_num; |
} |
return (0); |
} |
#endif |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
png_byte PNGAPI |
png_get_rgb_to_gray_status (png_const_structp png_ptr) |
{ |
return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0); |
} |
#endif |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
png_voidp PNGAPI |
png_get_user_chunk_ptr(png_const_structp png_ptr) |
{ |
return (png_ptr ? png_ptr->user_chunk_ptr : NULL); |
} |
#endif |
png_size_t PNGAPI |
png_get_compression_buffer_size(png_const_structp png_ptr) |
{ |
return (png_ptr ? png_ptr->zbuf_size : 0L); |
} |
#ifdef PNG_SET_USER_LIMITS_SUPPORTED |
/* These functions were added to libpng 1.2.6 and were enabled |
* by default in libpng-1.4.0 */ |
png_uint_32 PNGAPI |
png_get_user_width_max (png_const_structp png_ptr) |
{ |
return (png_ptr ? png_ptr->user_width_max : 0); |
} |
png_uint_32 PNGAPI |
png_get_user_height_max (png_const_structp png_ptr) |
{ |
return (png_ptr ? png_ptr->user_height_max : 0); |
} |
/* This function was added to libpng 1.4.0 */ |
png_uint_32 PNGAPI |
png_get_chunk_cache_max (png_const_structp png_ptr) |
{ |
return (png_ptr ? png_ptr->user_chunk_cache_max : 0); |
} |
/* This function was added to libpng 1.4.1 */ |
png_alloc_size_t PNGAPI |
png_get_chunk_malloc_max (png_const_structp png_ptr) |
{ |
return (png_ptr ? png_ptr->user_chunk_malloc_max : 0); |
} |
#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ |
/* These functions were added to libpng 1.4.0 */ |
#ifdef PNG_IO_STATE_SUPPORTED |
png_uint_32 PNGAPI |
png_get_io_state (png_structp png_ptr) |
{ |
return png_ptr->io_state; |
} |
png_uint_32 PNGAPI |
png_get_io_chunk_type (png_const_structp png_ptr) |
{ |
return ((png_ptr->chunk_name[0] << 24) + |
(png_ptr->chunk_name[1] << 16) + |
(png_ptr->chunk_name[2] << 8) + |
(png_ptr->chunk_name[3])); |
} |
png_const_bytep PNGAPI |
png_get_io_chunk_name (png_structp png_ptr) |
{ |
return png_ptr->chunk_name; |
} |
#endif /* ?PNG_IO_STATE_SUPPORTED */ |
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pnginfo.h |
---|
0,0 → 1,270 |
/* pnginfo.h - header file for PNG reference library |
* |
* Copyright (c) 1998-2011 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.) |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* |
* This code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
*/ |
/* 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, using png_set_*() functions, 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 libpng-1.5.0 this was moved into a separate private |
* file that is not visible to applications. |
* |
* 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. |
*/ |
#ifndef PNGINFO_H |
#define PNGINFO_H |
struct png_info_def |
{ |
/* 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_size_t 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) |
/* 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. |
*/ |
png_fixed_point gamma; |
#endif |
#ifdef 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 |
#ifdef 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 or comments to write */ |
int max_text; /* current size of text array */ |
png_textp text; /* array of comments read or comments to write */ |
#endif /* PNG_TEXT_SUPPORTED */ |
#ifdef 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 |
#ifdef 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; /* alpha values for paletted image */ |
png_bytep trans_alpha; /* alpha values for paletted image */ |
png_color_16 trans_color; /* 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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. |
*/ |
png_fixed_point x_white; |
png_fixed_point y_white; |
png_fixed_point x_red; |
png_fixed_point y_red; |
png_fixed_point x_green; |
png_fixed_point y_green; |
png_fixed_point x_blue; |
png_fixed_point y_blue; |
#endif |
#ifdef 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 */ |
png_uint_32 free_me; /* flags items libpng is responsible for freeing */ |
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ |
defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) |
/* Storage for unknown chunks that the library doesn't recognize. */ |
png_unknown_chunkp unknown_chunks; |
int unknown_chunks_num; |
#endif |
#ifdef PNG_iCCP_SUPPORTED |
/* iCCP chunk data. */ |
png_charp iccp_name; /* profile name */ |
png_bytep iccp_profile; /* International Color Consortium profile data */ |
png_uint_32 iccp_proflen; /* ICC profile data length */ |
png_byte iccp_compression; /* Always zero */ |
#endif |
#ifdef 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 |
#ifdef 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. Data values are valid if (valid & PNG_INFO_sCAL) is |
* non-zero. |
*/ |
png_byte scal_unit; /* unit of physical scale */ |
png_charp scal_s_width; /* string containing height */ |
png_charp scal_s_height; /* string containing width */ |
#endif |
#ifdef 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 |
}; |
#endif /* PNGINFO_H */ |
/programs/develop/libraries/libpng/pnglibconf.h |
---|
0,0 → 1,173 |
/* pnglibconf.h - library build configuration */ |
/* libpng version 1.5.0 - January 6, 2011 */ |
/* Copyright (c) 1998-2011 Glenn Randers-Pehrson */ |
/* This code is released under the libpng license. */ |
/* For conditions of distribution and use, see the disclaimer */ |
/* and license in png.h */ |
/* pnglibconf.h */ |
/* Machine generated file: DO NOT EDIT */ |
/* Derived from: scripts/pnglibconf.dfa */ |
#ifndef PNGLCONF_H |
#define PNGLCONF_H |
/* settings */ |
#define PNG_MAX_GAMMA_8 11 |
#define PNG_CALLOC_SUPPORTED |
#define PNG_QUANTIZE_RED_BITS 5 |
#define PNG_USER_WIDTH_MAX 1000000L |
#define PNG_QUANTIZE_GREEN_BITS 5 |
#define PNG_API_RULE 0 |
#define PNG_QUANTIZE_BLUE_BITS 5 |
#define PNG_USER_CHUNK_CACHE_MAX 0 |
#define PNG_USER_HEIGHT_MAX 1000000L |
#define PNG_sCAL_PRECISION 5 |
#define PNG_COST_SHIFT 3 |
#define PNG_WEIGHT_SHIFT 8 |
#define PNG_USER_CHUNK_MALLOC_MAX 0 |
#define PNG_DEFAULT_READ_MACROS 1 |
#define PNG_ZBUF_SIZE 8192 |
#define PNG_GAMMA_THRESHOLD_FIXED 5000 |
/* end of settings */ |
/* options */ |
#define PNG_INFO_IMAGE_SUPPORTED |
#define PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
#define PNG_POINTER_INDEXING_SUPPORTED |
#define PNG_WARNINGS_SUPPORTED |
#define PNG_FLOATING_ARITHMETIC_SUPPORTED |
#define PNG_WRITE_SUPPORTED |
#define PNG_WRITE_INTERLACING_SUPPORTED |
#define PNG_WRITE_16BIT_SUPPORTED |
#define PNG_EASY_ACCESS_SUPPORTED |
#define PNG_ALIGN_MEMORY_SUPPORTED |
#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
#define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_USER_LIMITS_SUPPORTED |
#define PNG_FIXED_POINT_SUPPORTED |
/*#undef PNG_ERROR_NUMBERS_SUPPORTED*/ |
#define PNG_ERROR_TEXT_SUPPORTED |
#define PNG_READ_SUPPORTED |
/*#undef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED*/ |
#define PNG_BENIGN_ERRORS_SUPPORTED |
#define PNG_SETJMP_SUPPORTED |
#define PNG_WRITE_FLUSH_SUPPORTED |
#define PNG_MNG_FEATURES_SUPPORTED |
#define PNG_FLOATING_POINT_SUPPORTED |
#define PNG_INCH_CONVERSIONS_SUPPORTED |
#define PNG_STDIO_SUPPORTED |
#define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_USER_MEM_SUPPORTED |
#define PNG_IO_STATE_SUPPORTED |
#define PNG_SET_USER_LIMITS_SUPPORTED |
#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED |
#define PNG_WRITE_INT_FUNCTIONS_SUPPORTED |
#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED |
#define PNG_WRITE_FILTER_SUPPORTED |
#define PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED |
#define PNG_WRITE_iCCP_SUPPORTED |
#define PNG_READ_TRANSFORMS_SUPPORTED |
#define PNG_READ_GAMMA_SUPPORTED |
#define PNG_READ_bKGD_SUPPORTED |
#define PNG_UNKNOWN_CHUNKS_SUPPORTED |
#define PNG_READ_sCAL_SUPPORTED |
#define PNG_WRITE_hIST_SUPPORTED |
#define PNG_READ_OPT_PLTE_SUPPORTED |
#define PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED |
#define PNG_WRITE_gAMA_SUPPORTED |
#define PNG_READ_GRAY_TO_RGB_SUPPORTED |
#define PNG_WRITE_pCAL_SUPPORTED |
#define PNG_READ_INVERT_ALPHA_SUPPORTED |
#define PNG_WRITE_TRANSFORMS_SUPPORTED |
#define PNG_READ_sBIT_SUPPORTED |
#define PNG_READ_PACK_SUPPORTED |
#define PNG_WRITE_SWAP_SUPPORTED |
#define PNG_READ_cHRM_SUPPORTED |
#define PNG_WRITE_tIME_SUPPORTED |
#define PNG_READ_INTERLACING_SUPPORTED |
#define PNG_READ_tRNS_SUPPORTED |
#define PNG_WRITE_pHYs_SUPPORTED |
#define PNG_WRITE_INVERT_SUPPORTED |
#define PNG_READ_RGB_TO_GRAY_SUPPORTED |
#define PNG_WRITE_sRGB_SUPPORTED |
#define PNG_READ_oFFs_SUPPORTED |
#define PNG_WRITE_FILLER_SUPPORTED |
#define PNG_WRITE_TEXT_SUPPORTED |
#define PNG_WRITE_SHIFT_SUPPORTED |
#define PNG_PROGRESSIVE_READ_SUPPORTED |
#define PNG_READ_SHIFT_SUPPORTED |
#define PNG_CONVERT_tIME_SUPPORTED |
#define PNG_READ_USER_TRANSFORM_SUPPORTED |
#define PNG_READ_INT_FUNCTIONS_SUPPORTED |
#define PNG_READ_USER_CHUNKS_SUPPORTED |
#define PNG_READ_hIST_SUPPORTED |
#define PNG_READ_16BIT_SUPPORTED |
#define PNG_READ_SWAP_ALPHA_SUPPORTED |
#define PNG_READ_COMPOSITE_NODIV_SUPPORTED |
#define PNG_SEQUENTIAL_READ_SUPPORTED |
#define PNG_READ_BACKGROUND_SUPPORTED |
#define PNG_READ_QUANTIZE_SUPPORTED |
#define PNG_READ_iCCP_SUPPORTED |
#define PNG_READ_STRIP_ALPHA_SUPPORTED |
#define PNG_READ_PACKSWAP_SUPPORTED |
#define PNG_READ_sRGB_SUPPORTED |
#define PNG_WRITE_tEXt_SUPPORTED |
#define PNG_READ_gAMA_SUPPORTED |
#define PNG_READ_pCAL_SUPPORTED |
#define PNG_READ_EXPAND_SUPPORTED |
#define PNG_WRITE_sPLT_SUPPORTED |
#define PNG_READ_SWAP_SUPPORTED |
#define PNG_READ_tIME_SUPPORTED |
#define PNG_READ_pHYs_SUPPORTED |
#define PNG_WRITE_SWAP_ALPHA_SUPPORTED |
#define PNG_TIME_RFC1123_SUPPORTED |
#define PNG_READ_TEXT_SUPPORTED |
#define PNG_WRITE_BGR_SUPPORTED |
#define PNG_USER_CHUNKS_SUPPORTED |
#define PNG_CONSOLE_IO_SUPPORTED |
#define PNG_WRITE_PACK_SUPPORTED |
#define PNG_READ_FILLER_SUPPORTED |
#define PNG_WRITE_bKGD_SUPPORTED |
#define PNG_WRITE_tRNS_SUPPORTED |
#define PNG_READ_sPLT_SUPPORTED |
#define PNG_WRITE_sCAL_SUPPORTED |
#define PNG_WRITE_oFFs_SUPPORTED |
#define PNG_READ_tEXt_SUPPORTED |
#define PNG_WRITE_sBIT_SUPPORTED |
#define PNG_READ_INVERT_SUPPORTED |
#define PNG_READ_16_TO_8_SUPPORTED |
#define PNG_WRITE_cHRM_SUPPORTED |
#define PNG_16BIT_SUPPORTED |
#define PNG_WRITE_USER_TRANSFORM_SUPPORTED |
#define PNG_READ_BGR_SUPPORTED |
#define PNG_WRITE_PACKSWAP_SUPPORTED |
#define PNG_WRITE_INVERT_ALPHA_SUPPORTED |
#define PNG_sCAL_SUPPORTED |
#define PNG_WRITE_zTXt_SUPPORTED |
#define PNG_USER_TRANSFORM_INFO_SUPPORTED |
#define PNG_sBIT_SUPPORTED |
#define PNG_cHRM_SUPPORTED |
#define PNG_bKGD_SUPPORTED |
#define PNG_tRNS_SUPPORTED |
#define PNG_WRITE_iTXt_SUPPORTED |
#define PNG_oFFs_SUPPORTED |
#define PNG_USER_TRANSFORM_PTR_SUPPORTED |
#define PNG_hIST_SUPPORTED |
#define PNG_iCCP_SUPPORTED |
#define PNG_sRGB_SUPPORTED |
#define PNG_READ_zTXt_SUPPORTED |
#define PNG_gAMA_SUPPORTED |
#define PNG_pCAL_SUPPORTED |
#define PNG_CHECK_cHRM_SUPPORTED |
#define PNG_tIME_SUPPORTED |
#define PNG_pHYs_SUPPORTED |
#define PNG_READ_iTXt_SUPPORTED |
#define PNG_TEXT_SUPPORTED |
#define PNG_SAVE_INT_32_SUPPORTED |
#define PNG_sPLT_SUPPORTED |
#define PNG_tEXt_SUPPORTED |
#define PNG_zTXt_SUPPORTED |
#define PNG_iTXt_SUPPORTED |
/* end of options */ |
#endif /* PNGLCONF_H */ |
/programs/develop/libraries/libpng/pngmem.c |
---|
0,0 → 1,658 |
/* pngmem.c - stub functions for memory allocation |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
* |
* 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. |
*/ |
#include "pngpriv.h" |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
/* 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_FUNCTION(png_voidp /* PRIVATE */, |
png_create_struct,(int type),PNG_ALLOCATED) |
{ |
# ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_struct_2(type, NULL, NULL)); |
} |
/* Alternate version of png_create_struct, for use with user-defined malloc. */ |
PNG_FUNCTION(png_voidp /* PRIVATE */, |
png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr), |
PNG_ALLOCATED) |
{ |
# endif /* PNG_USER_MEM_SUPPORTED */ |
png_size_t size; |
png_voidp struct_ptr; |
if (type == PNG_STRUCT_INFO) |
size = png_sizeof(png_info); |
else if (type == PNG_STRUCT_PNG) |
size = png_sizeof(png_struct); |
else |
return (png_get_copyright(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, (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, NULL, 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_FUNCTION(png_voidp,PNGAPI |
png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
png_voidp ret; |
ret = (png_malloc(png_ptr, size)); |
if (ret != NULL) |
png_memset(ret,0,(png_size_t)size); |
return (ret); |
} |
PNG_FUNCTION(png_voidp,PNGAPI |
png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
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)); |
else |
ret = (png_malloc_default(png_ptr, size)); |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of memory"); |
return (ret); |
} |
PNG_FUNCTION(png_voidp,PNGAPI |
png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
png_voidp ret; |
# endif /* PNG_USER_MEM_SUPPORTED */ |
if (png_ptr == NULL || size == 0) |
return (NULL); |
# ifdef PNG_MAX_MALLOC_64K |
if (size > (png_uint_32)65536L) |
{ |
png_warning(png_ptr, "Cannot Allocate > 64K"); |
ret = NULL; |
} |
else |
# endif |
if (size != (size_t)size) |
ret = NULL; |
else 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) |
{ |
# ifndef PNG_USER_MEM_SUPPORTED |
if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out Of Memory"); /* Note "O", "M" */ |
else |
png_warning(png_ptr, "Out Of Memory"); |
# endif |
return (NULL); |
} |
if ((png_size_t)table & 0xfff0) |
{ |
# ifndef PNG_USER_MEM_SUPPORTED |
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"); |
# endif |
return (NULL); |
} |
png_ptr->offset_table = table; |
png_ptr->offset_table_ptr = farmalloc(num_blocks * |
png_sizeof(png_bytep)); |
if (png_ptr->offset_table_ptr == NULL) |
{ |
# ifndef PNG_USER_MEM_SUPPORTED |
if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out Of memory"); /* Note "O", "m" */ |
else |
png_warning(png_ptr, "Out Of memory"); |
# endif |
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) |
{ |
# ifndef PNG_USER_MEM_SUPPORTED |
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"); |
# endif |
return (NULL); |
} |
ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++]; |
} |
else |
ret = farmalloc(size); |
# ifndef PNG_USER_MEM_SUPPORTED |
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" */ |
} |
# endif |
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 == NULL || ptr == NULL) |
return; |
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_FUNCTION(png_voidp /* PRIVATE */, |
png_create_struct,(int type),PNG_ALLOCATED) |
{ |
# ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_struct_2(type, NULL, 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_FUNCTION(png_voidp /* PRIVATE */, |
png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr), |
PNG_ALLOCATED) |
{ |
# endif /* PNG_USER_MEM_SUPPORTED */ |
png_size_t size; |
png_voidp struct_ptr; |
if (type == PNG_STRUCT_INFO) |
size = png_sizeof(png_info); |
else if (type == PNG_STRUCT_PNG) |
size = png_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__) |
struct_ptr = (png_voidp)farmalloc(size); |
# else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
struct_ptr = (png_voidp)halloc(size, 1); |
# else |
struct_ptr = (png_voidp)malloc(size); |
# endif |
# endif |
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, NULL, 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_FUNCTION(png_voidp,PNGAPI |
png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
png_voidp ret; |
ret = (png_malloc(png_ptr, size)); |
if (ret != NULL) |
png_memset(ret,0,(png_size_t)size); |
return (ret); |
} |
PNG_FUNCTION(png_voidp,PNGAPI |
png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
png_voidp ret; |
# ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr == NULL || size == 0) |
return (NULL); |
if (png_ptr->malloc_fn != NULL) |
ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); |
else |
ret = (png_malloc_default(png_ptr, size)); |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory"); |
return (ret); |
} |
PNG_FUNCTION(png_voidp,PNGAPI |
png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
png_voidp ret; |
# endif /* PNG_USER_MEM_SUPPORTED */ |
if (png_ptr == NULL || size == 0) |
return (NULL); |
# ifdef PNG_MAX_MALLOC_64K |
if (size > (png_uint_32)65536L) |
{ |
# ifndef PNG_USER_MEM_SUPPORTED |
if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Cannot Allocate > 64K"); |
else |
# endif |
return NULL; |
} |
# endif |
/* Check for overflow */ |
# if defined(__TURBOC__) && !defined(__FLAT__) |
if (size != (unsigned long)size) |
ret = NULL; |
else |
ret = farmalloc(size); |
# else |
# if defined(_MSC_VER) && defined(MAXSEG_64K) |
if (size != (unsigned long)size) |
ret = NULL; |
else |
ret = halloc(size, 1); |
# else |
if (size != (size_t)size) |
ret = NULL; |
else |
ret = malloc((size_t)size); |
# endif |
# endif |
# ifndef PNG_USER_MEM_SUPPORTED |
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) |
png_error(png_ptr, "Out of Memory"); |
# endif |
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 */ |
/* This function was added at libpng version 1.2.3. The png_malloc_warn() |
* function will set up png_malloc() to issue a png_warning and return NULL |
* instead of issuing a png_error, if it fails to allocate the requested |
* memory. |
*/ |
PNG_FUNCTION(png_voidp,PNGAPI |
png_malloc_warn,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED) |
{ |
png_voidp ptr; |
png_uint_32 save_flags; |
if (png_ptr == NULL) |
return (NULL); |
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); |
} |
#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) |
{ |
if (png_ptr != NULL) |
{ |
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_const_structp png_ptr) |
{ |
if (png_ptr == NULL) |
return (NULL); |
return ((png_voidp)png_ptr->mem_ptr); |
} |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngpread.c |
---|
0,0 → 1,1854 |
/* pngpread.c - read a png file in push mode |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
*/ |
#include "pngpriv.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) |
{ |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_push_restore_buffer(png_ptr, buffer, buffer_size); |
while (png_ptr->buffer_size) |
{ |
png_process_some_data(png_ptr, info_ptr); |
} |
} |
png_size_t PNGAPI |
png_process_data_pause(png_structp png_ptr, int save) |
{ |
if (png_ptr != NULL) |
{ |
/* It's easiest for the caller if we do the save, then the caller doesn't |
* have to supply the same data again: |
*/ |
if (save) |
png_push_save_buffer(png_ptr); |
else |
{ |
/* This includes any pending saved bytes: */ |
png_size_t remaining = png_ptr->buffer_size; |
png_ptr->buffer_size = 0; |
/* So subtract the saved buffer size, unless all the data |
* is actually 'saved', in which case we just return 0 |
*/ |
if (png_ptr->save_buffer_size < remaining) |
return remaining - png_ptr->save_buffer_size; |
} |
} |
return 0; |
} |
png_uint_32 PNGAPI |
png_process_data_skip(png_structp png_ptr) |
{ |
png_uint_32 remaining = 0; |
if (png_ptr != NULL && png_ptr->process_mode == PNG_SKIP_MODE && |
png_ptr->skip_length > 0) |
{ |
/* At the end of png_process_data the buffer size must be 0 (see the loop |
* above) so we can detect a broken call here: |
*/ |
if (png_ptr->buffer_size != 0) |
png_error(png_ptr, |
"png_process_data_skip called inside png_process_data"); |
/* If is impossible for there to be a saved buffer at this point - |
* otherwise we could not be in SKIP mode. This will also happen if |
* png_process_skip is called inside png_process_data (but only very |
* rarely.) |
*/ |
if (png_ptr->save_buffer_size != 0) |
png_error(png_ptr, "png_process_data_skip called with saved data"); |
remaining = png_ptr->skip_length; |
png_ptr->skip_length = 0; |
png_ptr->process_mode = PNG_READ_CHUNK_MODE; |
} |
return remaining; |
} |
/* 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) |
{ |
if (png_ptr == NULL) |
return; |
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; |
} |
#ifdef PNG_READ_tEXt_SUPPORTED |
case PNG_READ_tEXt_MODE: |
{ |
png_push_read_tEXt(png_ptr, info_ptr); |
break; |
} |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
case PNG_READ_zTXt_MODE: |
{ |
png_push_read_zTXt(png_ptr, info_ptr); |
break; |
} |
#endif |
#ifdef 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) |
{ |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#ifdef PNG_READ_bKGD_SUPPORTED |
PNG_bKGD; |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
PNG_cHRM; |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
PNG_gAMA; |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
PNG_hIST; |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
PNG_iCCP; |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
PNG_iTXt; |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
PNG_oFFs; |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
PNG_pCAL; |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
PNG_pHYs; |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
PNG_sBIT; |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
PNG_sCAL; |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
PNG_sRGB; |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
PNG_sPLT; |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
PNG_tEXt; |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
PNG_tIME; |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
PNG_tRNS; |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
PNG_zTXt; |
#endif |
/* 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_31(png_ptr, chunk_length); |
png_reset_crc(png_ptr); |
png_crc_read(png_ptr, png_ptr->chunk_name, 4); |
png_check_chunk_name(png_ptr, png_ptr->chunk_name); |
png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; |
} |
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
if (png_ptr->mode & PNG_AFTER_IDAT) |
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; |
if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) |
{ |
if (png_ptr->push_length != 13) |
png_error(png_ptr, "Invalid IHDR length"); |
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_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); |
} |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) |
{ |
if (png_ptr->push_length + 4 > png_ptr->buffer_size) |
{ |
png_push_save_buffer(png_ptr); |
return; |
} |
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) |
png_ptr->mode |= PNG_HAVE_IDAT; |
png_handle_unknown(png_ptr, info_ptr, png_ptr->push_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"); |
} |
} |
#endif |
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_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->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) |
if (png_ptr->push_length == 0) |
return; |
if (png_ptr->mode & PNG_AFTER_IDAT) |
png_benign_error(png_ptr, "Too many IDATs 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_ROWBYTES(png_ptr->pixel_depth, |
png_ptr->iwidth) + 1; |
png_ptr->zstream.next_out = png_ptr->row_buf; |
return; |
} |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 = png_ptr->save_buffer_size; |
png_uint_32 skip_length = png_ptr->skip_length; |
/* We want the smaller of 'skip_length' and 'save_buffer_size', but |
* they are of different types and we don't know which variable has the |
* fewest bits. Carefully select the smaller and cast it to the type of |
* the larger - this cannot overflow. Do not cast in the following test |
* - it will break on either 16 or 64 bit platforms. |
*/ |
if (skip_length < save_size) |
save_size = (png_size_t)skip_length; |
else |
skip_length = (png_uint_32)save_size; |
png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); |
png_ptr->skip_length -= skip_length; |
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 = png_ptr->current_buffer_size; |
png_uint_32 skip_length = png_ptr->skip_length; |
/* We want the smaller of 'skip_length' and 'current_buffer_size', here, |
* the same problem exists as above and the same solution. |
*/ |
if (skip_length < save_size) |
save_size = (png_size_t)skip_length; |
else |
skip_length = (png_uint_32)save_size; |
png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); |
png_ptr->skip_length -= skip_length; |
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 PNGCBAPI |
png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length) |
{ |
png_bytep ptr; |
if (png_ptr == NULL) |
return; |
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; |
if (png_ptr->save_buffer_size > PNG_SIZE_MAX - |
(png_ptr->current_buffer_size + 256)) |
{ |
png_error(png_ptr, "Potential overflow of save_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_warn(png_ptr, |
(png_size_t)new_max); |
if (png_ptr->save_buffer == NULL) |
{ |
png_free(png_ptr, old_buffer); |
png_error(png_ptr, "Insufficient memory for save_buffer"); |
} |
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) |
{ |
PNG_IDAT; |
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_31(png_ptr, 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_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 = png_ptr->save_buffer_size; |
png_uint_32 idat_size = png_ptr->idat_size; |
/* We want the smaller of 'idat_size' and 'current_buffer_size', but they |
* are of different types and we don't know which variable has the fewest |
* bits. Carefully select the smaller and cast it to the type of the |
* larger - this cannot overflow. Do not cast in the following test - it |
* will break on either 16 or 64 bit platforms. |
*/ |
if (idat_size < save_size) |
save_size = (png_size_t)idat_size; |
else |
idat_size = (png_uint_32)save_size; |
png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); |
png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size); |
png_ptr->idat_size -= idat_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 = png_ptr->current_buffer_size; |
png_uint_32 idat_size = png_ptr->idat_size; |
/* We want the smaller of 'idat_size' and 'current_buffer_size', but they |
* are of different types and we don't know which variable has the fewest |
* bits. Carefully select the smaller and cast it to the type of the |
* larger - this cannot overflow. |
*/ |
if (idat_size < save_size) |
save_size = (png_size_t)idat_size; |
else |
idat_size = (png_uint_32)save_size; |
png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); |
png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size); |
png_ptr->idat_size -= idat_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) |
{ |
/* The caller checks for a non-zero buffer length. */ |
if (!(buffer_length > 0) || buffer == NULL) |
png_error(png_ptr, "No IDAT data (internal error)"); |
/* This routine must process all the data it has been given |
* before returning, calling the row callback as required to |
* handle the uncompressed results. |
*/ |
png_ptr->zstream.next_in = buffer; |
png_ptr->zstream.avail_in = (uInt)buffer_length; |
/* Keep going until the decompressed data is all processed |
* or the stream marked as finished. |
*/ |
while (png_ptr->zstream.avail_in > 0 && |
!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
{ |
int ret; |
/* We have data for zlib, but we must check that zlib |
* has someplace to put the results. It doesn't matter |
* if we don't expect any results -- it may be the input |
* data is just the LZ end code. |
*/ |
if (!(png_ptr->zstream.avail_out > 0)) |
{ |
png_ptr->zstream.avail_out = |
(uInt) PNG_ROWBYTES(png_ptr->pixel_depth, |
png_ptr->iwidth) + 1; |
png_ptr->zstream.next_out = png_ptr->row_buf; |
} |
/* Using Z_SYNC_FLUSH here means that an unterminated |
* LZ stream (a stream with a missing end code) can still |
* be handled, otherwise (Z_NO_FLUSH) a future zlib |
* implementation might defer output and therefore |
* change the current behavior (see comments in inflate.c |
* for why this doesn't happen at present with zlib 1.2.5). |
*/ |
ret = inflate(&png_ptr->zstream, Z_SYNC_FLUSH); |
/* Check for any failure before proceeding. */ |
if (ret != Z_OK && ret != Z_STREAM_END) |
{ |
/* Terminate the decompression. */ |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
/* This may be a truncated stream (missing or |
* damaged end code). Treat that as a warning. |
*/ |
if (png_ptr->row_number >= png_ptr->num_rows || |
png_ptr->pass > 6) |
png_warning(png_ptr, "Truncated compressed data in IDAT"); |
else |
png_error(png_ptr, "Decompression error in IDAT"); |
/* Skip the check on unprocessed input */ |
return; |
} |
/* Did inflate output any data? */ |
if (png_ptr->zstream.next_out != png_ptr->row_buf) |
{ |
/* Is this unexpected data after the last row? |
* If it is, artificially terminate the LZ output |
* here. |
*/ |
if (png_ptr->row_number >= png_ptr->num_rows || |
png_ptr->pass > 6) |
{ |
/* Extra data. */ |
png_warning(png_ptr, "Extra compressed data in IDAT"); |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
/* Do no more processing; skip the unprocessed |
* input check below. |
*/ |
return; |
} |
/* Do we have a complete row? */ |
if (png_ptr->zstream.avail_out == 0) |
png_push_process_row(png_ptr); |
} |
/* And check for the end of the stream. */ |
if (ret == Z_STREAM_END) |
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; |
} |
/* All the data should have been processed, if anything |
* is left at this point we have bytes of IDAT data |
* after the zlib end code. |
*/ |
if (png_ptr->zstream.avail_in > 0) |
png_warning(png_ptr, "Extra compression data in IDAT"); |
} |
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_ROWBYTES(png_ptr->row_info.pixel_depth, |
png_ptr->row_info.width); |
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(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1); |
if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA)) |
png_do_read_transformations(png_ptr); |
#ifdef 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, 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, NULL); |
png_read_push_finish_row(png_ptr); |
} |
} |
if (png_ptr->pass == 6 && png_ptr->height <= 4) |
{ |
png_push_have_row(png_ptr, 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, 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, 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, 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, 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, NULL); |
png_read_push_finish_row(png_ptr); |
} |
if (png_ptr->pass == 6) /* Pass 5 might be empty */ |
{ |
png_push_have_row(png_ptr, 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, NULL); |
png_read_push_finish_row(png_ptr); |
} |
break; |
} |
default: |
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, 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) |
{ |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Start of interlace block */ |
PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; |
/* Offset to next interlace block */ |
PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; |
/* Start of interlace block in the y direction */ |
PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; |
/* Offset to next interlace block in the y direction */ |
PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; |
/* Height of interlace block. This is not currently used - if you need |
* it, uncomment it here and in png.h |
PNG_CONST int FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; |
*/ |
png_ptr->row_number++; |
if (png_ptr->row_number < png_ptr->num_rows) |
return; |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
if (png_ptr->interlaced) |
{ |
png_ptr->row_number = 0; |
png_memset(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]; |
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); |
} |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
} |
#ifdef 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_UNUSED(info_ptr) /* To quiet some compiler warnings */ |
png_error(png_ptr, "Out of place tEXt"); |
/*NOT REACHED*/ |
} |
#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_size_t)(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); |
#ifdef 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_sizeof(png_text)); |
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr->key = key; |
text_ptr->itxt_length = 0; |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
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 |
#ifdef 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_UNUSED(info_ptr) /* To quiet some compiler warnings */ |
png_error(png_ptr, "Out of place zTXt"); |
/*NOT REACHED*/ |
} |
#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_size_t)(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_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_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_sizeof(png_text)); |
text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt; |
text_ptr->key = key; |
text_ptr->itxt_length = 0; |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
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 |
#ifdef 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_UNUSED(info_ptr) /* To quiet some compiler warnings */ |
png_error(png_ptr, "Out of place iTXt"); |
/*NOT REACHED*/ |
} |
#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_size_t)(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); |
#ifdef 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 - 3) |
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 */ |
text=lang_key; |
if (lang_key < key + png_ptr->current_text_size - 1) |
{ |
for (; *text; text++) |
/* Empty loop */ ; |
} |
if (text < key + png_ptr->current_text_size) |
text++; |
text_ptr = (png_textp)png_malloc(png_ptr, |
png_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; |
if (!(png_ptr->chunk_name[0] & 0x20)) |
{ |
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
PNG_HANDLE_CHUNK_ALWAYS |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
&& png_ptr->read_user_chunk_fn == NULL |
#endif |
) |
#endif |
png_chunk_error(png_ptr, "unknown critical chunk"); |
PNG_UNUSED(info_ptr) /* To quiet some compiler warnings */ |
} |
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) |
{ |
#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_memcpy((png_charp)png_ptr->unknown_chunk.name, |
(png_charp)png_ptr->chunk_name, |
png_sizeof(png_ptr->unknown_chunk.name)); |
png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1] |
= '\0'; |
png_ptr->unknown_chunk.size = (png_size_t)length; |
if (length == 0) |
png_ptr->unknown_chunk.data = NULL; |
else |
{ |
png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, |
(png_size_t)length); |
png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length); |
} |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
if (png_ptr->read_user_chunk_fn != NULL) |
{ |
/* Callback to user unknown chunk handler */ |
int ret; |
ret = (*(png_ptr->read_user_chunk_fn)) |
(png_ptr, &png_ptr->unknown_chunk); |
if (ret < 0) |
png_chunk_error(png_ptr, "error in user chunk"); |
if (ret == 0) |
{ |
if (!(png_ptr->chunk_name[0] & 0x20)) |
if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
PNG_HANDLE_CHUNK_ALWAYS) |
png_chunk_error(png_ptr, "unknown critical chunk"); |
png_set_unknown_chunks(png_ptr, info_ptr, |
&png_ptr->unknown_chunk, 1); |
} |
} |
else |
#endif |
png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1); |
png_free(png_ptr, png_ptr->unknown_chunk.data); |
png_ptr->unknown_chunk.data = NULL; |
} |
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_const_bytep new_row) |
{ |
PNG_CONST int FARDATA png_pass_dsp_mask[7] = |
{0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; |
if (png_ptr == NULL) |
return; |
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) |
{ |
if (png_ptr == NULL) |
return; |
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_const_structp png_ptr) |
{ |
if (png_ptr == NULL) |
return (NULL); |
return png_ptr->io_ptr; |
} |
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ |
/programs/develop/libraries/libpng/pngpriv.h |
---|
0,0 → 1,1235 |
/* pngpriv.h - private declarations for use inside libpng |
* |
* For conditions of distribution and use, see copyright notice in png.h |
* Copyright (c) 1998-2011 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.) |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* |
* This code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
*/ |
/* The symbols declared in this file (including the functions declared |
* as PNG_EXTERN) are PRIVATE. They are not part of the libpng public |
* interface, and are not recommended for use by regular applications. |
* Some of them may become public in the future; others may stay private, |
* change in an incompatible way, or even disappear. |
* Although the libpng users are not forbidden to include this header, |
* they should be well aware of the issues that may arise from doing so. |
*/ |
#ifndef PNGPRIV_H |
#define PNGPRIV_H |
/* This is required for the definition of abort(), used as a last ditch |
* error handler when all else fails. |
*/ |
#include <stdlib.h> |
#define PNGLIB_BUILD |
#ifdef PNG_USER_CONFIG |
# include "pngusr.h" |
/* These should have been defined in pngusr.h */ |
# ifndef PNG_USER_PRIVATEBUILD |
# define PNG_USER_PRIVATEBUILD "Custom libpng build" |
# endif |
# ifndef PNG_USER_DLLFNAME_POSTFIX |
# define PNG_USER_DLLFNAME_POSTFIX "Cb" |
# endif |
#endif |
#include "png.h" |
#include "pnginfo.h" |
#include "pngstruct.h" |
/* This is used for 16 bit gamma tables - only the top level pointers are const, |
* this could be changed: |
*/ |
typedef PNG_CONST png_uint_16p FAR * png_const_uint_16pp; |
/* Added at libpng-1.2.9 */ |
/* Moved to pngpriv.h at libpng-1.5.0 */ |
/* config.h is created by and PNG_CONFIGURE_LIBPNG is set by the "configure" |
* script. We may need it here to get the correct configuration on things |
* like limits. |
*/ |
#ifdef PNG_CONFIGURE_LIBPNG |
# ifdef HAVE_CONFIG_H |
# include "config.h" |
# endif |
#endif |
/* Moved to pngpriv.h at libpng-1.5.0 */ |
/* NOTE: some of these may have been used in external applications as |
* these definitions were exposed in pngconf.h prior to 1.5. |
*/ |
/* 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. |
* |
* zlib provides 'MAXSEG_64K' which, if defined, indicates the |
* same limit and pngconf.h (already included) sets the limit |
* if certain operating systems are detected. |
*/ |
#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) |
# define PNG_MAX_MALLOC_64K |
#endif |
/* Unused formal parameter warnings are silenced using the following macro |
* which is expected to have no bad effects on performance (optimizing |
* compilers will probably remove it entirely). Note that if you replace |
* it with something other than whitespace, you must include the terminating |
* semicolon. |
*/ |
#define PNG_UNUSED(param) (void)param; |
/* Just a little check that someone hasn't tried to define something |
* contradictory. |
*/ |
#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K) |
# undef PNG_ZBUF_SIZE |
# define PNG_ZBUF_SIZE 65536L |
#endif |
/* If warnings or errors are turned off the code is disabled |
* or redirected here. |
*/ |
#ifndef PNG_WARNINGS_SUPPORTED |
# define png_warning(s1,s2) ((void)0) |
# define png_chunk_warning(s1,s2) ((void)0) |
#endif |
#ifndef PNG_ERROR_TEXT_SUPPORTED |
# define png_error(s1,s2) png_err(s1) |
# define png_chunk_error(s1,s2) png_err(s1) |
# define png_fixed_error(s1,s2) png_err(s1) |
#endif |
#ifndef PNG_EXTERN |
/* The functions exported by PNG_EXTERN are 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 might be made available again. |
# define PNG_EXTERN extern |
*/ |
# define PNG_EXTERN |
#endif |
/* Some fixed point APIs are still required even if not exported because |
* they get used by the corresponding floating point APIs. This magic |
* deals with this: |
*/ |
#ifdef PNG_FIXED_POINT_SUPPORTED |
# define PNGFAPI PNGAPI |
#else |
# define PNGFAPI /* PRIVATE */ |
#endif |
/* 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) ||\ |
defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) |
/* png.c requires the following ANSI-C constants if the conversion of |
* floating point to ASCII is implemented therein: |
* |
* DBL_DIG Maximum number of decimal digits (can be set to any constant) |
* DBL_MIN Smallest normalized fp number (can be set to an arbitrary value) |
* DBL_MAX Maximum floating point number (can be set to an arbitrary value) |
*/ |
# include <float.h> |
# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ |
defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) |
/* 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 |
/* This provides the non-ANSI (far) memory allocation routines. */ |
#if defined(__TURBOC__) && defined(__MSDOS__) |
# include <mem.h> |
# include <alloc.h> |
#endif |
/* Moved here around 1.5.0beta36 from pngconf.h */ |
/* Users may want to use these so they are not private. Any library |
* functions that are passed far data must be model-independent. |
*/ |
/* Memory model/platform independent fns */ |
#ifndef PNG_ABORT |
# ifdef _WINDOWS_ |
# define PNG_ABORT() ExitProcess(0) |
# else |
# define PNG_ABORT() abort() |
# endif |
#endif |
#ifdef USE_FAR_KEYWORD |
/* 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_strncpy _fstrncpy /* Added to v 1.2.6 */ |
# define png_strlen _fstrlen |
# define png_memcmp _fmemcmp /* SJT: added */ |
# define png_memcpy _fmemcpy |
# define png_memset _fmemset |
# define png_sprintf sprintf |
#else |
# ifdef _WINDOWS_ /* Favor Windows over C runtime fns */ |
# define CVT_PTR(ptr) (ptr) |
# define CVT_PTR_NOCHECK(ptr) (ptr) |
# define png_strcpy lstrcpyA |
# define png_strncpy lstrcpynA |
# define png_strlen lstrlenA |
# define png_memcmp memcmp |
# define png_memcpy CopyMemory |
# define png_memset memset |
# define png_sprintf wsprintfA |
# else |
# define CVT_PTR(ptr) (ptr) |
# define CVT_PTR_NOCHECK(ptr) (ptr) |
# define png_strcpy strcpy |
# define png_strncpy strncpy /* Added to v 1.2.6 */ |
# define png_strlen strlen |
# define png_memcmp memcmp /* SJT: added */ |
# define png_memcpy memcpy |
# define png_memset memset |
# define png_sprintf sprintf |
# endif |
#endif |
/* End of memory model/platform independent support */ |
#ifndef PNG_NO_SNPRINTF |
# ifdef _MSC_VER |
# define png_snprintf _snprintf /* Added to v 1.2.19 */ |
# define png_snprintf2 _snprintf |
# define png_snprintf6 _snprintf |
# else |
# define png_snprintf snprintf /* Added to v 1.2.19 */ |
# define png_snprintf2 snprintf |
# define png_snprintf6 snprintf |
# endif |
#else |
/* You don't have or don't want to use snprintf(). Caution: Using |
* sprintf instead of snprintf exposes your application to accidental |
* or malevolent buffer overflows. If you don't have snprintf() |
* as a general rule you should provide one (you can get one from |
* Portable OpenSSH). |
*/ |
# define png_snprintf(s1,n,fmt,x1) png_sprintf(s1,fmt,x1) |
# define png_snprintf2(s1,n,fmt,x1,x2) png_sprintf(s1,fmt,x1,x2) |
# define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \ |
png_sprintf(s1,fmt,x1,x2,x3,x4,x5,x6) |
#endif |
/* End of 1.5.0beta36 move from pngconf.h */ |
/* CONSTANTS and UTILITY MACROS |
* These are used internally by libpng and not exposed in the API |
*/ |
/* 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 /* Have complete zlib datastream */ |
#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 |
#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */ |
/* 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_QUANTIZE 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 */ |
/* 0x800000L Unused */ |
#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */ |
#define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */ |
/* 0x4000000L unused */ |
/* 0x8000000L unused */ |
/* 0x10000000L unused */ |
/* 0x20000000L unused */ |
/* 0x40000000L unused */ |
/* 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_FACTOR (1<<(PNG_WEIGHT_SHIFT)) |
#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 |
/* 0x1000 unused */ |
/* 0x2000 unused */ |
/* 0x4000 unused */ |
#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 |
#define PNG_FLAG_ADD_ALPHA 0x200000L /* Added to libpng-1.2.8 */ |
#define PNG_FLAG_STRIP_ALPHA 0x400000L /* Added to libpng-1.2.8 */ |
#define PNG_FLAG_BENIGN_ERRORS_WARN 0x800000L /* Added to libpng-1.4.0 */ |
/* 0x1000000L unused */ |
/* 0x2000000L unused */ |
/* 0x4000000L unused */ |
/* 0x8000000L unused */ |
/* 0x10000000L unused */ |
/* 0x20000000L unused */ |
/* 0x40000000L unused */ |
#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) |
/* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib |
* can handle at once. This type need be no larger than 16 bits (so maximum of |
* 65535), this define allows us to discover how big it is, but limited by the |
* maximuum for png_size_t. The value can be overriden in a library build |
* (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably |
* lower value (e.g. 255 works). A lower value may help memory usage (slightly) |
* and may even improve performance on some systems (and degrade it on others.) |
*/ |
#ifndef ZLIB_IO_MAX |
# define ZLIB_IO_MAX ((uInt)-1) |
#endif |
/* 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))) |
/* Added to libpng-1.2.6 JB */ |
#define PNG_ROWBYTES(pixel_bits, width) \ |
((pixel_bits) >= 8 ? \ |
((png_size_t)(width) * (((png_size_t)(pixel_bits)) >> 3)) : \ |
(( ((png_size_t)(width) * ((png_size_t)(pixel_bits))) + 7) >> 3) ) |
/* PNG_OUT_OF_RANGE returns true if value is outside the range |
* ideal-delta..ideal+delta. Each argument is evaluated twice. |
* "ideal" and "delta" should be constants, normally simple |
* integers, "value" a variable. Added to libpng-1.2.6 JB |
*/ |
#define PNG_OUT_OF_RANGE(value, ideal, delta) \ |
( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) ) |
/* Conversions between fixed and floating point, only defined if |
* required (to make sure the code doesn't accidentally use float |
* when it is supposedly disabled.) |
*/ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
/* The floating point conversion can't overflow, though it can and |
* does lose accuracy relative to the original fixed point value. |
* In practice this doesn't matter because png_fixed_point only |
* stores numbers with very low precision. The png_ptr and s |
* arguments are unused by default but are there in case error |
* checking becomes a requirement. |
*/ |
#define png_float(png_ptr, fixed, s) (.00001 * (fixed)) |
/* The fixed point conversion performs range checking and evaluates |
* its argument multiple times, so must be used with care. The |
* range checking uses the PNG specification values for a signed |
* 32 bit fixed point value except that the values are deliberately |
* rounded-to-zero to an integral value - 21474 (21474.83 is roughly |
* (2^31-1) * 100000). 's' is a string that describes the value being |
* converted. |
* |
* NOTE: this macro will raise a png_error if the range check fails, |
* therefore it is normally only appropriate to use this on values |
* that come from API calls or other sources where an out of range |
* error indicates a programming error, not a data error! |
* |
* NOTE: by default this is off - the macro is not used - because the |
* function call saves a lot of code. |
*/ |
#ifdef PNG_FIXED_POINT_MACRO_SUPPORTED |
#define png_fixed(png_ptr, fp, s) ((fp) <= 21474 && (fp) >= -21474 ?\ |
((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0)) |
#else |
PNG_EXTERN png_fixed_point png_fixed PNGARG((png_structp png_ptr, double fp, |
png_const_charp text)); |
#endif |
#endif |
/* Constant strings for known chunk types. If you need to add a chunk, |
* define the name here, and add an invocation of the macro wherever it's |
* needed. |
*/ |
#define PNG_IHDR PNG_CONST png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} |
#define PNG_IDAT PNG_CONST png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} |
#define PNG_IEND PNG_CONST png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} |
#define PNG_PLTE PNG_CONST png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} |
#define PNG_bKGD PNG_CONST png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} |
#define PNG_cHRM PNG_CONST png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} |
#define PNG_gAMA PNG_CONST png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} |
#define PNG_hIST PNG_CONST png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} |
#define PNG_iCCP PNG_CONST png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} |
#define PNG_iTXt PNG_CONST png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} |
#define PNG_oFFs PNG_CONST png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} |
#define PNG_pCAL PNG_CONST png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} |
#define PNG_sCAL PNG_CONST png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} |
#define PNG_pHYs PNG_CONST png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} |
#define PNG_sBIT PNG_CONST png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} |
#define PNG_sPLT PNG_CONST png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} |
#define PNG_sRGB PNG_CONST png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} |
#define PNG_sTER PNG_CONST png_byte png_sTER[5] = {115, 84, 69, 82, '\0'} |
#define PNG_tEXt PNG_CONST png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} |
#define PNG_tIME PNG_CONST png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} |
#define PNG_tRNS PNG_CONST png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} |
#define PNG_zTXt PNG_CONST png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} |
/* Inhibit C++ name-mangling for libpng functions but not for system calls. */ |
#ifdef __cplusplus |
extern "C" { |
#endif /* __cplusplus */ |
/* These 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. |
*/ |
/* Allocate memory for an internal libpng struct */ |
PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct,PNGARG((int type)), |
PNG_ALLOCATED); |
/* Free memory from internal libpng struct */ |
PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); |
PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct_2, |
PNGARG((int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)), |
PNG_ALLOCATED); |
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)); |
/* Function to allocate memory for zlib. PNGAPI is disallowed. */ |
PNG_EXTERN PNG_FUNCTION(voidpf,png_zalloc,PNGARG((voidpf png_ptr, uInt items, |
uInt size)),PNG_ALLOCATED); |
/* Function to free memory for zlib. PNGAPI is disallowed. */ |
PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); |
/* Next four functions are used internally as callbacks. PNGCBAPI is required |
* but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3, changed to |
* PNGCBAPI at 1.5.0 |
*/ |
PNG_EXTERN void PNGCBAPI png_default_read_data PNGARG((png_structp png_ptr, |
png_bytep data, png_size_t length)); |
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED |
PNG_EXTERN void PNGCBAPI png_push_fill_buffer PNGARG((png_structp png_ptr, |
png_bytep buffer, png_size_t length)); |
#endif |
PNG_EXTERN void PNGCBAPI png_default_write_data PNGARG((png_structp png_ptr, |
png_bytep data, png_size_t length)); |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
# ifdef PNG_STDIO_SUPPORTED |
PNG_EXTERN void PNGCBAPI png_default_flush PNGARG((png_structp png_ptr)); |
# endif |
#endif |
/* 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_const_bytep data, png_size_t length)); |
/* Read and check the PNG file signature */ |
PNG_EXTERN void png_read_sig PNGARG((png_structp png_ptr, png_infop info_ptr)); |
/* Read the chunk header (length + type name) */ |
PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr)); |
/* 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 void png_decompress_chunk PNGARG((png_structp png_ptr, |
int comp_type, 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_const_bytep ptr, png_size_t length)); |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); |
#endif |
/* 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_const_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)); |
#ifdef 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 |
#ifdef PNG_WRITE_sBIT_SUPPORTED |
PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, |
png_const_color_8p sbit, int color_type)); |
#endif |
#ifdef 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 |
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 |
#ifdef PNG_WRITE_sRGB_SUPPORTED |
PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, |
int intent)); |
#endif |
#ifdef PNG_WRITE_iCCP_SUPPORTED |
PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, |
png_const_charp name, int compression_type, |
png_const_charp profile, int proflen)); |
/* Note to maintainer: profile should be png_bytep */ |
#endif |
#ifdef PNG_WRITE_sPLT_SUPPORTED |
PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, |
png_const_sPLT_tp palette)); |
#endif |
#ifdef PNG_WRITE_tRNS_SUPPORTED |
PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, |
png_const_bytep trans, png_const_color_16p values, int number, |
int color_type)); |
#endif |
#ifdef PNG_WRITE_bKGD_SUPPORTED |
PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, |
png_const_color_16p values, int color_type)); |
#endif |
#ifdef PNG_WRITE_hIST_SUPPORTED |
PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, |
png_const_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_const_charp key, png_charpp new_key)); |
#endif |
#ifdef PNG_WRITE_tEXt_SUPPORTED |
PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_const_charp key, |
png_const_charp text, png_size_t text_len)); |
#endif |
#ifdef PNG_WRITE_zTXt_SUPPORTED |
PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_const_charp key, |
png_const_charp text, png_size_t text_len, int compression)); |
#endif |
#ifdef PNG_WRITE_iTXt_SUPPORTED |
PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, |
int compression, png_const_charp key, png_const_charp lang, |
png_const_charp lang_key, png_const_charp text)); |
#endif |
#ifdef 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_const_textp text_ptr, int num_text)); |
#endif |
#ifdef 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 |
#ifdef 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_const_charp units, png_charpp params)); |
#endif |
#ifdef 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 |
#ifdef PNG_WRITE_tIME_SUPPORTED |
PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, |
png_const_timep mod_time)); |
#endif |
#ifdef PNG_WRITE_sCAL_SUPPORTED |
PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, |
int unit, png_const_charp width, png_const_charp height)); |
#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)); |
/* 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)); |
#ifdef 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 */ |
#ifdef 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_const_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 */ |
#ifdef 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 |
#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED |
PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED |
PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED |
PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#ifdef 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 |
#ifdef PNG_16BIT_SUPPORTED |
#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 |
#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 |
#ifdef 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 |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#ifdef PNG_READ_PACK_SUPPORTED |
PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#ifdef PNG_READ_SHIFT_SUPPORTED |
PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, |
png_bytep row, png_const_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 |
#ifdef PNG_READ_16_TO_8_SUPPORTED |
PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, |
png_bytep row)); |
#endif |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
PNG_EXTERN void png_do_quantize PNGARG((png_row_infop row_info, |
png_bytep row, png_const_bytep palette_lookup, |
png_const_bytep quantize_lookup)); |
# ifdef 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 |
#ifdef 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 |
#ifdef PNG_WRITE_SHIFT_SUPPORTED |
PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, |
png_bytep row, png_const_color_8p bit_depth)); |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
# ifdef PNG_READ_GAMMA_SUPPORTED |
PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, |
png_bytep row, png_const_color_16p trans_color, |
png_const_color_16p background, png_const_color_16p background_1, |
png_const_bytep gamma_table, png_const_bytep gamma_from_1, |
png_const_bytep gamma_to_1, png_const_uint_16pp gamma_16, |
png_const_uint_16pp gamma_16_from_1, png_const_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_const_color_16p trans_color, |
png_const_color_16p background)); |
# endif |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, |
png_bytep row, png_const_bytep gamma_table, |
png_const_uint_16pp gamma_16_table, int gamma_shift)); |
#endif |
#ifdef PNG_READ_EXPAND_SUPPORTED |
PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, |
png_bytep row, png_const_colorp palette, png_const_bytep trans, |
int num_trans)); |
PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, |
png_bytep row, png_const_color_16p trans_color)); |
#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)); |
#ifdef PNG_READ_bKGD_SUPPORTED |
PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
PNG_EXTERN void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif /* PNG_READ_iCCP_SUPPORTED */ |
#ifdef PNG_READ_iTXt_SUPPORTED |
PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
PNG_EXTERN void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif /* PNG_READ_sPLT_SUPPORTED */ |
#ifdef PNG_READ_sRGB_SUPPORTED |
PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, |
png_uint_32 length)); |
#endif |
#ifdef 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_const_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)); |
# ifdef 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 |
# ifdef 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 |
# ifdef 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 |
/* Added at libpng version 1.4.0 */ |
#ifdef PNG_CHECK_cHRM_SUPPORTED |
PNG_EXTERN int png_check_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 |
#ifdef PNG_CHECK_cHRM_SUPPORTED |
/* Added at libpng version 1.2.34 and 1.4.0 */ |
/* Currently only used by png_check_cHRM_fixed */ |
PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2, |
unsigned long *hi_product, unsigned long *lo_product)); |
#endif |
/* Added at libpng version 1.4.0 */ |
PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr, |
png_uint_32 width, png_uint_32 height, int bit_depth, |
int color_type, int interlace_type, int compression_type, |
int filter_type)); |
/* Free all memory used by the read (old method - NOT DLL EXPORTED) */ |
PNG_EXTERN void png_read_destroy PNGARG((png_structp png_ptr, |
png_infop info_ptr, png_infop end_info_ptr)); |
/* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ |
PNG_EXTERN void png_write_destroy PNGARG((png_structp png_ptr)); |
#ifdef USE_FAR_KEYWORD /* memory model conversion function */ |
PNG_EXTERN void *png_far_to_near PNGARG((png_structp png_ptr, png_voidp ptr, |
int check)); |
#endif /* USE_FAR_KEYWORD */ |
#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) |
PNG_EXTERN PNG_FUNCTION(void, png_fixed_error, (png_structp png_ptr, |
png_const_charp name),PNG_NORETURN); |
#endif |
/* ASCII to FP interfaces, currently only implemented if sCAL |
* support is required. |
*/ |
#if defined(PNG_READ_sCAL_SUPPORTED) |
/* MAX_DIGITS is actually the maximum number of characters in an sCAL |
* width or height, derived from the precision (number of significant |
* digits - a build time settable option) and assumpitions about the |
* maximum ridiculous exponent. |
*/ |
#define PNG_sCAL_MAX_DIGITS (PNG_sCAL_PRECISION+1/*.*/+1/*E*/+10/*exponent*/) |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
PNG_EXTERN void png_ascii_from_fp PNGARG((png_structp png_ptr, png_charp ascii, |
png_size_t size, double fp, unsigned int precision)); |
#endif /* FLOATING_POINT */ |
#ifdef PNG_FIXED_POINT_SUPPORTED |
PNG_EXTERN void png_ascii_from_fixed PNGARG((png_structp png_ptr, |
png_charp ascii, png_size_t size, png_fixed_point fp)); |
#endif /* FIXED_POINT */ |
#endif /* READ_sCAL */ |
#if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) |
/* An internal API to validate the format of a floating point number. |
* The result is the index of the next character. If the number is |
* not valid it will be the index of a character in the supposed number. |
* |
* The format of a number is defined in the PNG extensions specification |
* and this API is strictly conformant to that spec, not anyone elses! |
* |
* The format as a regular expression is: |
* |
* [+-]?[0-9]+.?([Ee][+-]?[0-9]+)? |
* |
* or: |
* |
* [+-]?.[0-9]+(.[0-9]+)?([Ee][+-]?[0-9]+)? |
* |
* The complexity is that either integer or fraction must be present and the |
* fraction is permitted to have no digits only if the integer is present. |
* |
* NOTE: The dangling E problem. |
* There is a PNG valid floating point number in the following: |
* |
* PNG floating point numb1.ers are not greedy. |
* |
* Working this out requires *TWO* character lookahead (because of the |
* sign), the parser does not do this - it will fail at the 'r' - this |
* doesn't matter for PNG sCAL chunk values, but it requires more care |
* if the value were ever to be embedded in something more complex. Use |
* ANSI-C strtod if you need the lookahead. |
*/ |
/* State table for the parser. */ |
#define PNG_FP_INTEGER 0 /* before or in integer */ |
#define PNG_FP_FRACTION 1 /* before or in fraction */ |
#define PNG_FP_EXPONENT 2 /* before or in exponent */ |
#define PNG_FP_STATE 3 /* mask for the above */ |
#define PNG_FP_SAW_SIGN 4 /* Saw +/- in current state */ |
#define PNG_FP_SAW_DIGIT 8 /* Saw a digit in current state */ |
#define PNG_FP_SAW_DOT 16 /* Saw a dot in current state */ |
#define PNG_FP_SAW_E 32 /* Saw an E (or e) in current state */ |
#define PNG_FP_SAW_ANY 60 /* Saw any of the above 4 */ |
#define PNG_FP_WAS_VALID 64 /* Preceding substring is a valid fp number */ |
#define PNG_FP_INVALID 128 /* Available for callers as a distinct value */ |
/* Result codes for the parser (boolean - true meants ok, false means |
* not ok yet.) |
*/ |
#define PNG_FP_MAYBE 0 /* The number may be valid in the future */ |
#define PNG_FP_OK 1 /* The number is valid */ |
/* The actual parser. This can be called repeatedly, it updates |
* the index into the string and the state variable (which must |
* be initialzed to 0). It returns a result code, as above. There |
* is no point calling the parser any more if it fails to advance to |
* the end of the string - it is stuck on an invalid character (or |
* terminated by '\0'). |
* |
* Note that the pointer will consume an E or even an E+ then leave |
* a 'maybe' state even though a preceding integer.fraction is valid. |
* The PNG_FP_WAS_VALID flag indicates that a preceding substring was |
* a valid number. It's possible to recover from this by calling |
* the parser again (from the start, with state 0) but with a string |
* that omits the last character (i.e. set the size to the index of |
* the problem character.) This has not been tested within libpng. |
*/ |
PNG_EXTERN int png_check_fp_number PNGARG((png_const_charp string, |
png_size_t size, int *statep, png_size_tp whereami)); |
/* This is the same but it checks a complete string and returns true |
* only if it just contains a floating point number. |
*/ |
PNG_EXTERN int png_check_fp_string PNGARG((png_const_charp string, |
png_size_t size)); |
#endif /* pCAL || sCAL */ |
#if defined(PNG_READ_GAMMA_SUPPORTED) ||\ |
defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED) |
/* Added at libpng version 1.5.0 */ |
/* This is a utility to provide a*times/div (rounded) and indicate |
* if there is an overflow. The result is a boolean - false (0) |
* for overflow, true (1) if no overflow, in which case *res |
* holds the result. |
*/ |
PNG_EXTERN int png_muldiv PNGARG((png_fixed_point_p res, png_fixed_point a, |
png_int_32 times, png_int_32 div)); |
#endif |
#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED) |
/* Same deal, but issue a warning on overflow and return 0. */ |
PNG_EXTERN png_fixed_point png_muldiv_warn PNGARG((png_structp png_ptr, |
png_fixed_point a, png_int_32 times, png_int_32 div)); |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
/* Calculate a reciprocal - used for gamma values. This returns |
* 0 if the argument is 0 in order to maintain an undefined value, |
* there are no warnings. |
*/ |
PNG_EXTERN png_fixed_point png_reciprocal PNGARG((png_fixed_point a)); |
/* The same but gives a reciprocal of the product of two fixed point |
* values. Accuracy is suitable for gamma calculations but this is |
* not exact - use png_muldiv for that. |
*/ |
PNG_EXTERN png_fixed_point png_reciprocal2 PNGARG((png_fixed_point a, |
png_fixed_point b)); |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
/* Internal fixed point gamma correction. These APIs are called as |
* required to convert single values - they don't need to be fast, |
* they are not used when processing image pixel values. |
* |
* While the input is an 'unsigned' value it must actually be the |
* correct bit value - 0..255 or 0..65535 as required. |
*/ |
PNG_EXTERN png_uint_16 png_gamma_correct PNGARG((png_structp png_ptr, |
unsigned int value, png_fixed_point gamma)); |
PNG_EXTERN int png_gamma_significant PNGARG((png_fixed_point gamma)); |
PNG_EXTERN png_uint_16 png_gamma_16bit_correct PNGARG((unsigned int value, |
png_fixed_point gamma)); |
PNG_EXTERN png_byte png_gamma_8bit_correct PNGARG((unsigned int value, |
png_fixed_point gamma)); |
PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr, |
int bit_depth)); |
#endif |
/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ |
#include "pngdebug.h" |
#ifdef __cplusplus |
} |
#endif |
#endif /* PNGPRIV_H */ |
/programs/develop/libraries/libpng/pngread.c |
---|
0,0 → 1,1466 |
/* pngread.c - read a PNG file |
* |
* Last changed in libpng 1.5.1 [$RDATE%] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
* |
* This file contains routines that an application calls directly to |
* read a PNG file or stream. |
*/ |
#include "pngpriv.h" |
#ifdef PNG_READ_SUPPORTED |
/* Create a PNG structure for reading, and allocate any memory needed. */ |
PNG_FUNCTION(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),PNG_ALLOCATED) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn, |
warn_fn, NULL, NULL, NULL)); |
} |
/* Alternate create PNG structure for reading, and allocate any memory |
* needed. |
*/ |
PNG_FUNCTION(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),PNG_ALLOCATED) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
#ifdef PNG_SETJMP_SUPPORTED |
volatile |
#endif |
png_structp png_ptr; |
volatile int png_cleanup_needed = 0; |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
jmp_buf png_jmpbuf; |
#endif |
#endif |
int i; |
png_debug(1, "in png_create_read_struct"); |
#ifdef PNG_USER_MEM_SUPPORTED |
png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, |
malloc_fn, mem_ptr); |
#else |
png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); |
#endif |
if (png_ptr == NULL) |
return (NULL); |
/* Added at libpng-1.2.6 */ |
#ifdef PNG_USER_LIMITS_SUPPORTED |
png_ptr->user_width_max = PNG_USER_WIDTH_MAX; |
png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; |
# ifdef PNG_USER_CHUNK_CACHE_MAX |
/* Added at libpng-1.2.43 and 1.4.0 */ |
png_ptr->user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX; |
# endif |
# ifdef PNG_SET_USER_CHUNK_MALLOC_MAX |
/* Added at libpng-1.2.43 and 1.4.1 */ |
png_ptr->user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX; |
# endif |
#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(png_jmpbuf)) |
#else |
if (setjmp(png_jmpbuf(png_ptr))) /* Sets longjmp to match setjmp */ |
#endif |
PNG_ABORT(); |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_jmpbuf(png_ptr), png_jmpbuf, png_sizeof(jmp_buf)); |
#endif |
#endif /* PNG_SETJMP_SUPPORTED */ |
#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); |
if (user_png_ver) |
{ |
i = 0; |
do |
{ |
if (user_png_ver[i] != png_libpng_ver[i]) |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
} while (png_libpng_ver[i++]); |
} |
else |
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; |
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')) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char msg[80]; |
if (user_png_ver) |
{ |
png_snprintf2(msg, 80, |
"Application built with libpng-%.20s" |
" but running with %.20s", |
user_png_ver, |
png_libpng_ver); |
png_warning(png_ptr, msg); |
} |
#else |
png_warning(png_ptr, |
"Incompatible libpng version in application and library"); |
#endif |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags = 0; |
#endif |
png_cleanup_needed = 1; |
} |
} |
if (!png_cleanup_needed) |
{ |
/* Initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr, png_ptr->zbuf_size); |
if (png_ptr->zbuf == NULL) |
png_cleanup_needed = 1; |
} |
png_ptr->zstream.zalloc = png_zalloc; |
png_ptr->zstream.zfree = png_zfree; |
png_ptr->zstream.opaque = (voidpf)png_ptr; |
if (!png_cleanup_needed) |
{ |
switch (inflateInit(&png_ptr->zstream)) |
{ |
case Z_OK: |
break; /* Do nothing */ |
case Z_MEM_ERROR: |
png_warning(png_ptr, "zlib memory error"); |
png_cleanup_needed = 1; |
break; |
case Z_STREAM_ERROR: |
png_warning(png_ptr, "zlib stream error"); |
png_cleanup_needed = 1; |
break; |
case Z_VERSION_ERROR: |
png_warning(png_ptr, "zlib version error"); |
png_cleanup_needed = 1; |
break; |
default: png_warning(png_ptr, "Unknown zlib error"); |
png_cleanup_needed = 1; |
} |
} |
if (png_cleanup_needed) |
{ |
/* Clean up PNG structure and deallocate any memory. */ |
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); |
} |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
png_set_read_fn(png_ptr, NULL, NULL); |
return (png_ptr); |
} |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* 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"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* Read and check the PNG file signature. */ |
png_read_sig(png_ptr, info_ptr); |
for (;;) |
{ |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#ifdef PNG_READ_bKGD_SUPPORTED |
PNG_bKGD; |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
PNG_cHRM; |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
PNG_gAMA; |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
PNG_hIST; |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
PNG_iCCP; |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
PNG_iTXt; |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
PNG_oFFs; |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
PNG_pCAL; |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
PNG_pHYs; |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
PNG_sBIT; |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
PNG_sCAL; |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
PNG_sPLT; |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
PNG_sRGB; |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
PNG_tEXt; |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
PNG_tIME; |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
PNG_tRNS; |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
PNG_zTXt; |
#endif |
png_uint_32 length = png_read_chunk_header(png_ptr); |
PNG_CONST png_bytep chunk_name = png_ptr->chunk_name; |
/* This should be a binary subdivision search or a hash for |
* matching the chunk name rather than a linear search. |
*/ |
if (!png_memcmp(chunk_name, png_IDAT, 4)) |
if (png_ptr->mode & PNG_AFTER_IDAT) |
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; |
if (!png_memcmp(chunk_name, png_IHDR, 4)) |
png_handle_IHDR(png_ptr, info_ptr, length); |
else if (!png_memcmp(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, chunk_name)) |
{ |
if (!png_memcmp(chunk_name, png_IDAT, 4)) |
png_ptr->mode |= PNG_HAVE_IDAT; |
png_handle_unknown(png_ptr, info_ptr, length); |
if (!png_memcmp(chunk_name, png_PLTE, 4)) |
png_ptr->mode |= PNG_HAVE_PLTE; |
else if (!png_memcmp(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(chunk_name, png_PLTE, 4)) |
png_handle_PLTE(png_ptr, info_ptr, length); |
else if (!png_memcmp(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; |
} |
#ifdef PNG_READ_bKGD_SUPPORTED |
else if (!png_memcmp(chunk_name, png_bKGD, 4)) |
png_handle_bKGD(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
else if (!png_memcmp(chunk_name, png_cHRM, 4)) |
png_handle_cHRM(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
else if (!png_memcmp(chunk_name, png_gAMA, 4)) |
png_handle_gAMA(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
else if (!png_memcmp(chunk_name, png_hIST, 4)) |
png_handle_hIST(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
else if (!png_memcmp(chunk_name, png_oFFs, 4)) |
png_handle_oFFs(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
else if (!png_memcmp(chunk_name, png_pCAL, 4)) |
png_handle_pCAL(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sCAL, 4)) |
png_handle_sCAL(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
else if (!png_memcmp(chunk_name, png_pHYs, 4)) |
png_handle_pHYs(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sBIT, 4)) |
png_handle_sBIT(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sRGB, 4)) |
png_handle_sRGB(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
else if (!png_memcmp(chunk_name, png_iCCP, 4)) |
png_handle_iCCP(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sPLT, 4)) |
png_handle_sPLT(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tEXt, 4)) |
png_handle_tEXt(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tIME, 4)) |
png_handle_tIME(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tRNS, 4)) |
png_handle_tRNS(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_zTXt, 4)) |
png_handle_zTXt(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_iTXt, 4)) |
png_handle_iTXt(png_ptr, info_ptr, length); |
#endif |
else |
png_handle_unknown(png_ptr, info_ptr, length); |
} |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
/* 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"); |
if (png_ptr == NULL) |
return; |
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); |
} |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* 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"); |
if (png_ptr == NULL) |
return; |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
png_read_start_row(png_ptr); |
else |
png_warning(png_ptr, |
"Ignoring extra png_start_read_image() call;" |
" row buffer not reallocated"); |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
void PNGAPI |
png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) |
{ |
PNG_IDAT; |
PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, |
0xff}; |
PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; |
int ret; |
if (png_ptr == NULL) |
return; |
png_debug2(1, "in png_read_row (row %lu, pass %d)", |
(unsigned long)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 |
} |
#ifdef 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; |
default: |
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_ROWBYTES(png_ptr->pixel_depth, |
png_ptr->iwidth) + 1); |
do |
{ |
if (!(png_ptr->zstream.avail_in)) |
{ |
while (!png_ptr->idat_size) |
{ |
png_crc_finish(png_ptr, 0); |
png_ptr->idat_size = png_read_chunk_header(png_ptr); |
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_benign_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_ROWBYTES(png_ptr->row_info.pixel_depth, |
png_ptr->row_info.width); |
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(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1); |
#ifdef 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_ptr->flags&PNG_FLAG_STRIP_ALPHA)) |
png_do_read_transformations(png_ptr); |
#ifdef 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); |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* 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 this version of libpng |
*/ |
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"); |
if (png_ptr == NULL) |
return; |
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, NULL); |
rp++; |
} |
else if (dp != NULL) |
for (i = 0; i < num_rows; i++) |
{ |
png_bytep dptr = *dp; |
png_read_row(png_ptr, NULL, dptr); |
dp++; |
} |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* 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 this version of libpng |
*/ |
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"); |
if (png_ptr == NULL) |
return; |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
{ |
pass = png_set_interlace_handling(png_ptr); |
/* And make sure transforms are initialized. */ |
png_start_read_image(png_ptr); |
} |
else |
{ |
if (png_ptr->interlaced && !(png_ptr->transformations & PNG_INTERLACE)) |
{ |
/* Caller called png_start_read_image or png_read_update_info without |
* first turning on the PNG_INTERLACE transform. We can fix this here, |
* but the caller should do it! |
*/ |
png_warning(png_ptr, "Interlace handling should be turned on when " |
"using png_read_image"); |
/* Make sure this is set correctly */ |
png_ptr->num_rows = png_ptr->height; |
} |
/* Obtain the pass number, which also turns on the PNG_INTERLACE flag in |
* the above error case. |
*/ |
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; |
for (j = 0; j < pass; j++) |
{ |
rp = image; |
for (i = 0; i < image_height; i++) |
{ |
png_read_row(png_ptr, *rp, NULL); |
rp++; |
} |
} |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
/* 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_debug(1, "in png_read_end"); |
if (png_ptr == NULL) |
return; |
png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ |
do |
{ |
PNG_IHDR; |
PNG_IDAT; |
PNG_IEND; |
PNG_PLTE; |
#ifdef PNG_READ_bKGD_SUPPORTED |
PNG_bKGD; |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
PNG_cHRM; |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
PNG_gAMA; |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
PNG_hIST; |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
PNG_iCCP; |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
PNG_iTXt; |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
PNG_oFFs; |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
PNG_pCAL; |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
PNG_pHYs; |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
PNG_sBIT; |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
PNG_sCAL; |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
PNG_sPLT; |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
PNG_sRGB; |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
PNG_tEXt; |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
PNG_tIME; |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
PNG_tRNS; |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
PNG_zTXt; |
#endif |
png_uint_32 length = png_read_chunk_header(png_ptr); |
PNG_CONST png_bytep chunk_name = png_ptr->chunk_name; |
if (!png_memcmp(chunk_name, png_IHDR, 4)) |
png_handle_IHDR(png_ptr, info_ptr, length); |
else if (!png_memcmp(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, chunk_name)) |
{ |
if (!png_memcmp(chunk_name, png_IDAT, 4)) |
{ |
if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) |
png_benign_error(png_ptr, "Too many IDATs found"); |
} |
png_handle_unknown(png_ptr, info_ptr, length); |
if (!png_memcmp(chunk_name, png_PLTE, 4)) |
png_ptr->mode |= PNG_HAVE_PLTE; |
} |
#endif |
else if (!png_memcmp(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_HAVE_CHUNK_AFTER_IDAT)) |
png_benign_error(png_ptr, "Too many IDATs found"); |
png_crc_finish(png_ptr, length); |
} |
else if (!png_memcmp(chunk_name, png_PLTE, 4)) |
png_handle_PLTE(png_ptr, info_ptr, length); |
#ifdef PNG_READ_bKGD_SUPPORTED |
else if (!png_memcmp(chunk_name, png_bKGD, 4)) |
png_handle_bKGD(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_cHRM_SUPPORTED |
else if (!png_memcmp(chunk_name, png_cHRM, 4)) |
png_handle_cHRM(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_gAMA_SUPPORTED |
else if (!png_memcmp(chunk_name, png_gAMA, 4)) |
png_handle_gAMA(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
else if (!png_memcmp(chunk_name, png_hIST, 4)) |
png_handle_hIST(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_oFFs_SUPPORTED |
else if (!png_memcmp(chunk_name, png_oFFs, 4)) |
png_handle_oFFs(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_pCAL_SUPPORTED |
else if (!png_memcmp(chunk_name, png_pCAL, 4)) |
png_handle_pCAL(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sCAL_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sCAL, 4)) |
png_handle_sCAL(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_pHYs_SUPPORTED |
else if (!png_memcmp(chunk_name, png_pHYs, 4)) |
png_handle_pHYs(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sBIT_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sBIT, 4)) |
png_handle_sBIT(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sRGB_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sRGB, 4)) |
png_handle_sRGB(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_iCCP_SUPPORTED |
else if (!png_memcmp(chunk_name, png_iCCP, 4)) |
png_handle_iCCP(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_sPLT_SUPPORTED |
else if (!png_memcmp(chunk_name, png_sPLT, 4)) |
png_handle_sPLT(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tEXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tEXt, 4)) |
png_handle_tEXt(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tIME_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tIME, 4)) |
png_handle_tIME(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_tRNS_SUPPORTED |
else if (!png_memcmp(chunk_name, png_tRNS, 4)) |
png_handle_tRNS(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_zTXt_SUPPORTED |
else if (!png_memcmp(chunk_name, png_zTXt, 4)) |
png_handle_zTXt(png_ptr, info_ptr, length); |
#endif |
#ifdef PNG_READ_iTXt_SUPPORTED |
else if (!png_memcmp(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)); |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
/* 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"); |
if (png_ptr_ptr != NULL) |
png_ptr = *png_ptr_ptr; |
if (png_ptr == NULL) |
return; |
#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 (end_info_ptr_ptr != NULL) |
end_info_ptr = *end_info_ptr_ptr; |
png_read_destroy(png_ptr, info_ptr, end_info_ptr); |
if (info_ptr != NULL) |
{ |
#ifdef 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) |
{ |
#ifdef 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"); |
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); |
png_free(png_ptr, png_ptr->chunkdata); |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
png_free(png_ptr, png_ptr->palette_lookup); |
png_free(png_ptr, png_ptr->quantize_index); |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
png_free(png_ptr, png_ptr->gamma_table); |
#endif |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
png_free(png_ptr, png_ptr->gamma_from_1); |
png_free(png_ptr, png_ptr->gamma_to_1); |
#endif |
if (png_ptr->free_me & PNG_FREE_PLTE) |
png_zfree(png_ptr, png_ptr->palette); |
png_ptr->free_me &= ~PNG_FREE_PLTE; |
#if defined(PNG_tRNS_SUPPORTED) || \ |
defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) |
if (png_ptr->free_me & PNG_FREE_TRNS) |
png_free(png_ptr, png_ptr->trans_alpha); |
png_ptr->free_me &= ~PNG_FREE_TRNS; |
#endif |
#ifdef PNG_READ_hIST_SUPPORTED |
if (png_ptr->free_me & PNG_FREE_HIST) |
png_free(png_ptr, png_ptr->hist); |
png_ptr->free_me &= ~PNG_FREE_HIST; |
#endif |
#ifdef 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); |
} |
#ifdef 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 |
#ifdef 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->png_jmpbuf, png_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, png_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->png_jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); |
#endif |
} |
void PNGAPI |
png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) |
{ |
if (png_ptr == NULL) |
return; |
png_ptr->read_row_fn = read_row_fn; |
} |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
void PNGAPI |
png_read_png(png_structp png_ptr, png_infop info_ptr, |
int transforms, |
voidp params) |
{ |
int row; |
if (png_ptr == NULL) |
return; |
/* 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); |
if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep)) |
png_error(png_ptr, "Image is too high to process with png_read_png()"); |
/* -------------- image transformations start here ------------------- */ |
#ifdef PNG_READ_16_TO_8_SUPPORTED |
/* Tell libpng to strip 16 bit/color files down to 8 bits per color. |
*/ |
if (transforms & PNG_TRANSFORM_STRIP_16) |
png_set_strip_16(png_ptr); |
#endif |
#ifdef 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, or 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 |
#ifdef 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 |
#ifdef 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 quantizing. |
*/ |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
/* Added at libpng-1.2.41 */ |
#ifdef 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 |
/* Added at libpng-1.2.41 */ |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
/* Expand grayscale image to RGB */ |
if (transforms & PNG_TRANSFORM_GRAY_TO_RGB) |
png_set_gray_to_rgb(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 ------------------- */ |
png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); |
if (info_ptr->row_pointers == NULL) |
{ |
png_uint_32 iptr; |
info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, |
info_ptr->height * png_sizeof(png_bytep)); |
for (iptr=0; iptr<info_ptr->height; iptr++) |
info_ptr->row_pointers[iptr] = NULL; |
info_ptr->free_me |= PNG_FREE_ROWS; |
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); |
PNG_UNUSED(transforms) /* Quiet compiler warnings */ |
PNG_UNUSED(params) |
} |
#endif /* PNG_INFO_IMAGE_SUPPORTED */ |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
#endif /* PNG_READ_SUPPORTED */ |
/programs/develop/libraries/libpng/pngrio.c |
---|
0,0 → 1,176 |
/* pngrio.c - functions for data input |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
* |
* 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(...). |
*/ |
#include "pngpriv.h" |
#ifdef PNG_READ_SUPPORTED |
/* 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", (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"); |
} |
#ifdef PNG_STDIO_SUPPORTED |
/* 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 PNGCBAPI |
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_size_t check; |
if (png_ptr == NULL) |
return; |
/* 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. |
*/ |
check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr); |
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 PNGCBAPI |
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_size_t check; |
png_byte *n_data; |
png_FILE_p io_ptr; |
if (png_ptr == NULL) |
return; |
/* 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) |
{ |
check = fread(n_data, 1, length, io_ptr); |
} |
else |
{ |
png_byte buf[NEAR_BUF_SIZE]; |
png_size_t read, remaining, err; |
check = 0; |
remaining = length; |
do |
{ |
read = MIN(NEAR_BUF_SIZE, remaining); |
err = fread(buf, 1, read, io_ptr); |
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"). |
* May be NULL, in which case libpng's default function will |
* be used. |
*/ |
void PNGAPI |
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, |
png_rw_ptr read_data_fn) |
{ |
if (png_ptr == NULL) |
return; |
png_ptr->io_ptr = io_ptr; |
#ifdef PNG_STDIO_SUPPORTED |
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, |
"Can't set both read_data_fn and write_data_fn in the" |
" same structure"); |
} |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
png_ptr->output_flush_fn = NULL; |
#endif |
} |
#endif /* PNG_READ_SUPPORTED */ |
/programs/develop/libraries/libpng/pngrtran.c |
---|
0,0 → 1,4224 |
/* pngrtran.c - transforms the data in a row for PNG readers |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
* |
* 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. |
*/ |
#include "pngpriv.h" |
#ifdef PNG_READ_SUPPORTED |
/* 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"); |
if (png_ptr == NULL) |
return; |
/* 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; |
} |
/* Tell libpng how we react to CRC errors in ancillary chunks */ |
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; |
} |
} |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
/* Handle alpha and tRNS via a background color */ |
void PNGFAPI |
png_set_background_fixed(png_structp png_ptr, |
png_const_color_16p background_color, int background_gamma_code, |
int need_expand, png_fixed_point background_gamma) |
{ |
png_debug(1, "in png_set_background_fixed"); |
if (png_ptr == NULL) |
return; |
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, |
png_sizeof(png_color_16)); |
png_ptr->background_gamma = background_gamma; |
png_ptr->background_gamma_type = (png_byte)(background_gamma_code); |
png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0); |
} |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_background(png_structp png_ptr, |
png_const_color_16p background_color, int background_gamma_code, |
int need_expand, double background_gamma) |
{ |
png_set_background_fixed(png_ptr, background_color, background_gamma_code, |
need_expand, png_fixed(png_ptr, background_gamma, "png_set_background")); |
} |
# endif /* FLOATING_POINT */ |
#endif /* READ_BACKGROUND */ |
#ifdef 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"); |
if (png_ptr == NULL) |
return; |
png_ptr->transformations |= PNG_16_TO_8; |
} |
#endif |
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
void PNGAPI |
png_set_strip_alpha(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_strip_alpha"); |
if (png_ptr == NULL) |
return; |
png_ptr->flags |= PNG_FLAG_STRIP_ALPHA; |
} |
#endif |
#ifdef PNG_READ_QUANTIZE_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_quantize" indicates |
* whether we need a quantizing 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_quantize(png_structp png_ptr, png_colorp palette, |
int num_palette, int maximum_colors, png_const_uint_16p histogram, |
int full_quantize) |
{ |
png_debug(1, "in png_set_quantize"); |
if (png_ptr == NULL) |
return; |
png_ptr->transformations |= PNG_QUANTIZE; |
if (!full_quantize) |
{ |
int i; |
png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * png_sizeof(png_byte))); |
for (i = 0; i < num_palette; i++) |
png_ptr->quantize_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->quantize_sort = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * png_sizeof(png_byte))); |
/* Initialize the quantize_sort array */ |
for (i = 0; i < num_palette; i++) |
png_ptr->quantize_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->quantize_sort[j]] |
< histogram[png_ptr->quantize_sort[j + 1]]) |
{ |
png_byte t; |
t = png_ptr->quantize_sort[j]; |
png_ptr->quantize_sort[j] = png_ptr->quantize_sort[j + 1]; |
png_ptr->quantize_sort[j + 1] = t; |
done = 0; |
} |
} |
if (done) |
break; |
} |
/* Swap the palette around, and set up a table, if necessary */ |
if (full_quantize) |
{ |
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->quantize_sort[i] >= maximum_colors) |
{ |
do |
j--; |
while ((int)png_ptr->quantize_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->quantize_sort[i] >= maximum_colors) |
{ |
png_color tmp_color; |
do |
j--; |
while ((int)png_ptr->quantize_sort[j] >= maximum_colors); |
tmp_color = palette[j]; |
palette[j] = palette[i]; |
palette[i] = tmp_color; |
/* Indicate where the color went */ |
png_ptr->quantize_index[j] = (png_byte)i; |
png_ptr->quantize_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->quantize_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->quantize_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->quantize_index[i] = (png_byte)min_k; |
} |
} |
} |
png_free(png_ptr, png_ptr->quantize_sort); |
png_ptr->quantize_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 * png_sizeof(png_byte))); |
png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(num_palette * png_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_calloc(png_ptr, (png_uint_32)(769 * |
png_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)(png_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_quantize) |
{ |
int k; |
for (k = 0; k < num_palette; k++) |
{ |
if (png_ptr->quantize_index[k] == |
png_ptr->index_to_palette[j]) |
png_ptr->quantize_index[k] = |
png_ptr->index_to_palette[next_j]; |
if ((int)png_ptr->quantize_index[k] == |
num_new_palette) |
png_ptr->quantize_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_quantize) |
{ |
int i; |
png_bytep distance; |
int total_bits = PNG_QUANTIZE_RED_BITS + PNG_QUANTIZE_GREEN_BITS + |
PNG_QUANTIZE_BLUE_BITS; |
int num_red = (1 << PNG_QUANTIZE_RED_BITS); |
int num_green = (1 << PNG_QUANTIZE_GREEN_BITS); |
int num_blue = (1 << PNG_QUANTIZE_BLUE_BITS); |
png_size_t num_entries = ((png_size_t)1 << total_bits); |
png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr, |
(png_uint_32)(num_entries * png_sizeof(png_byte))); |
distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries * |
png_sizeof(png_byte))); |
png_memset(distance, 0xff, num_entries * png_sizeof(png_byte)); |
for (i = 0; i < num_palette; i++) |
{ |
int ir, ig, ib; |
int r = (palette[i].red >> (8 - PNG_QUANTIZE_RED_BITS)); |
int g = (palette[i].green >> (8 - PNG_QUANTIZE_GREEN_BITS)); |
int b = (palette[i].blue >> (8 - PNG_QUANTIZE_BLUE_BITS)); |
for (ir = 0; ir < num_red; ir++) |
{ |
/* int dr = abs(ir - r); */ |
int dr = ((ir > r) ? ir - r : r - ir); |
int index_r = (ir << (PNG_QUANTIZE_BLUE_BITS + |
PNG_QUANTIZE_GREEN_BITS)); |
for (ig = 0; ig < num_green; ig++) |
{ |
/* int dg = abs(ig - g); */ |
int dg = ((ig > g) ? ig - g : g - ig); |
int dt = dr + dg; |
int dm = ((dr > dg) ? dr : dg); |
int index_g = index_r | (ig << PNG_QUANTIZE_BLUE_BITS); |
for (ib = 0; ib < num_blue; ib++) |
{ |
int d_index = index_g | ib; |
/* int db = abs(ib - b); */ |
int db = ((ib > b) ? ib - b : b - ib); |
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 /* PNG_READ_QUANTIZE_SUPPORTED */ |
#ifdef PNG_READ_GAMMA_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. |
*/ |
static int /* PRIVATE */ |
png_gamma_threshold(png_fixed_point scrn_gamma, png_fixed_point file_gamma) |
{ |
/* PNG_GAMMA_THRESHOLD is the threshold for performing gamma |
* correction as a difference of the overall transform from 1.0 |
* |
* We want to compare the threshold with s*f - 1, if we get |
* overflow here it is because of wacky gamma values so we |
* turn on processing anyway. |
*/ |
png_fixed_point gtest; |
return !png_muldiv(>est, scrn_gamma, file_gamma, PNG_FP_1) || |
png_gamma_significant(gtest); |
} |
void PNGFAPI |
png_set_gamma_fixed(png_structp png_ptr, png_fixed_point scrn_gamma, |
png_fixed_point file_gamma) |
{ |
png_debug(1, "in png_set_gamma_fixed"); |
if (png_ptr == NULL) |
return; |
if ((png_ptr->color_type & PNG_COLOR_MASK_ALPHA) || |
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) || |
png_gamma_threshold(scrn_gamma, file_gamma)) |
png_ptr->transformations |= PNG_GAMMA; |
png_ptr->gamma = file_gamma; |
png_ptr->screen_gamma = scrn_gamma; |
} |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma) |
{ |
png_set_gamma_fixed(png_ptr, |
png_fixed(png_ptr, scrn_gamma, "png_set_gamma screen gamma"), |
png_fixed(png_ptr, file_gamma, "png_set_gamma file gamma")); |
} |
# endif /* FLOATING_POINT_SUPPORTED */ |
#endif /* READ_GAMMA */ |
#ifdef 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"); |
if (png_ptr == NULL) |
return; |
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); |
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; |
} |
/* 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. |
* |
* GRP 20060307: In libpng-1.2.9, png_set_gray_1_2_4_to_8() was modified |
* to expand only the sample depth but not to expand the tRNS to alpha |
* and its name was changed to png_set_expand_gray_1_2_4_to_8(). |
*/ |
/* Expand paletted images to RGB. */ |
void PNGAPI |
png_set_palette_to_rgb(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_palette_to_rgb"); |
if (png_ptr == NULL) |
return; |
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); |
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; |
} |
/* Expand grayscale images of less than 8-bit depth to 8 bits. */ |
void PNGAPI |
png_set_expand_gray_1_2_4_to_8(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_expand_gray_1_2_4_to_8"); |
if (png_ptr == NULL) |
return; |
png_ptr->transformations |= PNG_EXPAND; |
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; |
} |
/* Expand tRNS chunks to alpha channels. */ |
void PNGAPI |
png_set_tRNS_to_alpha(png_structp png_ptr) |
{ |
png_debug(1, "in png_set_tRNS_to_alpha"); |
png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); |
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; |
} |
#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */ |
#ifdef 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"); |
if (png_ptr != NULL) |
{ |
/* Because rgb must be 8 bits or more: */ |
png_set_expand_gray_1_2_4_to_8(png_ptr); |
png_ptr->transformations |= PNG_GRAY_TO_RGB; |
png_ptr->flags &= ~PNG_FLAG_ROW_INIT; |
} |
} |
#endif |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
void PNGFAPI |
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"); |
if (png_ptr == NULL) |
return; |
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; |
break; |
default: |
png_error(png_ptr, "invalid error action to rgb_to_gray"); |
break; |
} |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
#ifdef 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); |
} |
} |
#ifdef 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) |
{ |
if (png_ptr == NULL) |
return; |
png_set_rgb_to_gray_fixed(png_ptr, error_action, |
png_fixed(png_ptr, red, "rgb to gray red coefficient"), |
png_fixed(png_ptr, green, "rgb to gray green coefficient")); |
} |
#endif /* FLOATING POINT */ |
#endif |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_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"); |
if (png_ptr == NULL) |
return; |
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED |
png_ptr->transformations |= PNG_USER_TRANSFORM; |
png_ptr->read_user_transform_fn = read_user_transform_fn; |
#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"); |
{ |
#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) |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
/* Detect gray background and attempt to enable optimization |
* for gray --> RGB case |
* |
* Note: if PNG_BACKGROUND_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 ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && |
!(color_type & PNG_COLOR_MASK_COLOR)) |
{ |
png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; |
} |
else if ((png_ptr->transformations & PNG_BACKGROUND) && |
!(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && |
(png_ptr->transformations & PNG_GRAY_TO_RGB) && |
png_ptr->background.red == png_ptr->background.green && |
png_ptr->background.red == png_ptr->background.blue) |
{ |
png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; |
png_ptr->background.gray = png_ptr->background.red; |
} |
#endif |
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 and tRNS chunks */ |
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; |
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) |
{ |
png_ptr->trans_color.gray *= (png_uint_16)0xff; |
png_ptr->trans_color.red = png_ptr->trans_color.green |
= png_ptr->trans_color.blue = png_ptr->trans_color.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; |
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) |
{ |
png_ptr->trans_color.gray *= (png_uint_16)0x55; |
png_ptr->trans_color.red = png_ptr->trans_color.green |
= png_ptr->trans_color.blue = png_ptr->trans_color.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; |
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) |
{ |
png_ptr->trans_color.gray *= (png_uint_16)0x11; |
png_ptr->trans_color.red = png_ptr->trans_color.green |
= png_ptr->trans_color.blue = png_ptr->trans_color.gray; |
} |
break; |
default: |
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; |
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED |
if (png_ptr->transformations & PNG_INVERT_ALPHA) |
{ |
#ifdef PNG_READ_EXPAND_SUPPORTED |
if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) |
#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_alpha[i] = (png_byte)(255 - |
png_ptr->trans_alpha[i]); |
} |
} |
#endif |
} |
} |
#endif |
#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) |
png_ptr->background_1 = png_ptr->background; |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0) |
&& png_gamma_threshold(png_ptr->screen_gamma, png_ptr->gamma)) |
{ |
int i, k; |
k=0; |
for (i=0; i<png_ptr->num_trans; i++) |
{ |
if (png_ptr->trans_alpha[i] != 0 && png_ptr->trans_alpha[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_ptr->gamma != 0) |
{ |
png_build_gamma_table(png_ptr, png_ptr->bit_depth); |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
if (png_ptr->transformations & PNG_BACKGROUND) |
{ |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
/* Could skip if no transparency */ |
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 |
{ |
png_fixed_point g, gs; |
switch (png_ptr->background_gamma_type) |
{ |
case PNG_BACKGROUND_GAMMA_SCREEN: |
g = (png_ptr->screen_gamma); |
gs = PNG_FP_1; |
break; |
case PNG_BACKGROUND_GAMMA_FILE: |
g = png_reciprocal(png_ptr->gamma); |
gs = png_reciprocal2(png_ptr->gamma, |
png_ptr->screen_gamma); |
break; |
case PNG_BACKGROUND_GAMMA_UNIQUE: |
g = png_reciprocal(png_ptr->background_gamma); |
gs = png_reciprocal2(png_ptr->background_gamma, |
png_ptr->screen_gamma); |
break; |
default: |
g = PNG_FP_1; /* back_1 */ |
gs = PNG_FP_1; /* back */ |
break; |
} |
if (png_gamma_significant(gs)) |
{ |
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_gamma_8bit_correct(png_ptr->background.red, |
gs); |
back.green = png_gamma_8bit_correct(png_ptr->background.green, |
gs); |
back.blue = png_gamma_8bit_correct(png_ptr->background.blue, |
gs); |
} |
back_1.red = png_gamma_8bit_correct(png_ptr->background.red, g); |
back_1.green = png_gamma_8bit_correct(png_ptr->background.green, |
g); |
back_1.blue = png_gamma_8bit_correct(png_ptr->background.blue, |
g); |
} |
for (i = 0; i < num_palette; i++) |
{ |
if (i < (int)png_ptr->num_trans && |
png_ptr->trans_alpha[i] != 0xff) |
{ |
if (png_ptr->trans_alpha[i] == 0) |
{ |
palette[i] = back; |
} |
else /* if (png_ptr->trans_alpha[i] != 0xff) */ |
{ |
png_byte v, w; |
v = png_ptr->gamma_to_1[palette[i].red]; |
png_composite(w, v, png_ptr->trans_alpha[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_alpha[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_alpha[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]; |
} |
} |
/* Prevent the transformations being done again, and make sure |
* that the now spurious alpha channel is stripped - the code |
* has just reduced background composition and gamma correction |
* to a simple alpha channel strip. |
*/ |
png_ptr->transformations &= ~PNG_BACKGROUND; |
png_ptr->transformations &= ~PNG_GAMMA; |
png_ptr->flags |= PNG_FLAG_STRIP_ALPHA; |
} |
/* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */ |
else |
/* color_type != PNG_COLOR_TYPE_PALETTE */ |
{ |
png_fixed_point g = PNG_FP_1; |
png_fixed_point gs = PNG_FP_1; |
switch (png_ptr->background_gamma_type) |
{ |
case PNG_BACKGROUND_GAMMA_SCREEN: |
g = png_ptr->screen_gamma; |
/* gs = PNG_FP_1; */ |
break; |
case PNG_BACKGROUND_GAMMA_FILE: |
g = png_reciprocal(png_ptr->gamma); |
gs = png_reciprocal2(png_ptr->gamma, png_ptr->screen_gamma); |
break; |
case PNG_BACKGROUND_GAMMA_UNIQUE: |
g = png_reciprocal(png_ptr->background_gamma); |
gs = png_reciprocal2(png_ptr->background_gamma, |
png_ptr->screen_gamma); |
break; |
default: |
png_error(png_ptr, "invalid background gamma type"); |
} |
png_ptr->background_1.gray = png_gamma_correct(png_ptr, |
png_ptr->background.gray, g); |
png_ptr->background.gray = png_gamma_correct(png_ptr, |
png_ptr->background.gray, gs); |
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_gamma_correct(png_ptr, |
png_ptr->background.red, g); |
png_ptr->background_1.green = png_gamma_correct(png_ptr, |
png_ptr->background.green, g); |
png_ptr->background_1.blue = png_gamma_correct(png_ptr, |
png_ptr->background.blue, g); |
png_ptr->background.red = png_gamma_correct(png_ptr, |
png_ptr->background.red, gs); |
png_ptr->background.green = png_gamma_correct(png_ptr, |
png_ptr->background.green, gs); |
png_ptr->background.blue = png_gamma_correct(png_ptr, |
png_ptr->background.blue, gs); |
} |
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]; |
} |
/* Done the gamma correction. */ |
png_ptr->transformations &= ~PNG_GAMMA; |
} |
} |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
else |
#endif |
#endif /* PNG_READ_GAMMA_SUPPORTED */ |
#ifdef 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_alpha[i] == 0) |
{ |
palette[i] = back; |
} |
else if (png_ptr->trans_alpha[i] != 0xff) |
{ |
/* The png_composite() macro is defined in png.h */ |
png_composite(palette[i].red, palette[i].red, |
png_ptr->trans_alpha[i], back.red); |
png_composite(palette[i].green, palette[i].green, |
png_ptr->trans_alpha[i], back.green); |
png_composite(palette[i].blue, palette[i].blue, |
png_ptr->trans_alpha[i], back.blue); |
} |
} |
/* Handled alpha, still need to strip the channel. */ |
png_ptr->transformations &= ~PNG_BACKGROUND; |
png_ptr->flags |= PNG_FLAG_STRIP_ALPHA; |
} |
#endif /* PNG_READ_BACKGROUND_SUPPORTED */ |
#ifdef 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"); |
#ifdef PNG_READ_EXPAND_SUPPORTED |
if (png_ptr->transformations & PNG_EXPAND) |
{ |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if (png_ptr->num_trans && |
(png_ptr->transformations & PNG_EXPAND_tRNS)) |
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) |
{ |
if (png_ptr->transformations & PNG_EXPAND_tRNS) |
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 |
#ifdef PNG_READ_BACKGROUND_SUPPORTED |
if (png_ptr->transformations & PNG_BACKGROUND) |
{ |
info_ptr->color_type = (png_byte)(info_ptr->color_type & |
~PNG_COLOR_MASK_ALPHA); |
info_ptr->num_trans = 0; |
info_ptr->background = png_ptr->background; |
} |
#endif |
#ifdef PNG_READ_GAMMA_SUPPORTED |
if (png_ptr->transformations & PNG_GAMMA) |
{ |
info_ptr->gamma = png_ptr->gamma; |
} |
#endif |
#ifdef PNG_READ_16_TO_8_SUPPORTED |
#ifdef PNG_READ_16BIT_SUPPORTED |
if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16)) |
info_ptr->bit_depth = 8; |
#else |
/* Force chopping 16-bit input down to 8 */ |
if (info_ptr->bit_depth == 16) |
{ |
png_ptr->transformations |=PNG_16_TO_8; |
info_ptr->bit_depth = 8; |
} |
#endif |
#endif |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
if (png_ptr->transformations & PNG_GRAY_TO_RGB) |
info_ptr->color_type |= PNG_COLOR_MASK_COLOR; |
#endif |
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED |
if (png_ptr->transformations & PNG_RGB_TO_GRAY) |
info_ptr->color_type &= ~PNG_COLOR_MASK_COLOR; |
#endif |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
if (png_ptr->transformations & PNG_QUANTIZE) |
{ |
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 |
#ifdef PNG_READ_PACK_SUPPORTED |
if ((png_ptr->transformations & PNG_PACK) && (info_ptr->bit_depth < 8)) |
info_ptr->bit_depth = 8; |
#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; |
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA) |
info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; |
#endif |
if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA) |
info_ptr->channels++; |
#ifdef 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 adding a true alpha channel not just filler */ |
if (png_ptr->transformations & PNG_ADD_ALPHA) |
info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; |
} |
#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 = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width); |
#ifndef 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"); |
if (png_ptr->row_buf == NULL) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char msg[50]; |
png_snprintf2(msg, 50, |
"NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number, |
png_ptr->pass); |
png_error(png_ptr, msg); |
#else |
png_error(png_ptr, "NULL row buffer"); |
#endif |
} |
#ifdef PNG_WARN_UNINITIALIZED_ROW |
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) |
/* Application has failed to call either png_read_start_image() |
* or png_read_update_info() after setting transforms that expand |
* pixels. This check added to libpng-1.2.19 |
*/ |
#if (PNG_WARN_UNINITIALIZED_ROW==1) |
png_error(png_ptr, "Uninitialized row"); |
#else |
png_warning(png_ptr, "Uninitialized row"); |
#endif |
#endif |
#ifdef 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_alpha, png_ptr->num_trans); |
} |
else |
{ |
if (png_ptr->num_trans && |
(png_ptr->transformations & PNG_EXPAND_tRNS)) |
png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, |
&(png_ptr->trans_color)); |
else |
png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, |
NULL); |
} |
} |
#endif |
#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED |
if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA) |
png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, |
PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)); |
#endif |
#ifdef 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) == |
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) == |
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. |
*/ |
#ifdef 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 |
#ifdef 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_color), &(png_ptr->background) |
#ifdef 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 |
#ifdef PNG_READ_GAMMA_SUPPORTED |
if ((png_ptr->transformations & PNG_GAMMA) && |
#ifdef 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 |
#ifdef 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 |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
if (png_ptr->transformations & PNG_QUANTIZE) |
{ |
png_do_quantize(&(png_ptr->row_info), png_ptr->row_buf + 1, |
png_ptr->palette_lookup, png_ptr->quantize_index); |
if (png_ptr->row_info.rowbytes == 0) |
png_error(png_ptr, "png_do_quantize returned rowbytes=0"); |
} |
#endif /* PNG_READ_QUANTIZE_SUPPORTED */ |
#ifdef PNG_READ_INVERT_SUPPORTED |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#ifdef 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 |
#ifdef PNG_READ_PACK_SUPPORTED |
if (png_ptr->transformations & PNG_PACK) |
png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_BGR_SUPPORTED |
if (png_ptr->transformations & PNG_BGR) |
png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_READ_PACKSWAP_SUPPORTED |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef PNG_READ_16BIT_SUPPORTED |
#ifdef PNG_READ_SWAP_SUPPORTED |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#endif |
#ifdef 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_size_t 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 */ |
#ifdef 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_ROWBYTES(png_ptr->row_info.pixel_depth, |
png_ptr->row_info.width); |
} |
#endif |
} |
#ifdef 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"); |
if (row_info->bit_depth < 8) |
{ |
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; |
} |
default: |
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 |
#ifdef 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_const_color_8p sig_bits) |
{ |
png_debug(1, "in png_do_unshift"); |
if ( |
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) |
{ |
default: |
break; |
case 2: |
{ |
png_bytep bp; |
png_size_t i; |
png_size_t istop = row_info->rowbytes; |
for (bp = row, i = 0; i < istop; i++) |
{ |
*bp >>= 1; |
*bp++ &= 0x55; |
} |
break; |
} |
case 4: |
{ |
png_bytep bp = row; |
png_size_t i; |
png_size_t 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; |
} |
#ifdef PNG_READ_16BIT_SUPPORTED |
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 |
} |
} |
} |
#endif |
#ifdef 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"); |
if (row_info->bit_depth == 16) |
{ |
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++) |
{ |
#ifdef 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 |
#ifdef 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"); |
{ |
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; |
} |
} |
#ifdef PNG_READ_16BIT_SUPPORTED |
/* 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]; |
} |
} |
#endif |
} |
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; |
} |
} |
#ifdef PNG_READ_16BIT_SUPPORTED |
/* 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 |
} |
} |
} |
#endif |
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED |
void /* PRIVATE */ |
png_do_read_invert_alpha(png_row_infop row_info, png_bytep row) |
{ |
png_uint_32 row_width; |
png_debug(1, "in png_do_read_invert_alpha"); |
row_width = row_info->width; |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This inverts the alpha channel in RGBA */ |
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; |
} |
} |
#ifdef PNG_READ_16BIT_SUPPORTED |
/* 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; |
} |
} |
#endif |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This inverts the alpha channel in GA */ |
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); |
} |
} |
#ifdef PNG_READ_16BIT_SUPPORTED |
else |
{ |
/* This inverts the alpha channel in GGAA */ |
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 |
} |
} |
#endif |
#ifdef 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; |
#ifdef PNG_READ_16BIT_SUPPORTED |
png_byte hi_filler = (png_byte)((filler>>8) & 0xff); |
#endif |
png_byte lo_filler = (png_byte)(filler & 0xff); |
png_debug(1, "in png_do_read_filler"); |
if ( |
row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if (row_info->bit_depth == 8) |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This changes the data from G to GX */ |
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; |
} |
else |
{ |
/* This changes the data from G to XG */ |
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; |
} |
} |
#ifdef PNG_READ_16BIT_SUPPORTED |
else if (row_info->bit_depth == 16) |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This changes the data from GG to GGXX */ |
png_bytep sp = row + (png_size_t)row_width * 2; |
png_bytep dp = sp + (png_size_t)row_width * 2; |
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; |
} |
else |
{ |
/* This changes the data from GG to XXGG */ |
png_bytep sp = row + (png_size_t)row_width * 2; |
png_bytep dp = sp + (png_size_t)row_width * 2; |
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; |
} |
} |
#endif |
} /* COLOR_TYPE == GRAY */ |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB) |
{ |
if (row_info->bit_depth == 8) |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This changes the data from RGB to RGBX */ |
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; |
} |
else |
{ |
/* This changes the data from RGB to XRGB */ |
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; |
} |
} |
#ifdef PNG_READ_16BIT_SUPPORTED |
else if (row_info->bit_depth == 16) |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This changes the data from RRGGBB to RRGGBBXX */ |
png_bytep sp = row + (png_size_t)row_width * 6; |
png_bytep dp = sp + (png_size_t)row_width * 2; |
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; |
} |
else |
{ |
/* This changes the data from RRGGBB to XXRRGGBB */ |
png_bytep sp = row + (png_size_t)row_width * 6; |
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); |
*(--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; |
} |
} |
#endif |
} /* COLOR_TYPE == RGB */ |
} |
#endif |
#ifdef 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"); |
if (row_info->bit_depth >= 8 && |
!(row_info->color_type & PNG_COLOR_MASK_COLOR)) |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This changes G to RGB */ |
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 |
{ |
/* This changes GG to RRGGBB */ |
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) |
{ |
/* This changes GA to RGBA */ |
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 |
{ |
/* This changes GGAA to RRGGBBAA */ |
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 = PNG_ROWBYTES(row_info->pixel_depth, row_width); |
} |
} |
#endif |
#ifdef 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/> (THIS LINK IS DEAD June 2008) |
* New link: |
* <http://www.poynton.com/notes/colour_and_gamma/> |
* Charles Poynton poynton at poynton.com |
* |
* 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"); |
if (!(row_info->color_type & PNG_COLOR_MASK_PALETTE) && |
(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)((rc*red + gc*green + bc*blue)>>15); |
*(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 -= 2; |
row_info->color_type = (png_byte)(row_info->color_type & |
~PNG_COLOR_MASK_COLOR); |
row_info->pixel_depth = (png_byte)(row_info->channels * |
row_info->bit_depth); |
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); |
} |
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"); |
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; |
} |
} |
#ifdef 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_const_color_16p trans_color, png_const_color_16p background |
#ifdef PNG_READ_GAMMA_SUPPORTED |
, png_const_color_16p background_1, png_const_bytep gamma_table, |
png_const_bytep gamma_from_1, png_const_bytep gamma_to_1, |
png_const_uint_16pp gamma_16, png_const_uint_16pp gamma_16_from_1, |
png_const_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"); |
if (background != NULL && |
(!(row_info->color_type & PNG_COLOR_MASK_ALPHA) || |
(row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_color))) |
{ |
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_color->gray) |
{ |
*sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); |
*sp |= (png_byte)(background->gray << shift); |
} |
if (!shift) |
{ |
shift = 7; |
sp++; |
} |
else |
shift--; |
} |
break; |
} |
case 2: |
{ |
#ifdef 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_color->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_color->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: |
{ |
#ifdef 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_color->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_color->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: |
{ |
#ifdef PNG_READ_GAMMA_SUPPORTED |
if (gamma_table != NULL) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp++) |
{ |
if (*sp == trans_color->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_color->gray) |
*sp = (png_byte)background->gray; |
} |
} |
break; |
} |
case 16: |
{ |
#ifdef 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_color->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_color->gray) |
{ |
*sp = (png_byte)((background->gray >> 8) & 0xff); |
*(sp + 1) = (png_byte)(background->gray & 0xff); |
} |
} |
} |
break; |
} |
default: |
break; |
} |
break; |
} |
case PNG_COLOR_TYPE_RGB: |
{ |
if (row_info->bit_depth == 8) |
{ |
#ifdef PNG_READ_GAMMA_SUPPORTED |
if (gamma_table != NULL) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp += 3) |
{ |
if (*sp == trans_color->red && |
*(sp + 1) == trans_color->green && |
*(sp + 2) == trans_color->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_color->red && |
*(sp + 1) == trans_color->green && |
*(sp + 2) == trans_color->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) */ |
{ |
#ifdef 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_color->red && g == trans_color->green && |
b == trans_color->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_color->red && g == trans_color->green && |
b == trans_color->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) |
{ |
#ifdef 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; |
#ifdef 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) */ |
{ |
#ifdef 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); |
} |
#ifdef 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); |
} |
#ifdef 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); |
#ifdef 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); |
} |
#ifdef 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) |
{ |
#ifdef 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) */ |
{ |
#ifdef 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; |
} |
default: |
break; |
} |
if (row_info->color_type & PNG_COLOR_MASK_ALPHA) |
{ |
row_info->color_type = (png_byte)(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 = PNG_ROWBYTES(row_info->pixel_depth, row_width); |
} |
} |
} |
#endif |
#ifdef 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_const_bytep gamma_table, png_const_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"); |
if (((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; |
} |
default: |
break; |
} |
} |
} |
#endif |
#ifdef 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_const_colorp palette, png_const_bytep trans_alpha, 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"); |
if (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; |
} |
default: |
break; |
} |
row_info->bit_depth = 8; |
row_info->pixel_depth = 8; |
row_info->rowbytes = row_width; |
} |
if (row_info->bit_depth == 8) |
{ |
{ |
if (trans_alpha != 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_alpha[*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; |
} |
} |
} |
} |
} |
/* If the bit depth < 8, it is expanded to 8. Also, if the already |
* expanded transparency value is supplied, an alpha channel is built. |
*/ |
void /* PRIVATE */ |
png_do_expand(png_row_infop row_info, png_bytep row, |
png_const_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"); |
{ |
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 & 0x01) * 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 & 0x03) * 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 & 0x0f) * 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; |
} |
default: |
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) |
{ |
gray = gray & 0xff; |
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) |
{ |
png_byte gray_high = (png_byte)((gray >> 8) & 0xff); |
png_byte gray_low = (png_byte)(gray & 0xff); |
sp = row + row_info->rowbytes - 1; |
dp = row + (row_info->rowbytes << 1) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if (*(sp - 1) == gray_high && *(sp) == gray_low) |
{ |
*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 = PNG_ROWBYTES(row_info->pixel_depth, |
row_width); |
} |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value) |
{ |
if (row_info->bit_depth == 8) |
{ |
png_byte red = (png_byte)(trans_value->red & 0xff); |
png_byte green = (png_byte)(trans_value->green & 0xff); |
png_byte blue = (png_byte)(trans_value->blue & 0xff); |
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) == red && *(sp - 1) == green && *(sp) == blue) |
*dp-- = 0; |
else |
*dp-- = 0xff; |
*dp-- = *sp--; |
*dp-- = *sp--; |
*dp-- = *sp--; |
} |
} |
else if (row_info->bit_depth == 16) |
{ |
png_byte red_high = (png_byte)((trans_value->red >> 8) & 0xff); |
png_byte green_high = (png_byte)((trans_value->green >> 8) & 0xff); |
png_byte blue_high = (png_byte)((trans_value->blue >> 8) & 0xff); |
png_byte red_low = (png_byte)(trans_value->red & 0xff); |
png_byte green_low = (png_byte)(trans_value->green & 0xff); |
png_byte blue_low = (png_byte)(trans_value->blue & 0xff); |
sp = row + row_info->rowbytes - 1; |
dp = row + (png_size_t)(row_width << 3) - 1; |
for (i = 0; i < row_width; i++) |
{ |
if (*(sp - 5) == red_high && |
*(sp - 4) == red_low && |
*(sp - 3) == green_high && |
*(sp - 2) == green_low && |
*(sp - 1) == blue_high && |
*(sp ) == blue_low) |
{ |
*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 = PNG_ROWBYTES(row_info->pixel_depth, row_width); |
} |
} |
} |
#endif |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
void /* PRIVATE */ |
png_do_quantize(png_row_infop row_info, png_bytep row, |
png_const_bytep palette_lookup, png_const_bytep quantize_lookup) |
{ |
png_bytep sp, dp; |
png_uint_32 i; |
png_uint_32 row_width=row_info->width; |
png_debug(1, "in png_do_quantize"); |
if (row_info->bit_depth == 8) |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB && palette_lookup) |
{ |
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_QUANTIZE_RED_BITS)) & |
((1 << PNG_QUANTIZE_RED_BITS) - 1)) << |
(PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) | |
(((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) & |
((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) << |
(PNG_QUANTIZE_BLUE_BITS)) | |
((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) & |
((1 << PNG_QUANTIZE_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 = PNG_ROWBYTES(row_info->pixel_depth, row_width); |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && |
palette_lookup != NULL) |
{ |
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_QUANTIZE_RED_BITS)) & |
((1 << PNG_QUANTIZE_RED_BITS) - 1)) << |
(PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) | |
(((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) & |
((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) << |
(PNG_QUANTIZE_BLUE_BITS)) | |
((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) & |
((1 << PNG_QUANTIZE_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 = PNG_ROWBYTES(row_info->pixel_depth, row_width); |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && |
quantize_lookup) |
{ |
sp = row; |
for (i = 0; i < row_width; i++, sp++) |
{ |
*sp = quantize_lookup[*sp]; |
} |
} |
} |
} |
#endif /* PNG_READ_QUANTIZE_SUPPORTED */ |
#ifdef 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"); |
if ( |
(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 = (png_uint_32)((s0 + s1 + 65536L) & 0xffffL); |
png_uint_32 blue = (png_uint_32)((s2 + s1 + 65536L) & 0xffffL); |
*(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_READ_SUPPORTED */ |
/programs/develop/libraries/libpng/pngrutil.c |
---|
0,0 → 1,3616 |
/* pngrutil.c - utilities to read a PNG file |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
* |
* This file contains routines that are only called from within |
* libpng itself during the course of reading an image. |
*/ |
#include "pngpriv.h" |
#ifdef PNG_READ_SUPPORTED |
#define png_strtod(p,a,b) strtod(a,b) |
png_uint_32 PNGAPI |
png_get_uint_31(png_structp png_ptr, png_const_bytep buf) |
{ |
png_uint_32 uval = png_get_uint_32(buf); |
if (uval > PNG_UINT_31_MAX) |
png_error(png_ptr, "PNG unsigned integer out of range"); |
return (uval); |
} |
#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_READ_cHRM_SUPPORTED) |
/* The following is a variation on the above for use with the fixed |
* point values used for gAMA and cHRM. Instead of png_error it |
* issues a warning and returns (-1) - an invalid value because both |
* gAMA and cHRM use *unsigned* integers for fixed point values. |
*/ |
#define PNG_FIXED_ERROR (-1) |
static png_fixed_point /* PRIVATE */ |
png_get_fixed_point(png_structp png_ptr, png_const_bytep buf) |
{ |
png_uint_32 uval = png_get_uint_32(buf); |
if (uval <= PNG_UINT_31_MAX) |
return (png_fixed_point)uval; /* known to be in range */ |
/* The caller can turn off the warning by passing NULL. */ |
if (png_ptr != NULL) |
png_warning(png_ptr, "PNG fixed point integer out of range"); |
return PNG_FIXED_ERROR; |
} |
#endif |
#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED |
/* NOTE: the read macros will obscure these definitions, so that if |
* PNG_USE_READ_MACROS is set the library will not use them internally, |
* but the APIs will still be available externally. |
* |
* The parentheses around "PNGAPI function_name" in the following three |
* functions are necessary because they allow the macros to co-exist with |
* these (unused but exported) functions. |
*/ |
/* Grab an unsigned 32-bit integer from a buffer in big-endian format. */ |
png_uint_32 (PNGAPI |
png_get_uint_32)(png_const_bytep buf) |
{ |
png_uint_32 uval = |
((png_uint_32)(*(buf )) << 24) + |
((png_uint_32)(*(buf + 1)) << 16) + |
((png_uint_32)(*(buf + 2)) << 8) + |
((png_uint_32)(*(buf + 3)) ) ; |
return uval; |
} |
/* 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 there |
* is no guarantee that a 'png_int_32' is exactly 32 bits, therefore |
* the following code does a two's complement to native conversion. |
*/ |
png_int_32 (PNGAPI |
png_get_int_32)(png_const_bytep buf) |
{ |
png_uint_32 uval = png_get_uint_32(buf); |
if ((uval & 0x80000000L) == 0) /* non-negative */ |
return uval; |
uval = (uval ^ 0xffffffffL) + 1; /* 2's complement: -x = ~x+1 */ |
return -(png_int_32)uval; |
} |
/* Grab an unsigned 16-bit integer from a buffer in big-endian format. */ |
png_uint_16 (PNGAPI |
png_get_uint_16)(png_const_bytep buf) |
{ |
/* ANSI-C requires an int value to accomodate at least 16 bits so this |
* works and allows the compiler not to worry about possible narrowing |
* on 32 bit systems. (Pre-ANSI systems did not make integers smaller |
* than 16 bits either.) |
*/ |
unsigned int val = |
((unsigned int)(*buf) << 8) + |
((unsigned int)(*(buf + 1))); |
return (png_uint_16)val; |
} |
#endif /* PNG_READ_INT_FUNCTIONS_SUPPORTED */ |
/* Read and check the PNG file signature */ |
void /* PRIVATE */ |
png_read_sig(png_structp png_ptr, png_infop info_ptr) |
{ |
png_size_t num_checked, num_to_check; |
/* Exit if the user application does not expect a signature. */ |
if (png_ptr->sig_bytes >= 8) |
return; |
num_checked = png_ptr->sig_bytes; |
num_to_check = 8 - num_checked; |
#ifdef PNG_IO_STATE_SUPPORTED |
png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE; |
#endif |
/* The signature must be serialized in a single I/O call. */ |
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; |
} |
/* Read the chunk header (length + type name). |
* Put the type name into png_ptr->chunk_name, and return the length. |
*/ |
png_uint_32 /* PRIVATE */ |
png_read_chunk_header(png_structp png_ptr) |
{ |
png_byte buf[8]; |
png_uint_32 length; |
#ifdef PNG_IO_STATE_SUPPORTED |
png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR; |
#endif |
/* Read the length and the chunk name. |
* This must be performed in a single I/O call. |
*/ |
png_read_data(png_ptr, buf, 8); |
length = png_get_uint_31(png_ptr, buf); |
/* Put the chunk name into png_ptr->chunk_name. */ |
png_memcpy(png_ptr->chunk_name, buf + 4, 4); |
png_debug2(0, "Reading %s chunk, length = %u", |
png_ptr->chunk_name, length); |
/* Reset the crc and run it over the chunk name. */ |
png_reset_crc(png_ptr); |
png_calculate_crc(png_ptr, png_ptr->chunk_name, 4); |
/* Check to see if chunk name is valid. */ |
png_check_chunk_name(png_ptr, png_ptr->chunk_name); |
#ifdef PNG_IO_STATE_SUPPORTED |
png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA; |
#endif |
return length; |
} |
/* 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) |
{ |
if (png_ptr == NULL) |
return; |
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_benign_error(png_ptr, "CRC error"); |
return (0); |
} |
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; |
} |
#ifdef PNG_IO_STATE_SUPPORTED |
png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC; |
#endif |
/* The chunk CRC must be serialized in a single I/O call. */ |
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) |
static png_size_t |
png_inflate(png_structp png_ptr, png_bytep data, png_size_t size, |
png_bytep output, png_size_t output_size) |
{ |
png_size_t count = 0; |
/* zlib can't necessarily handle more than 65535 bytes at once (i.e. it can't |
* even necessarily handle 65536 bytes) because the type uInt is "16 bits or |
* more". Consequently it is necessary to chunk the input to zlib. This |
* code uses ZLIB_IO_MAX, from pngpriv.h, as the maximum (the maximum value |
* that can be stored in a uInt.) It is possible to set ZLIB_IO_MAX to a |
* lower value in pngpriv.h and this may sometimes have a performance |
* advantage, because it forces access of the input data to be separated from |
* at least some of the use by some period of time. |
*/ |
png_ptr->zstream.next_in = data; |
/* avail_in is set below from 'size' */ |
png_ptr->zstream.avail_in = 0; |
while (1) |
{ |
int ret, avail; |
/* The setting of 'avail_in' used to be outside the loop, by setting it |
* inside it is possible to chunk the input to zlib and simply rely on |
* zlib to advance the 'next_in' pointer. This allows arbitrary amounts o |
* data to be passed through zlib at the unavoidable cost of requiring a |
* window save (memcpy of up to 32768 output bytes) every ZLIB_IO_MAX |
* input bytes. |
*/ |
if (png_ptr->zstream.avail_in == 0 && size > 0) |
{ |
if (size <= ZLIB_IO_MAX) |
{ |
/* The value is less than ZLIB_IO_MAX so the cast is safe: */ |
png_ptr->zstream.avail_in = (uInt)size; |
size = 0; |
} |
else |
{ |
png_ptr->zstream.avail_in = ZLIB_IO_MAX; |
size -= ZLIB_IO_MAX; |
} |
} |
/* Reset the output buffer each time round - we empty it |
* after every inflate call. |
*/ |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = png_ptr->zbuf_size; |
ret = inflate(&png_ptr->zstream, Z_NO_FLUSH); |
avail = png_ptr->zbuf_size - png_ptr->zstream.avail_out; |
/* First copy/count any new output - but only if we didn't |
* get an error code. |
*/ |
if ((ret == Z_OK || ret == Z_STREAM_END) && avail > 0) |
{ |
png_size_t space = avail; /* > 0, see above */ |
if (output != 0 && output_size > count) |
{ |
png_size_t copy = output_size - count; |
if (space < copy) |
copy = space; |
png_memcpy(output + count, png_ptr->zbuf, copy); |
} |
count += space; |
} |
if (ret == Z_OK) |
continue; |
/* Termination conditions - always reset the zstream, it |
* must be left in inflateInit state. |
*/ |
png_ptr->zstream.avail_in = 0; |
inflateReset(&png_ptr->zstream); |
if (ret == Z_STREAM_END) |
return count; /* NOTE: may be zero. */ |
/* Now handle the error codes - the API always returns 0 |
* and the error message is dumped into the uncompressed |
* buffer if available. |
*/ |
{ |
PNG_CONST char *msg; |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char umsg[52]; |
#endif |
if (png_ptr->zstream.msg != 0) |
msg = png_ptr->zstream.msg; |
else |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
switch (ret) |
{ |
case Z_BUF_ERROR: |
msg = "Buffer error in compressed datastream in %s chunk"; |
break; |
case Z_DATA_ERROR: |
msg = "Data error in compressed datastream in %s chunk"; |
break; |
default: |
msg = "Incomplete compressed datastream in %s chunk"; |
break; |
} |
png_snprintf(umsg, sizeof umsg, msg, png_ptr->chunk_name); |
msg = umsg; |
#else |
msg = "Damaged compressed datastream in chunk other than IDAT"; |
#endif |
} |
png_warning(png_ptr, msg); |
} |
/* 0 means an error - notice that this code simply ignores |
* zero length compressed chunks as a result. |
*/ |
return 0; |
} |
} |
/* |
* 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). |
*/ |
void /* PRIVATE */ |
png_decompress_chunk(png_structp png_ptr, int comp_type, |
png_size_t chunklength, |
png_size_t prefix_size, png_size_t *newlength) |
{ |
/* The caller should guarantee this */ |
if (prefix_size > chunklength) |
{ |
/* The recovery is to delete the chunk. */ |
png_warning(png_ptr, "invalid chunklength"); |
prefix_size = 0; /* To delete everything */ |
} |
else if (comp_type == PNG_COMPRESSION_TYPE_BASE) |
{ |
png_size_t expanded_size = png_inflate(png_ptr, |
(png_bytep)(png_ptr->chunkdata + prefix_size), |
chunklength - prefix_size, |
0, /*output*/ |
0); /*output size*/ |
/* Now check the limits on this chunk - if the limit fails the |
* compressed data will be removed, the prefix will remain. |
*/ |
#ifdef PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED |
if (png_ptr->user_chunk_malloc_max && |
(prefix_size + expanded_size >= png_ptr->user_chunk_malloc_max - 1)) |
#else |
# ifdef PNG_USER_CHUNK_MALLOC_MAX |
if ((PNG_USER_CHUNK_MALLOC_MAX > 0) && |
prefix_size + expanded_size >= PNG_USER_CHUNK_MALLOC_MAX - 1) |
# endif |
#endif |
png_warning(png_ptr, "Exceeded size limit while expanding chunk"); |
/* If the size is zero either there was an error and a message |
* has already been output (warning) or the size really is zero |
* and we have nothing to do - the code will exit through the |
* error case below. |
*/ |
#if defined(PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED) || \ |
defined(PNG_USER_CHUNK_MALLOC_MAX) |
else if (expanded_size > 0) |
#else |
if (expanded_size > 0) |
#endif |
{ |
/* Success (maybe) - really uncompress the chunk. */ |
png_size_t new_size = 0; |
png_charp text = png_malloc_warn(png_ptr, |
prefix_size + expanded_size + 1); |
if (text != NULL) |
{ |
png_memcpy(text, png_ptr->chunkdata, prefix_size); |
new_size = png_inflate(png_ptr, |
(png_bytep)(png_ptr->chunkdata + prefix_size), |
chunklength - prefix_size, |
(png_bytep)(text + prefix_size), expanded_size); |
text[prefix_size + expanded_size] = 0; /* just in case */ |
if (new_size == expanded_size) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = text; |
*newlength = prefix_size + expanded_size; |
return; /* The success return! */ |
} |
png_warning(png_ptr, "png_inflate logic error"); |
png_free(png_ptr, text); |
} |
else |
png_warning(png_ptr, "Not enough memory to decompress chunk"); |
} |
} |
else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */ |
{ |
#ifdef PNG_STDIO_SUPPORTED |
char umsg[50]; |
png_snprintf(umsg, sizeof umsg, |
"Unknown zTXt compression type %d", comp_type); |
png_warning(png_ptr, umsg); |
#else |
png_warning(png_ptr, "Unknown zTXt compression type"); |
#endif |
/* The recovery is to simply drop the data. */ |
} |
/* Generic error return - leave the prefix, delete the compressed |
* data, reallocate the chunkdata to remove the potentially large |
* amount of compressed data. |
*/ |
{ |
png_charp text = png_malloc_warn(png_ptr, prefix_size + 1); |
if (text != NULL) |
{ |
if (prefix_size > 0) |
png_memcpy(text, png_ptr->chunkdata, prefix_size); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = text; |
/* This is an extra zero in the 'uncompressed' part. */ |
*(png_ptr->chunkdata + prefix_size) = 0x00; |
} |
/* Ignore a malloc error here - it is safe. */ |
} |
*newlength = prefix_size; |
} |
#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"); |
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_31(png_ptr, buf); |
height = png_get_uint_31(png_ptr, 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; |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
png_ptr->filter_type = (png_byte)filter_type; |
#endif |
png_ptr->compression_type = (png_byte)compression_type; |
/* Find number of channels */ |
switch (png_ptr->color_type) |
{ |
default: /* invalid, png_set_IHDR calls png_error */ |
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_ROWBYTES(png_ptr->pixel_depth, png_ptr->width); |
png_debug1(3, "bit_depth = %d", png_ptr->bit_depth); |
png_debug1(3, "channels = %d", png_ptr->channels); |
png_debug1(3, "rowbytes = %lu", (unsigned long)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; |
#ifdef PNG_POINTER_INDEXING_SUPPORTED |
png_colorp pal_ptr; |
#endif |
png_debug(1, "in png_handle_PLTE"); |
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; |
} |
#ifndef 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; |
#ifdef PNG_POINTER_INDEXING_SUPPORTED |
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. |
*/ |
#ifndef PNG_READ_OPT_PLTE_SUPPORTED |
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
#endif |
{ |
png_crc_finish(png_ptr, 0); |
} |
#ifndef 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_benign_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); |
#ifdef 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"); |
if (!(png_ptr->mode & PNG_HAVE_IHDR) || !(png_ptr->mode & PNG_HAVE_IDAT)) |
{ |
png_error(png_ptr, "No image in file"); |
} |
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); |
PNG_UNUSED(info_ptr) /* Quiet compiler warnings about unused info_ptr */ |
} |
#ifdef 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; |
png_byte buf[4]; |
png_debug(1, "in png_handle_gAMA"); |
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"); |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) |
#ifdef 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_get_fixed_point(NULL, buf); |
/* Check for zero gamma or an error. */ |
if (igamma <= 0) |
{ |
png_warning(png_ptr, |
"Ignoring gAMA chunk with out of range gamma"); |
return; |
} |
# ifdef PNG_READ_sRGB_SUPPORTED |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) |
{ |
if (PNG_OUT_OF_RANGE(igamma, 45500L, 500)) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect gAMA value when sRGB is also present"); |
# ifdef PNG_CONSOLE_IO_SUPPORTED |
fprintf(stderr, "gamma = (%d/100000)", (int)igamma); |
# endif |
return; |
} |
} |
# endif /* PNG_READ_sRGB_SUPPORTED */ |
# ifdef PNG_READ_GAMMA_SUPPORTED |
/* Gamma correction on read is supported. */ |
png_ptr->gamma = igamma; |
# endif |
/* And set the 'info' structure members. */ |
png_set_gAMA_fixed(png_ptr, info_ptr, igamma); |
} |
#endif |
#ifdef 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"); |
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"); |
} |
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 || length > 4) |
{ |
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 |
#ifdef PNG_READ_cHRM_SUPPORTED |
void /* PRIVATE */ |
png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
png_byte buf[32]; |
png_fixed_point x_white, y_white, x_red, y_red, x_green, y_green, x_blue, |
y_blue; |
png_debug(1, "in png_handle_cHRM"); |
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"); |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM) |
# ifdef 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, 32); |
if (png_crc_finish(png_ptr, 0)) |
return; |
x_white = png_get_fixed_point(NULL, buf); |
y_white = png_get_fixed_point(NULL, buf + 4); |
x_red = png_get_fixed_point(NULL, buf + 8); |
y_red = png_get_fixed_point(NULL, buf + 12); |
x_green = png_get_fixed_point(NULL, buf + 16); |
y_green = png_get_fixed_point(NULL, buf + 20); |
x_blue = png_get_fixed_point(NULL, buf + 24); |
y_blue = png_get_fixed_point(NULL, buf + 28); |
if (x_white == PNG_FIXED_ERROR || |
y_white == PNG_FIXED_ERROR || |
x_red == PNG_FIXED_ERROR || |
y_red == PNG_FIXED_ERROR || |
x_green == PNG_FIXED_ERROR || |
y_green == PNG_FIXED_ERROR || |
x_blue == PNG_FIXED_ERROR || |
y_blue == PNG_FIXED_ERROR) |
{ |
png_warning(png_ptr, "Ignoring cHRM chunk with negative chromaticities"); |
return; |
} |
#ifdef PNG_READ_sRGB_SUPPORTED |
if ((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB)) |
{ |
if (PNG_OUT_OF_RANGE(x_white, 31270, 1000) || |
PNG_OUT_OF_RANGE(y_white, 32900, 1000) || |
PNG_OUT_OF_RANGE(x_red, 64000L, 1000) || |
PNG_OUT_OF_RANGE(y_red, 33000, 1000) || |
PNG_OUT_OF_RANGE(x_green, 30000, 1000) || |
PNG_OUT_OF_RANGE(y_green, 60000L, 1000) || |
PNG_OUT_OF_RANGE(x_blue, 15000, 1000) || |
PNG_OUT_OF_RANGE(y_blue, 6000, 1000)) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect cHRM value when sRGB is also present"); |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
fprintf(stderr, "wx=%d, wy=%d, rx=%d, ry=%d\n", |
x_white, y_white, x_red, y_red); |
fprintf(stderr, "gx=%d, gy=%d, bx=%d, by=%d\n", |
x_green, y_green, x_blue, y_blue); |
#endif /* PNG_CONSOLE_IO_SUPPORTED */ |
} |
return; |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
png_set_cHRM_fixed(png_ptr, info_ptr, x_white, y_white, x_red, y_red, |
x_green, y_green, x_blue, y_blue); |
} |
#endif |
#ifdef 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"); |
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"); |
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 != NULL && (info_ptr->valid & PNG_INFO_gAMA)) |
{ |
if (PNG_OUT_OF_RANGE(info_ptr->gamma, 45500L, 500)) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect gAMA value when sRGB is also present"); |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
fprintf(stderr, "incorrect gamma=(%d/100000)\n", info_ptr->gamma); |
#endif |
} |
} |
#endif /* PNG_READ_gAMA_SUPPORTED */ |
#ifdef PNG_READ_cHRM_SUPPORTED |
if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) |
if (PNG_OUT_OF_RANGE(info_ptr->x_white, 31270, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->y_white, 32900, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->x_red, 64000L, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->y_red, 33000, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->x_green, 30000, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->y_green, 60000L, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->x_blue, 15000, 1000) || |
PNG_OUT_OF_RANGE(info_ptr->y_blue, 6000, 1000)) |
{ |
png_warning(png_ptr, |
"Ignoring incorrect cHRM value when sRGB is also present"); |
} |
#endif /* PNG_READ_cHRM_SUPPORTED */ |
png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent); |
} |
#endif /* PNG_READ_sRGB_SUPPORTED */ |
#ifdef 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_byte compression_type; |
png_bytep pC; |
png_charp profile; |
png_uint_32 skip = 0; |
png_uint_32 profile_size; |
png_alloc_size_t profile_length; |
png_size_t slength, prefix_length, data_length; |
png_debug(1, "in png_handle_iCCP"); |
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"); |
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 |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1); |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
png_ptr->chunkdata[slength] = 0x00; |
for (profile = png_ptr->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 >= png_ptr->chunkdata + slength - 1) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
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 - png_ptr->chunkdata; |
png_decompress_chunk(png_ptr, compression_type, |
slength, prefix_length, &data_length); |
profile_length = data_length - prefix_length; |
if (prefix_length > data_length || profile_length < 4) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
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)(png_ptr->chunkdata + prefix_length); |
profile_size = ((*(pC )) << 24) | |
((*(pC + 1)) << 16) | |
((*(pC + 2)) << 8) | |
((*(pC + 3)) ); |
/* NOTE: the following guarantees that 'profile_length' fits into 32 bits, |
* because profile_size is a 32 bit value. |
*/ |
if (profile_size < profile_length) |
profile_length = profile_size; |
/* And the following guarantees that profile_size == profile_length. */ |
if (profile_size > profile_length) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
#ifdef PNG_STDIO_SUPPORTED |
{ |
char umsg[80]; |
png_snprintf2(umsg, 80, |
"Ignoring iCCP chunk with declared size = %u " |
"and actual length = %u", |
(unsigned int) profile_size, |
(unsigned int) profile_length); |
png_warning(png_ptr, umsg); |
} |
#else |
png_warning(png_ptr, |
"Ignoring iCCP chunk with uncompressed size mismatch"); |
#endif |
return; |
} |
png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata, |
compression_type, (png_bytep)png_ptr->chunkdata + prefix_length, |
profile_size); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
} |
#endif /* PNG_READ_iCCP_SUPPORTED */ |
#ifdef 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 entry_start; |
png_sPLT_t new_palette; |
#ifdef PNG_POINTER_INDEXING_SUPPORTED |
png_sPLT_entryp pp; |
#endif |
png_uint_32 data_length; |
int entry_size, i; |
png_uint_32 skip = 0; |
png_size_t slength; |
png_uint_32 dl; |
png_size_t max_dl; |
png_debug(1, "in png_handle_sPLT"); |
#ifdef PNG_USER_LIMITS_SUPPORTED |
if (png_ptr->user_chunk_cache_max != 0) |
{ |
if (png_ptr->user_chunk_cache_max == 1) |
{ |
png_crc_finish(png_ptr, length); |
return; |
} |
if (--png_ptr->user_chunk_cache_max == 1) |
{ |
png_warning(png_ptr, "No space in chunk cache for sPLT"); |
png_crc_finish(png_ptr, length); |
return; |
} |
} |
#endif |
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 |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc(png_ptr, length + 1); |
/* WARNING: this may break if size_t is less than 32 bits; it is assumed |
* that the PNG_MAX_MALLOC_64K test is enabled in this case, but this is a |
* potential breakage point if the types in pngconf.h aren't exactly right. |
*/ |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
png_ptr->chunkdata[slength] = 0x00; |
for (entry_start = (png_bytep)png_ptr->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 > (png_bytep)png_ptr->chunkdata + slength - 2) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_warning(png_ptr, "malformed sPLT chunk"); |
return; |
} |
new_palette.depth = *entry_start++; |
entry_size = (new_palette.depth == 8 ? 6 : 10); |
/* This must fit in a png_uint_32 because it is derived from the original |
* chunk data length (and use 'length', not 'slength' here for clarity - |
* they are guaranteed to be the same, see the tests above.) |
*/ |
data_length = length - (png_uint_32)(entry_start - |
(png_bytep)png_ptr->chunkdata); |
/* Integrity-check the data length */ |
if (data_length % entry_size) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_warning(png_ptr, "sPLT chunk has bad length"); |
return; |
} |
dl = (png_int_32)(data_length / entry_size); |
max_dl = PNG_SIZE_MAX / png_sizeof(png_sPLT_entry); |
if (dl > max_dl) |
{ |
png_warning(png_ptr, "sPLT chunk too long"); |
return; |
} |
new_palette.nentries = (png_int_32)(data_length / entry_size); |
new_palette.entries = (png_sPLT_entryp)png_malloc_warn( |
png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry)); |
if (new_palette.entries == NULL) |
{ |
png_warning(png_ptr, "sPLT chunk requires too much memory"); |
return; |
} |
#ifdef PNG_POINTER_INDEXING_SUPPORTED |
for (i = 0; i < new_palette.nentries; i++) |
{ |
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_ptr->chunkdata; |
png_set_sPLT(png_ptr, info_ptr, &new_palette, 1); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_free(png_ptr, new_palette.entries); |
} |
#endif /* PNG_READ_sPLT_SUPPORTED */ |
#ifdef 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"); |
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_GRAY) |
{ |
png_byte buf[2]; |
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_color.gray = png_get_uint_16(buf); |
} |
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_color.red = png_get_uint_16(buf); |
png_ptr->trans_color.green = png_get_uint_16(buf + 2); |
png_ptr->trans_color.blue = png_get_uint_16(buf + 4); |
} |
else 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"); |
} |
if (length > (png_uint_32)png_ptr->num_palette || |
length > PNG_MAX_PALETTE_LENGTH) |
{ |
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 |
{ |
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)) |
{ |
png_ptr->num_trans = 0; |
return; |
} |
png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans, |
&(png_ptr->trans_color)); |
} |
#endif |
#ifdef 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"); |
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 && 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 |
#ifdef PNG_READ_hIST_SUPPORTED |
void /* PRIVATE */ |
png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) |
{ |
unsigned int num, i; |
png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH]; |
png_debug(1, "in png_handle_hIST"); |
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 = length / 2 ; |
if (num != (unsigned int)png_ptr->num_palette || num > |
(unsigned int)PNG_MAX_PALETTE_LENGTH) |
{ |
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 |
#ifdef 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"); |
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 |
#ifdef 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"); |
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 |
#ifdef 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_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"); |
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 (%u bytes)", |
length + 1); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (png_ptr->chunkdata == NULL) |
{ |
png_warning(png_ptr, "No memory for pCAL purpose"); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */ |
png_debug(3, "Finding end of pCAL purpose string"); |
for (buf = png_ptr->chunkdata; *buf; buf++) |
/* Empty loop */ ; |
endptr = png_ptr->chunkdata + 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, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
png_debug(3, "Reading pCAL X0, X1, type, nparams, and units"); |
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"); |
/* 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, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
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"); |
params = (png_charpp)png_malloc_warn(png_ptr, |
(png_size_t)(nparams * png_sizeof(png_charp))); |
if (params == NULL) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
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", i); |
for (params[i] = buf; buf <= endptr && *buf != 0x00; 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, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_free(png_ptr, params); |
return; |
} |
} |
png_set_pCAL(png_ptr, info_ptr, png_ptr->chunkdata, X0, X1, type, nparams, |
units, params); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_free(png_ptr, params); |
} |
#endif |
#ifdef 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_size_t slength, i; |
int state; |
png_debug(1, "in png_handle_sCAL"); |
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 (%u bytes)", |
length + 1); |
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (png_ptr->chunkdata == NULL) |
{ |
png_warning(png_ptr, "Out of memory while processing sCAL chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */ |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
/* Validate the unit. */ |
if (png_ptr->chunkdata[0] != 1 && png_ptr->chunkdata[0] != 2) |
{ |
png_warning(png_ptr, "Invalid sCAL ignored: invalid unit"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
/* Validate the ASCII numbers, need two ASCII numbers separated by |
* a '\0' and they need to fit exactly in the chunk data. |
*/ |
i = 0; |
state = 0; |
if (png_ptr->chunkdata[1] == 45 /* negative width */ || |
!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) || |
i >= slength || png_ptr->chunkdata[i++] != 0) |
png_warning(png_ptr, "Invalid sCAL chunk ignored: bad width format"); |
else |
{ |
png_size_t heighti = i; |
if (png_ptr->chunkdata[i] == 45 /* negative height */ || |
!png_check_fp_number(png_ptr->chunkdata, slength, &state, &i) || |
i != slength) |
png_warning(png_ptr, "Invalid sCAL chunk ignored: bad height format"); |
else |
/* This is the (only) success case. */ |
png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], |
png_ptr->chunkdata+1, png_ptr->chunkdata+heighti); |
} |
/* Clean up - just free the temporarily allocated buffer. */ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
} |
#endif |
#ifdef 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"); |
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 |
#ifdef 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"); |
#ifdef PNG_USER_LIMITS_SUPPORTED |
if (png_ptr->user_chunk_cache_max != 0) |
{ |
if (png_ptr->user_chunk_cache_max == 1) |
{ |
png_crc_finish(png_ptr, length); |
return; |
} |
if (--png_ptr->user_chunk_cache_max == 1) |
{ |
png_warning(png_ptr, "No space in chunk cache for tEXt"); |
png_crc_finish(png_ptr, length); |
return; |
} |
} |
#endif |
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 |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (png_ptr->chunkdata == NULL) |
{ |
png_warning(png_ptr, "No memory to process text chunk"); |
return; |
} |
slength = (png_size_t)length; |
png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); |
if (png_crc_finish(png_ptr, skip)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
key = png_ptr->chunkdata; |
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_sizeof(png_text)); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr, "Not enough memory to process text chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; |
text_ptr->key = key; |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
text_ptr->itxt_length = 0; |
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, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
png_free(png_ptr, text_ptr); |
if (ret) |
png_warning(png_ptr, "Insufficient memory to process text chunk"); |
} |
#endif |
#ifdef 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 text; |
int comp_type; |
int ret; |
png_size_t slength, prefix_len, data_len; |
png_debug(1, "in png_handle_zTXt"); |
#ifdef PNG_USER_LIMITS_SUPPORTED |
if (png_ptr->user_chunk_cache_max != 0) |
{ |
if (png_ptr->user_chunk_cache_max == 1) |
{ |
png_crc_finish(png_ptr, length); |
return; |
} |
if (--png_ptr->user_chunk_cache_max == 1) |
{ |
png_warning(png_ptr, "No space in chunk cache for zTXt"); |
png_crc_finish(png_ptr, length); |
return; |
} |
} |
#endif |
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 |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (png_ptr->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)png_ptr->chunkdata, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
png_ptr->chunkdata[slength] = 0x00; |
for (text = png_ptr->chunkdata; *text; text++) |
/* Empty loop */ ; |
/* zTXt must have some text after the chunkdataword */ |
if (text >= png_ptr->chunkdata + slength - 2) |
{ |
png_warning(png_ptr, "Truncated zTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
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 - png_ptr->chunkdata; |
png_decompress_chunk(png_ptr, comp_type, |
(png_size_t)length, prefix_len, &data_len); |
text_ptr = (png_textp)png_malloc_warn(png_ptr, |
png_sizeof(png_text)); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr, "Not enough memory to process zTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
text_ptr->compression = comp_type; |
text_ptr->key = png_ptr->chunkdata; |
text_ptr->lang = NULL; |
text_ptr->lang_key = NULL; |
text_ptr->itxt_length = 0; |
text_ptr->text = png_ptr->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, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
if (ret) |
png_error(png_ptr, "Insufficient memory to store zTXt chunk"); |
} |
#endif |
#ifdef 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 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"); |
#ifdef PNG_USER_LIMITS_SUPPORTED |
if (png_ptr->user_chunk_cache_max != 0) |
{ |
if (png_ptr->user_chunk_cache_max == 1) |
{ |
png_crc_finish(png_ptr, length); |
return; |
} |
if (--png_ptr->user_chunk_cache_max == 1) |
{ |
png_warning(png_ptr, "No space in chunk cache for iTXt"); |
png_crc_finish(png_ptr, length); |
return; |
} |
} |
#endif |
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 |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); |
if (png_ptr->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)png_ptr->chunkdata, slength); |
if (png_crc_finish(png_ptr, 0)) |
{ |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
png_ptr->chunkdata[slength] = 0x00; |
for (lang = png_ptr->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 >= png_ptr->chunkdata + slength - 3) |
{ |
png_warning(png_ptr, "Truncated iTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
else |
{ |
comp_flag = *lang++; |
comp_type = *lang++; |
} |
for (lang_key = lang; *lang_key; lang_key++) |
/* Empty loop */ ; |
lang_key++; /* Skip NUL separator */ |
if (lang_key >= png_ptr->chunkdata + slength) |
{ |
png_warning(png_ptr, "Truncated iTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
for (text = lang_key; *text; text++) |
/* Empty loop */ ; |
text++; /* Skip NUL separator */ |
if (text >= png_ptr->chunkdata + slength) |
{ |
png_warning(png_ptr, "Malformed iTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
prefix_len = text - png_ptr->chunkdata; |
key=png_ptr->chunkdata; |
if (comp_flag) |
png_decompress_chunk(png_ptr, comp_type, |
(size_t)length, prefix_len, &data_len); |
else |
data_len = png_strlen(png_ptr->chunkdata + prefix_len); |
text_ptr = (png_textp)png_malloc_warn(png_ptr, |
png_sizeof(png_text)); |
if (text_ptr == NULL) |
{ |
png_warning(png_ptr, "Not enough memory to process iTXt chunk"); |
png_free(png_ptr, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
return; |
} |
text_ptr->compression = (int)comp_flag + 1; |
text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key); |
text_ptr->lang = png_ptr->chunkdata + (lang - key); |
text_ptr->itxt_length = data_len; |
text_ptr->text_length = 0; |
text_ptr->key = png_ptr->chunkdata; |
text_ptr->text = png_ptr->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, png_ptr->chunkdata); |
png_ptr->chunkdata = NULL; |
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"); |
#ifdef PNG_USER_LIMITS_SUPPORTED |
if (png_ptr->user_chunk_cache_max != 0) |
{ |
if (png_ptr->user_chunk_cache_max == 1) |
{ |
png_crc_finish(png_ptr, length); |
return; |
} |
if (--png_ptr->user_chunk_cache_max == 1) |
{ |
png_warning(png_ptr, "No space in chunk cache for unknown chunk"); |
png_crc_finish(png_ptr, length); |
return; |
} |
} |
#endif |
if (png_ptr->mode & PNG_HAVE_IDAT) |
{ |
PNG_IDAT; |
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* Not an IDAT */ |
png_ptr->mode |= PNG_AFTER_IDAT; |
} |
if (!(png_ptr->chunk_name[0] & 0x20)) |
{ |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
PNG_HANDLE_CHUNK_ALWAYS |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
&& png_ptr->read_user_chunk_fn == NULL |
#endif |
) |
#endif |
png_chunk_error(png_ptr, "unknown critical chunk"); |
} |
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED |
if ((png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
|| (png_ptr->read_user_chunk_fn != NULL) |
#endif |
) |
{ |
#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_memcpy((png_charp)png_ptr->unknown_chunk.name, |
(png_charp)png_ptr->chunk_name, |
png_sizeof(png_ptr->unknown_chunk.name)); |
png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name)-1] |
= '\0'; |
png_ptr->unknown_chunk.size = (png_size_t)length; |
if (length == 0) |
png_ptr->unknown_chunk.data = NULL; |
else |
{ |
png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, length); |
png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length); |
} |
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED |
if (png_ptr->read_user_chunk_fn != NULL) |
{ |
/* Callback to user unknown chunk handler */ |
int ret; |
ret = (*(png_ptr->read_user_chunk_fn)) |
(png_ptr, &png_ptr->unknown_chunk); |
if (ret < 0) |
png_chunk_error(png_ptr, "error in user chunk"); |
if (ret == 0) |
{ |
if (!(png_ptr->chunk_name[0] & 0x20)) |
{ |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != |
PNG_HANDLE_CHUNK_ALWAYS) |
#endif |
png_chunk_error(png_ptr, "unknown critical chunk"); |
} |
png_set_unknown_chunks(png_ptr, info_ptr, |
&png_ptr->unknown_chunk, 1); |
} |
} |
else |
#endif |
png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1); |
png_free(png_ptr, png_ptr->unknown_chunk.data); |
png_ptr->unknown_chunk.data = NULL; |
} |
else |
#endif |
skip = length; |
png_crc_finish(png_ptr, skip); |
#ifndef PNG_READ_USER_CHUNKS_SUPPORTED |
PNG_UNUSED(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) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) |
void /* PRIVATE */ |
png_check_chunk_name(png_structp png_ptr, png_const_bytep chunk_name) |
{ |
png_debug(1, "in png_check_chunk_name"); |
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. |
*/ |
void /* PRIVATE */ |
png_combine_row(png_structp png_ptr, png_bytep row, int mask) |
{ |
png_debug(1, "in png_combine_row"); |
if (mask == 0xff) |
{ |
png_memcpy(row, png_ptr->row_buf + 1, |
PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width)); |
} |
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; |
#ifdef 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; |
#ifdef 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; |
#ifdef 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; |
} |
} |
} |
} |
#ifdef 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; |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Offset to next interlace block */ |
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
png_debug(1, "in png_do_read_interlace"); |
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; |
#ifdef 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; |
#ifdef 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]; |
#ifdef 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 = PNG_ROWBYTES(row_info->pixel_depth, final_width); |
} |
#ifndef PNG_READ_PACKSWAP_SUPPORTED |
PNG_UNUSED(transformations) /* Silence compiler warning */ |
#endif |
} |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
void /* PRIVATE */ |
png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row, |
png_const_bytep prev_row, int filter) |
{ |
png_debug(1, "in png_read_filter_row"); |
png_debug2(2, "row = %u, filter = %d", png_ptr->row_number, filter); |
switch (filter) |
{ |
case PNG_FILTER_VALUE_NONE: |
break; |
case PNG_FILTER_VALUE_SUB: |
{ |
png_size_t i; |
png_size_t istop = row_info->rowbytes; |
unsigned int 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_size_t i; |
png_size_t istop = row_info->rowbytes; |
png_bytep rp = row; |
png_const_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_size_t i; |
png_bytep rp = row; |
png_const_bytep pp = prev_row; |
png_bytep lp = row; |
unsigned int bpp = (row_info->pixel_depth + 7) >> 3; |
png_size_t 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_size_t i; |
png_bytep rp = row; |
png_const_bytep pp = prev_row; |
png_bytep lp = row; |
png_const_bytep cp = prev_row; |
unsigned int bpp = (row_info->pixel_depth + 7) >> 3; |
png_size_t 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_error(png_ptr, "Ignoring bad adaptive filter type"); |
/*NOT REACHED */ |
break; |
} |
} |
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED |
void /* PRIVATE */ |
png_read_finish_row(png_structp png_ptr) |
{ |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Start of interlace block */ |
PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* Offset to next interlace block */ |
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* Start of interlace block in the y direction */ |
PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* Offset to next interlace block in the y direction */ |
PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
png_debug(1, "in png_read_finish_row"); |
png_ptr->row_number++; |
if (png_ptr->row_number < png_ptr->num_rows) |
return; |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
if (png_ptr->interlaced) |
{ |
png_ptr->row_number = 0; |
png_memset(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]; |
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]; |
} |
else /* if (png_ptr->transformations & PNG_INTERLACE) */ |
break; /* libpng deinterlacing sees every row */ |
} while (png_ptr->num_rows == 0 || png_ptr->iwidth == 0); |
if (png_ptr->pass < 7) |
return; |
} |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) |
{ |
PNG_IDAT; |
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_crc_finish(png_ptr, 0); |
png_ptr->idat_size = png_read_chunk_header(png_ptr); |
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_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; |
} |
#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ |
void /* PRIVATE */ |
png_read_start_row(png_structp png_ptr) |
{ |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
/* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
/* Start of interlace block */ |
PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; |
/* Offset to next interlace block */ |
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; |
/* Start of interlace block in the y direction */ |
PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; |
/* Offset to next interlace block in the y direction */ |
PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
#endif |
int max_pixel_depth; |
png_size_t row_bytes; |
png_debug(1, "in png_read_start_row"); |
png_ptr->zstream.avail_in = 0; |
png_init_read_transformations(png_ptr); |
#ifdef PNG_READ_INTERLACING_SUPPORTED |
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]; |
} |
else |
#endif /* PNG_READ_INTERLACING_SUPPORTED */ |
{ |
png_ptr->num_rows = png_ptr->height; |
png_ptr->iwidth = png_ptr->width; |
} |
max_pixel_depth = png_ptr->pixel_depth; |
#ifdef PNG_READ_PACK_SUPPORTED |
if ((png_ptr->transformations & PNG_PACK) && png_ptr->bit_depth < 8) |
max_pixel_depth = 8; |
#endif |
#ifdef 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 |
#ifdef 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 |
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED |
if (png_ptr->transformations & PNG_GRAY_TO_RGB) |
{ |
if ( |
#ifdef PNG_READ_EXPAND_SUPPORTED |
(png_ptr->num_trans && (png_ptr->transformations & PNG_EXPAND)) || |
#endif |
#ifdef 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 = PNG_ROWBYTES(max_pixel_depth, row_bytes) + |
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 |
if (row_bytes + 48 > png_ptr->old_big_row_buf_size) |
{ |
png_free(png_ptr, png_ptr->big_row_buf); |
if (png_ptr->interlaced) |
png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr, |
row_bytes + 48); |
else |
png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, |
row_bytes + 48); |
png_ptr->old_big_row_buf_size = row_bytes + 48; |
#ifdef PNG_ALIGNED_MEMORY_SUPPORTED |
/* Use 16-byte aligned memory for row_buf with at least 16 bytes |
* of padding before and after row_buf. |
*/ |
png_ptr->row_buf = png_ptr->big_row_buf + 32 - |
(((png_alloc_size_t)png_ptr->big_row_buf + 15) & 0x0F); |
png_ptr->old_big_row_buf_size = row_bytes + 48; |
#else |
/* Use 32 bytes of padding before and 16 bytes after row_buf. */ |
png_ptr->row_buf = png_ptr->big_row_buf + 32; |
#endif |
png_ptr->old_big_row_buf_size = row_bytes + 48; |
} |
#ifdef PNG_MAX_MALLOC_64K |
if (png_ptr->rowbytes > 65535) |
png_error(png_ptr, "This image requires a row greater than 64KB"); |
#endif |
if (png_ptr->rowbytes > (PNG_SIZE_MAX - 1)) |
png_error(png_ptr, "Row has too many bytes to allocate in memory"); |
if (png_ptr->rowbytes + 1 > png_ptr->old_prev_row_size) |
{ |
png_free(png_ptr, png_ptr->prev_row); |
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1); |
png_ptr->old_prev_row_size = png_ptr->rowbytes + 1; |
} |
png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); |
png_debug1(3, "width = %u,", png_ptr->width); |
png_debug1(3, "height = %u,", png_ptr->height); |
png_debug1(3, "iwidth = %u,", png_ptr->iwidth); |
png_debug1(3, "num_rows = %u,", png_ptr->num_rows); |
png_debug1(3, "rowbytes = %lu,", (unsigned long)png_ptr->rowbytes); |
png_debug1(3, "irowbytes = %lu", |
(unsigned long)PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1); |
png_ptr->flags |= PNG_FLAG_ROW_INIT; |
} |
#endif /* PNG_READ_SUPPORTED */ |
/programs/develop/libraries/libpng/pngset.c |
---|
0,0 → 1,1225 |
/* pngset.c - storage of image information into info struct |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
* |
* 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. |
*/ |
#include "pngpriv.h" |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
#ifdef PNG_bKGD_SUPPORTED |
void PNGAPI |
png_set_bKGD(png_structp png_ptr, png_infop info_ptr, |
png_const_color_16p background) |
{ |
png_debug1(1, "in %s storage function", "bKGD"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_memcpy(&(info_ptr->background), background, png_sizeof(png_color_16)); |
info_ptr->valid |= PNG_INFO_bKGD; |
} |
#endif |
#ifdef PNG_cHRM_SUPPORTED |
void PNGFAPI |
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", "cHRM fixed"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
# ifdef PNG_CHECK_cHRM_SUPPORTED |
if (png_check_cHRM_fixed(png_ptr, |
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y)) |
# endif |
{ |
info_ptr->x_white = white_x; |
info_ptr->y_white = white_y; |
info_ptr->x_red = red_x; |
info_ptr->y_red = red_y; |
info_ptr->x_green = green_x; |
info_ptr->y_green = green_y; |
info_ptr->x_blue = blue_x; |
info_ptr->y_blue = blue_y; |
info_ptr->valid |= PNG_INFO_cHRM; |
} |
} |
# 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_set_cHRM_fixed(png_ptr, info_ptr, |
png_fixed(png_ptr, white_x, "cHRM White X"), |
png_fixed(png_ptr, white_y, "cHRM White Y"), |
png_fixed(png_ptr, red_x, "cHRM Red X"), |
png_fixed(png_ptr, red_y, "cHRM Red Y"), |
png_fixed(png_ptr, green_x, "cHRM Green X"), |
png_fixed(png_ptr, green_y, "cHRM Green Y"), |
png_fixed(png_ptr, blue_x, "cHRM Blue X"), |
png_fixed(png_ptr, blue_y, "cHRM Blue Y")); |
} |
# endif /* PNG_FLOATING_POINT_SUPPORTED */ |
#endif /* PNG_cHRM_SUPPORTED */ |
#ifdef PNG_gAMA_SUPPORTED |
void PNGFAPI |
png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point |
file_gamma) |
{ |
png_debug1(1, "in %s storage function", "gAMA"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* Previously these values were limited, however they must be |
* wrong, therefore storing them (and setting PNG_INFO_gAMA) |
* must be wrong too. |
*/ |
if (file_gamma > (png_fixed_point)PNG_UINT_31_MAX) |
png_warning(png_ptr, "Gamma too large, ignored"); |
else if (file_gamma <= 0) |
png_warning(png_ptr, "Negative or zero gamma ignored"); |
else |
{ |
info_ptr->gamma = file_gamma; |
info_ptr->valid |= PNG_INFO_gAMA; |
} |
} |
# ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma) |
{ |
png_set_gAMA_fixed(png_ptr, info_ptr, png_fixed(png_ptr, file_gamma, |
"png_set_gAMA")); |
} |
# endif |
#endif |
#ifdef PNG_hIST_SUPPORTED |
void PNGAPI |
png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_const_uint_16p hist) |
{ |
int i; |
png_debug1(1, "in %s storage function", "hIST"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (info_ptr->num_palette == 0 || info_ptr->num_palette |
> PNG_MAX_PALETTE_LENGTH) |
{ |
png_warning(png_ptr, |
"Invalid palette size, hIST allocation skipped"); |
return; |
} |
png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0); |
/* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in |
* version 1.2.1 |
*/ |
png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr, |
PNG_MAX_PALETTE_LENGTH * png_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; |
info_ptr->free_me |= PNG_FREE_HIST; |
} |
#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) |
{ |
png_debug1(1, "in %s storage function", "IHDR"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
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; |
png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height, |
info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type, |
info_ptr->compression_type, info_ptr->filter_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 potential overflow */ |
if (width > |
(PNG_UINT_32_MAX >> 3) /* 8-byte RRGGBBAA pixels */ |
- 48 /* bigrowbuf hack */ |
- 1 /* filter byte */ |
- 7*8 /* rounding of width to multiple of 8 pixels */ |
- 8) /* extra max_pixel_depth pad */ |
info_ptr->rowbytes = 0; |
else |
info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width); |
} |
#ifdef 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", "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 |
#ifdef PNG_pCAL_SUPPORTED |
void PNGAPI |
png_set_pCAL(png_structp png_ptr, png_infop info_ptr, |
png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type, |
int nparams, png_const_charp units, png_charpp params) |
{ |
png_size_t length; |
int i; |
png_debug1(1, "in %s storage function", "pCAL"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
length = png_strlen(purpose) + 1; |
png_debug1(3, "allocating purpose for info (%lu bytes)", |
(unsigned long)length); |
/* TODO: validate format of calibration name and unit name */ |
/* Check that the type matches the specification. */ |
if (type < 0 || type > 3) |
png_error(png_ptr, "Invalid pCAL equation type"); |
/* Validate params[nparams] */ |
for (i=0; i<nparams; ++i) |
if (!png_check_fp_string(params[i], png_strlen(params[i]))) |
png_error(png_ptr, "Invalid format for pCAL parameter"); |
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, length); |
png_debug(3, "storing X0, X1, type, and nparams in info"); |
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)", |
(unsigned long)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, length); |
info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr, |
(png_size_t)((nparams + 1) * png_sizeof(png_charp))); |
if (info_ptr->pcal_params == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory for pCAL params"); |
return; |
} |
png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp)); |
for (i = 0; i < nparams; i++) |
{ |
length = png_strlen(params[i]) + 1; |
png_debug2(3, "allocating parameter %d for info (%lu bytes)", i, |
(unsigned long)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], length); |
} |
info_ptr->valid |= PNG_INFO_pCAL; |
info_ptr->free_me |= PNG_FREE_PCAL; |
} |
#endif |
#ifdef PNG_sCAL_SUPPORTED |
void PNGAPI |
png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr, |
int unit, png_const_charp swidth, png_const_charp sheight) |
{ |
png_size_t lengthw = 0, lengthh = 0; |
png_debug1(1, "in %s storage function", "sCAL"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* Double check the unit (should never get here with an invalid |
* unit unless this is an API call.) |
*/ |
if (unit != 1 && unit != 2) |
png_error(png_ptr, "Invalid sCAL unit"); |
if (swidth == NULL || (lengthw = png_strlen(swidth)) <= 0 || |
swidth[0] == 45 /*'-'*/ || !png_check_fp_string(swidth, lengthw)) |
png_error(png_ptr, "Invalid sCAL width"); |
if (sheight == NULL || (lengthh = png_strlen(sheight)) <= 0 || |
sheight[0] == 45 /*'-'*/ || !png_check_fp_string(sheight, lengthh)) |
png_error(png_ptr, "Invalid sCAL height"); |
info_ptr->scal_unit = (png_byte)unit; |
++lengthw; |
png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw); |
info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, lengthw); |
if (info_ptr->scal_s_width == NULL) |
{ |
png_warning(png_ptr, "Memory allocation failed while processing sCAL"); |
return; |
} |
png_memcpy(info_ptr->scal_s_width, swidth, lengthw); |
++lengthh; |
png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh); |
info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, lengthh); |
if (info_ptr->scal_s_height == NULL) |
{ |
png_free (png_ptr, info_ptr->scal_s_width); |
info_ptr->scal_s_width = NULL; |
png_warning(png_ptr, "Memory allocation failed while processing sCAL"); |
return; |
} |
png_memcpy(info_ptr->scal_s_height, sheight, lengthh); |
info_ptr->valid |= PNG_INFO_sCAL; |
info_ptr->free_me |= PNG_FREE_SCAL; |
} |
# 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", "sCAL"); |
/* Check the arguments. */ |
if (width <= 0) |
png_warning(png_ptr, "Invalid sCAL width ignored"); |
else if (height <= 0) |
png_warning(png_ptr, "Invalid sCAL height ignored"); |
else |
{ |
/* Convert 'width' and 'height' to ASCII. */ |
char swidth[PNG_sCAL_MAX_DIGITS+1]; |
char sheight[PNG_sCAL_MAX_DIGITS+1]; |
png_ascii_from_fp(png_ptr, swidth, sizeof swidth, width, |
PNG_sCAL_PRECISION); |
png_ascii_from_fp(png_ptr, sheight, sizeof sheight, height, |
PNG_sCAL_PRECISION); |
png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight); |
} |
} |
# endif |
# ifdef PNG_FIXED_POINT_SUPPORTED |
void PNGAPI |
png_set_sCAL_fixed(png_structp png_ptr, png_infop info_ptr, int unit, |
png_fixed_point width, png_fixed_point height) |
{ |
png_debug1(1, "in %s storage function", "sCAL"); |
/* Check the arguments. */ |
if (width <= 0) |
png_warning(png_ptr, "Invalid sCAL width ignored"); |
else if (height <= 0) |
png_warning(png_ptr, "Invalid sCAL height ignored"); |
else |
{ |
/* Convert 'width' and 'height' to ASCII. */ |
char swidth[PNG_sCAL_MAX_DIGITS+1]; |
char sheight[PNG_sCAL_MAX_DIGITS+1]; |
png_ascii_from_fixed(png_ptr, swidth, sizeof swidth, width); |
png_ascii_from_fixed(png_ptr, sheight, sizeof sheight, height); |
png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight); |
} |
} |
# endif |
#endif |
#ifdef 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", "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_const_colorp palette, int num_palette) |
{ |
png_debug1(1, "in %s storage function", "PLTE"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH) |
{ |
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) |
png_error(png_ptr, "Invalid palette length"); |
else |
{ |
png_warning(png_ptr, "Invalid palette length"); |
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. |
*/ |
png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0); |
/* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead |
* of num_palette entries, in case of an invalid PNG file that has |
* too-large sample values. |
*/ |
png_ptr->palette = (png_colorp)png_calloc(png_ptr, |
PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color)); |
png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color)); |
info_ptr->palette = png_ptr->palette; |
info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette; |
info_ptr->free_me |= PNG_FREE_PLTE; |
info_ptr->valid |= PNG_INFO_PLTE; |
} |
#ifdef PNG_sBIT_SUPPORTED |
void PNGAPI |
png_set_sBIT(png_structp png_ptr, png_infop info_ptr, |
png_const_color_8p sig_bit) |
{ |
png_debug1(1, "in %s storage function", "sBIT"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_memcpy(&(info_ptr->sig_bit), sig_bit, png_sizeof(png_color_8)); |
info_ptr->valid |= PNG_INFO_sBIT; |
} |
#endif |
#ifdef PNG_sRGB_SUPPORTED |
void PNGAPI |
png_set_sRGB(png_structp png_ptr, png_infop info_ptr, int srgb_intent) |
{ |
png_debug1(1, "in %s storage function", "sRGB"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
info_ptr->srgb_intent = (png_byte)srgb_intent; |
info_ptr->valid |= PNG_INFO_sRGB; |
} |
void PNGAPI |
png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr, |
int srgb_intent) |
{ |
png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
png_set_sRGB(png_ptr, info_ptr, srgb_intent); |
# ifdef PNG_gAMA_SUPPORTED |
png_set_gAMA_fixed(png_ptr, info_ptr, 45455L); |
# endif |
# ifdef PNG_cHRM_SUPPORTED |
png_set_cHRM_fixed(png_ptr, info_ptr, |
/* color x y */ |
/* white */ 31270L, 32900L, |
/* red */ 64000L, 33000L, |
/* green */ 30000L, 60000L, |
/* blue */ 15000L, 6000L |
); |
# endif /* cHRM */ |
} |
#endif /* sRGB */ |
#ifdef PNG_iCCP_SUPPORTED |
void PNGAPI |
png_set_iCCP(png_structp png_ptr, png_infop info_ptr, |
png_const_charp name, int compression_type, |
png_const_bytep profile, png_uint_32 proflen) |
{ |
png_charp new_iccp_name; |
png_bytep new_iccp_profile; |
png_uint_32 length; |
png_debug1(1, "in %s storage function", "iCCP"); |
if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL) |
return; |
length = png_strlen(name)+1; |
new_iccp_name = (png_charp)png_malloc_warn(png_ptr, length); |
if (new_iccp_name == NULL) |
{ |
png_warning(png_ptr, "Insufficient memory to process iCCP chunk"); |
return; |
} |
png_memcpy(new_iccp_name, name, length); |
new_iccp_profile = (png_bytep)png_malloc_warn(png_ptr, proflen); |
if (new_iccp_profile == NULL) |
{ |
png_free (png_ptr, new_iccp_name); |
png_warning(png_ptr, |
"Insufficient memory to process iCCP profile"); |
return; |
} |
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; |
info_ptr->free_me |= PNG_FREE_ICCP; |
info_ptr->valid |= PNG_INFO_iCCP; |
} |
#endif |
#ifdef PNG_TEXT_SUPPORTED |
void PNGAPI |
png_set_text(png_structp png_ptr, png_infop info_ptr, png_const_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_const_textp text_ptr, int num_text) |
{ |
int i; |
png_debug1(1, "in %s storage function", ((png_ptr == NULL || |
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_size_t)(info_ptr->max_text * png_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 * |
png_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_size_t)(info_ptr->max_text * png_sizeof(png_text))); |
if (info_ptr->text == NULL) |
return(1); |
info_ptr->free_me |= PNG_FREE_TEXT; |
} |
png_debug1(3, "allocated %d entries for info_ptr->text", |
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; |
if (text_ptr[i].compression < PNG_TEXT_COMPRESSION_NONE || |
text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST) |
{ |
png_warning(png_ptr, "text compression mode is out of range"); |
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_iTXt_SUPPORTED */ |
{ |
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_size_t) |
(key_len + text_length + lang_len + lang_key_len + 4)); |
if (textp->key == NULL) |
return(1); |
png_debug2(2, "Allocated %lu bytes at %p in png_set_text", |
(unsigned long)(png_uint_32) |
(key_len + lang_len + lang_key_len + text_length + 4), |
textp->key); |
png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len)); |
*(textp->key + key_len) = '\0'; |
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 |
{ |
textp->lang=NULL; |
textp->lang_key=NULL; |
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; |
textp->itxt_length = 0; |
} |
info_ptr->num_text++; |
png_debug1(3, "transferred text chunk %d", info_ptr->num_text); |
} |
return(0); |
} |
#endif |
#ifdef PNG_tIME_SUPPORTED |
void PNGAPI |
png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time) |
{ |
png_debug1(1, "in %s storage function", "tIME"); |
if (png_ptr == NULL || info_ptr == NULL || |
(png_ptr->mode & PNG_WROTE_tIME)) |
return; |
png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time)); |
info_ptr->valid |= PNG_INFO_tIME; |
} |
#endif |
#ifdef PNG_tRNS_SUPPORTED |
void PNGAPI |
png_set_tRNS(png_structp png_ptr, png_infop info_ptr, |
png_const_bytep trans_alpha, int num_trans, png_const_color_16p trans_color) |
{ |
png_debug1(1, "in %s storage function", "tRNS"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (trans_alpha != NULL) |
{ |
/* It may not actually be necessary to set png_ptr->trans_alpha here; |
* we do it for backward compatibility with the way the png_handle_tRNS |
* function used to do the allocation. |
*/ |
png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0); |
/* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */ |
png_ptr->trans_alpha = info_ptr->trans_alpha = |
(png_bytep)png_malloc(png_ptr, (png_size_t)PNG_MAX_PALETTE_LENGTH); |
if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH) |
png_memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans); |
} |
if (trans_color != NULL) |
{ |
int sample_max = (1 << info_ptr->bit_depth); |
if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY && |
(int)trans_color->gray > sample_max) || |
(info_ptr->color_type == PNG_COLOR_TYPE_RGB && |
((int)trans_color->red > sample_max || |
(int)trans_color->green > sample_max || |
(int)trans_color->blue > sample_max))) |
png_warning(png_ptr, |
"tRNS chunk has out-of-range samples for bit_depth"); |
png_memcpy(&(info_ptr->trans_color), trans_color, |
png_sizeof(png_color_16)); |
if (num_trans == 0) |
num_trans = 1; |
} |
info_ptr->num_trans = (png_uint_16)num_trans; |
if (num_trans != 0) |
{ |
info_ptr->valid |= PNG_INFO_tRNS; |
info_ptr->free_me |= PNG_FREE_TRNS; |
} |
} |
#endif |
#ifdef PNG_sPLT_SUPPORTED |
void PNGAPI |
png_set_sPLT(png_structp png_ptr, |
png_infop info_ptr, png_const_sPLT_tp entries, int nentries) |
/* |
* entries - array of png_sPLT_t structures |
* to be added to the list of palettes |
* in the info structure. |
* |
* nentries - number of palette structures to be |
* added. |
*/ |
{ |
png_sPLT_tp np; |
int i; |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
np = (png_sPLT_tp)png_malloc_warn(png_ptr, |
(info_ptr->splt_palettes_num + nentries) * |
(png_size_t)png_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 * png_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_const_sPLT_tp from = entries + i; |
png_uint_32 length; |
length = png_strlen(from->name) + 1; |
to->name = (png_charp)png_malloc_warn(png_ptr, (png_size_t)length); |
if (to->name == NULL) |
{ |
png_warning(png_ptr, |
"Out of memory while processing sPLT chunk"); |
continue; |
} |
png_memcpy(to->name, from->name, length); |
to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr, |
(png_size_t)(from->nentries * png_sizeof(png_sPLT_entry))); |
if (to->entries == NULL) |
{ |
png_warning(png_ptr, |
"Out of memory while processing sPLT chunk"); |
png_free(png_ptr, to->name); |
to->name = NULL; |
continue; |
} |
png_memcpy(to->entries, from->entries, |
from->nentries * png_sizeof(png_sPLT_entry)); |
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; |
info_ptr->free_me |= PNG_FREE_SPLT; |
} |
#endif /* PNG_sPLT_SUPPORTED */ |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
void PNGAPI |
png_set_unknown_chunks(png_structp png_ptr, |
png_infop info_ptr, png_const_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, |
(png_size_t)(info_ptr->unknown_chunks_num + num_unknowns) * |
png_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, |
(png_size_t)info_ptr->unknown_chunks_num * |
png_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_const_unknown_chunkp from = unknowns + i; |
png_memcpy(to->name, from->name, png_sizeof(from->name)); |
to->name[png_sizeof(to->name)-1] = '\0'; |
to->size = from->size; |
/* Note our location in the read or write sequence */ |
to->location = (png_byte)(png_ptr->mode & 0xff); |
if (from->size == 0) |
to->data=NULL; |
else |
{ |
to->data = (png_bytep)png_malloc_warn(png_ptr, |
(png_size_t)from->size); |
if (to->data == NULL) |
{ |
png_warning(png_ptr, |
"Out of memory while processing unknown chunk"); |
to->size = 0; |
} |
else |
png_memcpy(to->data, from->data, from->size); |
} |
} |
info_ptr->unknown_chunks = np; |
info_ptr->unknown_chunks_num += num_unknowns; |
info_ptr->free_me |= PNG_FREE_UNKN; |
} |
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 < |
info_ptr->unknown_chunks_num) |
info_ptr->unknown_chunks[chunk].location = (png_byte)location; |
} |
#endif |
#ifdef 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"); |
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 |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
void PNGAPI |
png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_const_bytep |
chunk_list, int num_chunks) |
{ |
png_bytep new_list, p; |
int i, old_num_chunks; |
if (png_ptr == NULL) |
return; |
if (num_chunks == 0) |
{ |
if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE) |
png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS; |
else |
png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS; |
if (keep == PNG_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_size_t)(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; |
png_ptr->free_me |= PNG_FREE_LIST; |
} |
#endif |
#ifdef 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"); |
if (png_ptr == NULL) |
return; |
png_ptr->read_user_chunk_fn = read_user_chunk_fn; |
png_ptr->user_chunk_ptr = user_chunk_ptr; |
} |
#endif |
#ifdef 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", "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_size_t size) |
{ |
if (png_ptr == NULL) |
return; |
png_free(png_ptr, png_ptr->zbuf); |
if (size > ZLIB_IO_MAX) |
{ |
png_warning(png_ptr, "Attempt to set buffer size beyond max ignored"); |
png_ptr->zbuf_size = ZLIB_IO_MAX; |
size = ZLIB_IO_MAX; /* must fit */ |
} |
else |
png_ptr->zbuf_size = (uInt)size; |
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size); |
/* The following ensures a relatively safe failure if this gets called while |
* the buffer is actually in use. |
*/ |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = 0; |
png_ptr->zstream.avail_in = 0; |
} |
void PNGAPI |
png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask) |
{ |
if (png_ptr && info_ptr) |
info_ptr->valid &= ~mask; |
} |
#ifdef PNG_SET_USER_LIMITS_SUPPORTED |
/* This function was added to libpng 1.2.6 */ |
void PNGAPI |
png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max, |
png_uint_32 user_height_max) |
{ |
/* Images with dimensions larger than these limits will be |
* rejected by png_set_IHDR(). To accept any PNG datastream |
* regardless of dimensions, set both limits to 0x7ffffffL. |
*/ |
if (png_ptr == NULL) |
return; |
png_ptr->user_width_max = user_width_max; |
png_ptr->user_height_max = user_height_max; |
} |
/* This function was added to libpng 1.4.0 */ |
void PNGAPI |
png_set_chunk_cache_max (png_structp png_ptr, |
png_uint_32 user_chunk_cache_max) |
{ |
if (png_ptr) |
png_ptr->user_chunk_cache_max = user_chunk_cache_max; |
} |
/* This function was added to libpng 1.4.1 */ |
void PNGAPI |
png_set_chunk_malloc_max (png_structp png_ptr, |
png_alloc_size_t user_chunk_malloc_max) |
{ |
if (png_ptr) |
png_ptr->user_chunk_malloc_max = user_chunk_malloc_max; |
} |
#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ |
#ifdef PNG_BENIGN_ERRORS_SUPPORTED |
void PNGAPI |
png_set_benign_errors(png_structp png_ptr, int allowed) |
{ |
png_debug(1, "in png_set_benign_errors"); |
if (allowed) |
png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN; |
else |
png_ptr->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN; |
} |
#endif /* PNG_BENIGN_ERRORS_SUPPORTED */ |
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngstruct.h |
---|
0,0 → 1,308 |
/* pngstruct.h - header file for PNG reference library |
* |
* Copyright (c) 1998-2011 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.) |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* |
* This code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
*/ |
/* 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. |
*/ |
#ifndef PNGSTRUCT_H |
#define PNGSTRUCT_H |
/* zlib.h defines the structure z_stream, an instance of which is included |
* in this structure and is required for decompressing the LZ compressed |
* data in PNG files. |
*/ |
#include "zlib.h" |
struct png_struct_def |
{ |
#ifdef PNG_SETJMP_SUPPORTED |
jmp_buf png_jmpbuf; /* used in png_error */ |
png_longjmp_ptr longjmp_fn;/* setjmp non-local goto function. */ |
#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 */ |
#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED |
png_user_transform_ptr read_user_transform_fn; /* user read transform */ |
#endif |
#ifdef 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 */ |
#ifdef 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 */ |
uInt zbuf_size; /* size of zbuf (typically 65536) */ |
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_size_t rowbytes; /* size of 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) |
png_uint_16 filler; /* filler bytes for pixel expansion */ |
#endif |
#ifdef PNG_bKGD_SUPPORTED |
png_byte background_gamma_type; |
png_fixed_point background_gamma; |
png_color_16 background; /* background color in screen gamma space */ |
#ifdef PNG_READ_GAMMA_SUPPORTED |
png_color_16 background_1; /* background normalized to gamma 1.0 */ |
#endif |
#endif /* PNG_bKGD_SUPPORTED */ |
#ifdef 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 in 16-bit gamma */ |
png_fixed_point gamma; /* file gamma value */ |
png_fixed_point screen_gamma; /* screen gamma value (display_exponent) */ |
#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_alpha; /* alpha values for paletted files */ |
png_color_16 trans_color; /* transparent color 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 a 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 */ |
# ifdef 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 |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
png_bytep palette_lookup; /* lookup table for quantizing */ |
png_bytep quantize_index; /* index translation for palette files */ |
#endif |
#if defined(PNG_READ_QUANTIZE_SUPPORTED) || defined(PNG_hIST_SUPPORTED) |
png_uint_16p hist; /* histogram */ |
#endif |
#ifdef 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 |
#ifdef PNG_TIME_RFC1123_SUPPORTED |
png_charp time_buffer; /* String to hold RFC 1123 time text */ |
#endif |
/* New members added in libpng-1.0.6 */ |
png_uint_32 free_me; /* flags items libpng is responsible for freeing */ |
#ifdef PNG_USER_CHUNKS_SUPPORTED |
png_voidp user_chunk_ptr; |
png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ |
#endif |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
int num_chunk_list; |
png_bytep chunk_list; |
#endif |
/* New members added in libpng-1.0.3 */ |
#ifdef 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 */ |
png_uint_32 mng_features_permitted; |
#endif |
/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
png_byte filter_type; |
#endif |
/* New members added in libpng-1.2.0 */ |
/* 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 */ |
#ifdef PNG_READ_QUANTIZE_SUPPORTED |
/* The following three members were added at version 1.0.14 and 1.2.4 */ |
png_bytep quantize_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 |
/* New members added in libpng-1.0.16 and 1.2.6 */ |
png_byte compression_type; |
#ifdef PNG_USER_LIMITS_SUPPORTED |
png_uint_32 user_width_max; |
png_uint_32 user_height_max; |
/* Added in libpng-1.4.0: Total number of sPLT, text, and unknown |
* chunks that can be stored (0 means unlimited). |
*/ |
png_uint_32 user_chunk_cache_max; |
/* Total memory that a zTXt, sPLT, iTXt, iCCP, or unknown chunk |
* can occupy when decompressed. 0 means unlimited. |
*/ |
png_alloc_size_t user_chunk_malloc_max; |
#endif |
/* New member added in libpng-1.0.25 and 1.2.17 */ |
#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED |
/* Storage for unknown chunk that the library doesn't recognize. */ |
png_unknown_chunk unknown_chunk; |
#endif |
/* New members added in libpng-1.2.26 */ |
png_size_t old_big_row_buf_size; |
png_size_t old_prev_row_size; |
/* New member added in libpng-1.2.30 */ |
png_charp chunkdata; /* buffer for reading chunk data */ |
#ifdef PNG_IO_STATE_SUPPORTED |
/* New member added in libpng-1.4.0 */ |
png_uint_32 io_state; |
#endif |
}; |
#endif /* PNGSTRUCT_H */ |
/programs/develop/libraries/libpng/pngtrans.c |
---|
0,0 → 1,723 |
/* pngtrans.c - transforms the data in a row (used by both readers and writers) |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
*/ |
#include "pngpriv.h" |
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) |
#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"); |
if (png_ptr == NULL) |
return; |
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"); |
if (png_ptr == NULL) |
return; |
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"); |
if (png_ptr == NULL) |
return; |
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"); |
if (png_ptr == NULL) |
return; |
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_const_color_8p true_bits) |
{ |
png_debug(1, "in png_set_shift"); |
if (png_ptr == NULL) |
return; |
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"); |
if (png_ptr && 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"); |
if (png_ptr == NULL) |
return; |
png_ptr->transformations |= PNG_FILLER; |
png_ptr->filler = (png_uint_16)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_read_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; |
} |
} |
/* Added to libpng-1.2.7 */ |
void PNGAPI |
png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc) |
{ |
png_debug(1, "in png_set_add_alpha"); |
if (png_ptr == NULL) |
return; |
png_set_filler(png_ptr, filler, filler_loc); |
png_ptr->transformations |= PNG_ADD_ALPHA; |
} |
#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"); |
if (png_ptr == NULL) |
return; |
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"); |
if (png_ptr == NULL) |
return; |
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"); |
if (png_ptr == NULL) |
return; |
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"); |
/* This test removed from libpng version 1.0.13 and 1.2.0: |
* if (row_info->bit_depth == 1 && |
*/ |
if (row_info->color_type == PNG_COLOR_TYPE_GRAY) |
{ |
png_bytep rp = row; |
png_size_t i; |
png_size_t 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_size_t i; |
png_size_t istop = row_info->rowbytes; |
for (i = 0; i < istop; i += 2) |
{ |
*rp = (png_byte)(~(*rp)); |
rp += 2; |
} |
} |
#ifdef PNG_16BIT_SUPPORTED |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && |
row_info->bit_depth == 16) |
{ |
png_bytep rp = row; |
png_size_t i; |
png_size_t istop = row_info->rowbytes; |
for (i = 0; i < istop; i += 4) |
{ |
*rp = (png_byte)(~(*rp)); |
*(rp + 1) = (png_byte)(~(*(rp + 1))); |
rp += 4; |
} |
} |
#endif |
} |
#endif |
#ifdef PNG_16BIT_SUPPORTED |
#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"); |
if (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 |
#endif |
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) |
static PNG_CONST 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_CONST 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_CONST 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"); |
if (row_info->bit_depth < 8) |
{ |
png_bytep rp; |
png_const_bytep 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"); |
{ |
png_bytep sp = row; |
png_bytep dp = row; |
png_uint_32 row_width = row_info->width; |
png_uint_32 i; |
if ((row_info->color_type == PNG_COLOR_TYPE_RGB || |
(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && |
(flags & PNG_FLAG_STRIP_ALPHA))) && |
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; |
} |
else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY || |
(row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && |
(flags & PNG_FLAG_STRIP_ALPHA))) && |
row_info->channels == 2) |
{ |
if (row_info->bit_depth == 8) |
{ |
if (flags & PNG_FLAG_FILLER_AFTER) |
{ |
/* This converts from GX or GA to G */ |
for (i = 0; i < row_width; i++) |
{ |
*dp++ = *sp++; |
sp++; |
} |
} |
else |
{ |
/* This converts from XG or AG to G */ |
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; |
} |
if (flags & PNG_FLAG_STRIP_ALPHA) |
row_info->color_type = (png_byte)(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"); |
if ((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; |
} |
} |
} |
#ifdef PNG_16BIT_SUPPORTED |
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 |
} |
} |
#endif /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */ |
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ |
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) |
#ifdef PNG_USER_TRANSFORM_PTR_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"); |
if (png_ptr == NULL) |
return; |
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; |
} |
#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. |
*/ |
#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED |
png_voidp PNGAPI |
png_get_user_transform_ptr(png_const_structp png_ptr) |
{ |
if (png_ptr == NULL) |
return (NULL); |
return ((png_voidp)png_ptr->user_transform_ptr); |
} |
#endif |
png_uint_32 PNGAPI |
png_get_current_row_number(png_const_structp png_ptr) |
{ |
if (png_ptr != NULL) |
return png_ptr->row_number; |
return PNG_UINT_32_MAX; /* help the app not to fail silently */ |
} |
png_byte PNGAPI |
png_get_current_pass_number(png_const_structp png_ptr) |
{ |
if (png_ptr != NULL) |
return png_ptr->pass; |
return 8; /* invalid */ |
} |
#endif /* PNG_READ_USER_TRANSFORM_SUPPORTED || |
PNG_WRITE_USER_TRANSFORM_SUPPORTED */ |
#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngwio.c |
---|
0,0 → 1,254 |
/* pngwio.c - functions for data output |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
* |
* 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(...). |
*/ |
#include "pngpriv.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_const_bytep data, png_size_t length) |
{ |
/* NOTE: write_data_fn must not change the buffer! */ |
if (png_ptr->write_data_fn != NULL ) |
(*(png_ptr->write_data_fn))(png_ptr, (png_bytep)data, length); |
else |
png_error(png_ptr, "Call to NULL write function"); |
} |
#ifdef PNG_STDIO_SUPPORTED |
/* 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 PNGCBAPI |
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) |
{ |
png_size_t check; |
if (png_ptr == NULL) |
return; |
check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr)); |
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 PNGCBAPI |
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; |
if (png_ptr == NULL) |
return; |
/* 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) |
{ |
check = fwrite(near_data, 1, length, io_ptr); |
} |
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 */ |
err = fwrite(buf, 1, written, io_ptr); |
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. |
*/ |
#ifdef 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); |
} |
# ifdef PNG_STDIO_SUPPORTED |
void PNGCBAPI |
png_default_flush(png_structp png_ptr) |
{ |
png_FILE_p io_ptr; |
if (png_ptr == NULL) |
return; |
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); |
fflush(io_ptr); |
} |
# 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. May be |
* NULL, in which case libpng's default function will |
* be used. |
* 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 output, 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. May be NULL, in which case |
* libpng's default function will be used, if |
* PNG_WRITE_FLUSH_SUPPORTED is defined. This is not |
* a good idea if io_ptr does not point to a standard |
* *FILE structure. |
*/ |
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) |
{ |
if (png_ptr == NULL) |
return; |
png_ptr->io_ptr = io_ptr; |
#ifdef PNG_STDIO_SUPPORTED |
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 |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
# ifdef PNG_STDIO_SUPPORTED |
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, |
"Can't set both read_data_fn and write_data_fn in the" |
" same structure"); |
} |
} |
#ifdef USE_FAR_KEYWORD |
# ifdef _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 */ |
/programs/develop/libraries/libpng/pngwrite.c |
---|
0,0 → 1,1605 |
/* pngwrite.c - general routines to write a PNG file |
* |
* Last changed in libpng 1.5.1 [February 3, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
*/ |
#include "pngpriv.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"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) |
{ |
/* Write PNG signature */ |
png_write_sig(png_ptr); |
#ifdef 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"); |
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, |
#ifdef 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. |
*/ |
#ifdef PNG_WRITE_gAMA_SUPPORTED |
if (info_ptr->valid & PNG_INFO_gAMA) |
png_write_gAMA_fixed(png_ptr, info_ptr->gamma); |
#endif |
#ifdef PNG_WRITE_sRGB_SUPPORTED |
if (info_ptr->valid & PNG_INFO_sRGB) |
png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent); |
#endif |
#ifdef PNG_WRITE_iCCP_SUPPORTED |
if (info_ptr->valid & PNG_INFO_iCCP) |
png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE, |
(png_charp)info_ptr->iccp_profile, (int)info_ptr->iccp_proflen); |
#endif |
#ifdef 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 |
#ifdef PNG_WRITE_cHRM_SUPPORTED |
if (info_ptr->valid & PNG_INFO_cHRM) |
png_write_cHRM_fixed(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); |
#endif |
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks"); |
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 != PNG_HANDLE_CHUNK_NEVER && |
up->location && !(up->location & PNG_HAVE_PLTE) && |
!(up->location & PNG_HAVE_IDAT) && |
((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || |
(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) |
{ |
if (up->size == 0) |
png_warning(png_ptr, "Writing zero-length unknown chunk"); |
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"); |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
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"); |
#ifdef PNG_WRITE_tRNS_SUPPORTED |
if (info_ptr->valid & PNG_INFO_tRNS) |
{ |
#ifdef 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_alpha[j] = |
(png_byte)(255 - info_ptr->trans_alpha[j]); |
} |
#endif |
png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color), |
info_ptr->num_trans, info_ptr->color_type); |
} |
#endif |
#ifdef PNG_WRITE_bKGD_SUPPORTED |
if (info_ptr->valid & PNG_INFO_bKGD) |
png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type); |
#endif |
#ifdef PNG_WRITE_hIST_SUPPORTED |
if (info_ptr->valid & PNG_INFO_hIST) |
png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette); |
#endif |
#ifdef 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 |
#ifdef 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 |
#ifdef PNG_WRITE_sCAL_SUPPORTED |
if (info_ptr->valid & PNG_INFO_sCAL) |
png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit, |
info_ptr->scal_s_width, info_ptr->scal_s_height); |
#endif /* sCAL */ |
#ifdef 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 /* pHYs */ |
#ifdef 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 /* tIME */ |
#ifdef 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 /* sPLT */ |
#ifdef 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", i, |
info_ptr->text[i].compression); |
/* An internationalized chunk? */ |
if (info_ptr->text[i].compression > 0) |
{ |
#ifdef 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"); |
#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) |
{ |
#ifdef 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"); |
#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) |
{ |
#ifdef PNG_WRITE_tEXt_SUPPORTED |
/* Write uncompressed chunk */ |
png_write_tEXt(png_ptr, info_ptr->text[i].key, |
info_ptr->text[i].text, |
0); |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
#else |
/* Can't get here */ |
png_warning(png_ptr, "Unable to write uncompressed text"); |
#endif |
} |
} |
#endif /* tEXt */ |
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks"); |
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 != PNG_HANDLE_CHUNK_NEVER && |
up->location && (up->location & PNG_HAVE_PLTE) && |
!(up->location & PNG_HAVE_IDAT) && |
((up->name[3] & 0x20) || keep == PNG_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"); |
if (png_ptr == NULL) |
return; |
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) |
{ |
#ifdef PNG_WRITE_TEXT_SUPPORTED |
int i; /* local index variable */ |
#endif |
#ifdef 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 |
#ifdef 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", i, |
info_ptr->text[i].compression); |
/* An internationalized chunk? */ |
if (info_ptr->text[i].compression > 0) |
{ |
#ifdef 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"); |
#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) |
{ |
#ifdef 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"); |
#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) |
{ |
#ifdef 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"); |
#endif |
/* Mark this chunk as written */ |
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; |
} |
} |
#endif |
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED |
if (info_ptr->unknown_chunks_num) |
{ |
png_unknown_chunk *up; |
png_debug(5, "writing extra chunks"); |
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 != PNG_HANDLE_CHUNK_NEVER && |
up->location && (up->location & PNG_AFTER_IDAT) && |
((up->name[3] & 0x20) || keep == PNG_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); |
/* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03, |
* and restored again in libpng-1.2.30, may cause some applications that |
* do not set png_ptr->output_flush_fn to crash. If your application |
* experiences a problem, please try building libpng with |
* PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to |
* png-mng-implement at lists.sf.net . |
*/ |
#ifdef PNG_WRITE_FLUSH_SUPPORTED |
# ifdef PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED |
png_flush(png_ptr); |
# endif |
#endif |
} |
#ifdef PNG_CONVERT_tIME_SUPPORTED |
/* "tm" structure is not supported on WindowsCE */ |
void PNGAPI |
png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm FAR * ttime) |
{ |
png_debug(1, "in png_convert_from_struct_tm"); |
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"); |
tbuf = gmtime(&ttime); |
png_convert_from_struct_tm(ptime, tbuf); |
} |
#endif |
/* Initialize png_ptr structure, and allocate any memory needed */ |
PNG_FUNCTION(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),PNG_ALLOCATED) |
{ |
#ifdef PNG_USER_MEM_SUPPORTED |
return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn, |
warn_fn, NULL, NULL, NULL)); |
} |
/* Alternate initialize png_ptr structure, and allocate any memory needed */ |
static void png_reset_filter_heuristics(png_structp png_ptr); /* forward decl */ |
PNG_FUNCTION(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),PNG_ALLOCATED) |
{ |
#endif /* PNG_USER_MEM_SUPPORTED */ |
volatile int png_cleanup_needed = 0; |
#ifdef PNG_SETJMP_SUPPORTED |
volatile |
#endif |
png_structp png_ptr; |
#ifdef PNG_SETJMP_SUPPORTED |
#ifdef USE_FAR_KEYWORD |
jmp_buf png_jmpbuf; |
#endif |
#endif |
int i; |
png_debug(1, "in png_create_write_struct"); |
#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); |
/* Added at libpng-1.2.6 */ |
#ifdef PNG_SET_USER_LIMITS_SUPPORTED |
png_ptr->user_width_max = PNG_USER_WIDTH_MAX; |
png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; |
#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(png_jmpbuf)) |
#else |
if (setjmp(png_jmpbuf(png_ptr))) /* sets longjmp to match setjmp */ |
#endif |
#ifdef USE_FAR_KEYWORD |
png_memcpy(png_jmpbuf(png_ptr), png_jmpbuf, png_sizeof(jmp_buf)); |
#endif |
PNG_ABORT(); |
#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); |
if (user_png_ver) |
{ |
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')) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char msg[80]; |
if (user_png_ver) |
{ |
png_snprintf2(msg, 80, |
"Application built with libpng-%.20s" |
" but running with %.20s", |
user_png_ver, |
png_libpng_ver); |
png_warning(png_ptr, msg); |
} |
#else |
png_warning(png_ptr, |
"Incompatible libpng version in application and library"); |
#endif |
#ifdef PNG_ERROR_NUMBERS_SUPPORTED |
png_ptr->flags = 0; |
#endif |
png_cleanup_needed = 1; |
} |
} |
/* Initialize zbuf - compression buffer */ |
png_ptr->zbuf_size = PNG_ZBUF_SIZE; |
if (!png_cleanup_needed) |
{ |
png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr, |
png_ptr->zbuf_size); |
if (png_ptr->zbuf == NULL) |
png_cleanup_needed = 1; |
} |
if (png_cleanup_needed) |
{ |
/* Clean up PNG structure and deallocate any memory. */ |
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); |
} |
png_set_write_fn(png_ptr, NULL, NULL, NULL); |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
png_reset_filter_heuristics(png_ptr); |
#endif |
return (png_ptr); |
} |
/* 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"); |
if (png_ptr == NULL) |
return; |
/* 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 */ |
if (png_ptr == NULL) |
return; |
png_debug(1, "in png_write_image"); |
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
/* Initialize 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_const_bytep row) |
{ |
if (png_ptr == NULL) |
return; |
png_debug2(1, "in png_write_row (row %u, pass %d)", |
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); |
} |
#ifdef 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; |
default: /* error: ignore it */ |
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_ROWBYTES(png_ptr->row_info.pixel_depth, |
png_ptr->row_info.width); |
png_debug1(3, "row_info->color_type = %d", png_ptr->row_info.color_type); |
png_debug1(3, "row_info->width = %u", png_ptr->row_info.width); |
png_debug1(3, "row_info->channels = %d", png_ptr->row_info.channels); |
png_debug1(3, "row_info->bit_depth = %d", png_ptr->row_info.bit_depth); |
png_debug1(3, "row_info->pixel_depth = %d", png_ptr->row_info.pixel_depth); |
png_debug1(3, "row_info->rowbytes = %lu", |
(unsigned long)png_ptr->row_info.rowbytes); |
/* Copy user's row into buffer, leaving room for filter byte. */ |
png_memcpy(png_ptr->row_buf + 1, row, png_ptr->row_info.rowbytes); |
#ifdef 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); |
#ifdef 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); |
} |
#ifdef 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"); |
if (png_ptr == NULL) |
return; |
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"); |
if (png_ptr == NULL) |
return; |
/* 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"); |
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 |
} |
#ifdef PNG_USER_MEM_SUPPORTED |
if (png_ptr != NULL) |
{ |
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) |
{ |
if (png_ptr != NULL) |
{ |
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); |
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED |
if (png_ptr->num_chunk_list) |
{ |
png_free(png_ptr, png_ptr->chunk_list); |
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"); |
/* 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); |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
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); |
#endif |
#ifdef PNG_TIME_RFC1123_SUPPORTED |
png_free(png_ptr, png_ptr->time_buffer); |
#endif |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
/* Use this to save a little code space, it doesn't free the filter_costs */ |
png_reset_filter_heuristics(png_ptr); |
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->png_jmpbuf, png_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, png_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->png_jmpbuf, tmp_jmp, png_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"); |
if (png_ptr == NULL) |
return; |
#ifdef 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)) |
{ |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
case 5: |
case 6: |
case 7: png_warning(png_ptr, "Unknown row filter for method 0"); |
#endif /* PNG_WRITE_FILTER_SUPPORTED */ |
case PNG_FILTER_VALUE_NONE: |
png_ptr->do_filter = PNG_FILTER_NONE; break; |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
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; |
#else |
default: |
png_warning(png_ptr, "Unknown row filter for method 0"); |
#endif /* PNG_WRITE_FILTER_SUPPORTED */ |
} |
/* 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) |
{ |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
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_byte)(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_byte)(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) |
#endif /* PNG_WRITE_FILTER_SUPPORTED */ |
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. |
*/ |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* GRR 970116 */ |
/* Conveneince reset API. */ |
static void |
png_reset_filter_heuristics(png_structp png_ptr) |
{ |
/* Clear out any old values in the 'weights' - this must be done because if |
* the app calls set_filter_heuristics multiple times with different |
* 'num_weights' values we would otherwise potentially have wrong sized |
* arrays. |
*/ |
png_ptr->num_prev_filters = 0; |
png_ptr->heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED; |
if (png_ptr->prev_filters != NULL) |
{ |
png_bytep old = png_ptr->prev_filters; |
png_ptr->prev_filters = NULL; |
png_free(png_ptr, old); |
} |
if (png_ptr->filter_weights != NULL) |
{ |
png_uint_16p old = png_ptr->filter_weights; |
png_ptr->filter_weights = NULL; |
png_free(png_ptr, old); |
} |
if (png_ptr->inv_filter_weights != NULL) |
{ |
png_uint_16p old = png_ptr->inv_filter_weights; |
png_ptr->inv_filter_weights = NULL; |
png_free(png_ptr, old); |
} |
/* Leave the filter_costs - this array is fixed size. */ |
} |
static int |
png_init_filter_heuristics(png_structp png_ptr, int heuristic_method, |
int num_weights) |
{ |
if (png_ptr == NULL) |
return 0; |
/* Clear out the arrays */ |
png_reset_filter_heuristics(png_ptr); |
/* Check arguments; the 'reset' function makes the correct settings for the |
* unweighted case, but we must handle the weight case by initializing the |
* arrays for the caller. |
*/ |
if (heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int i; |
if (num_weights > 0) |
{ |
png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr, |
(png_uint_32)(png_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; |
} |
png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(png_sizeof(png_uint_16) * num_weights)); |
png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(png_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; |
} |
/* Safe to set this now */ |
png_ptr->num_prev_filters = (png_byte)num_weights; |
} |
/* 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)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); |
png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr, |
(png_uint_32)(png_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; |
} |
/* All the arrays are inited, safe to set this: */ |
png_ptr->heuristic_method = PNG_FILTER_HEURISTIC_WEIGHTED; |
/* Return the 'ok' code. */ |
return 1; |
} |
else if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT || |
heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED) |
{ |
return 1; |
} |
else |
{ |
png_warning(png_ptr, "Unknown filter heuristic method"); |
return 0; |
} |
} |
/* Provide floating and fixed point APIs */ |
#ifdef PNG_FLOATING_POINT_SUPPORTED |
void PNGAPI |
png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, |
int num_weights, png_const_doublep filter_weights, |
png_const_doublep filter_costs) |
{ |
png_debug(1, "in png_set_filter_heuristics"); |
/* The internal API allocates all the arrays and ensures that the elements of |
* those arrays are set to the default value. |
*/ |
if (!png_init_filter_heuristics(png_ptr, heuristic_method, num_weights)) |
return; |
/* If using the weighted method copy in the weights. */ |
if (heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int i; |
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)(PNG_WEIGHT_FACTOR*filter_weights[i]+.5); |
png_ptr->filter_weights[i] = |
(png_uint_16)(PNG_WEIGHT_FACTOR/filter_weights[i]+.5); |
} |
} |
/* 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[i] >= 1.0) |
{ |
png_ptr->inv_filter_costs[i] = |
(png_uint_16)(PNG_COST_FACTOR / filter_costs[i] + .5); |
png_ptr->filter_costs[i] = |
(png_uint_16)(PNG_COST_FACTOR * filter_costs[i] + .5); |
} |
} |
} |
#endif /* FLOATING_POINT */ |
#ifdef PNG_FIXED_POINT_SUPPORTED |
void PNGAPI |
png_set_filter_heuristics_fixed(png_structp png_ptr, int heuristic_method, |
int num_weights, png_const_fixed_point_p filter_weights, |
png_const_fixed_point_p filter_costs) |
{ |
png_debug(1, "in png_set_filter_heuristics_fixed"); |
/* The internal API allocates all the arrays and ensures that the elements of |
* those arrays are set to the default value. |
*/ |
if (!png_init_filter_heuristics(png_ptr, heuristic_method, num_weights)) |
return; |
/* If using the weighted method copy in the weights. */ |
if (heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) |
{ |
int i; |
for (i = 0; i < num_weights; i++) |
{ |
if (filter_weights[i] <= 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) |
((PNG_WEIGHT_FACTOR*filter_weights[i]+PNG_FP_HALF)/PNG_FP_1); |
png_ptr->filter_weights[i] = (png_uint_16)((PNG_WEIGHT_FACTOR* |
PNG_FP_1+(filter_weights[i]/2))/filter_weights[i]); |
} |
} |
/* 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[i] >= PNG_FP_1) |
{ |
png_uint_32 tmp; |
/* Use a 32 bit unsigned temporary here because otherwise the |
* intermediate value will be a 32 bit *signed* integer (ANSI rules) |
* and this will get the wrong answer on division. |
*/ |
tmp = PNG_COST_FACTOR*PNG_FP_1 + (filter_costs[i]/2); |
tmp /= filter_costs[i]; |
png_ptr->inv_filter_costs[i] = (png_uint_16)tmp; |
tmp = PNG_COST_FACTOR * filter_costs[i] + PNG_FP_HALF; |
tmp /= PNG_FP_1; |
png_ptr->filter_costs[i] = (png_uint_16)tmp; |
} |
} |
} |
#endif /* FIXED_POINT */ |
#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"); |
if (png_ptr == NULL) |
return; |
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"); |
if (png_ptr == NULL) |
return; |
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"); |
if (png_ptr == NULL) |
return; |
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 (png_ptr == NULL) |
return; |
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"); |
if (png_ptr == NULL) |
return; |
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) |
{ |
if (png_ptr == NULL) |
return; |
png_ptr->write_row_fn = write_row_fn; |
} |
#ifdef 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"); |
if (png_ptr == NULL) |
return; |
png_ptr->transformations |= PNG_USER_TRANSFORM; |
png_ptr->write_user_transform_fn = write_user_transform_fn; |
} |
#endif |
#ifdef PNG_INFO_IMAGE_SUPPORTED |
void PNGAPI |
png_write_png(png_structp png_ptr, png_infop info_ptr, |
int transforms, voidp params) |
{ |
if (png_ptr == NULL || info_ptr == NULL) |
return; |
/* Write the file header information. */ |
png_write_info(png_ptr, info_ptr); |
/* ------ these transformations don't touch the info structure ------- */ |
#ifdef PNG_WRITE_INVERT_SUPPORTED |
/* Invert monochrome pixels */ |
if (transforms & PNG_TRANSFORM_INVERT_MONO) |
png_set_invert_mono(png_ptr); |
#endif |
#ifdef 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 |
#ifdef PNG_WRITE_PACK_SUPPORTED |
/* Pack pixels into bytes */ |
if (transforms & PNG_TRANSFORM_PACKING) |
png_set_packing(png_ptr); |
#endif |
#ifdef 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 |
#ifdef PNG_WRITE_FILLER_SUPPORTED |
/* Pack XRGB/RGBX/ARGB/RGBA into * RGB (4 channels -> 3 channels) */ |
if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) |
png_set_filler(png_ptr, 0, PNG_FILLER_AFTER); |
else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) |
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); |
#endif |
#ifdef PNG_WRITE_BGR_SUPPORTED |
/* Flip BGR pixels to RGB */ |
if (transforms & PNG_TRANSFORM_BGR) |
png_set_bgr(png_ptr); |
#endif |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
/* ----------------------- 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); |
PNG_UNUSED(transforms) /* Quiet compiler warnings */ |
PNG_UNUSED(params) |
} |
#endif |
#endif /* PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngwtran.c |
---|
0,0 → 1,631 |
/* pngwtran.c - transforms the data in a row for PNG writers |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
*/ |
#include "pngpriv.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"); |
if (png_ptr == NULL) |
return; |
#ifdef 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_size_t 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 |
#ifdef 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 |
#ifdef PNG_WRITE_PACKSWAP_SUPPORTED |
if (png_ptr->transformations & PNG_PACKSWAP) |
png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#ifdef 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 |
#ifdef PNG_WRITE_SWAP_SUPPORTED |
if (png_ptr->transformations & PNG_SWAP_BYTES) |
png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#ifdef 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 |
#ifdef 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 |
#ifdef 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 |
#ifdef PNG_WRITE_BGR_SUPPORTED |
if (png_ptr->transformations & PNG_BGR) |
png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
#ifdef PNG_WRITE_INVERT_SUPPORTED |
if (png_ptr->transformations & PNG_INVERT_MONO) |
png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); |
#endif |
} |
#ifdef 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"); |
if (row_info->bit_depth == 8 && |
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; |
} |
default: |
break; |
} |
row_info->bit_depth = (png_byte)bit_depth; |
row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels); |
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, |
row_info->width); |
} |
} |
#endif |
#ifdef 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_const_color_8p bit_depth) |
{ |
png_debug(1, "in png_do_shift"); |
if (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_size_t i; |
png_byte mask; |
png_size_t 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 |
#ifdef 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"); |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This converts from ARGB to RGBA */ |
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; |
} |
} |
#ifdef PNG_WRITE_16BIT_SUPPORTED |
else |
{ |
/* This converts from AARRGGBB to RRGGBBAA */ |
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]; |
} |
} |
#endif /* PNG_WRITE_16BIT_SUPPORTED */ |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This converts from AG to GA */ |
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; |
} |
} |
#ifdef PNG_WRITE_16BIT_SUPPORTED |
else |
{ |
/* This converts from AAGG to GGAA */ |
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 /* PNG_WRITE_16BIT_SUPPORTED */ |
} |
} |
} |
#endif |
#ifdef 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"); |
{ |
if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This inverts the alpha channel in RGBA */ |
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++) |
{ |
/* Does nothing |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*/ |
sp+=3; dp = sp; |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
#ifdef PNG_WRITE_16BIT_SUPPORTED |
else |
{ |
/* This inverts the alpha channel in RRGGBBAA */ |
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++) |
{ |
/* Does nothing |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*/ |
sp+=6; dp = sp; |
*(dp++) = (png_byte)(255 - *(sp++)); |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
#endif /* PNG_WRITE_16BIT_SUPPORTED */ |
} |
else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) |
{ |
if (row_info->bit_depth == 8) |
{ |
/* This inverts the alpha channel in GA */ |
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++)); |
} |
} |
#ifdef PNG_WRITE_16BIT_SUPPORTED |
else |
{ |
/* This inverts the alpha channel in GGAA */ |
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++) |
{ |
/* Does nothing |
*(dp++) = *(sp++); |
*(dp++) = *(sp++); |
*/ |
sp+=2; dp = sp; |
*(dp++) = (png_byte)(255 - *(sp++)); |
*(dp++) = (png_byte)(255 - *(sp++)); |
} |
} |
#endif /* PNG_WRITE_16BIT_SUPPORTED */ |
} |
} |
} |
#endif |
#ifdef 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"); |
if ((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); |
} |
} |
#ifdef PNG_WRITE_16BIT_SUPPORTED |
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 = (png_uint_32)((s0 - s1) & 0xffffL); |
png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL); |
*(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_WRITE_16BIT_SUPPORTED */ |
} |
} |
#endif /* PNG_MNG_FEATURES_SUPPORTED */ |
#endif /* PNG_WRITE_SUPPORTED */ |
/programs/develop/libraries/libpng/pngwutil.c |
---|
0,0 → 1,2948 |
/* pngwutil.c - utilities to write a PNG file |
* |
* Last changed in libpng 1.5.0 [January 6, 2011] |
* Copyright (c) 1998-2011 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 code is released under the libpng license. |
* For conditions of distribution and use, see the disclaimer |
* and license in png.h |
*/ |
#include "pngpriv.h" |
#ifdef PNG_WRITE_SUPPORTED |
#ifdef PNG_WRITE_INT_FUNCTIONS_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 PNGAPI |
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); |
} |
#ifdef PNG_SAVE_INT_32_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. Note that, |
* the following works correctly even if png_int_32 has more than 32 bits |
* (compare the more complex code required on read for sign extention.) |
*/ |
void PNGAPI |
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 PNGAPI |
png_save_uint_16(png_bytep buf, unsigned int i) |
{ |
buf[0] = (png_byte)((i >> 8) & 0xff); |
buf[1] = (png_byte)(i & 0xff); |
} |
#endif |
/* 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 PNGAPI |
png_write_sig(png_structp png_ptr) |
{ |
png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; |
#ifdef PNG_IO_STATE_SUPPORTED |
/* Inform the I/O callback that the signature is being written */ |
png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE; |
#endif |
/* 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; |
} |
/* 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_const_bytep chunk_name, |
png_const_bytep data, png_size_t length) |
{ |
if (png_ptr == NULL) |
return; |
png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length); |
png_write_chunk_data(png_ptr, data, (png_size_t)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_const_bytep chunk_name, |
png_uint_32 length) |
{ |
png_byte buf[8]; |
png_debug2(0, "Writing %s chunk, length = %lu", chunk_name, |
(unsigned long)length); |
if (png_ptr == NULL) |
return; |
#ifdef PNG_IO_STATE_SUPPORTED |
/* Inform the I/O callback that the chunk header is being written. |
* PNG_IO_CHUNK_HDR requires a single I/O call. |
*/ |
png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR; |
#endif |
/* Write the length and the chunk name */ |
png_save_uint_32(buf, length); |
png_memcpy(buf + 4, chunk_name, 4); |
png_write_data(png_ptr, buf, (png_size_t)8); |
/* Put the chunk name into png_ptr->chunk_name */ |
png_memcpy(png_ptr->chunk_name, chunk_name, 4); |
/* Reset the crc and run it over the chunk name */ |
png_reset_crc(png_ptr); |
png_calculate_crc(png_ptr, chunk_name, 4); |
#ifdef PNG_IO_STATE_SUPPORTED |
/* Inform the I/O callback that chunk data will (possibly) be written. |
* PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls. |
*/ |
png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_DATA; |
#endif |
} |
/* 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_const_bytep data, |
png_size_t length) |
{ |
/* Write the data, and run the CRC over it */ |
if (png_ptr == NULL) |
return; |
if (data != NULL && length > 0) |
{ |
png_write_data(png_ptr, data, length); |
/* Update the CRC after writing the data, |
* in case that the user I/O routine alters it. |
*/ |
png_calculate_crc(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]; |
if (png_ptr == NULL) return; |
#ifdef PNG_IO_STATE_SUPPORTED |
/* Inform the I/O callback that the chunk CRC is being written. |
* PNG_IO_CHUNK_CRC requires a single I/O function call. |
*/ |
png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC; |
#endif |
/* Write the crc in a single operation */ |
png_save_uint_32(buf, png_ptr->crc); |
png_write_data(png_ptr, buf, (png_size_t)4); |
} |
#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 |
{ |
png_const_bytep input; /* The uncompressed input data */ |
png_size_t input_len; /* Its length */ |
int num_output_ptr; /* Number of output pointers used */ |
int max_output_ptr; /* Size of output_ptr */ |
png_bytep *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_const_charp text, png_size_t text_len, int compression, |
compression_state *comp) |
{ |
int ret; |
comp->num_output_ptr = 0; |
comp->max_output_ptr = 0; |
comp->output_ptr = NULL; |
comp->input = NULL; |
comp->input_len = 0; |
/* We may just want to pass the text right through */ |
if (compression == PNG_TEXT_COMPRESSION_NONE) |
{ |
comp->input = (png_const_bytep)text; |
comp->input_len = text_len; |
return((int)text_len); |
} |
if (compression >= PNG_TEXT_COMPRESSION_LAST) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char msg[50]; |
png_snprintf(msg, 50, "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 */ |
/* TODO: the following cast hides a potential overflow problem. */ |
png_ptr->zstream.avail_in = (uInt)text_len; |
/* NOTE: assume zlib doesn't overwrite the input */ |
png_ptr->zstream.next_in = (Bytef *)text; |
png_ptr->zstream.avail_out = png_ptr->zbuf_size; |
png_ptr->zstream.next_out = 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)) |
{ |
/* 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_bytepp old_ptr; |
old_ptr = comp->output_ptr; |
comp->output_ptr = (png_bytepp)png_malloc(png_ptr, |
(png_alloc_size_t) |
(comp->max_output_ptr * png_sizeof(png_charpp))); |
png_memcpy(comp->output_ptr, old_ptr, old_max |
* png_sizeof(png_charp)); |
png_free(png_ptr, old_ptr); |
} |
else |
comp->output_ptr = (png_bytepp)png_malloc(png_ptr, |
(png_alloc_size_t) |
(comp->max_output_ptr * png_sizeof(png_charp))); |
} |
/* Save the data */ |
comp->output_ptr[comp->num_output_ptr] = |
(png_bytep)png_malloc(png_ptr, |
(png_alloc_size_t)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_bytepp old_ptr; |
old_ptr = comp->output_ptr; |
/* This could be optimized to realloc() */ |
comp->output_ptr = (png_bytepp)png_malloc(png_ptr, |
(png_alloc_size_t)(comp->max_output_ptr * |
png_sizeof(png_charp))); |
png_memcpy(comp->output_ptr, old_ptr, |
old_max * png_sizeof(png_charp)); |
png_free(png_ptr, old_ptr); |
} |
else |
comp->output_ptr = (png_bytepp)png_malloc(png_ptr, |
(png_alloc_size_t)(comp->max_output_ptr * |
png_sizeof(png_charp))); |
} |
/* Save the data */ |
comp->output_ptr[comp->num_output_ptr] = |
(png_bytep)png_malloc(png_ptr, |
(png_alloc_size_t)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, comp->input, 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, comp->output_ptr[i], |
(png_size_t)png_ptr->zbuf_size); |
png_free(png_ptr, comp->output_ptr[i]); |
} |
if (comp->max_output_ptr != 0) |
png_free(png_ptr, comp->output_ptr); |
/* 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_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out)); |
/* Reset zlib for another zTXt/iTXt or image data */ |
deflateReset(&png_ptr->zstream); |
png_ptr->zstream.data_type = Z_BINARY; |
} |
#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) |
{ |
PNG_IHDR; |
int ret; |
png_byte buf[13]; /* Buffer to store the IHDR info */ |
png_debug(1, "in png_write_IHDR"); |
/* 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: |
#ifdef PNG_WRITE_16BIT_SUPPORTED |
case 16: |
#endif |
png_ptr->channels = 1; break; |
default: |
png_error(png_ptr, |
"Invalid bit depth for grayscale image"); |
} |
break; |
case PNG_COLOR_TYPE_RGB: |
#ifdef PNG_WRITE_16BIT_SUPPORTED |
if (bit_depth != 8 && bit_depth != 16) |
#else |
if (bit_depth != 8) |
#endif |
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: |
#ifdef PNG_WRITE_16BIT_SUPPORTED |
if (bit_depth != 8 && bit_depth != 16) |
#else |
if (bit_depth != 8) |
#endif |
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 ( |
#ifdef 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 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; |
#ifdef PNG_MNG_FEATURES_SUPPORTED |
png_ptr->filter_type = (png_byte)filter_type; |
#endif |
png_ptr->compression_type = (png_byte)compression_type; |
png_ptr->width = width; |
png_ptr->height = height; |
png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels); |
png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width); |
/* 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_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; |
ret = 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); |
if (ret != Z_OK) |
{ |
if (ret == Z_VERSION_ERROR) |
png_error(png_ptr, |
"zlib failed to initialize compressor -- version error"); |
if (ret == Z_STREAM_ERROR) |
png_error(png_ptr, |
"zlib failed to initialize compressor -- stream error"); |
if (ret == Z_MEM_ERROR) |
png_error(png_ptr, |
"zlib failed to initialize compressor -- mem error"); |
png_error(png_ptr, "zlib failed to initialize compressor"); |
} |
png_ptr->zstream.next_out = png_ptr->zbuf; |
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
/* libpng is not interested in zstream.data_type, so set it |
* to a predefined value, to avoid its evaluation inside zlib |
*/ |
png_ptr->zstream.data_type = Z_BINARY; |
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_const_colorp palette, |
png_uint_32 num_pal) |
{ |
PNG_PLTE; |
png_uint_32 i; |
png_const_colorp pal_ptr; |
png_byte buf[3]; |
png_debug(1, "in png_write_PLTE"); |
if (( |
#ifdef 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", png_ptr->num_palette); |
png_write_chunk_start(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3)); |
#ifdef PNG_POINTER_INDEXING_SUPPORTED |
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) |
{ |
PNG_IDAT; |
png_debug(1, "in png_write_IDAT"); |
/* Optimize the CMF field in the zlib stream. */ |
/* This hack of the zlib stream is compliant to the stream specification. */ |
if (!(png_ptr->mode & PNG_HAVE_IDAT) && |
png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) |
{ |
unsigned int z_cmf = data[0]; /* zlib compression method and flags */ |
if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) |
{ |
/* Avoid memory underflows and multiplication overflows. |
* |
* The conditions below are practically always satisfied; |
* however, they still must be checked. |
*/ |
if (length >= 2 && |
png_ptr->height < 16384 && png_ptr->width < 16384) |
{ |
png_uint_32 uncompressed_idat_size = png_ptr->height * |
((png_ptr->width * |
png_ptr->channels * png_ptr->bit_depth + 15) >> 3); |
unsigned int z_cinfo = z_cmf >> 4; |
unsigned int half_z_window_size = 1 << (z_cinfo + 7); |
while (uncompressed_idat_size <= half_z_window_size && |
half_z_window_size >= 256) |
{ |
z_cinfo--; |
half_z_window_size >>= 1; |
} |
z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4); |
if (data[0] != z_cmf) |
{ |
int tmp; |
data[0] = (png_byte)z_cmf; |
tmp = data[1] & 0xe0; |
tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f; |
data[1] = (png_byte)tmp; |
} |
} |
} |
else |
png_error(png_ptr, |
"Invalid zlib compression method or flags in IDAT"); |
} |
png_write_chunk(png_ptr, png_IDAT, data, length); |
png_ptr->mode |= PNG_HAVE_IDAT; |
} |
/* Write an IEND chunk */ |
void /* PRIVATE */ |
png_write_IEND(png_structp png_ptr) |
{ |
PNG_IEND; |
png_debug(1, "in png_write_IEND"); |
png_write_chunk(png_ptr, png_IEND, NULL, (png_size_t)0); |
png_ptr->mode |= PNG_HAVE_IEND; |
} |
#ifdef PNG_WRITE_gAMA_SUPPORTED |
/* Write a gAMA chunk */ |
void /* PRIVATE */ |
png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma) |
{ |
PNG_gAMA; |
png_byte buf[4]; |
png_debug(1, "in png_write_gAMA"); |
/* file_gamma is saved in 1/100,000ths */ |
png_save_uint_32(buf, (png_uint_32)file_gamma); |
png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4); |
} |
#endif |
#ifdef PNG_WRITE_sRGB_SUPPORTED |
/* Write a sRGB chunk */ |
void /* PRIVATE */ |
png_write_sRGB(png_structp png_ptr, int srgb_intent) |
{ |
PNG_sRGB; |
png_byte buf[1]; |
png_debug(1, "in png_write_sRGB"); |
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_sRGB, buf, (png_size_t)1); |
} |
#endif |
#ifdef PNG_WRITE_iCCP_SUPPORTED |
/* Write an iCCP chunk */ |
void /* PRIVATE */ |
png_write_iCCP(png_structp png_ptr, png_const_charp name, int compression_type, |
png_const_charp profile, int profile_len) |
{ |
PNG_iCCP; |
png_size_t name_len; |
png_charp new_name; |
compression_state comp; |
int embedded_profile_len = 0; |
png_debug(1, "in png_write_iCCP"); |
comp.num_output_ptr = 0; |
comp.max_output_ptr = 0; |
comp.output_ptr = NULL; |
comp.input = NULL; |
comp.input_len = 0; |
if ((name_len = png_check_keyword(png_ptr, name, &new_name)) == 0) |
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 > 3) |
embedded_profile_len = |
((*( (png_const_bytep)profile ))<<24) | |
((*( (png_const_bytep)profile + 1))<<16) | |
((*( (png_const_bytep)profile + 2))<< 8) | |
((*( (png_const_bytep)profile + 3)) ); |
if (embedded_profile_len < 0) |
{ |
png_warning(png_ptr, |
"Embedded profile length in iCCP chunk is negative"); |
png_free(png_ptr, new_name); |
return; |
} |
if (profile_len < embedded_profile_len) |
{ |
png_warning(png_ptr, |
"Embedded profile length too large in iCCP chunk"); |
png_free(png_ptr, new_name); |
return; |
} |
if (profile_len > embedded_profile_len) |
{ |
png_warning(png_ptr, |
"Truncating profile to actual length in iCCP chunk"); |
profile_len = embedded_profile_len; |
} |
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_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, |
(png_size_t)(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 |
#ifdef PNG_WRITE_sPLT_SUPPORTED |
/* Write a sPLT chunk */ |
void /* PRIVATE */ |
png_write_sPLT(png_structp png_ptr, png_const_sPLT_tp spalette) |
{ |
PNG_sPLT; |
png_size_t name_len; |
png_charp new_name; |
png_byte entrybuf[10]; |
png_size_t entry_size = (spalette->depth == 8 ? 6 : 10); |
png_size_t palette_size = entry_size * spalette->nentries; |
png_sPLT_entryp ep; |
#ifndef PNG_POINTER_INDEXING_SUPPORTED |
int i; |
#endif |
png_debug(1, "in png_write_sPLT"); |
if ((name_len = png_check_keyword(png_ptr,spalette->name, &new_name))==0) |
return; |
/* Make sure we include the NULL after the name */ |
png_write_chunk_start(png_ptr, png_sPLT, |
(png_uint_32)(name_len + 2 + palette_size)); |
png_write_chunk_data(png_ptr, (png_bytep)new_name, |
(png_size_t)(name_len + 1)); |
png_write_chunk_data(png_ptr, &spalette->depth, (png_size_t)1); |
/* Loop through each palette entry, writing appropriately */ |
#ifdef PNG_POINTER_INDEXING_SUPPORTED |
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, (png_size_t)entry_size); |
} |
#endif |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_name); |
} |
#endif |
#ifdef PNG_WRITE_sBIT_SUPPORTED |
/* Write the sBIT chunk */ |
void /* PRIVATE */ |
png_write_sBIT(png_structp png_ptr, png_const_color_8p sbit, int color_type) |
{ |
PNG_sBIT; |
png_byte buf[4]; |
png_size_t size; |
png_debug(1, "in png_write_sBIT"); |
/* 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_sBIT, buf, size); |
} |
#endif |
#ifdef PNG_WRITE_cHRM_SUPPORTED |
/* Write the cHRM chunk */ |
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) |
{ |
PNG_cHRM; |
png_byte buf[32]; |
png_debug(1, "in png_write_cHRM"); |
/* Each value is saved in 1/100,000ths */ |
#ifdef PNG_CHECK_cHRM_SUPPORTED |
if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y, |
green_x, green_y, blue_x, blue_y)) |
#endif |
{ |
png_save_uint_32(buf, (png_uint_32)white_x); |
png_save_uint_32(buf + 4, (png_uint_32)white_y); |
png_save_uint_32(buf + 8, (png_uint_32)red_x); |
png_save_uint_32(buf + 12, (png_uint_32)red_y); |
png_save_uint_32(buf + 16, (png_uint_32)green_x); |
png_save_uint_32(buf + 20, (png_uint_32)green_y); |
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_cHRM, buf, (png_size_t)32); |
} |
} |
#endif |
#ifdef PNG_WRITE_tRNS_SUPPORTED |
/* Write the tRNS chunk */ |
void /* PRIVATE */ |
png_write_tRNS(png_structp png_ptr, png_const_bytep trans_alpha, |
png_const_color_16p tran, int num_trans, int color_type) |
{ |
PNG_tRNS; |
png_byte buf[6]; |
png_debug(1, "in png_write_tRNS"); |
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_tRNS, trans_alpha, (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_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); |
#ifdef PNG_WRITE_16BIT_SUPPORTED |
if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) |
#else |
if (buf[0] | buf[2] | buf[4]) |
#endif |
{ |
png_warning(png_ptr, |
"Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8"); |
return; |
} |
png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)6); |
} |
else |
{ |
png_warning(png_ptr, "Can't write tRNS with an alpha channel"); |
} |
} |
#endif |
#ifdef PNG_WRITE_bKGD_SUPPORTED |
/* Write the background chunk */ |
void /* PRIVATE */ |
png_write_bKGD(png_structp png_ptr, png_const_color_16p back, int color_type) |
{ |
PNG_bKGD; |
png_byte buf[6]; |
png_debug(1, "in png_write_bKGD"); |
if (color_type == PNG_COLOR_TYPE_PALETTE) |
{ |
if ( |
#ifdef 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_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); |
#ifdef PNG_WRITE_16BIT_SUPPORTED |
if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) |
#else |
if (buf[0] | buf[2] | buf[4]) |
#endif |
{ |
png_warning(png_ptr, |
"Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8"); |
return; |
} |
png_write_chunk(png_ptr, 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_bKGD, buf, (png_size_t)2); |
} |
} |
#endif |
#ifdef PNG_WRITE_hIST_SUPPORTED |
/* Write the histogram */ |
void /* PRIVATE */ |
png_write_hIST(png_structp png_ptr, png_const_uint_16p hist, int num_hist) |
{ |
PNG_hIST; |
int i; |
png_byte buf[3]; |
png_debug(1, "in png_write_hIST"); |
if (num_hist > (int)png_ptr->num_palette) |
{ |
png_debug2(3, "num_hist = %d, num_palette = %d", num_hist, |
png_ptr->num_palette); |
png_warning(png_ptr, "Invalid number of histogram entries specified"); |
return; |
} |
png_write_chunk_start(png_ptr, 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_const_charp key, png_charpp new_key) |
{ |
png_size_t key_len; |
png_const_charp ikp; |
png_charp kp, dp; |
int kflag; |
int kwarn=0; |
png_debug(1, "in png_check_keyword"); |
*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'", key); |
*new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2)); |
if (*new_key == NULL) |
{ |
png_warning(png_ptr, "Out of memory while procesing keyword"); |
return ((png_size_t)0); |
} |
/* Replace non-printing characters with a blank and print a warning */ |
for (ikp = key, dp = *new_key; *ikp != '\0'; ikp++, dp++) |
{ |
if ((png_byte)*ikp < 0x20 || |
((png_byte)*ikp > 0x7E && (png_byte)*ikp < 0xA1)) |
{ |
#ifdef PNG_CONSOLE_IO_SUPPORTED |
char msg[40]; |
png_snprintf(msg, 40, |
"invalid keyword character 0x%02X", (png_byte)*ikp); |
png_warning(png_ptr, msg); |
#else |
png_warning(png_ptr, "invalid character in keyword"); |
#endif |
*dp = ' '; |
} |
else |
{ |
*dp = *ikp; |
} |
} |
*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'", 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); |
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 |
#ifdef PNG_WRITE_tEXt_SUPPORTED |
/* Write a tEXt chunk */ |
void /* PRIVATE */ |
png_write_tEXt(png_structp png_ptr, png_const_charp key, png_const_charp text, |
png_size_t text_len) |
{ |
PNG_tEXt; |
png_size_t key_len; |
png_charp new_key; |
png_debug(1, "in png_write_tEXt"); |
if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0) |
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_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, |
(png_size_t)(key_len + 1)); |
if (text_len) |
png_write_chunk_data(png_ptr, (png_const_bytep)text, |
(png_size_t)text_len); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_key); |
} |
#endif |
#ifdef PNG_WRITE_zTXt_SUPPORTED |
/* Write a compressed text chunk */ |
void /* PRIVATE */ |
png_write_zTXt(png_structp png_ptr, png_const_charp key, png_const_charp text, |
png_size_t text_len, int compression) |
{ |
PNG_zTXt; |
png_size_t key_len; |
png_byte buf; |
png_charp new_key; |
compression_state comp; |
png_debug(1, "in png_write_zTXt"); |
comp.num_output_ptr = 0; |
comp.max_output_ptr = 0; |
comp.output_ptr = NULL; |
comp.input = NULL; |
comp.input_len = 0; |
if ((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0) |
{ |
png_free(png_ptr, new_key); |
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); |
/* 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_zTXt, |
(png_uint_32)(key_len+text_len + 2)); |
/* Write key */ |
png_write_chunk_data(png_ptr, (png_bytep)new_key, |
(png_size_t)(key_len + 1)); |
png_free(png_ptr, new_key); |
buf = (png_byte)compression; |
/* Write compression */ |
png_write_chunk_data(png_ptr, &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 |
#ifdef PNG_WRITE_iTXt_SUPPORTED |
/* Write an iTXt chunk */ |
void /* PRIVATE */ |
png_write_iTXt(png_structp png_ptr, int compression, png_const_charp key, |
png_const_charp lang, png_const_charp lang_key, png_const_charp text) |
{ |
PNG_iTXt; |
png_size_t lang_len, key_len, lang_key_len, text_len; |
png_charp new_lang; |
png_charp new_key = NULL; |
png_byte cbuf[2]; |
compression_state comp; |
png_debug(1, "in png_write_iTXt"); |
comp.num_output_ptr = 0; |
comp.max_output_ptr = 0; |
comp.output_ptr = NULL; |
comp.input = NULL; |
if ((key_len = png_check_keyword(png_ptr, key, &new_key)) == 0) |
return; |
if ((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_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, (png_size_t)(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, (png_size_t)2); |
cbuf[0] = 0; |
png_write_chunk_data(png_ptr, (new_lang ? (png_const_bytep)new_lang : cbuf), |
(png_size_t)(lang_len + 1)); |
png_write_chunk_data(png_ptr, (lang_key ? (png_const_bytep)lang_key : cbuf), |
(png_size_t)(lang_key_len + 1)); |
png_write_compressed_data_out(png_ptr, &comp); |
png_write_chunk_end(png_ptr); |
png_free(png_ptr, new_key); |
png_free(png_ptr, new_lang); |
} |
#endif |
#ifdef 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) |
{ |
PNG_oFFs; |
png_byte buf[9]; |
png_debug(1, "in png_write_oFFs"); |
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_oFFs, buf, (png_size_t)9); |
} |
#endif |
#ifdef 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_const_charp units, |
png_charpp params) |
{ |
PNG_pCAL; |
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)", 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", (int)purpose_len); |
units_len = png_strlen(units) + (nparams == 0 ? 0 : 1); |
png_debug1(3, "pCAL units length = %d", (int)units_len); |
total_len = purpose_len + units_len + 10; |
params_len = (png_uint_32p)png_malloc(png_ptr, |
(png_alloc_size_t)(nparams * png_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", i, |
(unsigned long)params_len[i]); |
total_len += (png_size_t)params_len[i]; |
} |
png_debug1(3, "pCAL total length = %d", (int)total_len); |
png_write_chunk_start(png_ptr, png_pCAL, (png_uint_32)total_len); |
png_write_chunk_data(png_ptr, (png_const_bytep)new_purpose, |
(png_size_t)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_const_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_const_bytep)params[i], |
(png_size_t)params_len[i]); |
} |
png_free(png_ptr, params_len); |
png_write_chunk_end(png_ptr); |
} |
#endif |
#ifdef PNG_WRITE_sCAL_SUPPORTED |
/* Write the sCAL chunk */ |
void /* PRIVATE */ |
png_write_sCAL_s(png_structp png_ptr, int unit, png_const_charp width, |
png_const_charp height) |
{ |
PNG_sCAL; |
png_byte buf[64]; |
png_size_t wlen, hlen, total_len; |
png_debug(1, "in png_write_sCAL_s"); |
wlen = png_strlen(width); |
hlen = png_strlen(height); |
total_len = wlen + hlen + 2; |
if (total_len > 64) |
{ |
png_warning(png_ptr, "Can't write sCAL (buffer too small)"); |
return; |
} |
buf[0] = (png_byte)unit; |
png_memcpy(buf + 1, width, wlen + 1); /* Append the '\0' here */ |
png_memcpy(buf + wlen + 2, height, hlen); /* Do NOT append the '\0' here */ |
png_debug1(3, "sCAL total length = %u", (unsigned int)total_len); |
png_write_chunk(png_ptr, png_sCAL, buf, total_len); |
} |
#endif |
#ifdef 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) |
{ |
PNG_pHYs; |
png_byte buf[9]; |
png_debug(1, "in png_write_pHYs"); |
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_pHYs, buf, (png_size_t)9); |
} |
#endif |
#ifdef 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_const_timep mod_time) |
{ |
PNG_tIME; |
png_byte buf[7]; |
png_debug(1, "in png_write_tIME"); |
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_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_WRITE_INTERLACING_SUPPORTED |
/* 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"); |
buf_size = (png_size_t)(PNG_ROWBYTES( |
png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1); |
/* Set up row buffer */ |
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, |
(png_alloc_size_t)buf_size); |
png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
/* 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_calloc(png_ptr, |
(png_alloc_size_t)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; |
} |
} |
#endif /* PNG_WRITE_FILTER_SUPPORTED */ |
#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_WRITE_INTERLACING_SUPPORTED |
/* 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"); |
/* 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_ROWBYTES(png_ptr->usr_channels* |
png_ptr->usr_bit_depth, png_ptr->width)) + 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); |
png_ptr->zstream.data_type = Z_BINARY; |
} |
#ifdef 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) |
{ |
/* 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}; |
png_debug(1, "in png_do_write_interlace"); |
/* We don't have to do anything on the last pass (6) */ |
if (pass < 6) |
{ |
/* 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 = PNG_ROWBYTES(row_info->pixel_depth, |
row_info->width); |
} |
} |
#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)(-1)) >> 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 best_row; |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
png_bytep prev_row, row_buf; |
png_uint_32 mins, bpp; |
png_byte filter_to_do = png_ptr->do_filter; |
png_size_t row_bytes = row_info->rowbytes; |
#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
int num_p_filters = (int)png_ptr->num_prev_filters; |
#endif |
png_debug(1, "in png_write_find_filter"); |
#ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED |
if (png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS) |
{ |
/* These will never be selected so we need not test them. */ |
filter_to_do &= ~(PNG_FILTER_UP | PNG_FILTER_PAETH); |
} |
#endif |
/* Find out how many bytes offset each pixel is */ |
bpp = (row_info->pixel_depth + 7) >> 3; |
prev_row = png_ptr->prev_row; |
#endif |
best_row = png_ptr->row_buf; |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
row_buf = best_row; |
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_size_t i; |
int v; |
for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++) |
{ |
v = *rp; |
sum += (v < 128) ? v : 256 - v; |
} |
#ifdef 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_size_t 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_size_t i; |
int v; |
#ifdef 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_bytes; |
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; |
} |
#ifdef 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_size_t 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_size_t i; |
int v; |
#ifdef 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; |
} |
#ifdef 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_size_t i; |
int v; |
#ifdef 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; |
} |
#ifdef 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_size_t 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_size_t i; |
int v; |
#ifdef 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; |
} |
#ifdef 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; |
} |
} |
#endif /* PNG_WRITE_FILTER_SUPPORTED */ |
/* Do the actual writing of the filtered row data from the chosen filter. */ |
png_write_filtered_row(png_ptr, best_row); |
#ifdef PNG_WRITE_FILTER_SUPPORTED |
#ifdef 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 |
#endif /* PNG_WRITE_FILTER_SUPPORTED */ |
} |
/* Do the actual writing of a previously filtered row. */ |
void /* PRIVATE */ |
png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row) |
{ |
png_size_t avail; |
png_debug(1, "in png_write_filtered_row"); |
png_debug1(2, "filter = %d", filtered_row[0]); |
/* Set up the zlib input buffer */ |
png_ptr->zstream.next_in = filtered_row; |
png_ptr->zstream.avail_in = 0; |
avail = png_ptr->row_info.rowbytes + 1; |
/* Repeat until we have compressed all the data */ |
do |
{ |
int ret; /* Return of zlib */ |
/* Record the number of bytes available - zlib supports at least 65535 |
* bytes at one step, depending on the size of the zlib type 'uInt', the |
* maximum size zlib can write at once is ZLIB_IO_MAX (from pngpriv.h). |
* Use this because on 16 bit systems 'rowbytes' can be up to 65536 (i.e. |
* one more than 16 bits) and, in this case 'rowbytes+1' can overflow a |
* uInt. ZLIB_IO_MAX can be safely reduced to cause zlib to be called |
* with smaller chunks of data. |
*/ |
if (png_ptr->zstream.avail_in == 0) |
{ |
if (avail > ZLIB_IO_MAX) |
{ |
png_ptr->zstream.avail_in = ZLIB_IO_MAX; |
avail -= ZLIB_IO_MAX; |
} |
else |
{ |
/* So this will fit in the available uInt space: */ |
png_ptr->zstream.avail_in = (uInt)avail; |
avail = 0; |
} |
} |
/* 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 (avail > 0 || png_ptr->zstream.avail_in > 0); |
/* 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); |
#ifdef 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 */ |
/programs/develop/libraries/libpng |
---|
Property changes: |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |