Subversion Repositories Kolibri OS

; 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.)

; For conditions of distribution and use, see the disclaimer

; and license in png.inc

include '../../../../../../fs/kfar/trunk/zlib/deflate.inc'

include 'pngtokos.inc' ;integrate png to kos

include 'pnglibconf.inc'

include 'pngpriv.inc'

include 'png.inc'

include 'pngstruct.inc'

include 'pnginfo.inc'

include 'pngerror.asm'

include 'pngtrans.asm'

include 'pngget.asm'

include 'pngwrite.asm'

include 'pngmem.asm'

include 'pngset.asm'

include 'pngwutil.asm'

include 'pngwio.asm'

include 'pngwtran.asm'

;typedef png_libpng_version_1_6_25 Your_png_h_is_not_version_1_6_25;

; of the PNG file signature.  If the PNG data is embedded into another

; stream we can set num_bytes = 8 so that libpng will not attempt to read

; or write any of the magic bytes before it starts on the IHDR.

;void (png_structrp png_ptr, int num_bytes)

align 4

proc png_set_sig_bytes uses eax edi, png_ptr:dword, num_bytes:dword

	png_debug 1, 'in png_set_sig_bytes'

	cmp edi,0

	je .end_f ;if (..==0) return

	cmp eax,0

	jge @f

		xor eax,eax

	@@:

	cmp eax,8

	jle @f ;if (..>8)

		png_error edi, 'Too many bytes for PNG signature'

	@@:

	mov byte[edi+png_struct.sig_bytes],al

.end_f:

	ret

endp

; checking less than the full 8-byte signature so that those apps that

; already read the first few bytes of a file to determine the file type

; can simply check the remaining bytes for extra assurance.  Returns

; an integer less than, equal to, or greater than zero if sig is found,

; respectively, to be less than, to match, or be greater than the correct

; PNG signature (this is the same behavior as strcmp, memcmp, etc).

align 4

proc png_sig_cmp, sig:dword, start:dword, num_to_check:dword

;   byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};

;      num_to_check = 8;

;      return (-1);

;      return (-1);

;      num_to_check = 8 - start;

	ret

endp

;voidpf (voidpf png_ptr, uInt items, uInt size)

align 4

proc png_zalloc uses edx ecx, png_ptr:dword, items:dword, size:dword

	jne @f

		xor eax,eax

		jmp .end_f ;if (..==0) return 0

	@@:

	not eax

	xor edx,edx

	mov ecx,[size]

	div ecx

	cmp [items],eax

	jl @f ;if (..>=..)

		png_warning [png_ptr], 'Potential overflow in png_zalloc()'

		xor eax,eax

		jmp .end_f

	@@:

	imul ecx,[items]

	stdcall png_malloc_warn, [png_ptr], ecx

.end_f:

	ret

endp

;void (voidpf png_ptr, voidpf ptr)

align 4

proc png_zfree, png_ptr:dword, p2ptr:dword

	stdcall png_free, [png_ptr], [p2ptr]

	ret

endp

; in case CRC is > 32 bits to leave the top bits 0.

align 4

proc png_reset_crc uses eax edi, png_ptr:dword

	; The cast is safe because the crc is a 32-bit value.

	mov edi,[png_ptr]

	stdcall [calc_crc32], 0, Z_NULL, 0

	mov dword[edi+png_struct.crc],eax

	ret

endp

; much data to this routine as the largest single buffer size.  We

; also check that this data will actually be used before going to the

; trouble of calculating it.

align 4

proc png_calculate_crc uses eax ebx edi, png_ptr:dword, ptr:dword, length:dword

locals

	need_crc dd 1

	safe_length dd ?

endl

	mov edi,[png_ptr]

	PNG_CHUNK_ANCILLARY [edi+png_struct.chunk_name]

	cmp eax,0 ;if (..!=0)

	je @f

		mov eax,[edi+png_struct.flags]

		and eax,PNG_FLAG_CRC_ANCILLARY_MASK

		cmp eax,PNG_FLAG_CRC_ANCILLARY_USE or PNG_FLAG_CRC_ANCILLARY_NOWARN

		jne .end0 ;if (..==..)

			mov dword[need_crc],0

		jmp .end0

	@@: ;else ;critical

		mov eax,[edi+png_struct.flags]

		and eax,PNG_FLAG_CRC_CRITICAL_IGNORE

		jz .end0 ;if (..!=0)

			mov dword[need_crc],0

	.end0:

	; systems it is a 64-bit value.  crc32, however, returns 32 bits so the

	; following cast is safe.  'uInt' may be no more than 16 bits, so it is

	; necessary to perform a loop here.

	je .end_f

	cmp dword[length],0

	jle .end_f ;if (..!=0 && ..>0)

		mov eax,[edi+png_struct.crc] ;Should never issue a warning

			mov ebx,[length]

			mov [safe_length],ebx

;#ifndef __COVERITY__

;         if (safe_length == 0)

;            safe_length = (uInt)-1 ;evil, but safe

;end if

			stdcall [calc_crc32], eax, [ptr], [safe_length]

			; target system has characteristics that will probably violate other

			; assumptions within the libpng code.

			add [ptr],ebx

			sub [length],ebx

			cmp dword[length],0

		jg .cycle0 ;while (..>0)

		mov [edi+png_struct.crc],eax

	.end_f:

	ret

endp

; functions that create a png_struct.

align 4

proc png_user_version_check, png_ptr:dword, user_png_ver:dword

	; Libpng versions 1.0.0 and later are binary compatible if the version

	; string matches through the second '.'; we must recompile any

	; applications that use any older library version.

;   {

;      int i = -1;

;      int found_dots = 0;

;      {

;         i++;

;         if (user_png_ver[i] != PNG_LIBPNG_VER_STRING[i])

;            png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

;         if (user_png_ver[i] == '.')

;            found_dots++;

;      } while (found_dots < 2 && user_png_ver[i] != 0 &&

;            PNG_LIBPNG_VER_STRING[i] != 0);

;   }

;      png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;

;   {

if PNG_WARNINGS_SUPPORTED eq 1

;      size_t pos = 0;

;      char m[128];

;          "Application built with libpng-");

;      pos = png_safecat(m, (sizeof m), pos, user_png_ver);

;      pos = png_safecat(m, (sizeof m), pos, " but running with ");

;      pos = png_safecat(m, (sizeof m), pos, PNG_LIBPNG_VER_STRING);

end if

;      png_ptr->flags = 0;

end if

;   }

	xor eax,eax

	inc eax

.end_f:

	ret

endp

; contains the common initialization.

;    png_error_ptr error_fn, png_error_ptr warn_fn, voidp mem_ptr,

;    png_malloc_ptr malloc_fn, png_free_ptr free_fn)

align 4

proc png_create_png_struct uses ebx ecx edi esi, user_png_ver:dword, error_ptr:dword, error_fn:dword, warn_fn:dword, mem_ptr:dword, malloc_fn:dword, free_fn:dword

locals

if PNG_SETJMP_SUPPORTED eq 1

	create_jmp_buf dd ? ;jmp_buf

end if

	create_struct png_struct

endl

	; This temporary stack-allocated structure is used to provide a place to

	; build enough context to allow the user provided memory allocator (if any)

	; to be called.

	mov ecx,sizeof.png_struct

	mov edi,ebp

	sub edi,ecx

	mov ebx,edi

	rep stosb

if PNG_USER_LIMITS_SUPPORTED eq 1

	mov dword[ebx+png_struct.user_width_max], PNG_USER_WIDTH_MAX

	mov dword[ebx+png_struct.user_height_max], PNG_USER_HEIGHT_MAX

	mov dword[ebx+png_struct.user_chunk_cache_max], PNG_USER_CHUNK_CACHE_MAX

	; in png_struct regardless.

end if

	; to do them now even though error handling is not yet set up.

	stdcall png_set_mem_fn, ebx, [mem_ptr], [malloc_fn], [free_fn]

end if

	; this will result in a memory leak unless the error_fn does something

	; extremely sophisticated.  The design lacks merit but is implicit in the

	; API.

	stdcall setjmp,... ;create_jmp_buf

	cmp eax,0

	j... .end0 ;if (!setjmp(create_jmp_buf))

		; successfully completed this function.  This only works if we have

		; setjmp() support compiled in, but it is safe - this stuff should

		; never happen.

		mov dword[ebx+png_struct.jmp_buf_size],0 ;stack allocation

;         create_struct.longjmp_fn = longjmp;

end if

	; Call the general version checker (shared with read and write code):

		cmp eax,0

		je .end0 ;if (..!=0)

			stdcall png_malloc_warn, ebx, sizeof.png_struct

			;eax = png_ptr

			cmp eax,0

			je .end0 ;if (..!=0)

				; png_ptr->zstream holds a back-pointer to the png_struct, so

				; this can only be done now:

				mov [ebx+png_struct.zstream.zfree], png_zfree

				mov [ebx+png_struct.zstream.opaque], eax

				; Eliminate the local error handling:

				mov [ebx+png_struct.jmp_buf_ptr], 0

				mov [ebx+png_struct.jmp_buf_size], 0

				mov [ebx+png_struct.longjmp_fn], 0

end if

				mov ecx,sizeof.png_struct

				mov edi,eax

				mov esi,ebx

				rep movsb ;*png_ptr = create_struct

				jmp .end_f

	.end0:

	; simple failure to allocate the png_struct.

.end_f:

	ret

endp

;png_infop (png_structrp png_ptr)

align 4

proc png_create_info_struct uses ebx ecx edi, png_ptr:dword

	png_debug 1, 'in png_create_info_struct'

	;ebx - info_ptr dd ? ;png_inforp

	cmp edi,0

	jne @f ;if (..==0) return 0

		xor eax,eax

		jmp .end_f

	@@:

	; that this call always returns ok.  The application typically sets up the

	; error handling *after* creating the info_struct because this is the way it

	; has always been done in 'example.asm'.

	mov ebx,eax

	je @f

		mov edi,eax

		xor eax,eax

		mov ecx,sizeof.png_info_def

		rep stosb ;memset(...

	@@:

.end_f:

	ret

endp

; Normally, one would use either png_destroy_read_struct() or

; png_destroy_write_struct() to free an info struct, but this may be

; useful for some applications.  From libpng 1.6.0 this function is also used

; internally to implement the png_info release part of the 'struct' destroy

; APIs.  This ensures that all possible approaches free the same data (all of

; it).

align 4

proc png_destroy_info_struct uses eax ebx ecx edi, png_ptr:dword, info_ptr_ptr:dword

	png_debug 1, 'in png_destroy_info_struct'

	je .end_f ;if (..==0) return

	cmp edi,0 ;if (..!=0)

	je .end_f

		; Do this first in case of an error below; if the app implements its own

		; memory management this can lead to png_free calling png_error, which

		; will abort this routine and return control to the app error handler.

		; An infinite loop may result if it then tries to free the same info

		; ptr.

		mov ebx,edi

		xor eax,eax

		mov ecx,sizeof.png_info_def

		rep stosb

		stdcall png_free, [png_ptr], ebx

	.end_f:

	ret

endp

; and applications using it are urged to use png_create_info_struct()

; instead.  Use deprecated in 1.6.0, internal use removed (used internally it

; is just a memset).

; the user-memory mechanism and the user error handling/warning mechanisms in

; those cases where it does anything other than a memset.

align 4

proc png_info_init_3, ptr_ptr:dword, png_info_struct_size:dword

;   png_inforp info_ptr = *ptr_ptr;

;      return;

;   {

;      *ptr_ptr = NULL;

	; The following line is why this API should not be used:

;      free(info_ptr);

;      info_ptr = png_malloc_base(NULL, (sizeof *info_ptr));

;      if (info_ptr == NULL)

;         return;

;      *ptr_ptr = info_ptr;

;   }

;   memset(info_ptr, 0, (sizeof *info_ptr));

	ret

endp

;void (png_structrp png_ptr, png_inforp info_ptr, int freer, uint_32 mask)

align 4

proc png_data_freer uses edi esi, png_ptr:dword, info_ptr:dword, freer:dword, mask:dword

	png_debug 1, 'in png_data_freer'

	cmp edi,0

	je .end_f

	mov esi,[info_ptr]

	cmp esi,0

	je .end_f ;if (..==0 || ..==0) return

;      info_ptr->free_me |= mask;

;      info_ptr->free_me &= ~mask;

;      png_error(png_ptr, "Unknown freer parameter in png_data_freer");

.end_f

	ret

endp

align 4

proc png_free_data uses eax edi esi, png_ptr:dword, info_ptr:dword, mask:dword, num:dword

	png_debug 1, 'in png_free_data'

	cmp edi,0

	je .end_f

	mov esi,[info_ptr]

	cmp esi,0

	je .end_f ;if (..==0 || ..==0) return

	; Free text item num or (if num == -1) all text items

;   if (info_ptr->text != 0 &&

;       ((mask & PNG_FREE_TEXT) & info_ptr->free_me) != 0)

;   {

;      if (num != -1)

;      {

;         png_free(png_ptr, info_ptr->text[num].key);

;         info_ptr->text[num].key = NULL;

;      }

;      {

;         int i;

;            png_free(png_ptr, info_ptr->text[i].key);

;         info_ptr->text = NULL;

;         info_ptr->num_text = 0;

;      }

;   }

end if

	; Free any tRNS entry

	mov eax,[mask]

	and eax,PNG_FREE_TRNS

	and eax,[esi+png_info_def.free_me]

	jz @f ;if (..!=0)

		and dword[esi+png_info_def.valid], not PNG_INFO_tRNS

		stdcall png_free, edi, [esi+png_info_def.trans_alpha]

		mov dword[esi+png_info_def.trans_alpha],0

		mov word[esi+png_info_def.num_trans],0

	@@:

end if

	; Free any sCAL entry

	mov eax,[mask]

	and eax,PNG_FREE_SCAL

	and eax,[esi+png_info_def.free_me]

	jz @f ;if (..!=0)

		stdcall png_free, edi, [esi+png_info_def.scal_s_width]

		stdcall png_free, edi, [esi+png_info_def.scal_s_height]

		mov dword[esi+png_info_def.scal_s_width],0

		mov dword[esi+png_info_def.scal_s_height],0

		and dword[esi+png_info_def.valid], not PNG_INFO_sCAL

	@@:

end if

	; Free any pCAL entry

;   if (((mask & PNG_FREE_PCAL) & info_ptr->free_me) != 0)

;   {

;      png_free(png_ptr, info_ptr->pcal_purpose);

;      png_free(png_ptr, info_ptr->pcal_units);

;      info_ptr->pcal_purpose = NULL;

;      info_ptr->pcal_units = NULL;

;         {

;            int i;

;               png_free(png_ptr, info_ptr->pcal_params[i]);

;

;            png_free(png_ptr, info_ptr->pcal_params);

;            info_ptr->pcal_params = NULL;

;         }

;      info_ptr->valid &= ~PNG_INFO_pCAL;

;   }

end if

	; Free any profile entry

	mov eax,[mask]

	and eax,PNG_FREE_ICCP

	and eax,[esi+png_info_def.free_me]

	jz @f ;if (..!=0)

		stdcall png_free, edi, [esi+png_info_def.iccp_name]

		stdcall png_free, edi, [esi+png_info_def.iccp_profile]

		mov dword[esi+png_info_def.iccp_name],0

		mov dword[esi+png_info_def.iccp_profile],0

		and dword[esi+png_info_def.valid], not PNG_INFO_iCCP

	@@:

end if

	; Free a given sPLT entry, or (if num == -1) all sPLT entries

;   if (info_ptr->splt_palettes != 0 &&

;       ((mask & PNG_FREE_SPLT) & info_ptr->free_me) != 0)

;   {

;      if (num != -1)

;      {

;         png_free(png_ptr, info_ptr->splt_palettes[num].name);

;         png_free(png_ptr, info_ptr->splt_palettes[num].entries);

;         info_ptr->splt_palettes[num].name = NULL;

;         info_ptr->splt_palettes[num].entries = NULL;

;      }

;      {

;         int i;

;         {

;            png_free(png_ptr, info_ptr->splt_palettes[i].name);

;            png_free(png_ptr, info_ptr->splt_palettes[i].entries);

;         }

;         info_ptr->splt_palettes = NULL;

;         info_ptr->splt_palettes_num = 0;

;         info_ptr->valid &= ~PNG_INFO_sPLT;

;      }

;   }

end if

;   if (info_ptr->unknown_chunks != 0 &&

;       ((mask & PNG_FREE_UNKN) & info_ptr->free_me) != 0)

;   {

;      if (num != -1)

;      {

;          png_free(png_ptr, info_ptr->unknown_chunks[num].data);

;          info_ptr->unknown_chunks[num].data = NULL;

;      }

;      {

;         int i;

;            png_free(png_ptr, info_ptr->unknown_chunks[i].data);

;         info_ptr->unknown_chunks = NULL;

;         info_ptr->unknown_chunks_num = 0;

;      }

;   }

end if

	; Free any hIST entry

	mov eax,[mask]

	and eax,PNG_FREE_HIST

	and eax,[esi+png_info_def.free_me]

	jz @f ;if (..!=0)

		stdcall png_free, edi, [esi+png_info_def.hist]

		mov dword[esi+png_info_def.hist],0

		and dword[esi+png_info_def.valid], not PNG_INFO_hIST

	@@:

end if

	mov eax,[mask]

	and eax,PNG_FREE_PLTE

	and eax,[esi+png_info_def.free_me]

	jz @f ;if (..!=0)

		stdcall png_free, edi, [esi+png_info_def.palette]

		mov dword[esi+png_info_def.palette],0

		and dword[esi+png_info_def.valid],not PNG_INFO_PLTE

		mov dword[esi+png_info_def.num_palette],0

	@@:

	; Free any image bits attached to the info structure

;   if (((mask & PNG_FREE_ROWS) & info_ptr->free_me) != 0)

;   {

;      if (info_ptr->row_pointers != 0)

;      {

;         uint_32 row;

;         for (row = 0; row < info_ptr->height; row++)

;            png_free(png_ptr, info_ptr->row_pointers[row]);

;         info_ptr->row_pointers = NULL;

;      }

;      info_ptr->valid &= ~PNG_INFO_IDAT;

;   }

end if

;      mask &= ~PNG_FREE_MUL;

	not eax

	and [esi+png_info_def.free_me],eax

.end_f:

	ret

endp

; functions.  The application should free any memory associated with this

; pointer before png_write_destroy() or png_read_destroy() are called.

align 4

proc png_get_io_ptr, png_ptr:dword

	mov eax,[png_ptr]

	cmp eax,0

	je @f ;if (..==0) return 0

		mov eax,[eax+png_struct.io_ptr]

	@@:

	ret

endp

; Initialize the default input/output functions for the PNG file.  If you

; use your own read or write routines, you can call either png_set_read_fn()

; or png_set_write_fn() instead of png_init_io().  If you have defined

; PNG_NO_STDIO or otherwise disabled PNG_STDIO_SUPPORTED, you must use a

; function of your own because "FILE *" isn't necessarily available.

align 4

proc png_init_io uses eax edi, png_ptr:dword, fp:dword

	png_debug 1, 'in png_init_io'

	cmp edi,0

	je @f ;if (..==0) return

		mov eax,[fp]

		mov [edi+png_struct.io_ptr],eax

	@@:

	ret

endp

; defines a cast of a signed integer to an unsigned integer either to preserve

; the value, if it is positive, or to calculate:

; negative integral value is added the result will be an unsigned value

; correspnding to the 2's complement representation.

align 4

proc png_save_int_32, buf:dword, i:dword

	stdcall png_save_uint_32, [buf], [i]

	ret

endp

; Convert the supplied time into an RFC 1123 string suitable for use in

; a "Creation Time" or other text-based time string.

align 4

short_months db 'Jan',0, 'Feb',0, 'Mar',0, 'Apr',0, 'May',0, 'Jun',0,\

	'Jul',0, 'Aug',0, 'Sep',0, 'Oct',0, 'Nov',0, 'Dec',0

proc png_convert_to_rfc1123_buffer, out_29:dword, ptime:dword

	cmp dword[out_29],0

	jne @f

		xor eax,eax

		jmp .end_f ;if (..==0) return 0

	@@:

;       ptime->month == 0    ||  ptime->month > 12  ||

;       ptime->day   == 0    ||  ptime->day   > 31  ||

;       ptime->hour  > 23    ||  ptime->minute > 59 ||

;       ptime->second > 60)

;      return 0;

;      size_t pos = 0;

;      char number_buf[5]; /* enough for a four-digit year */

;#     define APPEND_NUMBER(format, value)\

;         APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value)))

;#     define APPEND(ch) if (pos < 28) out_29[pos++] = (ch)

;      APPEND(' ');

;      APPEND_STRING(short_months[(ptime->month - 1)]);

;      APPEND(' ');

;      APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year);

;      APPEND(' ');

;      APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour);

;      APPEND(':');

;      APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute);

;      APPEND(':');

;      APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second);

;      APPEND_STRING(" +0000"); /* This reliably terminates the buffer */

;#     undef APPEND_NUMBER

;#     undef APPEND_STRING

;   }

	inc eax

.end_f:

	ret

endp

; To do: remove the following from libpng-1.7

; Original API that uses a private buffer in png_struct.

; Deprecated because it causes png_struct to carry a spurious temporary

; buffer (png_struct::time_buffer), better to have the caller pass this in.

align 4

proc png_convert_to_rfc1123, png_ptr:dword, ptime:dword

;   if (png_ptr != NULL)

;   {

	; The only failure above if png_ptr != NULL is from an invalid ptime

;      if (png_convert_to_rfc1123_buffer(png_ptr->time_buffer, ptime) == 0)

;         png_warning(png_ptr, "Ignoring invalid time value");

;         return png_ptr->time_buffer;

;   }

	ret

endp

;#    endif /* LIBPNG_VER < 10700 */

;#  endif /* TIME_RFC1123 */

align 4

proc png_get_copyright, png_ptr:dword

jmp .end_0

@@: db 'libpng version 1.6.25 - September 1, 2016',13,10,\

	'      Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson',13,10,\

	'      Copyright (c) 1996-1997 Andreas Dilger',13,10,\

	'      Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.',0

.end_0:

	mov eax,@b

	ret

endp

; format 1.0.0 through 99.99.99zz.  To get the version of *.inc files

; used with your application, print out PNG_LIBPNG_VER_STRING, which

; is defined in png.inc.

; Note: now there is no difference between png_get_libpng_ver() and

; png_get_header_ver().  Due to the version_nn_nn_nn typedef guard,

; it is guaranteed that png.asm uses the correct version of png.inc.

align 4

proc png_get_libpng_ver, png_ptr:dword

	; Version of *.asm files used when building libpng

;   return png_get_header_ver(png_ptr);

	ret

endp

align 4

proc png_get_header_ver, png_ptr:dword

	; Version of *.inc files used when building libpng

;   return PNG_LIBPNG_VER_STRING;

	ret

endp

align 4

proc png_get_header_version, png_ptr:dword

	; Returns longer string containing both version and date

;if __STDC__

;   return PNG_HEADER_VERSION_STRING

;#  ifndef PNG_READ_SUPPORTED

;      " (NO READ SUPPORT)"

;#  endif

;      PNG_STRING_NEWLINE;

;#else

;   return PNG_HEADER_VERSION_STRING;

;end if

	ret

endp

; Build a grayscale palette.  Palette is assumed to be 1 << bit_depth

; large of png_color.  This lets grayscale images be treated as

; paletted.  Most useful for gamma correction and simplification

; of code.  This API is not used internally.

align 4

proc png_build_grayscale_palette, bit_depth:dword, palette:dword

;   int num_palette;

;   int color_inc;

;   int i;

;   int v;

;      return;

;   {

;      case 1:

;         num_palette = 2;

;         color_inc = 0xff;

;         break;

;

;      case 2:

;         num_palette = 4;

;         color_inc = 0x55;

;         break;

;

;      case 4:

;         num_palette = 16;

;         color_inc = 0x11;

;         break;

;

;      case 8:

;         num_palette = 256;

;         color_inc = 1;

;         break;

;

;      default:

;         num_palette = 0;

;         color_inc = 0;

;         break;

;   }

;

;   for (i = 0, v = 0; i < num_palette; i++, v += color_inc)

;   {

;      palette[i].red = (byte)(v & 0xff);

;      palette[i].green = (byte)(v & 0xff);

;      palette[i].blue = (byte)(v & 0xff);

;   }

	ret

endp

align 4

proc png_handle_as_unknown uses ecx edi esi, png_ptr:dword, chunk_name:dword

	; Check chunk_name and return "keep" value if it's on the list, else 0

;   bytep p, p_end;

	cmp edi,0

	je .end0

	cmp dword[chunk_name],0

	je .end0

	cmp dword[edi+png_struct.num_chunk_list],0

	je .end0

		jmp @f

	.end0: ;if (..==0 || ..==0 || ..==0)

		mov eax,PNG_HANDLE_CHUNK_AS_DEFAULT

		jmp .end_f

	@@:

;   p = p_end + png_ptr->num_chunk_list*5; /* beyond end */

	; code was always searched from the end of the list, this is no longer

	; necessary because the 'set' routine handles duplicate entries correcty.

;   {

;      p -= 5;

;         return p[4];

;   }

;   while (p > p_end);

	; be handled according to the value of png_ptr->unknown_default; this can be

	; confusing because, as a result, there are two levels of defaulting for

	; unknown chunks.

.end_f:

	ret

endp

align 4

proc png_chunk_unknown_handling, png_ptr:dword, chunk_name:dword

;   byte chunk_string[5];

;   return png_handle_as_unknown(png_ptr, chunk_string);

	ret

endp

;int (png_structrp png_ptr)

align 4

proc png_reset_zstream, png_ptr:dword

	mov eax,[png_ptr]

	cmp eax,0

	jne @f ;if (..==0)

		mov eax,Z_STREAM_ERROR

		jmp .end_f

	@@:

	; WARNING: this resets the window bits to the maximum!

	add eax,png_struct.zstream

	stdcall inflateReset,eax

.end_f:

	ret

endp

;uint_32 png_access_version_number(void)

align 4

png_access_version_number:

	; Version of *.asm files used when building libpng

	mov eax,PNG_LIBPNG_VER

	ret

; Ensure that png_ptr->zstream.msg holds some appropriate error message string.

; If it doesn't 'ret' is used to set it to something appropriate, even in cases

; like Z_OK or Z_STREAM_END where the error code is apparently a success code.

align 4

proc png_zstream_error uses eax edi, png_ptr:dword, p2ret:dword

	; Translate 'p2ret' into an appropriate error string, priority is given to the

	; one in zstream if set.  This always returns a string, even in cases like

	; Z_OK or Z_STREAM_END where the error code is a success code.

	cmp dword[edi+png_struct.zstream.msg],0

	jne .end_f ;if (..==0) switch (p2ret)

		mov eax,[p2ret]

;      default:

		cmp eax,Z_OK

		jne @f

			cStr dword[edi+png_struct.zstream.msg],'unexpected zlib return code'

			jmp .end_f

		@@:

		cmp eax,Z_STREAM_END

		jne @f

			; Normal exit

			cStr dword[edi+png_struct.zstream.msg],'unexpected end of LZ stream'

			jmp .end_f

		@@:

		cmp eax,Z_NEED_DICT

		jne @f

			; This means the deflate stream did not have a dictionary; this

			; indicates a bogus PNG.

			jmp .end_f

		@@:

		cmp eax,Z_ERRNO

		jne @f

			; gz APIs only: should not happen

			cStr dword[edi+png_struct.zstream.msg],'zlib IO error'

			jmp .end_f

		@@:

		cmp eax,Z_STREAM_ERROR

		jne @f

			; internal libpng error

			cStr dword[edi+png_struct.zstream.msg],'bad parameters to zlib'

			jmp .end_f

		@@:

		cmp eax,Z_DATA_ERROR

		jne @f

			cStr dword[edi+png_struct.zstream.msg],'damaged LZ stream'

			jmp .end_f

		@@:

		cmp eax,Z_MEM_ERROR

		jne @f

			cStr dword[edi+png_struct.zstream.msg],'insufficient memory'

			jmp .end_f

		@@:

		cmp eax,Z_BUF_ERROR

		jne @f

			; End of input or output; not a problem if the caller is doing

			; incremental read or write.

			jmp .end_f

		@@:

		cmp eax,Z_VERSION_ERROR

		jne @f

			cStr dword[edi+png_struct.zstream.msg],'unsupported zlib version'

			jmp .end_f

		@@:

		cmp eax,PNG_UNEXPECTED_ZLIB_RETURN

		jne .end_f

			; Compile errors here mean that zlib now uses the value co-opted in

			; pngpriv.inc for PNG_UNEXPECTED_ZLIB_RETURN; update the switch above

			; and change pngpriv.inc.  Note that this message is "... return",

			; whereas the default/Z_OK one is "... return code".

;         break;

.end_f:

	ret

endp