noahbackus/godot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

libpng: Update to 1.6.54

Browse Source 
(cherry picked from commit 7ac0eef82801fce2e069262c1a6149e2251bcfa2)
This commit is contained in:
Jakub Marcowski
2026-02-01 15:22:15 +01:00
committed by Thaddeus Crews
parent 0227be0bdb
commit 6188f459b3
21 changed files with 1430 additions and 1023 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
COPYRIGHT.txt
View File

@@ -390,8 +390,8 @@ License: BSD-3-clause
Files: thirdparty/libpng/*
Comment: libpng
Copyright: 1995-2025, The PNG Reference Library Authors.
2018-2025, Cosmin Truta.
Copyright: 1995-2026, The PNG Reference Library Authors.
2018-2026, Cosmin Truta.
2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson.
1996-1997, Andreas Dilger.
1995-1996, Guy Eric Schalnat, Group 42, Inc.

2
thirdparty/README.md vendored
View File

@@ -580,7 +580,7 @@ Files extracted from upstream source:
## libpng
- Upstream: http://libpng.org/pub/png/libpng.html
- Version: 1.6.53 (4e3f57d50f552841550a36eabbb3fbcecacb7750, 2025)
- Version: 1.6.54 (02f2b4f4699f0ef9111a6534f093b53732df4452, 2026)
- License: libpng/zlib
Files extracted from upstream source:

4
thirdparty/libpng/LICENSE vendored
View File

@@ -4,8 +4,8 @@ COPYRIGHT NOTICE, DISCLAIMER, and LICENSE
PNG Reference Library License version 2
---------------------------------------
* Copyright (c) 1995-2025 The PNG Reference Library Authors.
* Copyright (c) 2018-2025 Cosmin Truta.
* Copyright (c) 1995-2026 The PNG Reference Library Authors.
* Copyright (c) 2018-2026 Cosmin Truta.
* Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson.
* Copyright (c) 1996-1997 Andreas Dilger.
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.

42
thirdparty/libpng/intel/filter_sse2_intrinsics.c vendored
View File

@@ -26,29 +26,38 @@
* whichever of a, b, or c is closest to p=a+b-c.
*/
static __m128i load4(const void* p) {
static __m128i
load4(const void *p)
{
int tmp;
memcpy(&tmp, p, sizeof(tmp));
return _mm_cvtsi32_si128(tmp);
}
static void store4(void* p, __m128i v) {
static void
store4(void *p, __m128i v)
{
int tmp = _mm_cvtsi128_si32(v);
memcpy(p, &tmp, sizeof(int));
}
static __m128i load3(const void* p) {
static __m128i
load3(const void *p)
{
png_uint_32 tmp = 0;
memcpy(&tmp, p, 3);
return _mm_cvtsi32_si128(tmp);
}
static void store3(void* p, __m128i v) {
static void
store3(void *p, __m128i v)
{
int tmp = _mm_cvtsi128_si32(v);
memcpy(p, &tmp, 3);
}
void png_read_filter_row_sub3_sse2(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_sub3_sse2(png_row_infop row_info, png_bytep row,
png_const_bytep prev)
{
/* The Sub filter predicts each pixel as the previous pixel, a.
@@ -81,7 +90,8 @@ void png_read_filter_row_sub3_sse2(png_row_infop row_info, png_bytep row,
PNG_UNUSED(prev)
}
void png_read_filter_row_sub4_sse2(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_sub4_sse2(png_row_infop row_info, png_bytep row,
png_const_bytep prev)
{
/* The Sub filter predicts each pixel as the previous pixel, a.
@@ -106,7 +116,8 @@ void png_read_filter_row_sub4_sse2(png_row_infop row_info, png_bytep row,
PNG_UNUSED(prev)
}
void png_read_filter_row_avg3_sse2(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_avg3_sse2(png_row_infop row_info, png_bytep row,
png_const_bytep prev)
{
/* The Avg filter predicts each pixel as the (truncated) average of a and b.
@@ -161,7 +172,8 @@ void png_read_filter_row_avg3_sse2(png_row_infop row_info, png_bytep row,
}
}
void png_read_filter_row_avg4_sse2(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_avg4_sse2(png_row_infop row_info, png_bytep row,
png_const_bytep prev)
{
/* The Avg filter predicts each pixel as the (truncated) average of a and b.
@@ -198,7 +210,9 @@ void png_read_filter_row_avg4_sse2(png_row_infop row_info, png_bytep row,
}
/* Returns |x| for 16-bit lanes. */
static __m128i abs_i16(__m128i x) {
static __m128i
abs_i16(__m128i x)
{
#if PNG_INTEL_SSE_IMPLEMENTATION >= 2
return _mm_abs_epi16(x);
#else
@@ -217,7 +231,9 @@ static __m128i abs_i16(__m128i x) {
}
/* Bytewise c ? t : e. */
static __m128i if_then_else(__m128i c, __m128i t, __m128i e) {
static __m128i
if_then_else(__m128i c, __m128i t, __m128i e)
{
#if PNG_INTEL_SSE_IMPLEMENTATION >= 3
return _mm_blendv_epi8(e,t,c);
#else
@@ -225,7 +241,8 @@ static __m128i if_then_else(__m128i c, __m128i t, __m128i e) {
#endif
}
void png_read_filter_row_paeth3_sse2(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_paeth3_sse2(png_row_infop row_info, png_bytep row,
png_const_bytep prev)
{
/* Paeth tries to predict pixel d using the pixel to the left of it, a,
@@ -324,7 +341,8 @@ void png_read_filter_row_paeth3_sse2(png_row_infop row_info, png_bytep row,
}
}
void png_read_filter_row_paeth4_sse2(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_paeth4_sse2(png_row_infop row_info, png_bytep row,
png_const_bytep prev)
{
/* Paeth tries to predict pixel d using the pixel to the left of it, a,

27
thirdparty/libpng/loongarch/filter_lsx_intrinsics.c vendored
View File

@@ -102,7 +102,8 @@
out0 = __lsx_vadd_b(out0, _in3); \
}
void png_read_filter_row_up_lsx(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_up_lsx(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row)
{
size_t n = row_info->rowbytes;
@@ -165,7 +166,8 @@ void png_read_filter_row_up_lsx(png_row_infop row_info, png_bytep row,
}
}
void png_read_filter_row_sub3_lsx(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_sub3_lsx(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row)
{
size_t n = row_info->rowbytes;
@@ -199,7 +201,8 @@ void png_read_filter_row_sub3_lsx(png_row_infop row_info, png_bytep row,
}
}
void png_read_filter_row_sub4_lsx(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_sub4_lsx(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row)
{
size_t n = row_info->rowbytes;
@@ -222,7 +225,8 @@ void png_read_filter_row_sub4_lsx(png_row_infop row_info, png_bytep row,
}
}
void png_read_filter_row_avg3_lsx(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_avg3_lsx(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row)
{
size_t n = row_info->rowbytes;
@@ -275,7 +279,8 @@ void png_read_filter_row_avg3_lsx(png_row_infop row_info, png_bytep row,
}
}
void png_read_filter_row_avg4_lsx(png_row_infop row_info, png_bytep row,
void
png_read_filter_row_avg4_lsx(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row)
{
size_t n = row_info->rowbytes;
@@ -306,9 +311,9 @@ void png_read_filter_row_avg4_lsx(png_row_infop row_info, png_bytep row,
}
}
void png_read_filter_row_paeth3_lsx(png_row_infop row_info,
png_bytep row,
png_const_bytep prev_row)
void
png_read_filter_row_paeth3_lsx(png_row_infop row_info,
png_bytep row, png_const_bytep prev_row)
{
size_t n = row_info->rowbytes;
png_bytep nxt = row;
@@ -371,9 +376,9 @@ void png_read_filter_row_paeth3_lsx(png_row_infop row_info,
}
}
void png_read_filter_row_paeth4_lsx(png_row_infop row_info,
png_bytep row,
png_const_bytep prev_row)
void
png_read_filter_row_paeth4_lsx(png_row_infop row_info,
png_bytep row, png_const_bytep prev_row)
{
size_t n = row_info->rowbytes;
__m128i vec_a, vec_b, vec_c, vec_d;

3
thirdparty/libpng/loongarch/loongarch_lsx_init.c vendored
View File

@@ -17,7 +17,8 @@
#include <sys/auxv.h>
#define LA_HWCAP_LSX (1<<4)
static int png_has_lsx(void)
static int
png_has_lsx(void)
{
int flags = 0;
int flag = (int)getauxval(AT_HWCAP);

21
thirdparty/libpng/png.c vendored
View File

@@ -1,6 +1,6 @@
/* png.c - location for general purpose libpng functions
*
* Copyright (c) 2018-2025 Cosmin Truta
* Copyright (c) 2018-2026 Cosmin Truta
* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -13,7 +13,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_53 Your_png_h_is_not_version_1_6_53;
typedef png_libpng_version_1_6_54 Your_png_h_is_not_version_1_6_54;
/* Sanity check the chunks definitions - PNG_KNOWN_CHUNKS from pngpriv.h and the
* corresponding macro definitions. This causes a compile time failure if
@@ -101,7 +101,8 @@ png_sig_cmp(png_const_bytep sig, size_t start, size_t num_to_check)
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
/* Function to allocate memory for zlib */
PNG_FUNCTION(voidpf /* PRIVATE */,
png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)
png_zalloc,(voidpf png_ptr, uInt items, uInt size),
PNG_ALLOCATED)
{
png_alloc_size_t num_bytes = size;
@@ -257,7 +258,8 @@ png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)
PNG_FUNCTION(png_structp /* PRIVATE */,
png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
png_malloc_ptr malloc_fn, png_free_ptr free_fn),
PNG_ALLOCATED)
{
png_struct create_struct;
# ifdef PNG_SETJMP_SUPPORTED
@@ -361,7 +363,8 @@ png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
/* Allocate the memory for an info_struct for the application. */
PNG_FUNCTION(png_infop,PNGAPI
png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED)
png_create_info_struct,(png_const_structrp png_ptr),
PNG_ALLOCATED)
{
png_inforp info_ptr;
@@ -817,8 +820,8 @@ png_get_copyright(png_const_structrp png_ptr)
return PNG_STRING_COPYRIGHT
#else
return PNG_STRING_NEWLINE \
"libpng version 1.6.53" PNG_STRING_NEWLINE \
"Copyright (c) 2018-2025 Cosmin Truta" PNG_STRING_NEWLINE \
"libpng version 1.6.54" PNG_STRING_NEWLINE \
"Copyright (c) 2018-2026 Cosmin Truta" PNG_STRING_NEWLINE \
"Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson" \
PNG_STRING_NEWLINE \
"Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
@@ -2257,8 +2260,8 @@ PNG_FP_End:
int
png_check_fp_string(png_const_charp string, size_t size)
{
int state=0;
size_t char_index=0;
int state = 0;
size_t char_index = 0;
if (png_check_fp_number(string, size, &state, &char_index) != 0 &&
(char_index == size || string[char_index] == 0))

1011
thirdparty/libpng/png.h vendored
View File

File diff suppressed because it is too large Load Diff

4
thirdparty/libpng/pngconf.h vendored
View File

@@ -1,8 +1,8 @@
/* pngconf.h - machine-configurable file for libpng
*
* libpng version 1.6.53
* libpng version 1.6.54
*
* Copyright (c) 2018-2025 Cosmin Truta
* Copyright (c) 2018-2026 Cosmin Truta
* Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.

17
thirdparty/libpng/pngerror.c vendored
View File

@@ -49,7 +49,8 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
}
#else
PNG_FUNCTION(void,PNGAPI
png_err,(png_const_structrp png_ptr),PNG_NORETURN)
png_err,(png_const_structrp png_ptr),
PNG_NORETURN)
{
/* Prior to 1.5.2 the error_fn received a NULL pointer, expressed
* erroneously as '\0', instead of the empty string "". This was
@@ -376,8 +377,8 @@ static const char png_digit[16] = {
};
static void /* PRIVATE */
png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp
error_message)
png_format_buffer(png_const_structrp png_ptr, png_charp buffer,
png_const_charp error_message)
{
png_uint_32 chunk_name = png_ptr->chunk_name;
int iout = 0, ishift = 24;
@@ -456,8 +457,8 @@ png_chunk_warning(png_const_structrp png_ptr, png_const_charp warning_message)
#ifdef PNG_READ_SUPPORTED
#ifdef PNG_BENIGN_ERRORS_SUPPORTED
void PNGAPI
png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp
error_message)
png_chunk_benign_error(png_const_structrp png_ptr,
png_const_charp error_message)
{
if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
png_chunk_warning(png_ptr, error_message);
@@ -514,7 +515,8 @@ png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
#ifdef PNG_ERROR_TEXT_SUPPORTED
#ifdef PNG_FLOATING_POINT_SUPPORTED
PNG_FUNCTION(void,
png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),PNG_NORETURN)
png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),
PNG_NORETURN)
{
# define fixed_message "fixed point overflow in "
# define fixed_message_ln ((sizeof fixed_message)-1)
@@ -667,7 +669,8 @@ png_default_error,(png_const_structrp png_ptr, png_const_charp error_message),
}
PNG_FUNCTION(void,PNGAPI
png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN)
png_longjmp,(png_const_structrp png_ptr, int val),
PNG_NORETURN)
{
#ifdef PNG_SETJMP_SUPPORTED
if (png_ptr != NULL && png_ptr->longjmp_fn != NULL &&

13
thirdparty/libpng/pngget.c vendored
View File

@@ -122,8 +122,8 @@ png_get_compression_type(png_const_structrp png_ptr, png_const_inforp info_ptr)
}
png_uint_32 PNGAPI
png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
info_ptr)
png_get_x_pixels_per_meter(png_const_structrp png_ptr,
png_const_inforp info_ptr)
{
#ifdef PNG_pHYs_SUPPORTED
png_debug(1, "in png_get_x_pixels_per_meter");
@@ -143,8 +143,8 @@ png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
}
png_uint_32 PNGAPI
png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp
info_ptr)
png_get_y_pixels_per_meter(png_const_structrp png_ptr,
png_const_inforp info_ptr)
{
#ifdef PNG_pHYs_SUPPORTED
png_debug(1, "in png_get_y_pixels_per_meter");
@@ -186,8 +186,8 @@ png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr)
#ifdef PNG_FLOATING_POINT_SUPPORTED
float PNGAPI
png_get_pixel_aspect_ratio(png_const_structrp png_ptr, png_const_inforp
info_ptr)
png_get_pixel_aspect_ratio(png_const_structrp png_ptr,
png_const_inforp info_ptr)
{
#ifdef PNG_READ_pHYs_SUPPORTED
png_debug(1, "in png_get_pixel_aspect_ratio");
@@ -737,7 +737,6 @@ png_get_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
}
return 0;
}
#endif

4
thirdparty/libpng/pnglibconf.h vendored
View File

@@ -1,8 +1,8 @@
/* pnglibconf.h - library build configuration */
/* libpng version 1.6.53 */
/* libpng version 1.6.54 */
/* Copyright (c) 2018-2025 Cosmin Truta */
/* Copyright (c) 2018-2026 Cosmin Truta */
/* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson */
/* This code is released under the libpng license. */

19
thirdparty/libpng/pngmem.c vendored
View File

@@ -46,7 +46,8 @@ png_destroy_png_struct(png_structrp png_ptr)
* have the ability to do that.
*/
PNG_FUNCTION(png_voidp,PNGAPI
png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),
PNG_ALLOCATED)
{
png_voidp ret;
@@ -118,7 +119,8 @@ png_malloc_array_checked(png_const_structrp png_ptr, int nelements,
PNG_FUNCTION(png_voidp /* PRIVATE */,
png_malloc_array,(png_const_structrp png_ptr, int nelements,
size_t element_size),PNG_ALLOCATED)
size_t element_size),
PNG_ALLOCATED)
{
if (nelements <= 0 || element_size == 0)
png_error(png_ptr, "internal error: array alloc");
@@ -128,7 +130,8 @@ png_malloc_array,(png_const_structrp png_ptr, int nelements,
PNG_FUNCTION(png_voidp /* PRIVATE */,
png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED)
int old_elements, int add_elements, size_t element_size),
PNG_ALLOCATED)
{
/* These are internal errors: */
if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||
@@ -167,7 +170,8 @@ png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
* function png_malloc_default is also provided.
*/
PNG_FUNCTION(png_voidp,PNGAPI
png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),
PNG_ALLOCATED)
{
png_voidp ret;
@@ -241,7 +245,8 @@ png_free(png_const_structrp png_ptr, png_voidp ptr)
}
PNG_FUNCTION(void,PNGAPI
png_free_default,(png_const_structrp png_ptr, png_voidp ptr),PNG_DEPRECATED)
png_free_default,(png_const_structrp png_ptr, png_voidp ptr),
PNG_DEPRECATED)
{
if (png_ptr == NULL || ptr == NULL)
return;
@@ -255,8 +260,8 @@ png_free_default,(png_const_structrp png_ptr, png_voidp ptr),PNG_DEPRECATED)
* of allocating and freeing memory.
*/
void PNGAPI
png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr, png_malloc_ptr
malloc_fn, png_free_ptr free_fn)
png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr,
png_malloc_ptr malloc_fn, png_free_ptr free_fn)
{
if (png_ptr != NULL)
{

871
thirdparty/libpng/pngpriv.h vendored
View File

File diff suppressed because it is too large Load Diff

87
thirdparty/libpng/pngread.c vendored
View File

@@ -1,6 +1,6 @@
/* pngread.c - read a PNG file
*
* Copyright (c) 2018-2025 Cosmin Truta
* Copyright (c) 2018-2026 Cosmin Truta
* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -23,7 +23,8 @@
/* Create a PNG structure for reading, and allocate any memory needed. */
PNG_FUNCTION(png_structp,PNGAPI
png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)
png_error_ptr error_fn, png_error_ptr warn_fn),
PNG_ALLOCATED)
{
#ifndef PNG_USER_MEM_SUPPORTED
png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
@@ -39,7 +40,8 @@ png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
PNG_FUNCTION(png_structp,PNGAPI
png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
png_malloc_ptr malloc_fn, png_free_ptr free_fn),
PNG_ALLOCATED)
{
png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
@@ -519,7 +521,6 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
if (png_ptr->read_row_fn != NULL)
(*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
}
#endif /* SEQUENTIAL_READ */
@@ -867,7 +868,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, png_voidp params)
{
png_debug(1, "in png_read_png");
@@ -1104,16 +1105,17 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
typedef struct
{
/* Arguments: */
/* Arguments */
png_imagep image;
png_voidp buffer;
png_int_32 row_stride;
png_voidp colormap;
png_const_colorp background;
/* Local variables: */
/* Instance variables */
png_voidp local_row;
png_voidp first_row;
ptrdiff_t row_bytes; /* step between rows */
ptrdiff_t row_step; /* step between rows */
int file_encoding; /* E_ values above */
png_fixed_point gamma_to_linear; /* For P_FILE, reciprocal of gamma */
int colormap_processing; /* PNG_CMAP_ values above */
@@ -2841,7 +2843,7 @@ png_image_read_and_map(png_voidp argument)
png_uint_32 width = image->width;
int proc = display->colormap_processing;
png_bytep first_row = png_voidcast(png_bytep, display->first_row);
ptrdiff_t step_row = display->row_bytes;
ptrdiff_t row_step = display->row_step;
int pass;
for (pass = 0; pass < passes; ++pass)
@@ -2871,7 +2873,7 @@ png_image_read_and_map(png_voidp argument)
for (; y<height; y += stepy)
{
png_bytep inrow = png_voidcast(png_bytep, display->local_row);
png_bytep outrow = first_row + y * step_row;
png_bytep outrow = first_row + y * row_step;
png_const_bytep end_row = outrow + width;
/* Read read the libpng data into the temporary buffer. */
@@ -3080,20 +3082,20 @@ png_image_read_colormapped(png_voidp argument)
*/
{
png_voidp first_row = display->buffer;
ptrdiff_t row_bytes = display->row_stride;
ptrdiff_t row_step = display->row_stride;
/* The following expression is designed to work correctly whether it gives
* a signed or an unsigned result.
/* The following adjustment is to ensure that calculations are correct,
* regardless whether row_step is positive or negative.
*/
if (row_bytes < 0)
if (row_step < 0)
{
char *ptr = png_voidcast(char*, first_row);
ptr += (image->height-1) * (-row_bytes);
ptr += (image->height-1) * (-row_step);
first_row = png_voidcast(png_voidp, ptr);
}
display->first_row = first_row;
display->row_bytes = row_bytes;
display->row_step = row_step;
}
if (passes == 0)
@@ -3111,7 +3113,7 @@ png_image_read_colormapped(png_voidp argument)
else
{
png_alloc_size_t row_bytes = (png_alloc_size_t)display->row_bytes;
ptrdiff_t row_step = display->row_step;
while (--passes >= 0)
{
@@ -3121,7 +3123,7 @@ png_image_read_colormapped(png_voidp argument)
for (; y > 0; --y)
{
png_read_row(png_ptr, row, NULL);
row += row_bytes;
row += row_step;
}
}
@@ -3137,9 +3139,11 @@ png_image_read_direct_scaled(png_voidp argument)
argument);
png_imagep image = display->image;
png_structrp png_ptr = image->opaque->png_ptr;
png_inforp info_ptr = image->opaque->info_ptr;
png_bytep local_row = png_voidcast(png_bytep, display->local_row);
png_bytep first_row = png_voidcast(png_bytep, display->first_row);
ptrdiff_t row_bytes = display->row_bytes;
ptrdiff_t row_step = display->row_step;
size_t row_bytes = png_get_rowbytes(png_ptr, info_ptr);
int passes;
/* Handle interlacing. */
@@ -3168,9 +3172,14 @@ png_image_read_direct_scaled(png_voidp argument)
/* Read into local_row (gets transformed 8-bit data). */
png_read_row(png_ptr, local_row, NULL);
/* Copy from local_row to user buffer. */
memcpy(output_row, local_row, (size_t)row_bytes);
output_row += row_bytes;
/* Copy from local_row to user buffer.
* Use row_bytes (i.e. the actual size in bytes of the row data) for
* copying into output_row. Use row_step for advancing output_row,
* to respect the caller's stride for padding or negative (bottom-up)
* layouts.
*/
memcpy(output_row, local_row, row_bytes);
output_row += row_step;
}
}
@@ -3204,7 +3213,7 @@ png_image_read_composite(png_voidp argument)
{
png_uint_32 height = image->height;
png_uint_32 width = image->width;
ptrdiff_t step_row = display->row_bytes;
ptrdiff_t row_step = display->row_step;
unsigned int channels =
(image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
int optimize_alpha = (png_ptr->flags & PNG_FLAG_OPTIMIZE_ALPHA) != 0;
@@ -3245,7 +3254,7 @@ png_image_read_composite(png_voidp argument)
png_read_row(png_ptr, inrow, NULL);
outrow = png_voidcast(png_bytep, display->first_row);
outrow += y * step_row;
outrow += y * row_step;
end_row = outrow + width * channels;
/* Now do the composition on each pixel in this row. */
@@ -3390,7 +3399,7 @@ png_image_read_background(png_voidp argument)
*/
{
png_bytep first_row = png_voidcast(png_bytep, display->first_row);
ptrdiff_t step_row = display->row_bytes;
ptrdiff_t row_step = display->row_step;
for (pass = 0; pass < passes; ++pass)
{
@@ -3422,7 +3431,7 @@ png_image_read_background(png_voidp argument)
{
png_bytep inrow = png_voidcast(png_bytep,
display->local_row);
png_bytep outrow = first_row + y * step_row;
png_bytep outrow = first_row + y * row_step;
png_const_bytep end_row = outrow + width;
/* Read the row, which is packed: */
@@ -3467,7 +3476,7 @@ png_image_read_background(png_voidp argument)
{
png_bytep inrow = png_voidcast(png_bytep,
display->local_row);
png_bytep outrow = first_row + y * step_row;
png_bytep outrow = first_row + y * row_step;
png_const_bytep end_row = outrow + width;
/* Read the row, which is packed: */
@@ -3513,9 +3522,9 @@ png_image_read_background(png_voidp argument)
png_uint_16p first_row = png_voidcast(png_uint_16p,
display->first_row);
/* The division by two is safe because the caller passed in a
* stride which was multiplied by 2 (below) to get row_bytes.
* stride which was multiplied by 2 (below) to get row_step.
*/
ptrdiff_t step_row = display->row_bytes / 2;
ptrdiff_t row_step = display->row_step / 2;
unsigned int preserve_alpha = (image->format &
PNG_FORMAT_FLAG_ALPHA) != 0;
unsigned int outchannels = 1U+preserve_alpha;
@@ -3557,7 +3566,7 @@ png_image_read_background(png_voidp argument)
for (; y<height; y += stepy)
{
png_const_uint_16p inrow;
png_uint_16p outrow = first_row + y*step_row;
png_uint_16p outrow = first_row + y * row_step;
png_uint_16p end_row = outrow + width * outchannels;
/* Read the row, which is packed: */
@@ -3994,23 +4003,23 @@ png_image_read_direct(png_voidp argument)
*/
{
png_voidp first_row = display->buffer;
ptrdiff_t row_bytes = display->row_stride;
ptrdiff_t row_step = display->row_stride;
if (linear != 0)
row_bytes *= 2;
row_step *= 2;
/* The following expression is designed to work correctly whether it gives
* a signed or an unsigned result.
/* The following adjustment is to ensure that calculations are correct,
* regardless whether row_step is positive or negative.
*/
if (row_bytes < 0)
if (row_step < 0)
{
char *ptr = png_voidcast(char*, first_row);
ptr += (image->height-1) * (-row_bytes);
ptr += (image->height - 1) * (-row_step);
first_row = png_voidcast(png_voidp, ptr);
}
display->first_row = first_row;
display->row_bytes = row_bytes;
display->row_step = row_step;
}
if (do_local_compose != 0)
@@ -4059,7 +4068,7 @@ png_image_read_direct(png_voidp argument)
else
{
png_alloc_size_t row_bytes = (png_alloc_size_t)display->row_bytes;
ptrdiff_t row_step = display->row_step;
while (--passes >= 0)
{
@@ -4069,7 +4078,7 @@ png_image_read_direct(png_voidp argument)
for (; y > 0; --y)
{
png_read_row(png_ptr, row, NULL);
row += row_bytes;
row += row_step;
}
}

4
thirdparty/libpng/pngrtran.c vendored
View File

@@ -1120,8 +1120,8 @@ png_set_rgb_to_gray(png_structrp png_ptr, int error_action, double red,
#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
void PNGAPI
png_set_read_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr
read_user_transform_fn)
png_set_read_user_transform_fn(png_structrp png_ptr,
png_user_transform_ptr read_user_transform_fn)
{
png_debug(1, "in png_set_read_user_transform_fn");

4
thirdparty/libpng/pngtrans.c vendored
View File

@@ -802,8 +802,8 @@ png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
void PNGAPI
png_set_user_transform_info(png_structrp png_ptr, png_voidp
user_transform_ptr, int user_transform_depth, int user_transform_channels)
png_set_user_transform_info(png_structrp png_ptr, png_voidp user_transform_ptr,
int user_transform_depth, int user_transform_channels)
{
png_debug(1, "in png_set_user_transform_info");

42
thirdparty/libpng/pngwrite.c vendored
View File

@@ -1,6 +1,6 @@
/* pngwrite.c - general routines to write a PNG file
*
* Copyright (c) 2018-2025 Cosmin Truta
* Copyright (c) 2018-2026 Cosmin Truta
* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson
* Copyright (c) 1996-1997 Andreas Dilger
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@@ -542,7 +542,8 @@ png_convert_from_time_t(png_timep ptime, time_t ttime)
/* Initialize png_ptr structure, and allocate any memory needed */
PNG_FUNCTION(png_structp,PNGAPI
png_create_write_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED)
png_error_ptr error_fn, png_error_ptr warn_fn),
PNG_ALLOCATED)
{
#ifndef PNG_USER_MEM_SUPPORTED
png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
@@ -556,7 +557,8 @@ png_create_write_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
PNG_FUNCTION(png_structp,PNGAPI
png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
png_malloc_ptr malloc_fn, png_free_ptr free_fn),
PNG_ALLOCATED)
{
png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
@@ -1376,8 +1378,8 @@ png_set_write_status_fn(png_structrp png_ptr, png_write_status_ptr write_row_fn)
#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
void PNGAPI
png_set_write_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr
write_user_transform_fn)
png_set_write_user_transform_fn(png_structrp png_ptr,
png_user_transform_ptr write_user_transform_fn)
{
png_debug(1, "in png_set_write_user_transform_fn");
@@ -1393,7 +1395,7 @@ png_set_write_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr
#ifdef PNG_INFO_IMAGE_SUPPORTED
void PNGAPI
png_write_png(png_structrp png_ptr, png_inforp info_ptr,
int transforms, voidp params)
int transforms, png_voidp params)
{
png_debug(1, "in png_write_png");
@@ -1558,16 +1560,18 @@ png_image_write_init(png_imagep image)
/* Arguments to png_image_write_main: */
typedef struct
{
/* Arguments: */
/* Arguments */
png_imagep image;
png_const_voidp buffer;
png_int_32 row_stride;
png_const_voidp colormap;
int convert_to_8bit;
/* Local variables: */
/* Instance variables */
png_const_voidp first_row;
ptrdiff_t row_bytes;
png_voidp local_row;
ptrdiff_t row_step;
/* Byte count for memory writing */
png_bytep memory;
png_alloc_size_t memory_bytes; /* not used for STDIO */
@@ -1676,7 +1680,7 @@ png_write_image_16bit(png_voidp argument)
}
png_write_row(png_ptr, png_voidcast(png_const_bytep, display->local_row));
input_row += (png_uint_16)display->row_bytes/(sizeof (png_uint_16));
input_row += display->row_step / 2;
}
return 1;
@@ -1802,7 +1806,7 @@ png_write_image_8bit(png_voidp argument)
png_write_row(png_ptr, png_voidcast(png_const_bytep,
display->local_row));
input_row += (png_uint_16)display->row_bytes/(sizeof (png_uint_16));
input_row += display->row_step / 2;
} /* while y */
}
@@ -1827,7 +1831,7 @@ png_write_image_8bit(png_voidp argument)
}
png_write_row(png_ptr, output_row);
input_row += (png_uint_16)display->row_bytes/(sizeof (png_uint_16));
input_row += display->row_step / 2;
}
}
@@ -2143,16 +2147,16 @@ png_image_write_main(png_voidp argument)
{
png_const_bytep row = png_voidcast(png_const_bytep, display->buffer);
ptrdiff_t row_bytes = display->row_stride;
ptrdiff_t row_step = display->row_stride;
if (linear != 0)
row_bytes *= (sizeof (png_uint_16));
row_step *= 2;
if (row_bytes < 0)
row += (image->height-1) * (-row_bytes);
if (row_step < 0)
row += (image->height-1) * (-row_step);
display->first_row = row;
display->row_bytes = row_bytes;
display->row_step = row_step;
}
/* Apply 'fast' options if the flag is set. */
@@ -2199,13 +2203,13 @@ png_image_write_main(png_voidp argument)
else
{
png_const_bytep row = png_voidcast(png_const_bytep, display->first_row);
ptrdiff_t row_bytes = display->row_bytes;
ptrdiff_t row_step = display->row_step;
png_uint_32 y = image->height;
for (; y > 0; --y)
{
png_write_row(png_ptr, row);
row += row_bytes;
row += row_step;
}
}