Merge branch 'master' into bit-fields-type
This commit is contained in:
Stephan Mühlstrasser
commit
6c83f1468c
|
|
@ -0,0 +1,17 @@
|
|||
# Ignore files and directories made by `cmake .`.
|
||||
CMakeFiles/
|
||||
Makefile
|
||||
cmake_install.cmake
|
||||
/CMakeCache.txt
|
||||
/CPackConfig.cmake
|
||||
/CPackSourceConfig.cmake
|
||||
/CTestCustom.cmake
|
||||
/LICENSE.txt
|
||||
/OpenJPEGConfig.cmake
|
||||
/libopenjp2.pc
|
||||
/src/bin/common/opj_apps_config.h
|
||||
/src/lib/openjp2/opj_config.h
|
||||
/src/lib/openjp2/opj_config_private.h
|
||||
|
||||
# Ignore directories made by `make`.
|
||||
/bin/
|
||||
10
.travis.yml
10
.travis.yml
|
|
@ -21,6 +21,16 @@ matrix:
|
|||
- os: linux
|
||||
compiler: clang
|
||||
env: OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Debug OPJ_CI_ASAN=1
|
||||
- os: linux
|
||||
compiler: clang-3.8
|
||||
env: OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Release
|
||||
addons:
|
||||
apt:
|
||||
sources:
|
||||
- llvm-toolchain-precise-3.8
|
||||
- ubuntu-toolchain-r-test
|
||||
packages:
|
||||
- clang-3.8
|
||||
- os: linux
|
||||
compiler: x86_64-w64-mingw32-gcc
|
||||
env: OPJ_CI_ARCH=x86_64 OPJ_CI_BUILD_CONFIGURATION=Release
|
||||
|
|
|
|||
|
|
@ -129,16 +129,16 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_tcd_tilecomp_t* tilec, OPJ_UINT32 i, DWT
|
|||
static OPJ_BOOL opj_dwt_encode_procedure( opj_tcd_tilecomp_t * tilec,
|
||||
void (*p_function)(OPJ_INT32 *, OPJ_INT32,OPJ_INT32,OPJ_INT32) );
|
||||
|
||||
static OPJ_UINT32 opj_dwt_max_resolution(opj_tcd_resolution_t* restrict r, OPJ_UINT32 i);
|
||||
static OPJ_UINT32 opj_dwt_max_resolution(opj_tcd_resolution_t* OPJ_RESTRICT r, OPJ_UINT32 i);
|
||||
|
||||
/* <summary> */
|
||||
/* Inverse 9-7 wavelet transform in 1-D. */
|
||||
/* </summary> */
|
||||
static void opj_v4dwt_decode(opj_v4dwt_t* restrict dwt);
|
||||
static void opj_v4dwt_decode(opj_v4dwt_t* OPJ_RESTRICT dwt);
|
||||
|
||||
static void opj_v4dwt_interleave_h(opj_v4dwt_t* restrict w, OPJ_FLOAT32* restrict a, OPJ_INT32 x, OPJ_INT32 size);
|
||||
static void opj_v4dwt_interleave_h(opj_v4dwt_t* OPJ_RESTRICT w, OPJ_FLOAT32* OPJ_RESTRICT a, OPJ_INT32 x, OPJ_INT32 size);
|
||||
|
||||
static void opj_v4dwt_interleave_v(opj_v4dwt_t* restrict v , OPJ_FLOAT32* restrict a , OPJ_INT32 x, OPJ_INT32 nb_elts_read);
|
||||
static void opj_v4dwt_interleave_v(opj_v4dwt_t* OPJ_RESTRICT v , OPJ_FLOAT32* OPJ_RESTRICT a , OPJ_INT32 x, OPJ_INT32 nb_elts_read);
|
||||
|
||||
#ifdef __SSE__
|
||||
static void opj_v4dwt_decode_step1_sse(opj_v4_t* w, OPJ_INT32 count, const __m128 c);
|
||||
|
|
@ -543,7 +543,7 @@ void opj_dwt_calc_explicit_stepsizes(opj_tccp_t * tccp, OPJ_UINT32 prec) {
|
|||
/* <summary> */
|
||||
/* Determine maximum computed resolution level for inverse wavelet transform */
|
||||
/* </summary> */
|
||||
static OPJ_UINT32 opj_dwt_max_resolution(opj_tcd_resolution_t* restrict r, OPJ_UINT32 i) {
|
||||
static OPJ_UINT32 opj_dwt_max_resolution(opj_tcd_resolution_t* OPJ_RESTRICT r, OPJ_UINT32 i) {
|
||||
OPJ_UINT32 mr = 0;
|
||||
OPJ_UINT32 w;
|
||||
while( --i ) {
|
||||
|
|
@ -582,7 +582,7 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_tcd_tilecomp_t* tilec, OPJ_UINT32 numres
|
|||
v.mem = h.mem;
|
||||
|
||||
while( --numres) {
|
||||
OPJ_INT32 * restrict tiledp = tilec->data;
|
||||
OPJ_INT32 * OPJ_RESTRICT tiledp = tilec->data;
|
||||
OPJ_UINT32 j;
|
||||
|
||||
++tr;
|
||||
|
|
@ -617,8 +617,8 @@ static OPJ_BOOL opj_dwt_decode_tile(opj_tcd_tilecomp_t* tilec, OPJ_UINT32 numres
|
|||
return OPJ_TRUE;
|
||||
}
|
||||
|
||||
static void opj_v4dwt_interleave_h(opj_v4dwt_t* restrict w, OPJ_FLOAT32* restrict a, OPJ_INT32 x, OPJ_INT32 size){
|
||||
OPJ_FLOAT32* restrict bi = (OPJ_FLOAT32*) (w->wavelet + w->cas);
|
||||
static void opj_v4dwt_interleave_h(opj_v4dwt_t* OPJ_RESTRICT w, OPJ_FLOAT32* OPJ_RESTRICT a, OPJ_INT32 x, OPJ_INT32 size){
|
||||
OPJ_FLOAT32* OPJ_RESTRICT bi = (OPJ_FLOAT32*) (w->wavelet + w->cas);
|
||||
OPJ_INT32 count = w->sn;
|
||||
OPJ_INT32 i, k;
|
||||
|
||||
|
|
@ -660,8 +660,8 @@ static void opj_v4dwt_interleave_h(opj_v4dwt_t* restrict w, OPJ_FLOAT32* restric
|
|||
}
|
||||
}
|
||||
|
||||
static void opj_v4dwt_interleave_v(opj_v4dwt_t* restrict v , OPJ_FLOAT32* restrict a , OPJ_INT32 x, OPJ_INT32 nb_elts_read){
|
||||
opj_v4_t* restrict bi = v->wavelet + v->cas;
|
||||
static void opj_v4dwt_interleave_v(opj_v4dwt_t* OPJ_RESTRICT v , OPJ_FLOAT32* OPJ_RESTRICT a , OPJ_INT32 x, OPJ_INT32 nb_elts_read){
|
||||
opj_v4_t* OPJ_RESTRICT bi = v->wavelet + v->cas;
|
||||
OPJ_INT32 i;
|
||||
|
||||
for(i = 0; i < v->sn; ++i){
|
||||
|
|
@ -679,7 +679,7 @@ static void opj_v4dwt_interleave_v(opj_v4dwt_t* restrict v , OPJ_FLOAT32* restri
|
|||
#ifdef __SSE__
|
||||
|
||||
static void opj_v4dwt_decode_step1_sse(opj_v4_t* w, OPJ_INT32 count, const __m128 c){
|
||||
__m128* restrict vw = (__m128*) w;
|
||||
__m128* OPJ_RESTRICT vw = (__m128*) w;
|
||||
OPJ_INT32 i;
|
||||
/* 4x unrolled loop */
|
||||
for(i = 0; i < count >> 2; ++i){
|
||||
|
|
@ -700,8 +700,8 @@ static void opj_v4dwt_decode_step1_sse(opj_v4_t* w, OPJ_INT32 count, const __m12
|
|||
}
|
||||
|
||||
void opj_v4dwt_decode_step2_sse(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k, OPJ_INT32 m, __m128 c){
|
||||
__m128* restrict vl = (__m128*) l;
|
||||
__m128* restrict vw = (__m128*) w;
|
||||
__m128* OPJ_RESTRICT vl = (__m128*) l;
|
||||
__m128* OPJ_RESTRICT vw = (__m128*) w;
|
||||
OPJ_INT32 i;
|
||||
__m128 tmp1, tmp2, tmp3;
|
||||
tmp1 = vl[0];
|
||||
|
|
@ -729,7 +729,7 @@ void opj_v4dwt_decode_step2_sse(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k, OPJ_INT32
|
|||
|
||||
static void opj_v4dwt_decode_step1(opj_v4_t* w, OPJ_INT32 count, const OPJ_FLOAT32 c)
|
||||
{
|
||||
OPJ_FLOAT32* restrict fw = (OPJ_FLOAT32*) w;
|
||||
OPJ_FLOAT32* OPJ_RESTRICT fw = (OPJ_FLOAT32*) w;
|
||||
OPJ_INT32 i;
|
||||
for(i = 0; i < count; ++i){
|
||||
OPJ_FLOAT32 tmp1 = fw[i*8 ];
|
||||
|
|
@ -797,7 +797,7 @@ static void opj_v4dwt_decode_step2(opj_v4_t* l, opj_v4_t* w, OPJ_INT32 k, OPJ_IN
|
|||
/* <summary> */
|
||||
/* Inverse 9-7 wavelet transform in 1-D. */
|
||||
/* </summary> */
|
||||
static void opj_v4dwt_decode(opj_v4dwt_t* restrict dwt)
|
||||
static void opj_v4dwt_decode(opj_v4dwt_t* OPJ_RESTRICT dwt)
|
||||
{
|
||||
OPJ_INT32 a, b;
|
||||
if(dwt->cas == 0) {
|
||||
|
|
@ -834,7 +834,7 @@ static void opj_v4dwt_decode(opj_v4dwt_t* restrict dwt)
|
|||
/* <summary> */
|
||||
/* Inverse 9-7 wavelet transform in 2-D. */
|
||||
/* </summary> */
|
||||
OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* restrict tilec, OPJ_UINT32 numres)
|
||||
OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec, OPJ_UINT32 numres)
|
||||
{
|
||||
opj_v4dwt_t h;
|
||||
opj_v4dwt_t v;
|
||||
|
|
@ -854,7 +854,7 @@ OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* restrict tilec, OPJ_UINT32 numr
|
|||
v.wavelet = h.wavelet;
|
||||
|
||||
while( --numres) {
|
||||
OPJ_FLOAT32 * restrict aj = (OPJ_FLOAT32*) tilec->data;
|
||||
OPJ_FLOAT32 * OPJ_RESTRICT aj = (OPJ_FLOAT32*) tilec->data;
|
||||
OPJ_UINT32 bufsize = (OPJ_UINT32)((tilec->x1 - tilec->x0) * (tilec->y1 - tilec->y0));
|
||||
OPJ_INT32 j;
|
||||
|
||||
|
|
|
|||
|
|
@ -93,7 +93,7 @@ Apply an irreversible inverse DWT transform to a component of an image.
|
|||
@param tilec Tile component information (current tile)
|
||||
@param numres Number of resolution levels to decode
|
||||
*/
|
||||
OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* restrict tilec, OPJ_UINT32 numres);
|
||||
OPJ_BOOL opj_dwt_decode_real(opj_tcd_tilecomp_t* OPJ_RESTRICT tilec, OPJ_UINT32 numres);
|
||||
|
||||
/**
|
||||
Get the gain of a subband for the irreversible 9-7 DWT.
|
||||
|
|
|
|||
|
|
@ -8217,8 +8217,14 @@ static OPJ_BOOL opj_j2k_update_image_data (opj_tcd_t * p_tcd, OPJ_BYTE * p_data,
|
|||
|
||||
/* Allocate output component buffer if necessary */
|
||||
if (!l_img_comp_dest->data) {
|
||||
OPJ_SIZE_T l_width = l_img_comp_dest->w;
|
||||
OPJ_SIZE_T l_height = l_img_comp_dest->h;
|
||||
|
||||
l_img_comp_dest->data = (OPJ_INT32*) opj_calloc((OPJ_SIZE_T)l_img_comp_dest->w * (OPJ_SIZE_T)l_img_comp_dest->h, sizeof(OPJ_INT32));
|
||||
if ((l_height == 0U) || (l_width > (SIZE_MAX / l_height))) {
|
||||
/* would overflow */
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
l_img_comp_dest->data = (OPJ_INT32*) opj_calloc(l_width * l_height, sizeof(OPJ_INT32));
|
||||
if (! l_img_comp_dest->data) {
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -552,6 +552,11 @@ static OPJ_BOOL opj_jp2_read_ihdr( opj_jp2_t *jp2,
|
|||
assert(jp2 != 00);
|
||||
assert(p_manager != 00);
|
||||
|
||||
if (jp2->comps != NULL) {
|
||||
opj_event_msg(p_manager, EVT_WARNING, "Ignoring ihdr box. First ihdr box already read\n");
|
||||
return OPJ_TRUE;
|
||||
}
|
||||
|
||||
if (p_image_header_size != 14) {
|
||||
opj_event_msg(p_manager, EVT_ERROR, "Bad image header box (bad size)\n");
|
||||
return OPJ_FALSE;
|
||||
|
|
@ -564,6 +569,11 @@ static OPJ_BOOL opj_jp2_read_ihdr( opj_jp2_t *jp2,
|
|||
opj_read_bytes(p_image_header_data,&(jp2->numcomps),2); /* NC */
|
||||
p_image_header_data += 2;
|
||||
|
||||
if ((jp2->numcomps - 1U) >= 16384U) { /* unsigned underflow is well defined: 1U <= jp2->numcomps <= 16384U */
|
||||
opj_event_msg(p_manager, EVT_ERROR, "Invalid number of components (ihdr)\n");
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
||||
/* allocate memory for components */
|
||||
jp2->comps = (opj_jp2_comps_t*) opj_calloc(jp2->numcomps, sizeof(opj_jp2_comps_t));
|
||||
if (jp2->comps == 0) {
|
||||
|
|
@ -1810,7 +1820,6 @@ OPJ_BOOL opj_jp2_setup_encoder( opj_jp2_t *jp2,
|
|||
jp2->numcl = 1;
|
||||
jp2->cl = (OPJ_UINT32*) opj_malloc(jp2->numcl * sizeof(OPJ_UINT32));
|
||||
if (!jp2->cl){
|
||||
jp2->cl = NULL;
|
||||
opj_event_msg(p_manager, EVT_ERROR, "Not enough memory when setup the JP2 encoder\n");
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
|
|
@ -1821,7 +1830,6 @@ OPJ_BOOL opj_jp2_setup_encoder( opj_jp2_t *jp2,
|
|||
jp2->numcomps = image->numcomps; /* NC */
|
||||
jp2->comps = (opj_jp2_comps_t*) opj_malloc(jp2->numcomps * sizeof(opj_jp2_comps_t));
|
||||
if (!jp2->comps) {
|
||||
jp2->comps = NULL;
|
||||
opj_event_msg(p_manager, EVT_ERROR, "Not enough memory when setup the JP2 encoder\n");
|
||||
/* Memory of jp2->cl will be freed by opj_jp2_destroy */
|
||||
return OPJ_FALSE;
|
||||
|
|
|
|||
|
|
@ -74,9 +74,9 @@ const OPJ_FLOAT64 * opj_mct_get_mct_norms_real ()
|
|||
/* </summary> */
|
||||
#ifdef __SSE2__
|
||||
void opj_mct_encode(
|
||||
OPJ_INT32* restrict c0,
|
||||
OPJ_INT32* restrict c1,
|
||||
OPJ_INT32* restrict c2,
|
||||
OPJ_INT32* OPJ_RESTRICT c0,
|
||||
OPJ_INT32* OPJ_RESTRICT c1,
|
||||
OPJ_INT32* OPJ_RESTRICT c2,
|
||||
OPJ_UINT32 n)
|
||||
{
|
||||
OPJ_SIZE_T i;
|
||||
|
|
@ -116,9 +116,9 @@ void opj_mct_encode(
|
|||
}
|
||||
#else
|
||||
void opj_mct_encode(
|
||||
OPJ_INT32* restrict c0,
|
||||
OPJ_INT32* restrict c1,
|
||||
OPJ_INT32* restrict c2,
|
||||
OPJ_INT32* OPJ_RESTRICT c0,
|
||||
OPJ_INT32* OPJ_RESTRICT c1,
|
||||
OPJ_INT32* OPJ_RESTRICT c2,
|
||||
OPJ_UINT32 n)
|
||||
{
|
||||
OPJ_SIZE_T i;
|
||||
|
|
@ -143,9 +143,9 @@ void opj_mct_encode(
|
|||
/* </summary> */
|
||||
#ifdef __SSE2__
|
||||
void opj_mct_decode(
|
||||
OPJ_INT32* restrict c0,
|
||||
OPJ_INT32* restrict c1,
|
||||
OPJ_INT32* restrict c2,
|
||||
OPJ_INT32* OPJ_RESTRICT c0,
|
||||
OPJ_INT32* OPJ_RESTRICT c1,
|
||||
OPJ_INT32* OPJ_RESTRICT c2,
|
||||
OPJ_UINT32 n)
|
||||
{
|
||||
OPJ_SIZE_T i;
|
||||
|
|
@ -178,9 +178,9 @@ void opj_mct_decode(
|
|||
}
|
||||
#else
|
||||
void opj_mct_decode(
|
||||
OPJ_INT32* restrict c0,
|
||||
OPJ_INT32* restrict c1,
|
||||
OPJ_INT32* restrict c2,
|
||||
OPJ_INT32* OPJ_RESTRICT c0,
|
||||
OPJ_INT32* OPJ_RESTRICT c1,
|
||||
OPJ_INT32* OPJ_RESTRICT c2,
|
||||
OPJ_UINT32 n)
|
||||
{
|
||||
OPJ_UINT32 i;
|
||||
|
|
@ -210,9 +210,9 @@ OPJ_FLOAT64 opj_mct_getnorm(OPJ_UINT32 compno) {
|
|||
/* </summary> */
|
||||
#ifdef __SSE4_1__
|
||||
void opj_mct_encode_real(
|
||||
OPJ_INT32* restrict c0,
|
||||
OPJ_INT32* restrict c1,
|
||||
OPJ_INT32* restrict c2,
|
||||
OPJ_INT32* OPJ_RESTRICT c0,
|
||||
OPJ_INT32* OPJ_RESTRICT c1,
|
||||
OPJ_INT32* OPJ_RESTRICT c2,
|
||||
OPJ_UINT32 n)
|
||||
{
|
||||
OPJ_SIZE_T i;
|
||||
|
|
@ -351,9 +351,9 @@ void opj_mct_encode_real(
|
|||
}
|
||||
#else
|
||||
void opj_mct_encode_real(
|
||||
OPJ_INT32* restrict c0,
|
||||
OPJ_INT32* restrict c1,
|
||||
OPJ_INT32* restrict c2,
|
||||
OPJ_INT32* OPJ_RESTRICT c0,
|
||||
OPJ_INT32* OPJ_RESTRICT c1,
|
||||
OPJ_INT32* OPJ_RESTRICT c2,
|
||||
OPJ_UINT32 n)
|
||||
{
|
||||
OPJ_UINT32 i;
|
||||
|
|
@ -375,9 +375,9 @@ void opj_mct_encode_real(
|
|||
/* Inverse irreversible MCT. */
|
||||
/* </summary> */
|
||||
void opj_mct_decode_real(
|
||||
OPJ_FLOAT32* restrict c0,
|
||||
OPJ_FLOAT32* restrict c1,
|
||||
OPJ_FLOAT32* restrict c2,
|
||||
OPJ_FLOAT32* OPJ_RESTRICT c0,
|
||||
OPJ_FLOAT32* OPJ_RESTRICT c1,
|
||||
OPJ_FLOAT32* OPJ_RESTRICT c2,
|
||||
OPJ_UINT32 n)
|
||||
{
|
||||
OPJ_UINT32 i;
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ Apply a reversible multi-component transform to an image
|
|||
@param c2 Samples blue component
|
||||
@param n Number of samples for each component
|
||||
*/
|
||||
void opj_mct_encode(OPJ_INT32 *c0, OPJ_INT32 *c1, OPJ_INT32 *c2, OPJ_UINT32 n);
|
||||
void opj_mct_encode(OPJ_INT32* OPJ_RESTRICT c0, OPJ_INT32* OPJ_RESTRICT c1, OPJ_INT32* OPJ_RESTRICT c2, OPJ_UINT32 n);
|
||||
/**
|
||||
Apply a reversible multi-component inverse transform to an image
|
||||
@param c0 Samples for luminance component
|
||||
|
|
@ -68,7 +68,7 @@ Apply a reversible multi-component inverse transform to an image
|
|||
@param c2 Samples for blue chrominance component
|
||||
@param n Number of samples for each component
|
||||
*/
|
||||
void opj_mct_decode(OPJ_INT32 *c0, OPJ_INT32 *c1, OPJ_INT32 *c2, OPJ_UINT32 n);
|
||||
void opj_mct_decode(OPJ_INT32* OPJ_RESTRICT c0, OPJ_INT32* OPJ_RESTRICT c1, OPJ_INT32* OPJ_RESTRICT c2, OPJ_UINT32 n);
|
||||
/**
|
||||
Get norm of the basis function used for the reversible multi-component transform
|
||||
@param compno Number of the component (0->Y, 1->U, 2->V)
|
||||
|
|
@ -83,7 +83,7 @@ Apply an irreversible multi-component transform to an image
|
|||
@param c2 Samples blue component
|
||||
@param n Number of samples for each component
|
||||
*/
|
||||
void opj_mct_encode_real(OPJ_INT32 *c0, OPJ_INT32 *c1, OPJ_INT32 *c2, OPJ_UINT32 n);
|
||||
void opj_mct_encode_real(OPJ_INT32* OPJ_RESTRICT c0, OPJ_INT32* OPJ_RESTRICT c1, OPJ_INT32* OPJ_RESTRICT c2, OPJ_UINT32 n);
|
||||
/**
|
||||
Apply an irreversible multi-component inverse transform to an image
|
||||
@param c0 Samples for luminance component
|
||||
|
|
@ -91,7 +91,7 @@ Apply an irreversible multi-component inverse transform to an image
|
|||
@param c2 Samples for blue chrominance component
|
||||
@param n Number of samples for each component
|
||||
*/
|
||||
void opj_mct_decode_real(OPJ_FLOAT32* c0, OPJ_FLOAT32* c1, OPJ_FLOAT32* c2, OPJ_UINT32 n);
|
||||
void opj_mct_decode_real(OPJ_FLOAT32* OPJ_RESTRICT c0, OPJ_FLOAT32* OPJ_RESTRICT c1, OPJ_FLOAT32* OPJ_RESTRICT c2, OPJ_UINT32 n);
|
||||
/**
|
||||
Get norm of the basis function used for the irreversible multi-component transform
|
||||
@param compno Number of the component (0->Y, 1->U, 2->V)
|
||||
|
|
|
|||
|
|
@ -103,12 +103,21 @@
|
|||
*/
|
||||
|
||||
/* Are restricted pointers available? (C99) */
|
||||
#if (__STDC_VERSION__ != 199901L)
|
||||
/* Not a C99 compiler */
|
||||
#ifdef __GNUC__
|
||||
#define restrict __restrict__
|
||||
#if (__STDC_VERSION__ >= 199901L)
|
||||
#define OPJ_RESTRICT restrict
|
||||
#else
|
||||
#define restrict /* restrict */
|
||||
/* Not a C99 compiler */
|
||||
#if defined(__GNUC__)
|
||||
#define OPJ_RESTRICT __restrict__
|
||||
|
||||
/*
|
||||
vc14 (2015) outputs wrong results.
|
||||
Need to check OPJ_RESTRICT usage (or a bug in vc14)
|
||||
#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
|
||||
#define OPJ_RESTRICT __restrict
|
||||
*/
|
||||
#else
|
||||
#define OPJ_RESTRICT /* restrict */
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -1237,7 +1237,13 @@ opj_pi_iterator_t *opj_pi_create_decode(opj_image_t *p_image,
|
|||
l_current_pi = l_pi;
|
||||
|
||||
/* memory allocation for include */
|
||||
/* prevent an integer overflow issue */
|
||||
l_current_pi->include = 00;
|
||||
if (l_step_l <= (SIZE_MAX / (l_tcp->numlayers + 1U)))
|
||||
{
|
||||
l_current_pi->include = (OPJ_INT16*) opj_calloc((l_tcp->numlayers +1) * l_step_l, sizeof(OPJ_INT16));
|
||||
}
|
||||
|
||||
if
|
||||
(!l_current_pi->include)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1283,14 +1283,14 @@ OPJ_BOOL opj_t1_decode_cblks( opj_t1_t* t1,
|
|||
opj_tcd_resolution_t* res = &tilec->resolutions[resno];
|
||||
|
||||
for (bandno = 0; bandno < res->numbands; ++bandno) {
|
||||
opj_tcd_band_t* restrict band = &res->bands[bandno];
|
||||
opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
|
||||
|
||||
for (precno = 0; precno < res->pw * res->ph; ++precno) {
|
||||
opj_tcd_precinct_t* precinct = &band->precincts[precno];
|
||||
|
||||
for (cblkno = 0; cblkno < precinct->cw * precinct->ch; ++cblkno) {
|
||||
opj_tcd_cblk_dec_t* cblk = &precinct->cblks.dec[cblkno];
|
||||
OPJ_INT32* restrict datap;
|
||||
OPJ_INT32* OPJ_RESTRICT datap;
|
||||
OPJ_UINT32 cblk_w, cblk_h;
|
||||
OPJ_INT32 x, y;
|
||||
OPJ_UINT32 i, j;
|
||||
|
|
@ -1333,7 +1333,7 @@ OPJ_BOOL opj_t1_decode_cblks( opj_t1_t* t1,
|
|||
}
|
||||
}
|
||||
if (tccp->qmfbid == 1) {
|
||||
OPJ_INT32* restrict tiledp = &tilec->data[(OPJ_UINT32)y * tile_w + (OPJ_UINT32)x];
|
||||
OPJ_INT32* OPJ_RESTRICT tiledp = &tilec->data[(OPJ_UINT32)y * tile_w + (OPJ_UINT32)x];
|
||||
for (j = 0; j < cblk_h; ++j) {
|
||||
for (i = 0; i < cblk_w; ++i) {
|
||||
OPJ_INT32 tmp = datap[(j * cblk_w) + i];
|
||||
|
|
@ -1341,9 +1341,9 @@ OPJ_BOOL opj_t1_decode_cblks( opj_t1_t* t1,
|
|||
}
|
||||
}
|
||||
} else { /* if (tccp->qmfbid == 0) */
|
||||
OPJ_FLOAT32* restrict tiledp = (OPJ_FLOAT32*) &tilec->data[(OPJ_UINT32)y * tile_w + (OPJ_UINT32)x];
|
||||
OPJ_FLOAT32* OPJ_RESTRICT tiledp = (OPJ_FLOAT32*) &tilec->data[(OPJ_UINT32)y * tile_w + (OPJ_UINT32)x];
|
||||
for (j = 0; j < cblk_h; ++j) {
|
||||
OPJ_FLOAT32* restrict tiledp2 = tiledp;
|
||||
OPJ_FLOAT32* OPJ_RESTRICT tiledp2 = tiledp;
|
||||
for (i = 0; i < cblk_w; ++i) {
|
||||
OPJ_FLOAT32 tmp = (OPJ_FLOAT32)*datap * band->stepsize;
|
||||
*tiledp2 = tmp;
|
||||
|
|
@ -1475,7 +1475,7 @@ OPJ_BOOL opj_t1_encode_cblks( opj_t1_t *t1,
|
|||
opj_tcd_resolution_t *res = &tilec->resolutions[resno];
|
||||
|
||||
for (bandno = 0; bandno < res->numbands; ++bandno) {
|
||||
opj_tcd_band_t* restrict band = &res->bands[bandno];
|
||||
opj_tcd_band_t* OPJ_RESTRICT band = &res->bands[bandno];
|
||||
OPJ_INT32 bandconst = 8192 * 8192 / ((OPJ_INT32) floor(band->stepsize * 8192));
|
||||
|
||||
for (precno = 0; precno < res->pw * res->ph; ++precno) {
|
||||
|
|
@ -1483,7 +1483,7 @@ OPJ_BOOL opj_t1_encode_cblks( opj_t1_t *t1,
|
|||
|
||||
for (cblkno = 0; cblkno < prc->cw * prc->ch; ++cblkno) {
|
||||
opj_tcd_cblk_enc_t* cblk = &prc->cblks.enc[cblkno];
|
||||
OPJ_INT32* restrict tiledp;
|
||||
OPJ_INT32* OPJ_RESTRICT tiledp;
|
||||
OPJ_UINT32 cblk_w;
|
||||
OPJ_UINT32 cblk_h;
|
||||
OPJ_UINT32 i, j, tileIndex=0, tileLineAdvance;
|
||||
|
|
|
|||
|
|
@ -808,12 +808,22 @@ static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no,
|
|||
l_br_prc_y_end = opj_int_ceildivpow2(l_res->y1, (OPJ_INT32)l_pdy) << l_pdy;
|
||||
/*fprintf(stderr, "\t\t\tprc_x_start=%d, prc_y_start=%d, br_prc_x_end=%d, br_prc_y_end=%d \n", l_tl_prc_x_start, l_tl_prc_y_start, l_br_prc_x_end ,l_br_prc_y_end );*/
|
||||
|
||||
l_res->pw = (l_res->x0 == l_res->x1) ? 0 : (OPJ_UINT32)((l_br_prc_x_end - l_tl_prc_x_start) >> l_pdx);
|
||||
l_res->ph = (l_res->y0 == l_res->y1) ? 0 : (OPJ_UINT32)((l_br_prc_y_end - l_tl_prc_y_start) >> l_pdy);
|
||||
l_res->pw = (l_res->x0 == l_res->x1) ? 0U : (OPJ_UINT32)((l_br_prc_x_end - l_tl_prc_x_start) >> l_pdx);
|
||||
l_res->ph = (l_res->y0 == l_res->y1) ? 0U : (OPJ_UINT32)((l_br_prc_y_end - l_tl_prc_y_start) >> l_pdy);
|
||||
/*fprintf(stderr, "\t\t\tres_pw=%d, res_ph=%d\n", l_res->pw, l_res->ph );*/
|
||||
|
||||
if ((l_res->pw != 0U) && ((((OPJ_UINT32)-1) / l_res->pw) < l_res->ph)) {
|
||||
opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n");
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
l_nb_precincts = l_res->pw * l_res->ph;
|
||||
|
||||
if ((((OPJ_UINT32)-1) / (OPJ_UINT32)sizeof(opj_tcd_precinct_t)) < l_nb_precincts) {
|
||||
opj_event_msg(manager, EVT_ERROR, "Not enough memory for tile data\n");
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
l_nb_precinct_size = l_nb_precincts * (OPJ_UINT32)sizeof(opj_tcd_precinct_t);
|
||||
|
||||
if (resno == 0) {
|
||||
tlcbgxstart = l_tl_prc_x_start;
|
||||
tlcbgystart = l_tl_prc_y_start;
|
||||
|
|
@ -870,6 +880,7 @@ static INLINE OPJ_BOOL opj_tcd_init_tile(opj_tcd_t *p_tcd, OPJ_UINT32 p_tile_no,
|
|||
if (!l_band->precincts && (l_nb_precincts > 0U)) {
|
||||
l_band->precincts = (opj_tcd_precinct_t *) opj_malloc( /*3 * */ l_nb_precinct_size);
|
||||
if (! l_band->precincts) {
|
||||
opj_event_msg(manager, EVT_ERROR, "Not enough memory to handle band precints\n");
|
||||
return OPJ_FALSE;
|
||||
}
|
||||
/*fprintf(stderr, "\t\t\t\tAllocate precincts of a band (opj_tcd_precinct_t): %d\n",l_nb_precinct_size); */
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@
|
|||
//
|
||||
//---------------------------------------------------------------------------------
|
||||
//
|
||||
// Version 2.8beta0
|
||||
// Version 2.8
|
||||
//
|
||||
|
||||
#ifndef _lcms2_H
|
||||
|
|
@ -656,7 +656,7 @@ typedef void* cmsHTRANSFORM;
|
|||
// T: Pixeltype
|
||||
// F: Flavor 0=MinIsBlack(Chocolate) 1=MinIsWhite(Vanilla)
|
||||
// P: Planar? 0=Chunky, 1=Planar
|
||||
// X: swap 16 bps endianess?
|
||||
// X: swap 16 bps endianness?
|
||||
// S: Do swap? ie, BGR, KYMC
|
||||
// E: Extra samples
|
||||
// C: Channels (Samples per pixel)
|
||||
|
|
@ -1016,7 +1016,7 @@ CMSAPI long int CMSEXPORT cmsfilelength(FILE* f);
|
|||
// Context handling --------------------------------------------------------------------------------------------------------
|
||||
|
||||
// Each context holds its owns globals and its own plug-ins. There is a global context with the id = 0 for lecacy compatibility
|
||||
// though using the global context is not recomended. Proper context handling makes lcms more thread-safe.
|
||||
// though using the global context is not recommended. Proper context handling makes lcms more thread-safe.
|
||||
|
||||
typedef struct _cmsContext_struct* cmsContext;
|
||||
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ struct _cms_io_handler {
|
|||
const void* Buffer);
|
||||
};
|
||||
|
||||
// Endianess adjust functions
|
||||
// Endianness adjust functions
|
||||
CMSAPI cmsUInt16Number CMSEXPORT _cmsAdjustEndianess16(cmsUInt16Number Word);
|
||||
CMSAPI cmsUInt32Number CMSEXPORT _cmsAdjustEndianess32(cmsUInt32Number Value);
|
||||
CMSAPI void CMSEXPORT _cmsAdjustEndianess64(cmsUInt64Number* Result, cmsUInt64Number* QWord);
|
||||
|
|
|
|||
|
|
@ -413,17 +413,12 @@ void _cmsHandleExtraChannels(_cmsTRANSFORM* p, const void* in,
|
|||
cmsUInt32Number LineCount,
|
||||
const cmsStride* Stride)
|
||||
{
|
||||
size_t i, j, k;
|
||||
cmsUInt32Number i, j, k;
|
||||
cmsUInt32Number nExtra;
|
||||
cmsUInt32Number SourceStartingOrder[cmsMAXCHANNELS];
|
||||
cmsUInt32Number SourceIncrements[cmsMAXCHANNELS];
|
||||
cmsUInt32Number DestStartingOrder[cmsMAXCHANNELS];
|
||||
cmsUInt32Number DestIncrements[cmsMAXCHANNELS];
|
||||
cmsUInt32Number SourceStrideIncrements[cmsMAXCHANNELS];
|
||||
cmsUInt32Number DestStrideIncrements[cmsMAXCHANNELS];
|
||||
|
||||
cmsUInt8Number* SourcePtr[cmsMAXCHANNELS];
|
||||
cmsUInt8Number* DestPtr[cmsMAXCHANNELS];
|
||||
|
||||
cmsFormatterAlphaFn copyValueFn;
|
||||
|
||||
|
|
@ -431,6 +426,10 @@ void _cmsHandleExtraChannels(_cmsTRANSFORM* p, const void* in,
|
|||
if (!(p->dwOriginalFlags & cmsFLAGS_COPY_ALPHA))
|
||||
return;
|
||||
|
||||
// Exit early if in-place color-management is occurring - no need to copy extra channels to themselves.
|
||||
if (p->InputFormat == p->OutputFormat && in == out)
|
||||
return;
|
||||
|
||||
// Make sure we have same number of alpha channels. If not, just return as this should be checked at transform creation time.
|
||||
nExtra = T_EXTRA(p->InputFormat);
|
||||
if (nExtra != T_EXTRA(p->OutputFormat))
|
||||
|
|
@ -447,6 +446,42 @@ void _cmsHandleExtraChannels(_cmsTRANSFORM* p, const void* in,
|
|||
// Check for conversions 8, 16, half, float, dbl
|
||||
copyValueFn = _cmsGetFormatterAlpha(p->ContextID, p->InputFormat, p->OutputFormat);
|
||||
|
||||
if (nExtra == 1) { // Optimized routine for copying a single extra channel quickly
|
||||
|
||||
cmsUInt8Number* SourcePtr;
|
||||
cmsUInt8Number* DestPtr;
|
||||
|
||||
cmsUInt32Number SourceStrideIncrement = 0;
|
||||
cmsUInt32Number DestStrideIncrement = 0;
|
||||
|
||||
// The loop itself
|
||||
for (i = 0; i < LineCount; i++) {
|
||||
|
||||
// Prepare pointers for the loop
|
||||
SourcePtr = (cmsUInt8Number*)in + SourceStartingOrder[0] + SourceStrideIncrement;
|
||||
DestPtr = (cmsUInt8Number*)out + DestStartingOrder[0] + DestStrideIncrement;
|
||||
|
||||
for (j = 0; j < PixelsPerLine; j++) {
|
||||
|
||||
copyValueFn(DestPtr, SourcePtr);
|
||||
|
||||
SourcePtr += SourceIncrements[0];
|
||||
DestPtr += DestIncrements[0];
|
||||
}
|
||||
|
||||
SourceStrideIncrement += Stride->BytesPerLineIn;
|
||||
DestStrideIncrement += Stride->BytesPerLineOut;
|
||||
}
|
||||
|
||||
}
|
||||
else { // General case with more than one extra channel
|
||||
|
||||
cmsUInt8Number* SourcePtr[cmsMAXCHANNELS];
|
||||
cmsUInt8Number* DestPtr[cmsMAXCHANNELS];
|
||||
|
||||
cmsUInt32Number SourceStrideIncrements[cmsMAXCHANNELS];
|
||||
cmsUInt32Number DestStrideIncrements[cmsMAXCHANNELS];
|
||||
|
||||
memset(SourceStrideIncrements, 0, sizeof(SourceStrideIncrements));
|
||||
memset(DestStrideIncrements, 0, sizeof(DestStrideIncrements));
|
||||
|
||||
|
|
@ -478,4 +513,6 @@ void _cmsHandleExtraChannels(_cmsTRANSFORM* p, const void* in,
|
|||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -596,7 +596,7 @@ void ReadReal(cmsIT8* it8, int inum)
|
|||
}
|
||||
|
||||
// Parses a float number
|
||||
// This can not call directly atof because it uses locale dependant
|
||||
// This can not call directly atof because it uses locale dependent
|
||||
// parsing, while CCMX files always use . as decimal separator
|
||||
static
|
||||
cmsFloat64Number ParseFloatNumber(const char *Buffer)
|
||||
|
|
@ -1817,7 +1817,7 @@ cmsBool CMSEXPORT cmsIT8SaveToMem(cmsHANDLE hIT8, void *MemPtr, cmsUInt32Number*
|
|||
}
|
||||
|
||||
|
||||
// -------------------------------------------------------------- Higer level parsing
|
||||
// -------------------------------------------------------------- Higher level parsing
|
||||
|
||||
static
|
||||
cmsBool DataFormatSection(cmsIT8* it8)
|
||||
|
|
@ -2120,7 +2120,7 @@ cmsBool ParseIT8(cmsIT8* it8, cmsBool nosheet)
|
|||
|
||||
|
||||
|
||||
// Init usefull pointers
|
||||
// Init useful pointers
|
||||
|
||||
static
|
||||
void CookPointers(cmsIT8* it8)
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ static cmsIntentsList DefaultIntents[] = {
|
|||
};
|
||||
|
||||
|
||||
// A pointer to the begining of the list
|
||||
// A pointer to the beginning of the list
|
||||
_cmsIntentsPluginChunkType _cmsIntentsPluginChunk = { NULL };
|
||||
|
||||
// Duplicates the zone of memory used by the plug-in in the new context
|
||||
|
|
@ -889,7 +889,7 @@ int BlackPreservingSampler(register const cmsUInt16Number In[], register cmsUInt
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
// Make sure to pass thru K (which now is fixed)
|
||||
// Make sure to pass through K (which now is fixed)
|
||||
Outf[3] = LabK[3];
|
||||
|
||||
// Apply TAC if needed
|
||||
|
|
@ -957,7 +957,7 @@ cmsPipeline* BlackPreservingKPlaneIntents(cmsContext ContextID,
|
|||
memset(&bp, 0, sizeof(bp));
|
||||
|
||||
// We need the input LUT of the last profile, assuming this one is responsible of
|
||||
// black generation. This LUT will be seached in inverse order.
|
||||
// black generation. This LUT will be searched in inverse order.
|
||||
bp.LabK2cmyk = _cmsReadInputLUT(hProfiles[nProfiles-1], INTENT_RELATIVE_COLORIMETRIC);
|
||||
if (bp.LabK2cmyk == NULL) goto Cleanup;
|
||||
|
||||
|
|
|
|||
|
|
@ -198,7 +198,7 @@ void _cmsAllocMemPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsCo
|
|||
}
|
||||
}
|
||||
|
||||
// Auxiliar to fill memory management functions from plugin (or context 0 defaults)
|
||||
// Auxiliary to fill memory management functions from plugin (or context 0 defaults)
|
||||
void _cmsInstallAllocFunctions(cmsPluginMemHandler* Plugin, _cmsMemPluginChunkType* ptr)
|
||||
{
|
||||
if (Plugin == NULL) {
|
||||
|
|
@ -430,14 +430,14 @@ void* _cmsSubAllocDup(_cmsSubAllocator* s, const void *ptr, cmsUInt32Number size
|
|||
|
||||
// Error logging ******************************************************************
|
||||
|
||||
// There is no error handling at all. When a funtion fails, it returns proper value.
|
||||
// There is no error handling at all. When a function fails, it returns proper value.
|
||||
// For example, all create functions does return NULL on failure. Other return FALSE
|
||||
// It may be interesting, for the developer, to know why the function is failing.
|
||||
// for that reason, lcms2 does offer a logging function. This function does recive
|
||||
// a ENGLISH string with some clues on what is going wrong. You can show this
|
||||
// info to the end user, or just create some sort of log.
|
||||
// The logging function should NOT terminate the program, as this obviously can leave
|
||||
// resources. It is the programmer's responsability to check each function return code
|
||||
// resources. It is the programmer's responsibility to check each function return code
|
||||
// to make sure it didn't fail.
|
||||
|
||||
// Error messages are limited to MAX_ERROR_MESSAGE_LEN
|
||||
|
|
|
|||
|
|
@ -567,7 +567,7 @@ cmsFloat64Number DefaultEvalParametricFn(cmsInt32Number Type, const cmsFloat64Nu
|
|||
return Val;
|
||||
}
|
||||
|
||||
// Evaluate a segmented funtion for a single value. Return -1 if no valid segment found .
|
||||
// Evaluate a segmented function for a single value. Return -1 if no valid segment found .
|
||||
// If fn type is 0, perform an interpolation on the table
|
||||
static
|
||||
cmsFloat64Number EvalSegmentedFn(const cmsToneCurve *g, cmsFloat64Number R)
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@
|
|||
#include "lcms2_internal.h"
|
||||
|
||||
|
||||
// Auxiliar: append a Lab identity after the given sequence of profiles
|
||||
// Auxiliary: append a Lab identity after the given sequence of profiles
|
||||
// and return the transform. Lab profile is closed, rest of profiles are kept open.
|
||||
cmsHTRANSFORM _cmsChain2Lab(cmsContext ContextID,
|
||||
cmsUInt32Number nProfiles,
|
||||
|
|
@ -172,7 +172,7 @@ cmsToneCurve* _cmsBuildKToneCurve(cmsContext ContextID,
|
|||
}
|
||||
|
||||
// Build the relationship. This effectively limits the maximum accuracy to 16 bits, but
|
||||
// since this is used on black-preserving LUTs, we are not loosing accuracy in any case
|
||||
// since this is used on black-preserving LUTs, we are not losing accuracy in any case
|
||||
KTone = cmsJoinToneCurve(ContextID, in, out, nPoints);
|
||||
|
||||
// Get rid of components
|
||||
|
|
@ -278,7 +278,7 @@ int GamutSampler(register const cmsUInt16Number In[], register cmsUInt16Number O
|
|||
}
|
||||
|
||||
// Does compute a gamut LUT going back and forth across pcs -> relativ. colorimetric intent -> pcs
|
||||
// the dE obtained is then annotated on the LUT. Values truely out of gamut are clipped to dE = 0xFFFE
|
||||
// the dE obtained is then annotated on the LUT. Values truly out of gamut are clipped to dE = 0xFFFE
|
||||
// and values changed are supposed to be handled by any gamut remapping, so, are out of gamut as well.
|
||||
//
|
||||
// **WARNING: This algorithm does assume that gamut remapping algorithms does NOT move in-gamut colors,
|
||||
|
|
|
|||
|
|
@ -156,7 +156,7 @@ cmsInterpParams* _cmsComputeInterpParams(cmsContext ContextID, int nSamples, int
|
|||
int i;
|
||||
cmsUInt32Number Samples[MAX_INPUT_DIMENSIONS];
|
||||
|
||||
// Fill the auxiliar array
|
||||
// Fill the auxiliary array
|
||||
for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
|
||||
Samples[i] = nSamples;
|
||||
|
||||
|
|
|
|||
|
|
@ -324,7 +324,7 @@ cmsUInt32Number FileRead(cmsIOHANDLER* iohandler, void *Buffer, cmsUInt32Number
|
|||
return nReaded;
|
||||
}
|
||||
|
||||
// Postion file pointer in the file
|
||||
// Position file pointer in the file
|
||||
static
|
||||
cmsBool FileSeek(cmsIOHANDLER* iohandler, cmsUInt32Number offset)
|
||||
{
|
||||
|
|
@ -368,6 +368,7 @@ cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromFile(cmsContext ContextID, const cha
|
|||
{
|
||||
cmsIOHANDLER* iohandler = NULL;
|
||||
FILE* fm = NULL;
|
||||
cmsInt32Number fileLen;
|
||||
|
||||
_cmsAssert(FileName != NULL);
|
||||
_cmsAssert(AccessMode != NULL);
|
||||
|
|
@ -384,7 +385,16 @@ cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromFile(cmsContext ContextID, const cha
|
|||
cmsSignalError(ContextID, cmsERROR_FILE, "File '%s' not found", FileName);
|
||||
return NULL;
|
||||
}
|
||||
iohandler -> ReportedSize = (cmsUInt32Number) cmsfilelength(fm);
|
||||
fileLen = cmsfilelength(fm);
|
||||
if (fileLen < 0)
|
||||
{
|
||||
fclose(fm);
|
||||
_cmsFree(ContextID, iohandler);
|
||||
cmsSignalError(ContextID, cmsERROR_FILE, "Cannot get size of file '%s'", FileName);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
iohandler -> ReportedSize = (cmsUInt32Number) fileLen;
|
||||
break;
|
||||
|
||||
case 'w':
|
||||
|
|
@ -424,6 +434,14 @@ cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromFile(cmsContext ContextID, const cha
|
|||
cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromStream(cmsContext ContextID, FILE* Stream)
|
||||
{
|
||||
cmsIOHANDLER* iohandler = NULL;
|
||||
cmsInt32Number fileSize;
|
||||
|
||||
fileSize = cmsfilelength(Stream);
|
||||
if (fileSize < 0)
|
||||
{
|
||||
cmsSignalError(ContextID, cmsERROR_FILE, "Cannot get size of stream");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
iohandler = (cmsIOHANDLER*) _cmsMallocZero(ContextID, sizeof(cmsIOHANDLER));
|
||||
if (iohandler == NULL) return NULL;
|
||||
|
|
@ -431,7 +449,7 @@ cmsIOHANDLER* CMSEXPORT cmsOpenIOhandlerFromStream(cmsContext ContextID, FILE* S
|
|||
iohandler -> ContextID = ContextID;
|
||||
iohandler -> stream = (void*) Stream;
|
||||
iohandler -> UsedSpace = 0;
|
||||
iohandler -> ReportedSize = (cmsUInt32Number) cmsfilelength(Stream);
|
||||
iohandler -> ReportedSize = (cmsUInt32Number) fileSize;
|
||||
iohandler -> PhysicalFile[0] = 0;
|
||||
|
||||
iohandler ->Read = FileRead;
|
||||
|
|
@ -623,7 +641,7 @@ cmsBool _cmsNewTag(_cmsICCPROFILE* Icc, cmsTagSignature sig, int* NewPos)
|
|||
}
|
||||
|
||||
|
||||
// Check existance
|
||||
// Check existence
|
||||
cmsBool CMSEXPORT cmsIsTag(cmsHPROFILE hProfile, cmsTagSignature sig)
|
||||
{
|
||||
_cmsICCPROFILE* Icc = (_cmsICCPROFILE*) (void*) hProfile;
|
||||
|
|
@ -679,7 +697,7 @@ cmsBool _cmsReadHeader(_cmsICCPROFILE* Icc)
|
|||
return FALSE;
|
||||
}
|
||||
|
||||
// Adjust endianess of the used parameters
|
||||
// Adjust endianness of the used parameters
|
||||
Icc -> DeviceClass = (cmsProfileClassSignature) _cmsAdjustEndianess32(Header.deviceClass);
|
||||
Icc -> ColorSpace = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Header.colorSpace);
|
||||
Icc -> PCS = (cmsColorSpaceSignature) _cmsAdjustEndianess32(Header.pcs);
|
||||
|
|
@ -797,7 +815,7 @@ cmsBool _cmsWriteHeader(_cmsICCPROFILE* Icc, cmsUInt32Number UsedSpace)
|
|||
|
||||
memset(&Header.reserved, 0, sizeof(Header.reserved));
|
||||
|
||||
// Set profile ID. Endianess is always big endian
|
||||
// Set profile ID. Endianness is always big endian
|
||||
memmove(&Header.profileID, &Icc ->ProfileID, 16);
|
||||
|
||||
// Dump the header
|
||||
|
|
@ -1544,7 +1562,7 @@ void* CMSEXPORT cmsReadTag(cmsHPROFILE hProfile, cmsTagSignature sig)
|
|||
LocalTypeHandler.ICCVersion = Icc ->Version;
|
||||
Icc -> TagPtrs[n] = LocalTypeHandler.ReadPtr(&LocalTypeHandler, io, &ElemCount, TagSize);
|
||||
|
||||
// The tag type is supported, but something wrong happend and we cannot read the tag.
|
||||
// The tag type is supported, but something wrong happened and we cannot read the tag.
|
||||
// let know the user about this (although it is just a warning)
|
||||
if (Icc -> TagPtrs[n] == NULL) {
|
||||
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ cmsBool _cmsReadCHAD(cmsMAT3* Dest, cmsHPROFILE hProfile)
|
|||
}
|
||||
|
||||
|
||||
// Auxiliar, read colorants as a MAT3 structure. Used by any function that needs a matrix-shaper
|
||||
// Auxiliary, read colorants as a MAT3 structure. Used by any function that needs a matrix-shaper
|
||||
static
|
||||
cmsBool ReadICCMatrixRGB2XYZ(cmsMAT3* r, cmsHPROFILE hProfile)
|
||||
{
|
||||
|
|
@ -314,7 +314,7 @@ cmsPipeline* _cmsReadInputLUT(cmsHPROFILE hProfile, int Intent)
|
|||
cmsTagSignature tagFloat;
|
||||
cmsContext ContextID = cmsGetProfileContextID(hProfile);
|
||||
|
||||
// On named color, take the appropiate tag
|
||||
// On named color, take the appropriate tag
|
||||
if (cmsGetDeviceClass(hProfile) == cmsSigNamedColorClass) {
|
||||
|
||||
cmsPipeline* Lut;
|
||||
|
|
@ -336,9 +336,9 @@ cmsPipeline* _cmsReadInputLUT(cmsHPROFILE hProfile, int Intent)
|
|||
return Lut;
|
||||
}
|
||||
|
||||
// This is an attempt to reuse this funtion to retrieve the matrix-shaper as pipeline no
|
||||
// This is an attempt to reuse this function to retrieve the matrix-shaper as pipeline no
|
||||
// matter other LUT are present and have precedence. Intent = -1 means just this.
|
||||
if (Intent != -1) {
|
||||
if (Intent >= INTENT_PERCEPTUAL && Intent <= INTENT_ABSOLUTE_COLORIMETRIC) {
|
||||
|
||||
tag16 = Device2PCS16[Intent];
|
||||
tagFloat = Device2PCSFloat[Intent];
|
||||
|
|
@ -394,7 +394,7 @@ Error:
|
|||
// Check if this is a grayscale profile.
|
||||
if (cmsGetColorSpace(hProfile) == cmsSigGrayData) {
|
||||
|
||||
// if so, build appropiate conversion tables.
|
||||
// if so, build appropriate conversion tables.
|
||||
// The tables are the PCS iluminant, scaled across GrayTRC
|
||||
return BuildGrayInputMatrixPipeline(hProfile);
|
||||
}
|
||||
|
|
@ -549,7 +549,7 @@ cmsPipeline* _cmsReadFloatOutputTag(cmsHPROFILE hProfile, cmsTagSignature tagFlo
|
|||
if (Lut == NULL) return NULL;
|
||||
|
||||
// If PCS is Lab or XYZ, the floating point tag is accepting data in the space encoding,
|
||||
// and since the formatter has already accomodated to 0..1.0, we should undo this change
|
||||
// and since the formatter has already accommodated to 0..1.0, we should undo this change
|
||||
if ( PCS == cmsSigLabData)
|
||||
{
|
||||
if (!cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToLabFloat(ContextID)))
|
||||
|
|
@ -590,7 +590,7 @@ cmsPipeline* _cmsReadOutputLUT(cmsHPROFILE hProfile, int Intent)
|
|||
cmsContext ContextID = cmsGetProfileContextID(hProfile);
|
||||
|
||||
|
||||
if (Intent != -1) {
|
||||
if (Intent >= INTENT_PERCEPTUAL && Intent <= INTENT_ABSOLUTE_COLORIMETRIC) {
|
||||
|
||||
tag16 = PCS2Device16[Intent];
|
||||
tagFloat = PCS2DeviceFloat[Intent];
|
||||
|
|
@ -651,7 +651,7 @@ Error:
|
|||
// Check if this is a grayscale profile.
|
||||
if (cmsGetColorSpace(hProfile) == cmsSigGrayData) {
|
||||
|
||||
// if so, build appropiate conversion tables.
|
||||
// if so, build appropriate conversion tables.
|
||||
// The tables are the PCS iluminant, scaled across GrayTRC
|
||||
return BuildGrayOutputPipeline(hProfile);
|
||||
}
|
||||
|
|
@ -709,12 +709,18 @@ cmsPipeline* _cmsReadDevicelinkLUT(cmsHPROFILE hProfile, int Intent)
|
|||
{
|
||||
cmsPipeline* Lut;
|
||||
cmsTagTypeSignature OriginalType;
|
||||
cmsTagSignature tag16 = Device2PCS16[Intent];
|
||||
cmsTagSignature tagFloat = Device2PCSFloat[Intent];
|
||||
cmsTagSignature tag16;
|
||||
cmsTagSignature tagFloat;
|
||||
cmsContext ContextID = cmsGetProfileContextID(hProfile);
|
||||
|
||||
|
||||
// On named color, take the appropiate tag
|
||||
if (Intent < INTENT_PERCEPTUAL || Intent > INTENT_ABSOLUTE_COLORIMETRIC)
|
||||
return NULL;
|
||||
|
||||
tag16 = Device2PCS16[Intent];
|
||||
tagFloat = Device2PCSFloat[Intent];
|
||||
|
||||
// On named color, take the appropriate tag
|
||||
if (cmsGetDeviceClass(hProfile) == cmsSigNamedColorClass) {
|
||||
|
||||
cmsNAMEDCOLORLIST* nc = (cmsNAMEDCOLORLIST*)cmsReadTag(hProfile, cmsSigNamedColor2Tag);
|
||||
|
|
@ -739,6 +745,7 @@ Error:
|
|||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence
|
||||
|
||||
// Floating point LUT are always V
|
||||
|
|
@ -921,7 +928,7 @@ cmsBool _cmsWriteProfileSequence(cmsHPROFILE hProfile, const cmsSEQ* seq)
|
|||
}
|
||||
|
||||
|
||||
// Auxiliar, read and duplicate a MLU if found.
|
||||
// Auxiliary, read and duplicate a MLU if found.
|
||||
static
|
||||
cmsMLU* GetMLUFromProfile(cmsHPROFILE h, cmsTagSignature sig)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ void CMSEXPORT _cmsVEC3init(cmsVEC3* r, cmsFloat64Number x, cmsFloat64Number y,
|
|||
r -> n[VZ] = z;
|
||||
}
|
||||
|
||||
// Vector substraction
|
||||
// Vector subtraction
|
||||
void CMSEXPORT _cmsVEC3minus(cmsVEC3* r, const cmsVEC3* a, const cmsVEC3* b)
|
||||
{
|
||||
r -> n[VX] = a -> n[VX] - b -> n[VX];
|
||||
|
|
|
|||
|
|
@ -206,10 +206,10 @@ void strFrom16(char str[3], cmsUInt16Number n)
|
|||
|
||||
}
|
||||
|
||||
// Add an ASCII entry.
|
||||
// Add an ASCII entry. Do not add any \0 termination (ICC1v43_2010-12.pdf page 61)
|
||||
cmsBool CMSEXPORT cmsMLUsetASCII(cmsMLU* mlu, const char LanguageCode[3], const char CountryCode[3], const char* ASCIIString)
|
||||
{
|
||||
cmsUInt32Number i, len = (cmsUInt32Number) strlen(ASCIIString)+1;
|
||||
cmsUInt32Number i, len = (cmsUInt32Number) strlen(ASCIIString);
|
||||
wchar_t* WStr;
|
||||
cmsBool rc;
|
||||
cmsUInt16Number Lang = strTo16(LanguageCode);
|
||||
|
|
@ -243,8 +243,7 @@ cmsUInt32Number mywcslen(const wchar_t *s)
|
|||
return (cmsUInt32Number)(p - s);
|
||||
}
|
||||
|
||||
|
||||
// Add a wide entry
|
||||
// Add a wide entry. Do not add any \0 terminator (ICC1v43_2010-12.pdf page 61)
|
||||
cmsBool CMSEXPORT cmsMLUsetWide(cmsMLU* mlu, const char Language[3], const char Country[3], const wchar_t* WideString)
|
||||
{
|
||||
cmsUInt16Number Lang = strTo16(Language);
|
||||
|
|
@ -254,7 +253,7 @@ cmsBool CMSEXPORT cmsMLUsetWide(cmsMLU* mlu, const char Language[3], const char
|
|||
if (mlu == NULL) return FALSE;
|
||||
if (WideString == NULL) return FALSE;
|
||||
|
||||
len = (cmsUInt32Number) (mywcslen(WideString) + 1) * sizeof(wchar_t);
|
||||
len = (cmsUInt32Number) (mywcslen(WideString)) * sizeof(wchar_t);
|
||||
return AddMLUBlock(mlu, len, WideString, Lang, Cntry);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -529,7 +529,7 @@ cmsBool PatchLUT(cmsStage* CLUT, cmsUInt16Number At[], cmsUInt16Number Value[],
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
// Auxiliar, to see if two values are equal or very different
|
||||
// Auxiliary, to see if two values are equal or very different
|
||||
static
|
||||
cmsBool WhitesAreEqual(int n, cmsUInt16Number White1[], cmsUInt16Number White2[] )
|
||||
{
|
||||
|
|
@ -537,7 +537,7 @@ cmsBool WhitesAreEqual(int n, cmsUInt16Number White1[], cmsUInt16Number White2[]
|
|||
|
||||
for (i=0; i < n; i++) {
|
||||
|
||||
if (abs(White1[i] - White2[i]) > 0xf000) return TRUE; // Values are so extremly different that the fixup should be avoided
|
||||
if (abs(White1[i] - White2[i]) > 0xf000) return TRUE; // Values are so extremely different that the fixup should be avoided
|
||||
if (White1[i] != White2[i]) return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ typedef struct {
|
|||
#define ANYFLAVOR FLAVOR_SH(1)
|
||||
|
||||
|
||||
// Supress waning about info never being used
|
||||
// Suppress waning about info never being used
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(disable : 4100)
|
||||
|
|
|
|||
|
|
@ -308,7 +308,7 @@ void CMSEXPORT cmsFloat2LabEncoded(cmsUInt16Number wLab[3], const cmsCIELab* fLa
|
|||
wLab[2] = ab2Fix4(Lab.b);
|
||||
}
|
||||
|
||||
// Auxiliar: convert to Radians
|
||||
// Auxiliary: convert to Radians
|
||||
static
|
||||
cmsFloat64Number RADIANS(cmsFloat64Number deg)
|
||||
{
|
||||
|
|
@ -316,7 +316,7 @@ cmsFloat64Number RADIANS(cmsFloat64Number deg)
|
|||
}
|
||||
|
||||
|
||||
// Auxiliar: atan2 but operating in degrees and returning 0 if a==b==0
|
||||
// Auxiliary: atan2 but operating in degrees and returning 0 if a==b==0
|
||||
static
|
||||
cmsFloat64Number atan2deg(cmsFloat64Number a, cmsFloat64Number b)
|
||||
{
|
||||
|
|
@ -339,7 +339,7 @@ cmsFloat64Number atan2deg(cmsFloat64Number a, cmsFloat64Number b)
|
|||
}
|
||||
|
||||
|
||||
// Auxiliar: Square
|
||||
// Auxiliary: Square
|
||||
static
|
||||
cmsFloat64Number Sqr(cmsFloat64Number v)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ void CMSEXPORT _cmsAdjustEndianess64(cmsUInt64Number* Result, cmsUInt64Number*
|
|||
#endif
|
||||
}
|
||||
|
||||
// Auxiliar -- read 8, 16 and 32-bit numbers
|
||||
// Auxiliary -- read 8, 16 and 32-bit numbers
|
||||
cmsBool CMSEXPORT _cmsReadUInt8Number(cmsIOHANDLER* io, cmsUInt8Number* n)
|
||||
{
|
||||
cmsUInt8Number tmp;
|
||||
|
|
@ -172,13 +172,13 @@ cmsBool CMSEXPORT _cmsReadFloat32Number(cmsIOHANDLER* io, cmsFloat32Number* n)
|
|||
|
||||
_cmsAssert(io != NULL);
|
||||
|
||||
if (io -> Read(io, &tmp, sizeof(cmsFloat32Number), 1) != 1)
|
||||
if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1)
|
||||
return FALSE;
|
||||
|
||||
if (n != NULL) {
|
||||
|
||||
tmp = _cmsAdjustEndianess32(tmp);
|
||||
*n = *(cmsFloat32Number*) &tmp;
|
||||
*n = *(cmsFloat32Number*) (void*) &tmp;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
|
@ -289,7 +289,7 @@ cmsBool CMSEXPORT _cmsWriteFloat32Number(cmsIOHANDLER* io, cmsFloat32Number n)
|
|||
|
||||
_cmsAssert(io != NULL);
|
||||
|
||||
tmp = *(cmsUInt32Number*) &n;
|
||||
tmp = *(cmsUInt32Number*) (void*) &n;
|
||||
tmp = _cmsAdjustEndianess32(tmp);
|
||||
if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
|
||||
return FALSE;
|
||||
|
|
@ -485,7 +485,10 @@ cmsBool CMSEXPORT _cmsIOPrintf(cmsIOHANDLER* io, const char* frm, ...)
|
|||
va_start(args, frm);
|
||||
|
||||
len = vsnprintf((char*) Buffer, 2047, frm, args);
|
||||
if (len < 0) return FALSE; // Truncated, which is a fatal error for us
|
||||
if (len < 0) {
|
||||
va_end(args);
|
||||
return FALSE; // Truncated, which is a fatal error for us
|
||||
}
|
||||
|
||||
rc = io ->Write(io, len, Buffer);
|
||||
|
||||
|
|
|
|||
|
|
@ -579,7 +579,7 @@ void EmitNGamma(cmsIOHANDLER* m, int n, cmsToneCurve* g[])
|
|||
//
|
||||
// Each row contains Pipeline values for all but first component. So, I
|
||||
// detect row changing by keeping a copy of last value of first
|
||||
// component. -1 is used to mark begining of whole block.
|
||||
// component. -1 is used to mark beginning of whole block.
|
||||
|
||||
static
|
||||
int OutputValueSampler(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)
|
||||
|
|
|
|||
|
|
@ -318,7 +318,7 @@ void CMSEXPORT cmsGBDFree(cmsHANDLE hGBD)
|
|||
}
|
||||
|
||||
|
||||
// Auxiliar to retrieve a pointer to the segmentr containing the Lab value
|
||||
// Auxiliary to retrieve a pointer to the segmentr containing the Lab value
|
||||
static
|
||||
cmsGDBPoint* GetPoint(cmsGDB* gbd, const cmsCIELab* Lab, cmsSpherical* sp)
|
||||
{
|
||||
|
|
@ -330,7 +330,7 @@ cmsGDBPoint* GetPoint(cmsGDB* gbd, const cmsCIELab* Lab, cmsSpherical* sp)
|
|||
_cmsAssert(Lab != NULL);
|
||||
_cmsAssert(sp != NULL);
|
||||
|
||||
// Center L* by substracting half of its domain, that's 50
|
||||
// Center L* by subtracting half of its domain, that's 50
|
||||
_cmsVEC3init(&v, Lab ->L - 50.0, Lab ->a, Lab ->b);
|
||||
|
||||
// Convert to spherical coordinates
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@
|
|||
// This file implements every single tag and tag type as described in the ICC spec. Some types
|
||||
// have been deprecated, like ncl and Data. There is no implementation for those types as there
|
||||
// are no profiles holding them. The programmer can also extend this list by defining his own types
|
||||
// by using the appropiate plug-in. There are three types of plug ins regarding that. First type
|
||||
// by using the appropriate plug-in. There are three types of plug ins regarding that. First type
|
||||
// allows to define new tags using any existing type. Next plug-in type allows to define new types
|
||||
// and the third one is very specific: allows to extend the number of elements in the multiprocessing
|
||||
// elements special type.
|
||||
|
|
@ -113,7 +113,7 @@ cmsTagTypeHandler* GetHandler(cmsTagTypeSignature sig, _cmsTagTypeLinkedList* Pl
|
|||
}
|
||||
|
||||
|
||||
// Auxiliar to convert UTF-32 to UTF-16 in some cases
|
||||
// Auxiliary to convert UTF-32 to UTF-16 in some cases
|
||||
static
|
||||
cmsBool _cmsWriteWCharArray(cmsIOHANDLER* io, cmsUInt32Number n, const wchar_t* Array)
|
||||
{
|
||||
|
|
@ -129,7 +129,7 @@ cmsBool _cmsWriteWCharArray(cmsIOHANDLER* io, cmsUInt32Number n, const wchar_t*
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
// Auxiliar to read an array of wchar_t
|
||||
// Auxiliary to read an array of wchar_t
|
||||
static
|
||||
cmsBool _cmsReadWCharArray(cmsIOHANDLER* io, cmsUInt32Number n, wchar_t* Array)
|
||||
{
|
||||
|
|
@ -160,7 +160,7 @@ typedef cmsBool (* PositionTableEntryFn)(struct _cms_typehandler_struct* self,
|
|||
cmsUInt32Number n,
|
||||
cmsUInt32Number SizeOfTag);
|
||||
|
||||
// Helper function to deal with position tables as decribed in ICC spec 4.3
|
||||
// Helper function to deal with position tables as described in ICC spec 4.3
|
||||
// A table of n elements is readed, where first comes n records containing offsets and sizes and
|
||||
// then a block containing the data itself. This allows to reuse same data in more than one entry
|
||||
static
|
||||
|
|
@ -994,7 +994,7 @@ cmsBool Type_Text_Description_Write(struct _cms_typehandler_struct* self, cmsIO
|
|||
}
|
||||
|
||||
// Tell the real text len including the null terminator and padding
|
||||
len_text = strlen(Text) + 1;
|
||||
len_text = (cmsUInt32Number) strlen(Text) + 1;
|
||||
// Compute an total tag size requirement
|
||||
len_tag_requirement = (8+4+len_text+4+4+2*len_text+2+1+67);
|
||||
len_aligned = _cmsALIGNLONG(len_tag_requirement);
|
||||
|
|
@ -1474,7 +1474,7 @@ void *Type_MLU_Read(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsU
|
|||
LargestPosition = EndOfThisString;
|
||||
}
|
||||
|
||||
// Now read the remaining of tag and fill all strings. Substract the directory
|
||||
// Now read the remaining of tag and fill all strings. Subtract the directory
|
||||
SizeOfTag = (LargestPosition * sizeof(wchar_t)) / sizeof(cmsUInt16Number);
|
||||
if (SizeOfTag == 0)
|
||||
{
|
||||
|
|
@ -3609,7 +3609,7 @@ country varies for each element:
|
|||
|
||||
|
||||
|
||||
// Auxiliar, read an string specified as count + string
|
||||
// Auxiliary, read an string specified as count + string
|
||||
static
|
||||
cmsBool ReadCountAndSting(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, cmsMLU* mlu, cmsUInt32Number* SizeOfTag, const char* Section)
|
||||
{
|
||||
|
|
@ -4312,13 +4312,13 @@ Error:
|
|||
static
|
||||
cmsBool Type_MPEclut_Write(struct _cms_typehandler_struct* self, cmsIOHANDLER* io, void* Ptr, cmsUInt32Number nItems)
|
||||
{
|
||||
cmsUInt8Number Dimensions8[16];
|
||||
cmsUInt8Number Dimensions8[16]; // 16 because the spec says 16 and not max number of channels
|
||||
cmsUInt32Number i;
|
||||
cmsStage* mpe = (cmsStage*) Ptr;
|
||||
_cmsStageCLutData* clut = (_cmsStageCLutData*) mpe ->Data;
|
||||
|
||||
// Check for maximum number of channels
|
||||
if (mpe -> InputChannels > 15) return FALSE;
|
||||
// Check for maximum number of channels supported by lcms
|
||||
if (mpe -> InputChannels > MAX_INPUT_DIMENSIONS) return FALSE;
|
||||
|
||||
// Only floats are supported in MPE
|
||||
if (clut ->HasFloatValues == FALSE) return FALSE;
|
||||
|
|
|
|||
|
|
@ -1138,15 +1138,20 @@ cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat
|
|||
// If no way, then force CLUT that for sure can be written
|
||||
if (AllowedLUT == NULL) {
|
||||
|
||||
cmsStage* FirstStage;
|
||||
cmsStage* LastStage;
|
||||
|
||||
dwFlags |= cmsFLAGS_FORCE_CLUT;
|
||||
_cmsOptimizePipeline(ContextID, &LUT, xform ->RenderingIntent, &FrmIn, &FrmOut, &dwFlags);
|
||||
|
||||
// Put identity curves if needed
|
||||
if (cmsPipelineGetPtrToFirstStage(LUT) ->Type != cmsSigCurveSetElemType)
|
||||
FirstStage = cmsPipelineGetPtrToFirstStage(LUT);
|
||||
if (FirstStage != NULL && FirstStage ->Type != cmsSigCurveSetElemType)
|
||||
if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, ChansIn)))
|
||||
goto Error;
|
||||
|
||||
if (cmsPipelineGetPtrToLastStage(LUT) ->Type != cmsSigCurveSetElemType)
|
||||
LastStage = cmsPipelineGetPtrToLastStage(LUT);
|
||||
if (LastStage != NULL && LastStage ->Type != cmsSigCurveSetElemType)
|
||||
if (!cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, ChansOut)))
|
||||
goto Error;
|
||||
|
||||
|
|
|
|||
|
|
@ -413,7 +413,7 @@ void PrecalculatedXFORM(_cmsTRANSFORM* p,
|
|||
}
|
||||
|
||||
|
||||
// Auxiliar: Handle precalculated gamut check. The retrieval of context may be alittle bit slow, but this function is not critical.
|
||||
// Auxiliary: Handle precalculated gamut check. The retrieval of context may be alittle bit slow, but this function is not critical.
|
||||
static
|
||||
void TransformOnePixelWithGamutCheck(_cmsTRANSFORM* p,
|
||||
const cmsUInt16Number wIn[],
|
||||
|
|
|
|||
|
|
@ -739,7 +739,7 @@ typedef struct _cms_iccprofile_struct {
|
|||
// Dictionary
|
||||
cmsUInt32Number TagCount;
|
||||
cmsTagSignature TagNames[MAX_TABLE_TAG];
|
||||
cmsTagSignature TagLinked[MAX_TABLE_TAG]; // The tag to wich is linked (0=none)
|
||||
cmsTagSignature TagLinked[MAX_TABLE_TAG]; // The tag to which is linked (0=none)
|
||||
cmsUInt32Number TagSizes[MAX_TABLE_TAG]; // Size on disk
|
||||
cmsUInt32Number TagOffsets[MAX_TABLE_TAG];
|
||||
cmsBool TagSaveAsRaw[MAX_TABLE_TAG]; // True to write uncooked
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ this sentence.
|
|||
|
||||
This code is released under the libpng license.
|
||||
|
||||
libpng versions 1.0.7, July 1, 2000, through 1.6.21, January 15, 2016, are
|
||||
libpng versions 1.0.7, July 1, 2000 through 1.6.24, August 4, 2016 are
|
||||
Copyright (c) 2000-2002, 2004, 2006-2016 Glenn Randers-Pehrson, are
|
||||
derived from libpng-1.0.6, and are distributed according to the same
|
||||
disclaimer and license as libpng-1.0.6 with the following individuals
|
||||
|
|
@ -32,6 +32,10 @@ and with the following additions to the disclaimer:
|
|||
risk of satisfactory quality, performance, accuracy, and effort is with
|
||||
the user.
|
||||
|
||||
Some files in the "contrib" directory and some configure-generated
|
||||
files that are distributed with libpng have other copyright owners and
|
||||
are released under other open source licenses.
|
||||
|
||||
libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
|
||||
Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
|
||||
libpng-0.96, and are distributed according to the same disclaimer and
|
||||
|
|
@ -55,6 +59,9 @@ Contributing Authors:
|
|||
Greg Roelofs
|
||||
Tom Tanner
|
||||
|
||||
Some files in the "scripts" directory have other copyright owners
|
||||
but are released under this license.
|
||||
|
||||
libpng versions 0.5, May 1995, through 0.88, January 1996, are
|
||||
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
|
||||
|
||||
|
|
@ -95,18 +102,29 @@ appreciated.
|
|||
|
||||
END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
|
||||
|
||||
A "png_get_copyright" function is available, for convenient use in "about"
|
||||
boxes and the like:
|
||||
TRADEMARK:
|
||||
|
||||
printf("%s", png_get_copyright(NULL));
|
||||
The name "libpng" has not been registered by the Copyright owner
|
||||
as a trademark in any jurisdiction. However, because libpng has
|
||||
been distributed and maintained world-wide, continually since 1995,
|
||||
the Copyright owner claims "common-law trademark protection" in any
|
||||
jurisdiction where common-law trademark is recognized.
|
||||
|
||||
Also, the PNG logo (in PNG format, of course) is supplied in the
|
||||
files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
|
||||
OSI CERTIFICATION:
|
||||
|
||||
Libpng is OSI Certified Open Source Software. OSI Certified Open Source is
|
||||
a certification mark of the Open Source Initiative. OSI has not addressed
|
||||
the additional disclaimers inserted at version 1.0.7.
|
||||
|
||||
EXPORT CONTROL:
|
||||
|
||||
The Copyright owner believes that the Export Control Classification
|
||||
Number (ECCN) for libpng is EAR99, which means not subject to export
|
||||
controls or International Traffic in Arms Regulations (ITAR) because
|
||||
it is open source, publicly available software, that does not contain
|
||||
any encryption software. See the EAR, paragraphs 734.3(b)(3) and
|
||||
734.7(b).
|
||||
|
||||
Glenn Randers-Pehrson
|
||||
glennrp at users.sourceforge.net
|
||||
January 15, 2016
|
||||
August 4, 2016
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
/* png.c - location for general purpose libpng functions
|
||||
*
|
||||
* Last changed in libpng 1.6.19 [November 12, 2015]
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 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.)
|
||||
|
|
@ -14,7 +14,7 @@
|
|||
#include "pngpriv.h"
|
||||
|
||||
/* Generate a compiler error if there is an old png.h in the search path. */
|
||||
typedef png_libpng_version_1_6_21 Your_png_h_is_not_version_1_6_21;
|
||||
typedef png_libpng_version_1_6_24 Your_png_h_is_not_version_1_6_24;
|
||||
|
||||
/* 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
|
||||
|
|
@ -775,14 +775,14 @@ png_get_copyright(png_const_structrp png_ptr)
|
|||
#else
|
||||
# ifdef __STDC__
|
||||
return PNG_STRING_NEWLINE \
|
||||
"libpng version 1.6.21 - January 15, 2016" PNG_STRING_NEWLINE \
|
||||
"libpng version 1.6.24 - August 4, 2016" PNG_STRING_NEWLINE \
|
||||
"Copyright (c) 1998-2002,2004,2006-2016 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.6.21 - January 15, 2016\
|
||||
return "libpng version 1.6.24 - August 4, 2016\
|
||||
Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson\
|
||||
Copyright (c) 1996-1997 Andreas Dilger\
|
||||
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
|
||||
|
|
@ -2354,7 +2354,6 @@ png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
|
|||
|
||||
return 0; /* no match */
|
||||
}
|
||||
#endif /* PNG_sRGB_PROFILE_CHECKS >= 0 */
|
||||
|
||||
void /* PRIVATE */
|
||||
png_icc_set_sRGB(png_const_structrp png_ptr,
|
||||
|
|
@ -2363,12 +2362,11 @@ png_icc_set_sRGB(png_const_structrp png_ptr,
|
|||
/* Is this profile one of the known ICC sRGB profiles? If it is, just set
|
||||
* the sRGB information.
|
||||
*/
|
||||
#if PNG_sRGB_PROFILE_CHECKS >= 0
|
||||
if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0)
|
||||
#endif
|
||||
(void)png_colorspace_set_sRGB(png_ptr, colorspace,
|
||||
(int)/*already checked*/png_get_uint_32(profile+64));
|
||||
}
|
||||
#endif /* PNG_sRGB_PROFILE_CHECKS >= 0 */
|
||||
#endif /* sRGB */
|
||||
|
||||
int /* PRIVATE */
|
||||
|
|
@ -2385,7 +2383,7 @@ png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace,
|
|||
png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,
|
||||
profile) != 0)
|
||||
{
|
||||
# ifdef PNG_sRGB_SUPPORTED
|
||||
# if defined(PNG_sRGB_SUPPORTED) && PNG_sRGB_PROFILE_CHECKS >= 0
|
||||
/* If no sRGB support, don't try storing sRGB information */
|
||||
png_icc_set_sRGB(png_ptr, colorspace, profile, 0);
|
||||
# endif
|
||||
|
|
@ -4092,9 +4090,9 @@ png_build_gamma_table(png_structrp png_ptr, int bit_depth)
|
|||
|
||||
/* Remove any existing table; this copes with multiple calls to
|
||||
* png_read_update_info. The warning is because building the gamma tables
|
||||
* multiple times is a performance hit - it's harmless but the ability to call
|
||||
* png_read_update_info() multiple times is new in 1.5.6 so it seems sensible
|
||||
* to warn if the app introduces such a hit.
|
||||
* multiple times is a performance hit - it's harmless but the ability to
|
||||
* call png_read_update_info() multiple times is new in 1.5.6 so it seems
|
||||
* sensible to warn if the app introduces such a hit.
|
||||
*/
|
||||
if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)
|
||||
{
|
||||
|
|
@ -4105,7 +4103,8 @@ png_build_gamma_table(png_structrp png_ptr, int bit_depth)
|
|||
if (bit_depth <= 8)
|
||||
{
|
||||
png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
|
||||
png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
|
||||
png_ptr->screen_gamma > 0 ?
|
||||
png_reciprocal2(png_ptr->colorspace.gamma,
|
||||
png_ptr->screen_gamma) : PNG_FP_1);
|
||||
|
||||
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
|
||||
|
|
@ -4117,7 +4116,8 @@ png_build_gamma_table(png_structrp png_ptr, int bit_depth)
|
|||
png_reciprocal(png_ptr->colorspace.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->screen_gamma > 0 ?
|
||||
png_reciprocal(png_ptr->screen_gamma) :
|
||||
png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
|
||||
}
|
||||
#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
|
||||
|
|
@ -4148,8 +4148,8 @@ png_build_gamma_table(png_structrp png_ptr, int bit_depth)
|
|||
* 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:
|
||||
* 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]
|
||||
*
|
||||
|
|
@ -4182,8 +4182,8 @@ png_build_gamma_table(png_structrp png_ptr, int bit_depth)
|
|||
|
||||
/* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now
|
||||
* PNG_COMPOSE). This effectively smashed the background calculation for
|
||||
* 16-bit output because the 8-bit table assumes the result will be reduced
|
||||
* to 8 bits.
|
||||
* 16-bit output because the 8-bit table assumes the result will be
|
||||
* reduced to 8 bits.
|
||||
*/
|
||||
if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
|
||||
png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
|
||||
/* png.h - header file for PNG reference library
|
||||
*
|
||||
* libpng version 1.6.21, January 15, 2016
|
||||
* libpng version 1.6.24, August 4, 2016
|
||||
*
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
|
|
@ -12,7 +12,7 @@
|
|||
* Authors and maintainers:
|
||||
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
|
||||
* libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger
|
||||
* libpng versions 0.97, January 1998, through 1.6.21, January 15, 2016:
|
||||
* libpng versions 0.97, January 1998, through 1.6.24, August 4, 2016:
|
||||
* Glenn Randers-Pehrson.
|
||||
* See also "Contributing Authors", below.
|
||||
*/
|
||||
|
|
@ -25,7 +25,11 @@
|
|||
*
|
||||
* This code is released under the libpng license.
|
||||
*
|
||||
* libpng versions 1.0.7, July 1, 2000, through 1.6.21, January 15, 2016, are
|
||||
* Some files in the "contrib" directory and some configure-generated
|
||||
* files that are distributed with libpng have other copyright owners and
|
||||
* are released under other open source licenses.
|
||||
*
|
||||
* libpng versions 1.0.7, July 1, 2000 through 1.6.24, August 4, 2016 are
|
||||
* Copyright (c) 2000-2002, 2004, 2006-2016 Glenn Randers-Pehrson, are
|
||||
* derived from libpng-1.0.6, and are distributed according to the same
|
||||
* disclaimer and license as libpng-1.0.6 with the following individuals
|
||||
|
|
@ -47,6 +51,10 @@
|
|||
* risk of satisfactory quality, performance, accuracy, and effort is with
|
||||
* the user.
|
||||
*
|
||||
* Some files in the "contrib" directory have other copyright owners and
|
||||
* are released under other open source licenses.
|
||||
*
|
||||
*
|
||||
* libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
|
||||
* Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
|
||||
* libpng-0.96, and are distributed according to the same disclaimer and
|
||||
|
|
@ -57,6 +65,9 @@
|
|||
* Glenn Randers-Pehrson
|
||||
* Willem van Schaik
|
||||
*
|
||||
* Some files in the "scripts" directory have different copyright owners
|
||||
* but are also released under this license.
|
||||
*
|
||||
* libpng versions 0.89, June 1996, through 0.96, May 1997, are
|
||||
* Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
|
||||
* and are distributed according to the same disclaimer and license as
|
||||
|
|
@ -70,6 +81,9 @@
|
|||
* Greg Roelofs
|
||||
* Tom Tanner
|
||||
*
|
||||
* Some files in the "scripts" directory have other copyright owners
|
||||
* but are released under this license.
|
||||
*
|
||||
* libpng versions 0.5, May 1995, through 0.88, January 1996, are
|
||||
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
|
||||
*
|
||||
|
|
@ -109,6 +123,29 @@
|
|||
* appreciated.
|
||||
*
|
||||
* END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
|
||||
*
|
||||
* TRADEMARK:
|
||||
*
|
||||
* The name "libpng" has not been registered by the Copyright owner
|
||||
* as a trademark in any jurisdiction. However, because libpng has
|
||||
* been distributed and maintained world-wide, continually since 1995,
|
||||
* the Copyright owner claims "common-law trademark protection" in any
|
||||
* jurisdiction where common-law trademark is recognized.
|
||||
*
|
||||
* OSI CERTIFICATION:
|
||||
*
|
||||
* Libpng is OSI Certified Open Source Software. OSI Certified Open Source is
|
||||
* a certification mark of the Open Source Initiative. OSI has not addressed
|
||||
* the additional disclaimers inserted at version 1.0.7.
|
||||
*
|
||||
* EXPORT CONTROL:
|
||||
*
|
||||
* The Copyright owner believes that the Export Control Classification
|
||||
* Number (ECCN) for libpng is EAR99, which means not subject to export
|
||||
* controls or International Traffic in Arms Regulations (ITAR) because
|
||||
* it is open source, publicly available software, that does not contain
|
||||
* any encryption software. See the EAR, paragraphs 734.3(b)(3) and
|
||||
* 734.7(b).
|
||||
*/
|
||||
|
||||
/*
|
||||
|
|
@ -121,12 +158,6 @@
|
|||
* 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. OSI has not addressed
|
||||
* the additional disclaimers inserted at version 1.0.7.
|
||||
*/
|
||||
|
||||
/*
|
||||
* The contributing authors would like to thank all those who helped
|
||||
* with testing, bug fixes, and patience. This wouldn't have been
|
||||
|
|
@ -182,11 +213,11 @@
|
|||
* ...
|
||||
* 1.0.19 10 10019 10.so.0.19[.0]
|
||||
* ...
|
||||
* 1.2.53 13 10253 12.so.0.53[.0]
|
||||
* 1.2.56 13 10256 12.so.0.56[.0]
|
||||
* ...
|
||||
* 1.5.23 15 10523 15.so.15.23[.0]
|
||||
* 1.5.27 15 10527 15.so.15.27[.0]
|
||||
* ...
|
||||
* 1.6.21 16 10621 16.so.16.21[.0]
|
||||
* 1.6.24 16 10624 16.so.16.24[.0]
|
||||
*
|
||||
* Henceforth the source version will match the shared-library major
|
||||
* and minor numbers; the shared-library major version number will be
|
||||
|
|
@ -214,13 +245,13 @@
|
|||
* Y2K compliance in libpng:
|
||||
* =========================
|
||||
*
|
||||
* January 15, 2016
|
||||
* August 4, 2016
|
||||
*
|
||||
* 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.6.21 are Y2K compliant. It is my belief that
|
||||
* upward through 1.6.24 are Y2K compliant. It is my belief that
|
||||
* earlier versions were also Y2K compliant.
|
||||
*
|
||||
* Libpng only has two year fields. One is a 2-byte unsigned integer
|
||||
|
|
@ -282,9 +313,8 @@
|
|||
*/
|
||||
|
||||
/* Version information for png.h - this should match the version in png.c */
|
||||
#define PNG_LIBPNG_VER_STRING "1.6.21"
|
||||
#define PNG_HEADER_VERSION_STRING \
|
||||
" libpng version 1.6.21 - January 15, 2016\n"
|
||||
#define PNG_LIBPNG_VER_STRING "1.6.24"
|
||||
#define PNG_HEADER_VERSION_STRING " libpng version 1.6.24 - August 4, 2016\n"
|
||||
|
||||
#define PNG_LIBPNG_VER_SONUM 16
|
||||
#define PNG_LIBPNG_VER_DLLNUM 16
|
||||
|
|
@ -292,7 +322,7 @@
|
|||
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
|
||||
#define PNG_LIBPNG_VER_MAJOR 1
|
||||
#define PNG_LIBPNG_VER_MINOR 6
|
||||
#define PNG_LIBPNG_VER_RELEASE 21
|
||||
#define PNG_LIBPNG_VER_RELEASE 24
|
||||
|
||||
/* This should match the numeric part of the final component of
|
||||
* PNG_LIBPNG_VER_STRING, omitting any leading zero:
|
||||
|
|
@ -323,7 +353,7 @@
|
|||
* 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 10621 /* 1.6.21 */
|
||||
#define PNG_LIBPNG_VER 10624 /* 1.6.24 */
|
||||
|
||||
/* Library configuration: these options cannot be changed after
|
||||
* the library has been built.
|
||||
|
|
@ -433,7 +463,7 @@ extern "C" {
|
|||
/* 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_6_21;
|
||||
typedef char* png_libpng_version_1_6_24;
|
||||
|
||||
/* Basic control structions. Read libpng-manual.txt or libpng.3 for more info.
|
||||
*
|
||||
|
|
@ -734,24 +764,22 @@ typedef png_unknown_chunk * * png_unknown_chunkpp;
|
|||
* 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 */
|
||||
#if INT_MAX >= 0x8000 /* else this might break */
|
||||
#define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */
|
||||
#endif
|
||||
#define PNG_INFO_gAMA 0x0001U
|
||||
#define PNG_INFO_sBIT 0x0002U
|
||||
#define PNG_INFO_cHRM 0x0004U
|
||||
#define PNG_INFO_PLTE 0x0008U
|
||||
#define PNG_INFO_tRNS 0x0010U
|
||||
#define PNG_INFO_bKGD 0x0020U
|
||||
#define PNG_INFO_hIST 0x0040U
|
||||
#define PNG_INFO_pHYs 0x0080U
|
||||
#define PNG_INFO_oFFs 0x0100U
|
||||
#define PNG_INFO_tIME 0x0200U
|
||||
#define PNG_INFO_pCAL 0x0400U
|
||||
#define PNG_INFO_sRGB 0x0800U /* GR-P, 0.96a */
|
||||
#define PNG_INFO_iCCP 0x1000U /* ESR, 1.0.6 */
|
||||
#define PNG_INFO_sPLT 0x2000U /* ESR, 1.0.6 */
|
||||
#define PNG_INFO_sCAL 0x4000U /* ESR, 1.0.6 */
|
||||
#define PNG_INFO_IDAT 0x8000U /* 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
|
||||
|
|
@ -1322,7 +1350,7 @@ PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr));
|
|||
#endif
|
||||
|
||||
#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
|
||||
#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */
|
||||
#define PNG_READ_16_TO_8_SUPPORTED /* Name prior to 1.5.4 */
|
||||
/* Strip the second byte of information from a 16-bit depth file. */
|
||||
PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr));
|
||||
#endif
|
||||
|
|
@ -1473,8 +1501,8 @@ PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method,
|
|||
#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)
|
||||
#define PNG_FAST_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP)
|
||||
#define PNG_ALL_FILTERS (PNG_FAST_FILTERS | PNG_FILTER_AVG | PNG_FILTER_PAETH)
|
||||
|
||||
/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
|
||||
* These defines should NOT be changed.
|
||||
|
|
@ -1751,21 +1779,21 @@ PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr,
|
|||
#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_HIST 0x0008U
|
||||
#define PNG_FREE_ICCP 0x0010U
|
||||
#define PNG_FREE_SPLT 0x0020U
|
||||
#define PNG_FREE_ROWS 0x0040U
|
||||
#define PNG_FREE_PCAL 0x0080U
|
||||
#define PNG_FREE_SCAL 0x0100U
|
||||
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
# define PNG_FREE_UNKN 0x0200
|
||||
# define PNG_FREE_UNKN 0x0200U
|
||||
#endif
|
||||
/* PNG_FREE_LIST 0x0400 removed in 1.6.0 because it is ignored */
|
||||
#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 */
|
||||
/* PNG_FREE_LIST 0x0400U removed in 1.6.0 because it is ignored */
|
||||
#define PNG_FREE_PLTE 0x1000U
|
||||
#define PNG_FREE_TRNS 0x2000U
|
||||
#define PNG_FREE_TEXT 0x4000U
|
||||
#define PNG_FREE_ALL 0x7fffU
|
||||
#define PNG_FREE_MUL 0x4220U /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
|
||||
|
||||
#ifdef PNG_USER_MEM_SUPPORTED
|
||||
PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
|
||||
|
|
@ -2271,8 +2299,10 @@ PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
|
|||
* except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to
|
||||
* be processed by libpng.
|
||||
*/
|
||||
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
|
||||
PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr,
|
||||
int keep, png_const_bytep chunk_list, int num_chunks));
|
||||
#endif /* HANDLE_AS_UNKNOWN */
|
||||
|
||||
/* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned;
|
||||
* the result is therefore true (non-zero) if special handling is required,
|
||||
|
|
@ -2280,7 +2310,7 @@ PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr,
|
|||
*/
|
||||
PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr,
|
||||
png_const_bytep chunk_name));
|
||||
#endif
|
||||
#endif /* SET_UNKNOWN_CHUNKS */
|
||||
|
||||
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr,
|
||||
|
|
@ -2502,18 +2532,22 @@ PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
|
|||
/* 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 temp = (png_uint_16)((png_uint_16)(fg) \
|
||||
* (png_uint_16)(alpha) \
|
||||
+ (png_uint_16)(bg)*(png_uint_16)(255 \
|
||||
- (png_uint_16)(alpha)) + 128); \
|
||||
(composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); }
|
||||
(composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); \
|
||||
}
|
||||
|
||||
# define png_composite_16(composite, fg, alpha, bg) \
|
||||
{ png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
|
||||
{ \
|
||||
png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
|
||||
* (png_uint_32)(alpha) \
|
||||
+ (png_uint_32)(bg)*(65535 \
|
||||
- (png_uint_32)(alpha)) + 32768); \
|
||||
(composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); }
|
||||
(composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); \
|
||||
}
|
||||
|
||||
#else /* Standard method using integer division */
|
||||
|
||||
|
|
@ -2889,12 +2923,19 @@ typedef struct
|
|||
* is the minimum 'row stride', the minimum count of components between each
|
||||
* row. For a color-mapped image this is the minimum number of bytes in a
|
||||
* row.
|
||||
*
|
||||
* WARNING: this macro overflows for some images with more than one component
|
||||
* and very large image widths. libpng will refuse to process an image where
|
||||
* this macro would overflow.
|
||||
*/
|
||||
|
||||
#define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\
|
||||
(PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride))
|
||||
/* Return the size, in bytes, of an image buffer given a png_image and a row
|
||||
* stride - the number of components to leave space for in each row.
|
||||
*
|
||||
* WARNING: this macro overflows a 32-bit integer for some large PNG images,
|
||||
* libpng will refuse to process an image where such an overflow would occur.
|
||||
*/
|
||||
|
||||
#define PNG_IMAGE_SIZE(image)\
|
||||
|
|
@ -3015,7 +3056,6 @@ PNG_EXPORT(238, void, png_image_free, (png_imagep image));
|
|||
#endif /* SIMPLIFIED_READ */
|
||||
|
||||
#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
|
||||
#ifdef PNG_STDIO_SUPPORTED
|
||||
/* WRITE APIS
|
||||
* ----------
|
||||
* For write you must initialize a png_image structure to describe the image to
|
||||
|
|
@ -3032,6 +3072,7 @@ PNG_EXPORT(238, void, png_image_free, (png_imagep image));
|
|||
* values do not correspond to the colors in sRGB.
|
||||
* colormap_entries: set to the number of entries in the color-map (0 to 256)
|
||||
*/
|
||||
#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
|
||||
PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image,
|
||||
const char *file, int convert_to_8bit, const void *buffer,
|
||||
png_int_32 row_stride, const void *colormap));
|
||||
|
|
@ -3041,8 +3082,9 @@ PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
|
|||
int convert_to_8_bit, const void *buffer, png_int_32 row_stride,
|
||||
const void *colormap));
|
||||
/* Write the image to the given (FILE*). */
|
||||
#endif /* SIMPLIFIED_WRITE_STDIO */
|
||||
|
||||
/* With both write APIs if image is in one of the linear formats with 16-bit
|
||||
/* With all write APIs if image is in one of the linear formats with 16-bit
|
||||
* data then setting convert_to_8_bit will cause the output to be an 8-bit PNG
|
||||
* gamma encoded according to the sRGB specification, otherwise a 16-bit linear
|
||||
* encoded PNG file is written.
|
||||
|
|
@ -3054,13 +3096,103 @@ PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
|
|||
*
|
||||
* With all APIs row_stride is handled as in the read APIs - it is the spacing
|
||||
* from one row to the next in component sized units (1 or 2 bytes) and if
|
||||
* negative indicates a bottom-up row layout in the buffer. If row_stride is zero,
|
||||
* libpng will calculate it for you from the image width and number of channels.
|
||||
* negative indicates a bottom-up row layout in the buffer. If row_stride is
|
||||
* zero, libpng will calculate it for you from the image width and number of
|
||||
* channels.
|
||||
*
|
||||
* Note that the write API does not support interlacing, sub-8-bit pixels, indexed
|
||||
* PNG (color_type 3) or most ancillary chunks.
|
||||
* Note that the write API does not support interlacing, sub-8-bit pixels or
|
||||
* most ancillary chunks. If you need to write text chunks (e.g. for copyright
|
||||
* notices) you need to use one of the other APIs.
|
||||
*/
|
||||
|
||||
PNG_EXPORT(245, int, png_image_write_to_memory, (png_imagep image, void *memory,
|
||||
png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8_bit,
|
||||
const void *buffer, png_int_32 row_stride, const void *colormap));
|
||||
/* Write the image to the given memory buffer. The function both writes the
|
||||
* whole PNG data stream to *memory and updates *memory_bytes with the count
|
||||
* of bytes written.
|
||||
*
|
||||
* 'memory' may be NULL. In this case *memory_bytes is not read however on
|
||||
* success the number of bytes which would have been written will still be
|
||||
* stored in *memory_bytes. On failure *memory_bytes will contain 0.
|
||||
*
|
||||
* If 'memory' is not NULL it must point to memory[*memory_bytes] of
|
||||
* writeable memory.
|
||||
*
|
||||
* If the function returns success memory[*memory_bytes] (if 'memory' is not
|
||||
* NULL) contains the written PNG data. *memory_bytes will always be less
|
||||
* than or equal to the original value.
|
||||
*
|
||||
* If the function returns false and *memory_bytes was not changed an error
|
||||
* occured during write. If *memory_bytes was changed, or is not 0 if
|
||||
* 'memory' was NULL, the write would have succeeded but for the memory
|
||||
* buffer being too small. *memory_bytes contains the required number of
|
||||
* bytes and will be bigger that the original value.
|
||||
*/
|
||||
|
||||
#define png_image_write_get_memory_size(image, size, convert_to_8_bit, buffer,\
|
||||
row_stride, colormap)\
|
||||
png_image_write_to_memory(&(image), 0, &(size), convert_to_8_bit, buffer,\
|
||||
row_stride, colormap)
|
||||
/* Return the amount of memory in 'size' required to compress this image.
|
||||
* The png_image structure 'image' must be filled in as in the above
|
||||
* function and must not be changed before the actual write call, the buffer
|
||||
* and all other parameters must also be identical to that in the final
|
||||
* write call. The 'size' variable need not be initialized.
|
||||
*
|
||||
* NOTE: the macro returns true/false, if false is returned 'size' will be
|
||||
* set to zero and the write failed and probably will fail if tried again.
|
||||
*/
|
||||
|
||||
/* You can pre-allocate the buffer by making sure it is of sufficient size
|
||||
* regardless of the amount of compression achieved. The buffer size will
|
||||
* always be bigger than the original image and it will never be filled. The
|
||||
* following macros are provided to assist in allocating the buffer.
|
||||
*/
|
||||
#define PNG_IMAGE_DATA_SIZE(image) (PNG_IMAGE_SIZE(image)+(image).height)
|
||||
/* The number of uncompressed bytes in the PNG byte encoding of the image;
|
||||
* uncompressing the PNG IDAT data will give this number of bytes.
|
||||
*
|
||||
* NOTE: while PNG_IMAGE_SIZE cannot overflow for an image in memory this
|
||||
* macro can because of the extra bytes used in the PNG byte encoding. You
|
||||
* need to avoid this macro if your image size approaches 2^30 in width or
|
||||
* height. The same goes for the remainder of these macros; they all produce
|
||||
* bigger numbers than the actual in-memory image size.
|
||||
*/
|
||||
#ifndef PNG_ZLIB_MAX_SIZE
|
||||
# define PNG_ZLIB_MAX_SIZE(b) ((b)+(((b)+7U)>>3)+(((b)+63U)>>6)+11U)
|
||||
/* An upper bound on the number of compressed bytes given 'b' uncompressed
|
||||
* bytes. This is based on deflateBounds() in zlib; different
|
||||
* implementations of zlib compression may conceivably produce more data so
|
||||
* if your zlib implementation is not zlib itself redefine this macro
|
||||
* appropriately.
|
||||
*/
|
||||
#endif
|
||||
|
||||
#define PNG_IMAGE_COMPRESSED_SIZE_MAX(image)\
|
||||
PNG_ZLIB_MAX_SIZE((png_alloc_size_t)PNG_IMAGE_DATA_SIZE(image))
|
||||
/* An upper bound on the size of the data in the PNG IDAT chunks. */
|
||||
|
||||
#define PNG_IMAGE_PNG_SIZE_MAX_(image, image_size)\
|
||||
((8U/*sig*/+25U/*IHDR*/+16U/*gAMA*/+44U/*cHRM*/+12U/*IEND*/+\
|
||||
(((image).format&PNG_FORMAT_FLAG_COLORMAP)?/*colormap: PLTE, tRNS*/\
|
||||
12U+3U*(image).colormap_entries/*PLTE data*/+\
|
||||
(((image).format&PNG_FORMAT_FLAG_ALPHA)?\
|
||||
12U/*tRNS*/+(image).colormap_entries:0U):0U)+\
|
||||
12U)+(12U*((image_size)/PNG_ZBUF_SIZE))/*IDAT*/+(image_size))
|
||||
/* A helper for the following macro; if your compiler cannot handle the
|
||||
* following macro use this one with the result of
|
||||
* PNG_IMAGE_COMPRESSED_SIZE_MAX(image) as the second argument (most
|
||||
* compilers should handle this just fine.)
|
||||
*/
|
||||
|
||||
#define PNG_IMAGE_PNG_SIZE_MAX(image)\
|
||||
PNG_IMAGE_PNG_SIZE_MAX_(image, PNG_IMAGE_COMPRESSED_SIZE_MAX(image))
|
||||
/* An upper bound on the total length of the PNG data stream for 'image'.
|
||||
* The result is of type png_alloc_size_t, on 32-bit systems this may
|
||||
* overflow even though PNG_IMAGE_DATA_SIZE does not overflow; the write will
|
||||
* run out of buffer space but return a corrected size which should work.
|
||||
*/
|
||||
#endif /* STDIO */
|
||||
#endif /* SIMPLIFIED_WRITE */
|
||||
/*******************************************************************************
|
||||
* END OF SIMPLIFIED API
|
||||
|
|
@ -3118,7 +3250,7 @@ PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option,
|
|||
* one to use is one more than this.)
|
||||
*/
|
||||
#ifdef PNG_EXPORT_LAST_ORDINAL
|
||||
PNG_EXPORT_LAST_ORDINAL(244);
|
||||
PNG_EXPORT_LAST_ORDINAL(245);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
|
||||
/* pngconf.h - machine configurable file for libpng
|
||||
*
|
||||
* libpng version 1.6.21, January 15, 2016
|
||||
* libpng version 1.6.24, August 4, 2016
|
||||
*
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngerror.c - stub functions for i/o and memory allocation
|
||||
*
|
||||
* Last changed in libpng 1.6.15 [November 20, 2014]
|
||||
* Copyright (c) 1998-2002,2004,2006-2014 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
@ -44,7 +44,7 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
|
|||
if (png_ptr != NULL)
|
||||
{
|
||||
if ((png_ptr->flags &
|
||||
(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0
|
||||
(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0)
|
||||
{
|
||||
if (*error_message == PNG_LITERAL_SHARP)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngget.c - retrieval of values from info struct
|
||||
*
|
||||
* Last changed in libpng 1.6.17 [March 26, 2015]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
/* libpng 1.6.21 STANDARD API DEFINITION */
|
||||
/* libpng 1.6.24 STANDARD API DEFINITION */
|
||||
|
||||
/* pnglibconf.h - library build configuration */
|
||||
|
||||
/* Libpng version 1.6.21 - January 15, 2016 */
|
||||
/* Libpng version 1.6.24 - August 4, 2016 */
|
||||
|
||||
/* Copyright (c) 1998-2015 Glenn Randers-Pehrson */
|
||||
|
||||
|
|
@ -109,6 +109,7 @@
|
|||
#define PNG_SIMPLIFIED_READ_SUPPORTED
|
||||
#define PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
|
||||
#define PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
|
||||
#define PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
|
||||
#define PNG_SIMPLIFIED_WRITE_SUPPORTED
|
||||
#define PNG_STDIO_SUPPORTED
|
||||
#define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngmem.c - stub functions for memory allocation
|
||||
*
|
||||
* Last changed in libpng 1.6.15 [November 20, 2014]
|
||||
* Copyright (c) 1998-2002,2004,2006-2014 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2014,2016 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.)
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngpread.c - read a png file in push mode
|
||||
*
|
||||
* Last changed in libpng 1.6.18 [July 23, 2015]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
@ -210,13 +210,15 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
|
|||
(png_ptr->mode & PNG_HAVE_PLTE) == 0)
|
||||
png_error(png_ptr, "Missing PLTE before IDAT");
|
||||
|
||||
png_ptr->mode |= PNG_HAVE_IDAT;
|
||||
png_ptr->process_mode = PNG_READ_IDAT_MODE;
|
||||
|
||||
if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
|
||||
if ((png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) == 0)
|
||||
if (png_ptr->push_length == 0)
|
||||
return;
|
||||
|
||||
png_ptr->mode |= PNG_HAVE_IDAT;
|
||||
|
||||
if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
|
||||
png_benign_error(png_ptr, "Too many IDATs found");
|
||||
}
|
||||
|
|
@ -499,7 +501,10 @@ png_push_save_buffer(png_structrp png_ptr)
|
|||
png_error(png_ptr, "Insufficient memory for save_buffer");
|
||||
}
|
||||
|
||||
if (old_buffer)
|
||||
memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
|
||||
else if (png_ptr->save_buffer_size)
|
||||
png_error(png_ptr, "save_buffer error");
|
||||
png_free(png_ptr, old_buffer);
|
||||
png_ptr->save_buffer_max = new_max;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngpriv.h - private declarations for use inside libpng
|
||||
*
|
||||
* Last changed in libpng 1.6.21 [January 15, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
@ -1174,6 +1174,7 @@ PNG_INTERNAL_FUNCTION(void,png_do_write_interlace,(png_row_infop row_info,
|
|||
PNG_INTERNAL_FUNCTION(void,png_read_filter_row,(png_structrp pp, png_row_infop
|
||||
row_info, png_bytep row, png_const_bytep prev_row, int filter),PNG_EMPTY);
|
||||
|
||||
#if PNG_ARM_NEON_OPT > 0
|
||||
PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_neon,(png_row_infop row_info,
|
||||
png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
|
||||
PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_neon,(png_row_infop
|
||||
|
|
@ -1188,6 +1189,7 @@ PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_neon,(png_row_infop
|
|||
row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
|
||||
PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,(png_row_infop
|
||||
row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
|
||||
#endif
|
||||
|
||||
/* Choose the best filter to use and filter the row data */
|
||||
PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr,
|
||||
|
|
@ -1913,9 +1915,11 @@ PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr,
|
|||
* the builder of libpng passes the definition of PNG_FILTER_OPTIMIZATIONS in
|
||||
* CFLAGS in place of CPPFLAGS *and* uses symbol prefixing.
|
||||
*/
|
||||
# if PNG_ARM_NEON_OPT > 0
|
||||
PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon,
|
||||
(png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
|
||||
# endif
|
||||
#endif
|
||||
|
||||
PNG_INTERNAL_FUNCTION(png_uint_32, png_check_keyword, (png_structrp png_ptr,
|
||||
png_const_charp key, png_bytep new_key), PNG_EMPTY);
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngread.c - read a PNG file
|
||||
*
|
||||
* Last changed in libpng 1.6.17 [March 26, 2015]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
@ -127,7 +127,10 @@ png_read_info(png_structrp png_ptr, png_inforp info_ptr)
|
|||
}
|
||||
|
||||
else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
|
||||
{
|
||||
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
|
||||
png_ptr->mode |= PNG_AFTER_IDAT;
|
||||
}
|
||||
|
||||
/* This should be a binary subdivision search or a hash for
|
||||
* matching the chunk name rather than a linear search.
|
||||
|
|
@ -785,6 +788,9 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
|
|||
png_uint_32 length = png_read_chunk_header(png_ptr);
|
||||
png_uint_32 chunk_name = png_ptr->chunk_name;
|
||||
|
||||
if (chunk_name != png_IDAT)
|
||||
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
|
||||
|
||||
if (chunk_name == png_IEND)
|
||||
png_handle_IEND(png_ptr, info_ptr, length);
|
||||
|
||||
|
|
@ -799,9 +805,9 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
|
|||
{
|
||||
if (chunk_name == png_IDAT)
|
||||
{
|
||||
if ((length > 0) ||
|
||||
(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
|
||||
png_benign_error(png_ptr, "Too many IDATs found");
|
||||
if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
|
||||
|| (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
|
||||
png_benign_error(png_ptr, ".Too many IDATs found");
|
||||
}
|
||||
png_handle_unknown(png_ptr, info_ptr, length, keep);
|
||||
if (chunk_name == png_PLTE)
|
||||
|
|
@ -812,10 +818,14 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
|
|||
else if (chunk_name == png_IDAT)
|
||||
{
|
||||
/* Zero length IDATs are legal after the last IDAT has been
|
||||
* read, but not after other chunks have been read.
|
||||
* read, but not after other chunks have been read. 1.6 does not
|
||||
* always read all the deflate data; specifically it cannot be relied
|
||||
* upon to read the Adler32 at the end. If it doesn't ignore IDAT
|
||||
* chunks which are longer than zero as well:
|
||||
*/
|
||||
if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
|
||||
png_benign_error(png_ptr, "Too many IDATs found");
|
||||
if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
|
||||
|| (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
|
||||
png_benign_error(png_ptr, "..Too many IDATs found");
|
||||
|
||||
png_crc_finish(png_ptr, length);
|
||||
}
|
||||
|
|
@ -1020,8 +1030,7 @@ png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn)
|
|||
#ifdef PNG_INFO_IMAGE_SUPPORTED
|
||||
void PNGAPI
|
||||
png_read_png(png_structrp png_ptr, png_inforp info_ptr,
|
||||
int transforms,
|
||||
voidp params)
|
||||
int transforms, voidp params)
|
||||
{
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
return;
|
||||
|
|
@ -2095,7 +2104,7 @@ png_image_read_colormap(png_voidp argument)
|
|||
|
||||
else if (display->background == NULL /* no way to remove it */)
|
||||
png_error(png_ptr,
|
||||
"a background color must be supplied to remove alpha/transparency");
|
||||
"background color must be supplied to remove alpha/transparency");
|
||||
|
||||
/* Get a copy of the background color (this avoids repeating the checks
|
||||
* below.) The encoding is 8-bit sRGB or 16-bit linear, depending on the
|
||||
|
|
@ -2420,8 +2429,8 @@ png_image_read_colormap(png_voidp argument)
|
|||
background_index = i;
|
||||
png_create_colormap_entry(display, i++, back_r, back_g, back_b,
|
||||
#ifdef __COVERITY__
|
||||
/* Coverity claims that output_encoding cannot be 2 (P_LINEAR)
|
||||
* here.
|
||||
/* Coverity claims that output_encoding
|
||||
* cannot be 2 (P_LINEAR) here.
|
||||
*/ 255U,
|
||||
#else
|
||||
output_encoding == P_LINEAR ? 65535U : 255U,
|
||||
|
|
@ -2809,12 +2818,12 @@ png_image_read_colormap(png_voidp argument)
|
|||
* on the sRGB color in 'back'.
|
||||
*/
|
||||
png_create_colormap_entry(display, i,
|
||||
png_colormap_compose(display, colormap[i].red, P_FILE,
|
||||
trans[i], back_r, output_encoding),
|
||||
png_colormap_compose(display, colormap[i].green, P_FILE,
|
||||
trans[i], back_g, output_encoding),
|
||||
png_colormap_compose(display, colormap[i].blue, P_FILE,
|
||||
trans[i], back_b, output_encoding),
|
||||
png_colormap_compose(display, colormap[i].red,
|
||||
P_FILE, trans[i], back_r, output_encoding),
|
||||
png_colormap_compose(display, colormap[i].green,
|
||||
P_FILE, trans[i], back_g, output_encoding),
|
||||
png_colormap_compose(display, colormap[i].blue,
|
||||
P_FILE, trans[i], back_b, output_encoding),
|
||||
output_encoding == P_LINEAR ? trans[i] * 257U :
|
||||
trans[i],
|
||||
output_encoding);
|
||||
|
|
@ -3423,8 +3432,7 @@ png_image_read_background(png_voidp argument)
|
|||
|
||||
for (pass = 0; pass < passes; ++pass)
|
||||
{
|
||||
png_bytep row = png_voidcast(png_bytep,
|
||||
display->first_row);
|
||||
png_bytep row = png_voidcast(png_bytep, display->first_row);
|
||||
unsigned int startx, stepx, stepy;
|
||||
png_uint_32 y;
|
||||
|
||||
|
|
@ -4070,11 +4078,26 @@ png_image_finish_read(png_imagep image, png_const_colorp background,
|
|||
void *buffer, png_int_32 row_stride, void *colormap)
|
||||
{
|
||||
if (image != NULL && image->version == PNG_IMAGE_VERSION)
|
||||
{
|
||||
/* Check for row_stride overflow. This check is not performed on the
|
||||
* original PNG format because it may not occur in the output PNG format
|
||||
* and libpng deals with the issues of reading the original.
|
||||
*/
|
||||
const unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
|
||||
|
||||
/* The following checks just the 'row_stride' calculation to ensure it
|
||||
* fits in a signed 32-bit value. Because channels/components can be
|
||||
* either 1 or 2 bytes in size the length of a row can still overflow 32
|
||||
* bits; this is just to verify that the 'row_stride' argument can be
|
||||
* represented.
|
||||
*/
|
||||
if (image->width <= 0x7FFFFFFFU/channels) /* no overflow */
|
||||
{
|
||||
png_uint_32 check;
|
||||
const png_uint_32 png_row_stride = image->width * channels;
|
||||
|
||||
if (row_stride == 0)
|
||||
row_stride = PNG_IMAGE_ROW_STRIDE(*image);
|
||||
row_stride = (png_int_32)/*SAFE*/png_row_stride;
|
||||
|
||||
if (row_stride < 0)
|
||||
check = -row_stride;
|
||||
|
|
@ -4082,8 +4105,30 @@ png_image_finish_read(png_imagep image, png_const_colorp background,
|
|||
else
|
||||
check = row_stride;
|
||||
|
||||
if (image->opaque != NULL && buffer != NULL &&
|
||||
check >= PNG_IMAGE_ROW_STRIDE(*image))
|
||||
/* This verifies 'check', the absolute value of the actual stride
|
||||
* passed in and detects overflow in the application calculation (i.e.
|
||||
* if the app did actually pass in a non-zero 'row_stride'.
|
||||
*/
|
||||
if (image->opaque != NULL && buffer != NULL && check >= png_row_stride)
|
||||
{
|
||||
/* Now check for overflow of the image buffer calculation; this
|
||||
* limits the whole image size to 32 bits for API compatibility with
|
||||
* the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro.
|
||||
*
|
||||
* The PNG_IMAGE_BUFFER_SIZE macro is:
|
||||
*
|
||||
* (PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)*height*(row_stride))
|
||||
*
|
||||
* And the component size is always 1 or 2, so make sure that the
|
||||
* number of *bytes* that the application is saying are available
|
||||
* does actually fit into a 32-bit number.
|
||||
*
|
||||
* NOTE: this will be changed in 1.7 because PNG_IMAGE_BUFFER_SIZE
|
||||
* will be changed to use png_alloc_size_t; bigger images can be
|
||||
* accomodated on 64-bit systems.
|
||||
*/
|
||||
if (image->height <=
|
||||
0xFFFFFFFFU/PNG_IMAGE_PIXEL_COMPONENT_SIZE(image->format)/check)
|
||||
{
|
||||
if ((image->format & PNG_FORMAT_FLAG_COLORMAP) == 0 ||
|
||||
(image->colormap_entries > 0 && colormap != NULL))
|
||||
|
|
@ -4099,17 +4144,20 @@ png_image_finish_read(png_imagep image, png_const_colorp background,
|
|||
display.background = background;
|
||||
display.local_row = NULL;
|
||||
|
||||
/* Choose the correct 'end' routine; for the color-map case all the
|
||||
* setup has already been done.
|
||||
/* Choose the correct 'end' routine; for the color-map case
|
||||
* all the setup has already been done.
|
||||
*/
|
||||
if ((image->format & PNG_FORMAT_FLAG_COLORMAP) != 0)
|
||||
result =
|
||||
png_safe_execute(image, png_image_read_colormap, &display) &&
|
||||
png_safe_execute(image, png_image_read_colormapped, &display);
|
||||
png_safe_execute(image,
|
||||
png_image_read_colormap, &display) &&
|
||||
png_safe_execute(image,
|
||||
png_image_read_colormapped, &display);
|
||||
|
||||
else
|
||||
result =
|
||||
png_safe_execute(image, png_image_read_direct, &display);
|
||||
png_safe_execute(image,
|
||||
png_image_read_direct, &display);
|
||||
|
||||
png_image_free(image);
|
||||
return result;
|
||||
|
|
@ -4120,11 +4168,21 @@ png_image_finish_read(png_imagep image, png_const_colorp background,
|
|||
"png_image_finish_read[color-map]: no color-map");
|
||||
}
|
||||
|
||||
else
|
||||
return png_image_error(image,
|
||||
"png_image_finish_read: image too large");
|
||||
}
|
||||
|
||||
else
|
||||
return png_image_error(image,
|
||||
"png_image_finish_read: invalid argument");
|
||||
}
|
||||
|
||||
else
|
||||
return png_image_error(image,
|
||||
"png_image_finish_read: row_stride too large");
|
||||
}
|
||||
|
||||
else if (image != NULL)
|
||||
return png_image_error(image,
|
||||
"png_image_finish_read: damaged PNG_IMAGE_VERSION");
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngrio.c - functions for data input
|
||||
*
|
||||
* Last changed in libpng 1.6.17 [March 26, 2015]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngrtran.c - transforms the data in a row for PNG readers
|
||||
*
|
||||
* Last changed in libpng 1.6.19 [November 12, 2015]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
@ -289,9 +289,12 @@ png_set_alpha_mode_fixed(png_structrp png_ptr, int mode,
|
|||
* is expected to be 1 or greater, but this range test allows for some
|
||||
* viewing correction values. The intent is to weed out users of this API
|
||||
* who use the inverse of the gamma value accidentally! Since some of these
|
||||
* values are reasonable this may have to be changed.
|
||||
* values are reasonable this may have to be changed:
|
||||
*
|
||||
* 1.6.x: changed from 0.07..3 to 0.01..100 (to accomodate the optimal 16-bit
|
||||
* gamma of 36, and its reciprocal.)
|
||||
*/
|
||||
if (output_gamma < 70000 || output_gamma > 300000)
|
||||
if (output_gamma < 1000 || output_gamma > 10000000)
|
||||
png_error(png_ptr, "output gamma out of expected range");
|
||||
|
||||
/* The default file gamma is the inverse of the output gamma; the output
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngrutil.c - utilities to read a PNG file
|
||||
*
|
||||
* Last changed in libpng 1.6.20 [December 3, 2014]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
@ -590,6 +590,7 @@ png_inflate(png_structrp png_ptr, png_uint_32 owner, int finish,
|
|||
}
|
||||
}
|
||||
|
||||
#if defined(PNG_READ_zTXt_SUPPORTED) || defined (PNG_READ_iTXt_SUPPORTED)
|
||||
/*
|
||||
* Decompress trailing data in a chunk. The assumption is that read_buffer
|
||||
* points at an allocated area holding the contents of a chunk with a
|
||||
|
|
@ -754,6 +755,7 @@ png_decompress_chunk(png_structrp png_ptr,
|
|||
return Z_MEM_ERROR;
|
||||
}
|
||||
}
|
||||
#endif /* READ_zTXt || READ_iTXt */
|
||||
#endif /* READ_COMPRESSED_TEXT */
|
||||
|
||||
#ifdef PNG_READ_iCCP_SUPPORTED
|
||||
|
|
@ -802,8 +804,8 @@ png_inflate_read(png_structrp png_ptr, png_bytep read_buffer, uInt read_size,
|
|||
* the available output is produced; this allows reading of truncated
|
||||
* streams.
|
||||
*/
|
||||
ret = PNG_INFLATE(png_ptr,
|
||||
*chunk_bytes > 0 ? Z_NO_FLUSH : (finish ? Z_FINISH : Z_SYNC_FLUSH));
|
||||
ret = PNG_INFLATE(png_ptr, *chunk_bytes > 0 ?
|
||||
Z_NO_FLUSH : (finish ? Z_FINISH : Z_SYNC_FLUSH));
|
||||
}
|
||||
while (ret == Z_OK && (*out_size > 0 || png_ptr->zstream.avail_out > 0));
|
||||
|
||||
|
|
@ -1512,7 +1514,7 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
|
|||
png_crc_finish(png_ptr, length);
|
||||
finished = 1;
|
||||
|
||||
# ifdef PNG_sRGB_SUPPORTED
|
||||
# if defined(PNG_sRGB_SUPPORTED) && PNG_sRGB_PROFILE_CHECKS >= 0
|
||||
/* Check for a match against sRGB */
|
||||
png_icc_set_sRGB(png_ptr,
|
||||
&png_ptr->colorspace, profile,
|
||||
|
|
@ -3418,8 +3420,8 @@ png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
|
|||
/* Everything is aligned for png_uint_16 copies, but try for
|
||||
* png_uint_32 first.
|
||||
*/
|
||||
if (png_isaligned(dp, png_uint_32) != 0 &&
|
||||
png_isaligned(sp, png_uint_32) != 0 &&
|
||||
if (png_isaligned(dp, png_uint_32) &&
|
||||
png_isaligned(sp, png_uint_32) &&
|
||||
bytes_to_copy % (sizeof (png_uint_32)) == 0 &&
|
||||
bytes_to_jump % (sizeof (png_uint_32)) == 0)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngset.c - storage of image information into info struct
|
||||
*
|
||||
* Last changed in libpng 1.6.21 [January 15, 2016]
|
||||
* Copyright (c) 1998-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2016 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.)
|
||||
*
|
||||
|
|
@ -952,13 +952,15 @@ png_set_tRNS(png_structrp png_ptr, png_inforp info_ptr,
|
|||
|
||||
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_voidcast(png_bytep,
|
||||
png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH));
|
||||
|
||||
if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
|
||||
{
|
||||
/* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
|
||||
info_ptr->trans_alpha = png_voidcast(png_bytep,
|
||||
png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH));
|
||||
memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);
|
||||
}
|
||||
png_ptr->trans_alpha = info_ptr->trans_alpha;
|
||||
}
|
||||
|
||||
if (trans_color != NULL)
|
||||
{
|
||||
|
|
@ -1660,7 +1662,9 @@ png_set_check_for_invalid_index(png_structrp png_ptr, int allowed)
|
|||
png_uint_32 /* PRIVATE */
|
||||
png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
|
||||
{
|
||||
#ifdef PNG_WARNINGS_SUPPORTED
|
||||
png_const_charp orig_key = key;
|
||||
#endif
|
||||
png_uint_32 key_len = 0;
|
||||
int bad_character = 0;
|
||||
int space = 1;
|
||||
|
|
@ -1723,7 +1727,9 @@ png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
|
|||
|
||||
png_formatted_warning(png_ptr, p, "keyword \"@1\": bad character '0x@2'");
|
||||
}
|
||||
#endif /* WARNINGS */
|
||||
#else /* !WARNINGS */
|
||||
PNG_UNUSED(png_ptr)
|
||||
#endif /* !WARNINGS */
|
||||
|
||||
return key_len;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngstruct.h - header file for PNG reference library
|
||||
*
|
||||
* Last changed in libpng 1.6.18 [July 23, 2015]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
@ -249,7 +249,7 @@ struct png_struct_def
|
|||
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 do_filter; /* row filter flags (see PNG_FILTER_ in png.h ) */
|
||||
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: write only */
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngtrans.c - transforms the data in a row (used by both readers and writers)
|
||||
*
|
||||
* Last changed in libpng 1.6.18 [July 23, 2015]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
@ -172,7 +172,8 @@ png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
|
|||
* size!
|
||||
*/
|
||||
png_app_error(png_ptr,
|
||||
"png_set_filler is invalid for low bit depth gray output");
|
||||
"png_set_filler is invalid for"
|
||||
" low bit depth gray output");
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngwio.c - functions for data output
|
||||
*
|
||||
* Last changed in libpng 1.6.15 [November 20, 2014]
|
||||
* Copyright (c) 1998-2002,2004,2006-2014 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2014,2016 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.)
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngwrite.c - general routines to write a PNG file
|
||||
*
|
||||
* Last changed in libpng 1.6.19 [November 12, 2015]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
@ -12,9 +12,9 @@
|
|||
*/
|
||||
|
||||
#include "pngpriv.h"
|
||||
#if defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
|
||||
#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
|
||||
# include <errno.h>
|
||||
#endif
|
||||
#endif /* SIMPLIFIED_WRITE_STDIO */
|
||||
|
||||
#ifdef PNG_WRITE_SUPPORTED
|
||||
|
||||
|
|
@ -1452,7 +1452,6 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
|
|||
|
||||
|
||||
#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
|
||||
# ifdef PNG_STDIO_SUPPORTED /* currently required for png_image_write_* */
|
||||
/* Initialize the write structure - general purpose utility. */
|
||||
static int
|
||||
png_image_write_init(png_imagep image)
|
||||
|
|
@ -1504,6 +1503,10 @@ typedef struct
|
|||
png_const_voidp first_row;
|
||||
ptrdiff_t row_bytes;
|
||||
png_voidp local_row;
|
||||
/* Byte count for memory writing */
|
||||
png_bytep memory;
|
||||
png_alloc_size_t memory_bytes; /* not used for STDIO */
|
||||
png_alloc_size_t output_bytes; /* running total */
|
||||
} png_image_write_control;
|
||||
|
||||
/* Write png_uint_16 input to a 16-bit PNG; the png_ptr has already been set to
|
||||
|
|
@ -1931,9 +1934,43 @@ png_image_write_main(png_voidp argument)
|
|||
png_set_benign_errors(png_ptr, 0/*error*/);
|
||||
# endif
|
||||
|
||||
/* Default the 'row_stride' parameter if required. */
|
||||
/* Default the 'row_stride' parameter if required, also check the row stride
|
||||
* and total image size to ensure that they are within the system limits.
|
||||
*/
|
||||
{
|
||||
const unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
|
||||
|
||||
if (image->width <= 0x7FFFFFFFU/channels) /* no overflow */
|
||||
{
|
||||
png_uint_32 check;
|
||||
const png_uint_32 png_row_stride = image->width * channels;
|
||||
|
||||
if (display->row_stride == 0)
|
||||
display->row_stride = PNG_IMAGE_ROW_STRIDE(*image);
|
||||
display->row_stride = (png_int_32)/*SAFE*/png_row_stride;
|
||||
|
||||
if (display->row_stride < 0)
|
||||
check = -display->row_stride;
|
||||
|
||||
else
|
||||
check = display->row_stride;
|
||||
|
||||
if (check >= png_row_stride)
|
||||
{
|
||||
/* Now check for overflow of the image buffer calculation; this
|
||||
* limits the whole image size to 32 bits for API compatibility with
|
||||
* the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro.
|
||||
*/
|
||||
if (image->height > 0xFFFFFFFF/png_row_stride)
|
||||
png_error(image->opaque->png_ptr, "memory image too large");
|
||||
}
|
||||
|
||||
else
|
||||
png_error(image->opaque->png_ptr, "supplied row stride too small");
|
||||
}
|
||||
|
||||
else
|
||||
png_error(image->opaque->png_ptr, "image row stride too large");
|
||||
}
|
||||
|
||||
/* Set the required transforms then write the rows in the correct order. */
|
||||
if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0)
|
||||
|
|
@ -2110,6 +2147,122 @@ png_image_write_main(png_voidp argument)
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static void (PNGCBAPI
|
||||
image_memory_write)(png_structp png_ptr, png_bytep/*const*/ data,
|
||||
png_size_t size)
|
||||
{
|
||||
png_image_write_control *display = png_voidcast(png_image_write_control*,
|
||||
png_ptr->io_ptr/*backdoor: png_get_io_ptr(png_ptr)*/);
|
||||
const png_alloc_size_t ob = display->output_bytes;
|
||||
|
||||
/* Check for overflow; this should never happen: */
|
||||
if (size <= ((png_alloc_size_t)-1) - ob)
|
||||
{
|
||||
/* I don't think libpng ever does this, but just in case: */
|
||||
if (size > 0)
|
||||
{
|
||||
if (display->memory_bytes >= ob+size) /* writing */
|
||||
memcpy(display->memory+ob, data, size);
|
||||
|
||||
/* Always update the size: */
|
||||
display->output_bytes = ob+size;
|
||||
}
|
||||
}
|
||||
|
||||
else
|
||||
png_error(png_ptr, "png_image_write_to_memory: PNG too big");
|
||||
}
|
||||
|
||||
static void (PNGCBAPI
|
||||
image_memory_flush)(png_structp png_ptr)
|
||||
{
|
||||
PNG_UNUSED(png_ptr)
|
||||
}
|
||||
|
||||
static int
|
||||
png_image_write_memory(png_voidp argument)
|
||||
{
|
||||
png_image_write_control *display = png_voidcast(png_image_write_control*,
|
||||
argument);
|
||||
|
||||
/* The rest of the memory-specific init and write_main in an error protected
|
||||
* environment. This case needs to use callbacks for the write operations
|
||||
* since libpng has no built in support for writing to memory.
|
||||
*/
|
||||
png_set_write_fn(display->image->opaque->png_ptr, display/*io_ptr*/,
|
||||
image_memory_write, image_memory_flush);
|
||||
|
||||
return png_image_write_main(display);
|
||||
}
|
||||
|
||||
int PNGAPI
|
||||
png_image_write_to_memory(png_imagep image, void *memory,
|
||||
png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8bit,
|
||||
const void *buffer, png_int_32 row_stride, const void *colormap)
|
||||
{
|
||||
/* Write the image to the given buffer, or count the bytes if it is NULL */
|
||||
if (image != NULL && image->version == PNG_IMAGE_VERSION)
|
||||
{
|
||||
if (memory_bytes != NULL && buffer != NULL)
|
||||
{
|
||||
/* This is to give the caller an easier error detection in the NULL
|
||||
* case and guard against uninitialized variable problems:
|
||||
*/
|
||||
if (memory == NULL)
|
||||
*memory_bytes = 0;
|
||||
|
||||
if (png_image_write_init(image) != 0)
|
||||
{
|
||||
png_image_write_control display;
|
||||
int result;
|
||||
|
||||
memset(&display, 0, (sizeof display));
|
||||
display.image = image;
|
||||
display.buffer = buffer;
|
||||
display.row_stride = row_stride;
|
||||
display.colormap = colormap;
|
||||
display.convert_to_8bit = convert_to_8bit;
|
||||
display.memory = png_voidcast(png_bytep, memory);
|
||||
display.memory_bytes = *memory_bytes;
|
||||
display.output_bytes = 0;
|
||||
|
||||
result = png_safe_execute(image, png_image_write_memory, &display);
|
||||
png_image_free(image);
|
||||
|
||||
/* write_memory returns true even if we ran out of buffer. */
|
||||
if (result)
|
||||
{
|
||||
/* On out-of-buffer this function returns '0' but still updates
|
||||
* memory_bytes:
|
||||
*/
|
||||
if (memory != NULL && display.output_bytes > *memory_bytes)
|
||||
result = 0;
|
||||
|
||||
*memory_bytes = display.output_bytes;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
else
|
||||
return png_image_error(image,
|
||||
"png_image_write_to_memory: invalid argument");
|
||||
}
|
||||
|
||||
else if (image != NULL)
|
||||
return png_image_error(image,
|
||||
"png_image_write_to_memory: incorrect PNG_IMAGE_VERSION");
|
||||
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
|
||||
int PNGAPI
|
||||
png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit,
|
||||
const void *buffer, png_int_32 row_stride, const void *colormap)
|
||||
|
|
@ -2117,7 +2270,7 @@ png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit,
|
|||
/* Write the image to the given (FILE*). */
|
||||
if (image != NULL && image->version == PNG_IMAGE_VERSION)
|
||||
{
|
||||
if (file != NULL)
|
||||
if (file != NULL && buffer != NULL)
|
||||
{
|
||||
if (png_image_write_init(image) != 0)
|
||||
{
|
||||
|
|
@ -2167,7 +2320,7 @@ png_image_write_to_file(png_imagep image, const char *file_name,
|
|||
/* Write the image to the named file. */
|
||||
if (image != NULL && image->version == PNG_IMAGE_VERSION)
|
||||
{
|
||||
if (file_name != NULL)
|
||||
if (file_name != NULL && buffer != NULL)
|
||||
{
|
||||
FILE *fp = fopen(file_name, "wb");
|
||||
|
||||
|
|
@ -2225,6 +2378,6 @@ png_image_write_to_file(png_imagep image, const char *file_name,
|
|||
else
|
||||
return 0;
|
||||
}
|
||||
# endif /* STDIO */
|
||||
#endif /* SIMPLIFIED_WRITE_STDIO */
|
||||
#endif /* SIMPLIFIED_WRITE */
|
||||
#endif /* WRITE */
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngwtran.c - transforms the data in a row for PNG writers
|
||||
*
|
||||
* Last changed in libpng 1.6.18 [July 23, 2015]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
|
||||
/* pngwutil.c - utilities to write a PNG file
|
||||
*
|
||||
* Last changed in libpng 1.6.21 [January 15, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson
|
||||
* Last changed in libpng 1.6.24 [August 4, 2016]
|
||||
* Copyright (c) 1998-2002,2004,2006-2016 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.)
|
||||
*
|
||||
|
|
@ -23,10 +23,10 @@
|
|||
void PNGAPI
|
||||
png_save_uint_32(png_bytep buf, png_uint_32 i)
|
||||
{
|
||||
buf[0] = (png_byte)(i >> 24);
|
||||
buf[1] = (png_byte)(i >> 16);
|
||||
buf[2] = (png_byte)(i >> 8);
|
||||
buf[3] = (png_byte)(i );
|
||||
buf[0] = (png_byte)((i >> 24) & 0xffU);
|
||||
buf[1] = (png_byte)((i >> 16) & 0xffU);
|
||||
buf[2] = (png_byte)((i >> 8) & 0xffU);
|
||||
buf[3] = (png_byte)( i & 0xffU);
|
||||
}
|
||||
|
||||
/* Place a 16-bit number into a buffer in PNG byte order.
|
||||
|
|
@ -36,8 +36,8 @@ png_save_uint_32(png_bytep buf, png_uint_32 i)
|
|||
void PNGAPI
|
||||
png_save_uint_16(png_bytep buf, unsigned int i)
|
||||
{
|
||||
buf[0] = (png_byte)(i >> 8);
|
||||
buf[1] = (png_byte)(i );
|
||||
buf[0] = (png_byte)((i >> 8) & 0xffU);
|
||||
buf[1] = (png_byte)( i & 0xffU);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -1441,7 +1441,8 @@ png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
|
|||
#endif
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
|
||||
"Ignoring attempt to write 16-bit bKGD chunk "
|
||||
"when bit_depth is 8");
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
@ -2262,14 +2263,22 @@ png_setup_sub_row(png_structrp png_ptr, const png_uint_32 bpp,
|
|||
i++, rp++, dp++)
|
||||
{
|
||||
v = *dp = *rp;
|
||||
#ifdef PNG_USE_ABS
|
||||
sum += 128 - abs(v - 128);
|
||||
#else
|
||||
sum += (v < 128) ? v : 256 - v;
|
||||
#endif
|
||||
}
|
||||
|
||||
for (lp = png_ptr->row_buf + 1; i < row_bytes;
|
||||
i++, rp++, lp++, dp++)
|
||||
{
|
||||
v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
|
||||
#ifdef PNG_USE_ABS
|
||||
sum += 128 - abs(v - 128);
|
||||
#else
|
||||
sum += (v < 128) ? v : 256 - v;
|
||||
#endif
|
||||
|
||||
if (sum > lmins) /* We are already worse, don't continue. */
|
||||
break;
|
||||
|
|
@ -2278,6 +2287,28 @@ png_setup_sub_row(png_structrp png_ptr, const png_uint_32 bpp,
|
|||
return (sum);
|
||||
}
|
||||
|
||||
static void /* PRIVATE */
|
||||
png_setup_sub_row_only(png_structrp png_ptr, const png_uint_32 bpp,
|
||||
const png_size_t row_bytes)
|
||||
{
|
||||
png_bytep rp, dp, lp;
|
||||
png_size_t i;
|
||||
|
||||
png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB;
|
||||
|
||||
for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1; i < bpp;
|
||||
i++, rp++, dp++)
|
||||
{
|
||||
*dp = *rp;
|
||||
}
|
||||
|
||||
for (lp = png_ptr->row_buf + 1; i < row_bytes;
|
||||
i++, rp++, lp++, dp++)
|
||||
{
|
||||
*dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
|
||||
}
|
||||
}
|
||||
|
||||
static png_size_t /* PRIVATE */
|
||||
png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes,
|
||||
const png_size_t lmins)
|
||||
|
|
@ -2294,7 +2325,11 @@ png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes,
|
|||
i++, rp++, pp++, dp++)
|
||||
{
|
||||
v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
|
||||
#ifdef PNG_USE_ABS
|
||||
sum += 128 - abs(v - 128);
|
||||
#else
|
||||
sum += (v < 128) ? v : 256 - v;
|
||||
#endif
|
||||
|
||||
if (sum > lmins) /* We are already worse, don't continue. */
|
||||
break;
|
||||
|
|
@ -2302,6 +2337,21 @@ png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes,
|
|||
|
||||
return (sum);
|
||||
}
|
||||
static void /* PRIVATE */
|
||||
png_setup_up_row_only(png_structrp png_ptr, const png_size_t row_bytes)
|
||||
{
|
||||
png_bytep rp, dp, pp;
|
||||
png_size_t i;
|
||||
|
||||
png_ptr->try_row[0] = PNG_FILTER_VALUE_UP;
|
||||
|
||||
for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
|
||||
pp = png_ptr->prev_row + 1; i < row_bytes;
|
||||
i++, rp++, pp++, dp++)
|
||||
{
|
||||
*dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
|
||||
}
|
||||
}
|
||||
|
||||
static png_size_t /* PRIVATE */
|
||||
png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
|
||||
|
|
@ -2319,7 +2369,11 @@ png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
|
|||
{
|
||||
v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
|
||||
|
||||
#ifdef PNG_USE_ABS
|
||||
sum += 128 - abs(v - 128);
|
||||
#else
|
||||
sum += (v < 128) ? v : 256 - v;
|
||||
#endif
|
||||
}
|
||||
|
||||
for (lp = png_ptr->row_buf + 1; i < row_bytes; i++)
|
||||
|
|
@ -2327,7 +2381,11 @@ png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
|
|||
v = *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
|
||||
& 0xff);
|
||||
|
||||
#ifdef PNG_USE_ABS
|
||||
sum += 128 - abs(v - 128);
|
||||
#else
|
||||
sum += (v < 128) ? v : 256 - v;
|
||||
#endif
|
||||
|
||||
if (sum > lmins) /* We are already worse, don't continue. */
|
||||
break;
|
||||
|
|
@ -2335,6 +2393,27 @@ png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
|
|||
|
||||
return (sum);
|
||||
}
|
||||
static void /* PRIVATE */
|
||||
png_setup_avg_row_only(png_structrp png_ptr, const png_uint_32 bpp,
|
||||
const png_size_t row_bytes)
|
||||
{
|
||||
png_bytep rp, dp, pp, lp;
|
||||
png_uint_32 i;
|
||||
|
||||
png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG;
|
||||
|
||||
for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
|
||||
pp = png_ptr->prev_row + 1; i < bpp; i++)
|
||||
{
|
||||
*dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
|
||||
}
|
||||
|
||||
for (lp = png_ptr->row_buf + 1; i < row_bytes; i++)
|
||||
{
|
||||
*dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
|
||||
& 0xff);
|
||||
}
|
||||
}
|
||||
|
||||
static png_size_t /* PRIVATE */
|
||||
png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
|
||||
|
|
@ -2352,7 +2431,11 @@ png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
|
|||
{
|
||||
v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
|
||||
|
||||
#ifdef PNG_USE_ABS
|
||||
sum += 128 - abs(v - 128);
|
||||
#else
|
||||
sum += (v < 128) ? v : 256 - v;
|
||||
#endif
|
||||
}
|
||||
|
||||
for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes;
|
||||
|
|
@ -2381,7 +2464,11 @@ png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
|
|||
|
||||
v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
|
||||
|
||||
#ifdef PNG_USE_ABS
|
||||
sum += 128 - abs(v - 128);
|
||||
#else
|
||||
sum += (v < 128) ? v : 256 - v;
|
||||
#endif
|
||||
|
||||
if (sum > lmins) /* We are already worse, don't continue. */
|
||||
break;
|
||||
|
|
@ -2389,6 +2476,48 @@ png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
|
|||
|
||||
return (sum);
|
||||
}
|
||||
static void /* PRIVATE */
|
||||
png_setup_paeth_row_only(png_structrp png_ptr, const png_uint_32 bpp,
|
||||
const png_size_t row_bytes)
|
||||
{
|
||||
png_bytep rp, dp, pp, cp, lp;
|
||||
png_size_t i;
|
||||
|
||||
png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH;
|
||||
|
||||
for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
|
||||
pp = png_ptr->prev_row + 1; i < bpp; i++)
|
||||
{
|
||||
*dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
|
||||
}
|
||||
|
||||
for (lp = png_ptr->row_buf + 1, cp = png_ptr->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);
|
||||
}
|
||||
}
|
||||
#endif /* WRITE_FILTER */
|
||||
|
||||
void /* PRIVATE */
|
||||
|
|
@ -2397,7 +2526,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
|
|||
#ifndef PNG_WRITE_FILTER_SUPPORTED
|
||||
png_write_filtered_row(png_ptr, png_ptr->row_buf, row_info->rowbytes+1);
|
||||
#else
|
||||
png_byte filter_to_do = png_ptr->do_filter;
|
||||
unsigned int filter_to_do = png_ptr->do_filter;
|
||||
png_bytep row_buf;
|
||||
png_bytep best_row;
|
||||
png_uint_32 bpp;
|
||||
|
|
@ -2443,32 +2572,33 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
|
|||
*/
|
||||
best_row = png_ptr->row_buf;
|
||||
|
||||
|
||||
if ((filter_to_do & PNG_FILTER_NONE) != 0 && filter_to_do != PNG_FILTER_NONE)
|
||||
if (PNG_SIZE_MAX/128 <= row_bytes)
|
||||
{
|
||||
/* Overflow can occur in the calculation, just select the lowest set
|
||||
* filter.
|
||||
*/
|
||||
filter_to_do &= 0U-filter_to_do;
|
||||
}
|
||||
else if ((filter_to_do & PNG_FILTER_NONE) != 0 &&
|
||||
filter_to_do != PNG_FILTER_NONE)
|
||||
{
|
||||
/* Overflow not possible and multiple filters in the list, including the
|
||||
* 'none' filter.
|
||||
*/
|
||||
png_bytep rp;
|
||||
png_size_t sum = 0;
|
||||
png_size_t i;
|
||||
int v;
|
||||
|
||||
if (PNG_SIZE_MAX/128 <= row_bytes)
|
||||
{
|
||||
for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
|
||||
{
|
||||
/* Check for overflow */
|
||||
if (sum > PNG_SIZE_MAX/128 - 256)
|
||||
break;
|
||||
|
||||
v = *rp;
|
||||
sum += (v < 128) ? v : 256 - v;
|
||||
}
|
||||
}
|
||||
else /* Overflow is not possible */
|
||||
{
|
||||
for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
|
||||
{
|
||||
v = *rp;
|
||||
#ifdef PNG_USE_ABS
|
||||
sum += 128 - abs(v - 128);
|
||||
#else
|
||||
sum += (v < 128) ? v : 256 - v;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2479,7 +2609,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
|
|||
if (filter_to_do == PNG_FILTER_SUB)
|
||||
/* It's the only filter so no testing is needed */
|
||||
{
|
||||
(void) png_setup_sub_row(png_ptr, bpp, row_bytes, mins);
|
||||
png_setup_sub_row_only(png_ptr, bpp, row_bytes);
|
||||
best_row = png_ptr->try_row;
|
||||
}
|
||||
|
||||
|
|
@ -2505,7 +2635,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
|
|||
/* Up filter */
|
||||
if (filter_to_do == PNG_FILTER_UP)
|
||||
{
|
||||
(void) png_setup_up_row(png_ptr, row_bytes, mins);
|
||||
png_setup_up_row_only(png_ptr, row_bytes);
|
||||
best_row = png_ptr->try_row;
|
||||
}
|
||||
|
||||
|
|
@ -2531,7 +2661,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
|
|||
/* Avg filter */
|
||||
if (filter_to_do == PNG_FILTER_AVG)
|
||||
{
|
||||
(void) png_setup_avg_row(png_ptr, bpp, row_bytes, mins);
|
||||
png_setup_avg_row_only(png_ptr, bpp, row_bytes);
|
||||
best_row = png_ptr->try_row;
|
||||
}
|
||||
|
||||
|
|
@ -2555,9 +2685,9 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
|
|||
}
|
||||
|
||||
/* Paeth filter */
|
||||
if ((filter_to_do == PNG_FILTER_PAETH) != 0)
|
||||
if (filter_to_do == PNG_FILTER_PAETH)
|
||||
{
|
||||
(void) png_setup_paeth_row(png_ptr, bpp, row_bytes, mins);
|
||||
png_setup_paeth_row_only(png_ptr, bpp, row_bytes);
|
||||
best_row = png_ptr->try_row;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -115,33 +115,3 @@ if [ "${OPJ_CI_SKIP_TESTS:-}" != "1" ]; then
|
|||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
# Install clang if necessary.
|
||||
# clang-3.4 is available on base image
|
||||
# For more up-to-date versions, use packages from http://llvm.org/apt
|
||||
# Cannot use addons.apt.packages because clang-3.9 is currently on hold
|
||||
# (see https://github.com/travis-ci/apt-package-whitelist/pull/2780 or https://github.com/travis-ci/apt-package-whitelist/pull/2770)
|
||||
# "sudo: required" should be set in .travis.yml matrix for those configurations
|
||||
if echo "${CC:-}" | egrep -q "^clang-3.[7-9]?$" ; then
|
||||
case "${CC:-}" in
|
||||
clang-3.7)
|
||||
echo "deb http://llvm.org/apt/precise/ llvm-toolchain-precise-3.7 main" | sudo tee /etc/apt/sources.list.d/llvm.list
|
||||
;;
|
||||
clang-3.8)
|
||||
echo "deb http://llvm.org/apt/precise/ llvm-toolchain-precise-3.8 main" | sudo tee /etc/apt/sources.list.d/llvm.list
|
||||
;;
|
||||
clang-3.9)
|
||||
echo "deb http://llvm.org/apt/precise/ llvm-toolchain-precise main" | sudo tee /etc/apt/sources.list.d/llvm.list
|
||||
;;
|
||||
*)
|
||||
echo "We should never have been there. Exiting..."
|
||||
exit 1
|
||||
esac
|
||||
wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key | sudo apt-key add -
|
||||
|
||||
# On precise, ubuntu-toolchain ppa must be installed also (see http://llvm.org/apt)
|
||||
sudo add-apt-repository --yes ppa:ubuntu-toolchain-r/test
|
||||
|
||||
sudo apt-get update -qq
|
||||
sudo apt-get install "${CC:-}" -y
|
||||
fi
|
||||
|
|
|
|||
Loading…
Reference in New Issue