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

; with unsigned numbers for convenience, although one supported

; ancillary chunk uses signed (two's complement) numbers.

align 4

proc png_save_uint_32 uses eax edi, buf:dword, i:dword

	mov eax,[i]

	bswap eax

	mov edi,[buf]

	stosd

	ret

endp

; The parameter is declared unsigned int, not uint_16,

; just to avoid potential problems on pre-ANSI C compilers.

align 4

proc png_save_uint_16 uses eax edi, buf:dword, i:dword

	mov eax,[i]

	ror eax,16

	bswap eax

	mov edi,[buf]

	stosw

	ret

endp

; the magic bytes of the signature, or more likely, the PNG stream is

; being embedded into another stream and doesn't need its own signature,

; we should call png_set_sig_bytes() to tell libpng how many of the

; bytes have already been written.

png_signature db 137, 80, 78, 71, 13, 10, 26, 10

align 4

proc png_write_sig uses eax ebx edi, png_ptr:dword

if PNG_IO_STATE_SUPPORTED eq 1

	; Inform the I/O callback that the signature is being written

	mov edi,[png_ptr]

	mov dword[edi+png_struct.io_state], PNG_IO_WRITING or PNG_IO_SIGNATURE

end if

	movzx eax,byte[edi+png_struct.sig_bytes]

	mov ebx,8

	sub ebx,eax

	add eax,png_signature

	stdcall png_write_data, edi, eax, ebx

	jge @f

		or dword[edi+png_struct.mode], PNG_HAVE_PNG_SIGNATURE

	@@:

	ret

endp

; The total_length is the sum of the lengths of all the data you will be

; passing in png_write_chunk_data().

align 4

proc png_write_chunk_header uses ebx edi, png_ptr:dword, chunk_name:dword, length:dword

locals

	buf rb 8 ;ebp-8

endl

;   PNG_CSTRING_FROM_CHUNK(buf, chunk_name);

;   png_debug2(0, "Writing %s chunk, length = %lu", buf, (unsigned long)length);

;end if

	cmp edi,0

	je .end_f ;if (png_ptr == NULL) return

	; Inform the I/O callback that the chunk header is being written.

	; PNG_IO_CHUNK_HDR requires a single I/O call.

end if

	mov ebx,ebp

	sub ebx,8

	stdcall png_save_uint_32, ebx, [length]

	m2m dword[ebx+4],dword[chunk_name]

	stdcall png_write_data, edi, ebx, 8

	m2m dword[edi+png_struct.chunk_name],dword[chunk_name]

	stdcall png_reset_crc, edi

	sub ebx,4 ;buf + 4

	stdcall png_calculate_crc, edi, ebx, 4

	; Inform the I/O callback that chunk data will (possibly) be written.

	; PNG_IO_CHUNK_DATA does NOT require a specific number of I/O calls.

end if

.end_f:

	ret

endp

align 4

proc png_write_chunk_start uses eax, png_ptr:dword, chunk_string:dword, length:dword

	mov eax,[chunk_string]

	stdcall png_write_chunk_header, [png_ptr], [eax], [length]

	ret

endp

; Note that multiple calls to this function are allowed, and that the

; sum of the lengths from these calls *must* add up to the total_length

; given to png_write_chunk_header().

align 4

proc png_write_chunk_data uses edi, png_ptr:dword, p2data:dword, length:dword

	; Write the data, and run the CRC over it

	mov edi,[png_ptr]

	cmp edi,0

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

	je .end_f

	cmp dword[length],0

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

		stdcall png_write_data, edi, [p2data], [length]

		; Update the CRC after writing the data,

		; in case the user I/O routine alters it.

		stdcall png_calculate_crc, edi, [p2data], [length]

.end_f:

	ret

endp

;void (png_structrp png_ptr)

align 4

proc png_write_chunk_end uses ebx edi, png_ptr:dword

locals

	buf rb 4 ;ebp-4

endl

	mov edi,[png_ptr]

	cmp edi,0

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

	; Inform the I/O callback that the chunk CRC is being written.

	; PNG_IO_CHUNK_CRC requires a single I/O function call.

end if

	mov ebx,ebp

	sub ebx,4

	stdcall png_save_uint_32, ebx, [edi+png_struct.crc]

.end_f:

	ret

endp

; representing the chunk name.  The array must be at least 4 bytes in

; length, and does not need to be null terminated.  To be safe, pass the

; pre-defined chunk names here, and if you need a new one, define it

; where the others are defined.  The length is the length of the data.

; All the data must be present.  If that is not possible, use the

; png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end()

; functions instead.

align 4

proc png_write_complete_chunk uses edi, png_ptr:dword, chunk_name:dword, p3data:dword, length:dword

	mov edi,[png_ptr]

	cmp edi,0

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

	cmp dword[length],PNG_UINT_31_MAX ;if(..>..)

	jle @f

		png_error edi, 'length exceeds PNG maximum'

	@@:

	stdcall png_write_chunk_header, edi, [chunk_name], [length]

	stdcall png_write_chunk_data, edi, [p3data], [length]

	stdcall png_write_chunk_end, edi

.end_f:

	ret

endp

;void (png_structrp png_ptr, bytep chunk_string, bytep data, png_size_t length)

align 4

proc png_write_chunk, png_ptr:dword, chunk_string:dword, p3data:dword, length:dword

	stdcall png_write_complete_chunk, [png_ptr], [chunk_string], [p3data], [length]

	ret

endp

; so it only needs to be accurate if the size is less than 16384 bytes (the

; point at which a lower LZ window size can be used.)

align 4

proc png_image_size uses ebx ecx edx edi esi, png_ptr:dword

; Only return sizes up to the maximum of a uint_32; do this by limiting

; the width and height used to 15 bits.

	mov ebx,[edi+png_struct.height]

	jge .end0

	cmp ebx,32768

	jge .end0 ;if (..<..  && ..<..)

		cmp byte[edi+png_struct.interlaced],0

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

			; Interlacing makes the image larger because of the replication of

			; both the filter byte and the padding to a byte boundary.

			xor ecx,ecx

			.cycle0:

				PNG_PASS_COLS [edi+png_struct.width], ecx

				;eax = pw

				jle @f ;if (..>0)

					mov edx,eax

					movzx eax,byte[edi+png_struct.pixel_depth]

					PNG_ROWBYTES eax, edx

					inc eax

					mov edx,eax

					PNG_PASS_ROWS ebx, ecx

					imul eax,edx

					add esi,eax

				@@:

				inc ecx

				cmp ecx,6

				jle .cycle0

			jmp .end_f

		.end1: ;else

			mov eax,[edi+png_struct.rowbytes]

			inc eax

			imul eax,ebx

			jmp .end_f

	.end0: ;else

		mov eax,0xffffffff

.end_f:

	ret

endp

; deflate header) to correct the windowBits value to match the actual data

; size.  Note that the second argument is the *uncompressed* size but the

; first argument is the *compressed* data (and it must be deflate

; compressed.)

align 4

proc optimize_cmf, p1data:dword, data_size:dword

; Optimize the CMF field in the zlib stream.  The resultant zlib stream is

; still compliant to the stream specification.

	png_debug 1, 'optimize_cmf'

pushad

	cmp dword[data_size],16384

	jg .end_f ;if (..<=..) ;else windowBits must be 15

		mov esi,[p1data]

		movzx ebx,byte[esi]

		;ebx = z_cmf ;zlib compression method and flags

		and eax,0x0f

		cmp eax,8

		jne .end_f

		mov eax,ebx

		and eax,0xf0

		cmp eax,0x70

		jg .end_f ;if (..==.. && ..<=..)

			;ecx = z_cinfo

			;edi = half_z_window_size

			shr ecx,4

			xor edi,edi

			inc edi

			shl edi,7

			shl edi,cl

			jg .end_f ;if (..<=..) ;else no change

				.cycle0: ;do

					shr edi,1

					dec ecx

					cmp ecx,0

					jle @f

					cmp [data_size],edi

					jle .cycle0

				@@: ;while (..>0 && ..<=..);

				mov eax,ecx

				shl eax,4

				or ebx,eax

				movzx eax,byte[esi+1]

				and eax,0xe0

				shl ebx,8

				add ebx,eax

				add eax,0x1f

				xchg eax,ebx

				xor edx,edx

				mov ecx,0x1f

				div ecx

				sub ebx,edx

				mov byte[esi+1],bl

.end_f:

popad

	ret

endp

;int (png_structrp png_ptr, uint_32 owner, png_alloc_size_t data_size)

;input:

; edi - png_ptr

align 4

proc png_deflate_claim uses ebx ecx, owner:dword, data_size:dword

locals

	level dd ? ;int

	method dd ? ;int

	windowBits dd ? ;int

	memLevel dd ? ;int

	strategy dd ? ;int

	msg rb 64 ;char[64]

endl

	png_debug 1, 'in png_deflate_claim'

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

		mov ebx,ebp

		sub ebx,64

if (PNG_WARNINGS_SUPPORTED eq 1) | (PNG_ERROR_TEXT_SUPPORTED eq 1)

		mov eax,[owner]

		mov [ebx],eax

		mov word[ebx+4],': '

		mov eax,[edi+png_struct.zowner]

		mov [ebx+6],eax

		; So the message that results is " using zstream"; this is an

		; internal error, but is very useful for debugging.  i18n requirements

		; are minimal.

		stdcall png_safecat, ebx, 64, 10, eax

end if

if PNG_RELEASE_BUILD eq 1

		png_warning edi, ebx

		cmp dword[edi+png_struct.zowner],png_IDAT

		jne @f ;if (..==.) ;don't steal from IDAT

			cStr dword[edi+png_struct.zstream.msg],'in use by IDAT'

			mov eax,Z_STREAM_ERROR

			jmp .end_f

		@@:

		mov dword[edi+png_struct.zowner],0

else

		png_error edi, ebx

end if

	.end0:

	mov [level],eax

	mov eax,[edi+png_struct.zlib_method]

	mov [method],eax

	mov eax,[edi+png_struct.zlib_window_bits]

	mov [windowBits],eax

	mov eax,[edi+png_struct.zlib_mem_level]

	mov [memLevel],eax

	jne .end1 ;if (..==..)

		mov eax,[edi+png_struct.flags]

		and eax,PNG_FLAG_ZLIB_CUSTOM_STRATEGY

		cmp eax,0

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

			mov eax,[edi+png_struct.zlib_strategy]

			mov dword[strategy],eax

			jmp .end2

		@@:

		cmp byte[edi+png_struct.do_filter],PNG_FILTER_NONE

		je @f ;else if (..!=..)

			mov dword[strategy],PNG_Z_DEFAULT_STRATEGY

			jmp .end2

		@@: ;else

			mov dword[strategy],PNG_Z_DEFAULT_NOFILTER_STRATEGY

		jmp .end2

	.end1: ;else

if PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED eq 1

		mov eax,[edi+png_struct.zlib_text_level]

		mov [level],eax

		mov eax,[edi+png_struct.zlib_text_method]

		mov [method],eax

		mov eax,[edi+png_struct.zlib_text_window_bits]

		mov [windowBits],eax

		mov eax,[edi+png_struct.zlib_text_mem_level]

		mov [memLevel],eax

		mov eax,[edi+png_struct.zlib_text_strategy]

		mov [strategy],eax

else

		; If customization is not supported the values all come from the

		; IDAT values except for the strategy, which is fixed to the

		; default.  (This is the pre-1.6.0 behavior too, although it was

		; implemented in a very different way.)

end if

	.end2:

	; happening just pass 32768 as the data_size parameter.  Notice that zlib

	; requires an extra 262 bytes in the window in addition to the data to be

	; able to see the whole of the data, so if data_size+262 takes us to the

	; next windowBits size we need to fix up the value later.  (Because even

	; though deflate needs the extra window, inflate does not!)

	jg .end3 ;if (..<=..)

		; IMPLEMENTATION NOTE: this 'half_window_size' stuff is only here to

		; work round a Microsoft Visual C misbehavior which, contrary to C-90,

		; widens the result of the following shift to 64-bits if (and,

		; apparently, only if) it is used in a test.

		dec ecx

		xor eax,eax

		inc eax

		shl eax,cl ;eax = half_window_size

		mov ecx,[data_size]

		add ecx,262

		@@: ;while (..<=..)

			cmp ecx,eax

			jg .end3

			shr eax,1

			dec dword[windowBits]

			jmp @b

	.end3:

	mov eax,[edi+png_struct.flags]

	and eax,PNG_FLAG_ZSTREAM_INITIALIZED

	cmp eax,0

	je .end4

	mov eax,[level]

	cmp [edi+png_struct.zlib_set_level],eax

	jne @f

	mov eax,[method]

	cmp [edi+png_struct.zlib_set_method],eax

	jne @f

	mov eax,[windowBits]

	cmp [edi+png_struct.zlib_set_window_bits],eax

	jne @f

	mov eax,[memLevel]

	cmp [edi+png_struct.zlib_set_mem_level],eax

	jne @f

	mov eax,[strategy]

	cmp [edi+png_struct.zlib_set_strategy],eax

	je .end4

	@@: ;if (..!=0 && (..!=.. || ..!=.. || ..!=.. || ..!=.. || ..!=..))

		mov eax,edi

		add eax,png_struct.zstream

		stdcall [deflateEnd], eax

		cmp eax,Z_OK

		je @f ;if (..!=..)

			png_warning edi, 'deflateEnd failed (ignored)'

		@@:

		and dword[edi+png_struct.flags], not PNG_FLAG_ZSTREAM_INITIALIZED

	.end4:

	; doesn't use them on Init, but it might in the future).

	mov dword[edi+png_struct.zstream.avail_in],0

	mov dword[edi+png_struct.zstream.next_out],0

	mov word[edi+png_struct.zstream.avail_out],0

	; to a simple reset to the previous parameters.

	add ecx,png_struct.zstream

	mov eax,[edi+png_struct.flags]

	and eax,PNG_FLAG_ZSTREAM_INITIALIZED

	cmp eax,0

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

		stdcall [deflateReset], ecx

		jmp .end5

	@@: ;else

		stdcall [deflateInit2], ecx, [level], [method], [windowBits],\

			[memLevel], [strategy]

		je .end5 ;if (..==..)

			or dword[edi+png_struct.flags],PNG_FLAG_ZSTREAM_INITIALIZED

	.end5:

	; pretty much the same set of error codes.

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

		mov ecx,[owner]

		mov [edi+png_struct.zowner],ecx

		jmp .end_f

	@@: ;else

		stdcall png_zstream_error, edi, eax

	ret

endp

;void (png_structrp png_ptr, png_compression_bufferp *listp)

align 4

proc png_free_buffer_list uses eax ebx ecx edi, png_ptr:dword, listp:dword

	mov eax,[listp]

	mov ebx,[eax]

	;eax = png_compression_bufferp list

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

		mov dword[eax],0

		.cycle0: ;do

			mov ecx,[ebx+png_compression_buffer.next]

			stdcall png_free, edi, ebx

			mov ebx,ecx

		cmp ebx,0

		jne .cycle0 ;while (..!=0)

	@@:

	ret

endp

; This pair of functions encapsulates the operation of (a) compressing a

; text string, and (b) issuing it later as a series of chunk data writes.

; The compression_state structure is shared context for these functions

; set up by the caller to allow access to the relevant local variables.

; temporary buffers.  From 1.6.0 it is retained in png_struct so that it will

; be correctly freed in the event of a write error (previous implementations

; just leaked memory.)

	input      dd ? ;bytep      ;The uncompressed input data

	input_len  dd ? ;png_alloc_size_t ;Its length

	output_len dd ? ;uint_32          ;Final compressed length

	output     rb 1024 ;byte[1024]    ;First block of output

ends

align 4

proc png_text_compress_init uses eax ebx, comp:dword, input:dword, input_len:dword

	mov ebx,[comp]

	mov eax,[input]

	mov [ebx+compression_state.input],eax

	mov eax,[input_len]

	mov [ebx+compression_state.input_len],eax

	mov dword[ebx+compression_state.output_len],0

	ret

endp

;int (png_structrp png_ptr, uint_32 chunk_name, compression_state *comp, uint_32 prefix_len)

align 4

proc png_text_compress uses ebx ecx edx edi esi, png_ptr:dword, chunk_name:dword, comp:dword, prefix_len:dword

locals

	output_len dd ? ;uint_32

	avail_in   dd ? ;uInt

	next       dd ? ;png_compression_buffer*

endl

	; To find the length of the output it is necessary to first compress the

	; input. The result is buffered rather than using the two-pass algorithm

	; that is used on the inflate side; deflate is assumed to be slower and a

	; PNG writer is assumed to have more memory available than a PNG reader.

	; upper limit on the output size, but it is always bigger than the input

	; size so it is likely to be more efficient to use this linked-list

	; approach.

	mov edi,[png_ptr]

	stdcall png_deflate_claim, [chunk_name], [ebx+compression_state.input_len]

	jne .end_f ;if (..!=Z_OK) return ..

	; uInt.  Use ZLIB_IO_MAX to limit the input.  The output is always limited

	; by the output buffer size, so there is no need to check that.  Since this

	; is ANSI-C we know that an 'int', hence a uInt, is always at least 16 bits

	; in size.

	add edx,png_struct.zbuffer_list

	mov ecx,[ebx+compression_state.input_len] ;may be zero!

	;ecx = input_len

	;edx = end

	;esi = ret

	mov eax,[ebx+compression_state.input]

	mov [edi+png_struct.zstream.next_in],eax

	mov dword[edi+png_struct.zstream.avail_in],0 ;Set below

	mov eax,ebx

	add eax,compression_state.output

	mov [edi+png_struct.zstream.next_out],eax

	mov eax,sizeof.compression_state.output ;1024

	mov [edi+png_struct.zstream.avail_out],ax

		mov dword[avail_in],ZLIB_IO_MAX

		jle @f ;if (..>..)

			mov [avail_in],ecx

		@@:

		sub ecx,[avail_in]

		mov [edi+png_struct.zstream.avail_in],eax

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

			; Chunk data is limited to 2^31 bytes in length, so the prefix

			; length must be counted here.

			add eax,[prefix_len]

			cmp eax,PNG_UINT_31_MAX

			jle @f ;if (..>..)

				mov esi,Z_MEM_ERROR

				jmp .cycle0end

			@@:

			; already.

			mov [next],eax

			jne .end1 ;if (..==0)

				PNG_COMPRESSION_BUFFER_SIZE edi

				stdcall png_malloc, edi, eax

				mov [next],eax

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

					mov esi,Z_MEM_ERROR

					jmp .cycle0end

				@@:

				mov dword[eax+png_compression_buffer.next],0

				mov [edx],eax

			.end1:

			mov eax,[eax+png_compression_buffer.output]

			mov [edi+png_struct.zstream.next_out],eax

			mov eax,[edi+png_struct.zbuffer_size]

			mov [edi+png_struct.zstream.avail_out],ax

			add [output_len],eax

			mov eax,[next]

			add eax,png_compression_buffer.next

			mov edx,eax

		.end0:

		mov eax,Z_FINISH

		cmp dword[input_len],0

		jle @f

			mov eax,Z_NO_FLUSH

		@@:

		push eax

		mov eax,edi

		add eax,png_struct.zstream

		stdcall [deflate], eax ;, ...

		mov esi,eax

		; reset above every time round the loop).

		add [input_len],eax

		mov dword[edi+png_struct.zstream.avail_in],0 ;safety

		cmp esi,Z_OK

		je .cycle0 ;while (..==..)

	.cycle0end:

	; be subtracted from output_len.

	sub [output_len],eax

	mov word[edi+png_struct.zstream.avail_out],0 ;safety

	mov eax,[output_len]

	mov [ebx+compression_state.output_len],eax

	; too long.  Otherwise ensure the z_stream::msg pointer is set to

	; something.

	add eax,[prefix_len]

	cmp eax,PNG_UINT_31_MAX

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

		cStr dword[edi+png_struct.zstream.msg],'compressed data too long'

		mov esi,Z_MEM_ERROR

		jmp .end2

	@@: ;else

		stdcall png_zstream_error, edi, esi

	.end2:

	mov dword[edi+png_struct.zowner],0

	; is an internal error.

	jne @f

	cmp dword[input_len],0

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

if PNG_WRITE_OPTIMIZE_CMF_SUPPORTED eq 1

		; Fix up the deflate header, if required

		mov eax,ebx

		add eax,compression_state.output

		stdcall optimize_cmf, eax, [ebx+compression_state.input_len]

end if

		; But Z_OK is returned, not Z_STREAM_END; this allows the claim

		; function above to return Z_STREAM_END on an error (though it never

		; does in the current versions of zlib.)

		jmp .end_f

	@@: ;else

		mov eax,esi

.end_f:

	ret

endp

;void (png_structrp png_ptr, compression_state *comp)

align 4

proc png_write_compressed_data_out uses ebx edi, png_ptr:dword, comp:dword

locals

	output_len dd ? ;uint_32 ;= comp.output_len

	output dd ? ;bytep ;= comp.output

	avail  dd ? ;uint_32     ;= sizeof.comp.output

	next   dd ? ;png_compression_buffer* ;= png_ptr.zbuffer_list

endl

	mov ebx,[comp]

	mov eax,[ebx+compression_state.output_len]

	mov [output_len],eax

	mov eax,ebx

	add eax,compression_state.output

	mov [output],eax

	mov [avail],sizeof.compression_state.output ;1024

	mov edi,[png_ptr]

	mov eax,[edi+png_struct.zbuffer_list]

	mov [next],eax

		mov eax,[output_len]

		cmp [avail],eax

		jle @f ;if (..>..)

			mov [avail],eax

		@@:

		sub [output_len],eax

		je .cycle0end

		cmp dword[next],0

		je .cycle0end ;if (..==0 || ..==0) break

		mov [avail],eax

		mov eax,[next]

		add eax,png_compression_buffer.output

		mov [output],eax

		mov eax,[next]

		mov eax,[eax+png_compression_buffer.next]

		mov [next],eax

		jmp .cycle0

	.cycle0end:

	cmp dword[output_len],0

	jle @f ;if (..>0)

		png_error edi, 'error writing ancillary chunked compressed data'

	@@:

	ret

endp

end if ;WRITE_COMPRESSED_TEXT

; information.  Note that the rest of this code depends upon this

; information being correct.

;    int bit_depth, int color_type, int compression_type, int filter_type, int interlace_type)

align 4

proc png_write_IHDR, png_ptr:dword, width:dword, height:dword, bit_depth:dword,\

	color_type:dword, compression_type:dword, filter_type:dword, interlace_type:dword

locals

	buf rb 13 ;byte[13] ;Buffer to store the IHDR info

endl

	png_debug 1, 'in png_write_IHDR'

pushad

	; Check that we have valid input data from the application info

	mov edi,[png_ptr]

	movzx ebx,byte[color_type]

	cmp ebx,PNG_COLOR_TYPE_GRAY

	jne .end_0

		cmp byte[bit_depth],1

		je @f

		cmp byte[bit_depth],2

		je @f

		cmp byte[bit_depth],4

		je @f

		cmp byte[bit_depth],8

		je @f

if PNG_WRITE_16BIT_SUPPORTED eq 1

		cmp byte[bit_depth],16

		je @f

end if

		jmp .def_0

	@@:

		mov byte[edi+png_struct.channels], 1

		jmp .end_s0

	.def_0: ;default

		png_error edi, 'Invalid bit depth for grayscale image'

		jmp .end_s0

	.end_0:

	jne .end_1

		cmp byte[bit_depth],8

		je @f ;if (..!=8)

if PNG_WRITE_16BIT_SUPPORTED eq 1

		cmp byte[bit_depth],16

		je @f ;if (..!=16)

end if

            png_error edi, 'Invalid bit depth for RGB image'

		@@:

		mov byte[edi+png_struct.channels], 3

		jmp .end_s0

	.end_1:

	jne .end_2

		cmp byte[bit_depth],1

		je @f

		cmp byte[bit_depth],2

		je @f

		cmp byte[bit_depth],4

		je @f

		cmp byte[bit_depth],8

		je @f

		jmp .def_1

		@@:

			mov byte[edi+png_struct.channels], 1

			jmp .end_s0

		.def_1: ;default

			png_error edi, 'Invalid bit depth for paletted image'

		jmp .end_s0

	.end_2:

	jne .end_3

		cmp byte[bit_depth],8

		je @f ;if (..!=8)

		cmp byte[bit_depth],16

		je @f ;if (..!=16)

            png_error edi, 'Invalid bit depth for grayscale+alpha image'

		@@:

		mov byte[edi+png_struct.channels], 2

		jmp .end_s0

	.end_3:

	jne .end_4

		cmp byte[bit_depth],8

		je @f ;if (..!=8)

if PNG_WRITE_16BIT_SUPPORTED eq 1

		cmp byte[bit_depth],16

		je @f ;if (..!=16)

end if

			png_error edi, 'Invalid bit depth for RGBA image'

		@@:

		mov byte[edi+png_struct.channels], 4

		jmp .end_s0

	.end_4:

		png_error edi, 'Invalid image color type specified'

	.end_s0:

	je @f ;if (..!=..)

		png_warning edi, 'Invalid compression type specified'

		mov dword[compression_type], PNG_COMPRESSION_TYPE_BASE

	@@:

	; 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and

	; 2. Libpng did not write a PNG signature (this filter_method is only

	;    used in PNG datastreams that are embedded in MNG datastreams) and

	; 3. The application called png_permit_mng_features with a mask that

	;    included PNG_FLAG_MNG_FILTER_64 and

	; 4. The filter_method is 64 and

	; 5. The color_type is RGB or RGBA

if PNG_MNG_FEATURES_SUPPORTED eq 1

;       !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&

;       ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&

;       (color_type == PNG_COLOR_TYPE_RGB ||

;        color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&

;       (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&

end if

	cmp dword[filter_type],PNG_FILTER_TYPE_BASE

	je @f ;if (..!=..)

		png_warning edi, 'Invalid filter type specified'

		mov dword[filter_type], PNG_FILTER_TYPE_BASE

	@@:

	cmp dword[interlace_type],PNG_INTERLACE_NONE

	je @f ;if (..!=..)

	cmp dword[interlace_type],PNG_INTERLACE_ADAM7

	je @f ;if (..!=..)

		png_warning edi, 'Invalid interlace type specified'

		mov dword[interlace_type], PNG_INTERLACE_ADAM7

	@@:

else

	mov dword[interlace_type], PNG_INTERLACE_NONE

end if

	mov al,byte[bit_depth]

	mov byte[edi+png_struct.bit_depth],al

	mov al,byte[color_type]

	mov byte[edi+png_struct.color_type],al

	mov al,byte[interlace_type]

	mov byte[edi+png_struct.interlaced],al

if PNG_MNG_FEATURES_SUPPORTED eq 1

	mov al,byte[filter_type]

	mov byte[edi+png_struct.filter_type],al

end if

	mov al,byte[compression_type]

	mov byte[edi+png_struct.compression_type],al

	mov eax,[width]

	mov [edi+png_struct.width],eax

	mov eax,[height]

	mov [edi+png_struct.height],eax

	imul ax,word[bit_depth]

	mov byte[edi+png_struct.pixel_depth],al

	PNG_ROWBYTES eax, [width]

	mov [edi+png_struct.rowbytes],eax

	; Set the usr info, so any transformations can modify it

	mov eax,[edi+png_struct.width]

	mov [edi+png_struct.usr_width],eax

	mov al,[edi+png_struct.bit_depth]

	mov [edi+png_struct.usr_bit_depth],al

	mov al,[edi+png_struct.channels]

	mov [edi+png_struct.usr_channels],al

	mov ebx,ebp

	sub ebx,13

	stdcall png_save_uint_32, ebx, [width]

	add ebx,4

	stdcall png_save_uint_32, ebx, [height]

	add ebx,4

	mov al,byte[bit_depth]

	mov byte[ebx],al ;buf[8] = (byte)bit_depth

	inc ebx

	mov al,byte[color_type]

	mov byte[ebx],al ;buf[9] = (byte)color_type

	inc ebx

	mov al,byte[compression_type]

	mov byte[ebx],al ;buf[10] = (byte)compression_type

	inc ebx

	mov al,byte[filter_type]

	mov byte[ebx],al ;buf[11] = (byte)filter_type

	inc ebx

	mov al,byte[interlace_type]

	mov byte[ebx],al ;buf[12] = (byte)interlace_type

	sub ebx,12

	stdcall png_write_complete_chunk, edi, png_IHDR, ebx, dword 13

	jne .end_5 ;if (..==..)

	je @f

	cmp byte[edi+png_struct.bit_depth],8

	jl @f ;if ((..==..)||(..<..))

		jmp .els_5

	@@:

		mov byte[edi+png_struct.do_filter], PNG_FILTER_NONE

		jmp .end_5

	.els_5: ;else

		mov byte[edi+png_struct.do_filter], PNG_ALL_FILTERS

	.end_5:

popad

	ret

endp

; correct order for PNG, so people can redefine it to any convenient

; structure.

align 4

proc png_write_PLTE, png_ptr:dword, palette:dword, num_pal:dword

locals

	;max_palette_length dd ? ;uint_32

	i dd ?

	pal_ptr dd ? ;png_const_colorp

	buf rb 3 ;byte[3]

endl

	png_debug 1, 'in png_write_PLTE'

	mov edi,[png_ptr]

	movzx eax,byte[edi+png_struct.color_type]

	cmp eax,PNG_COLOR_TYPE_PALETTE

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

		;mov dword[max_palette_length],PNG_MAX_PALETTE_LENGTH

		mov eax,PNG_MAX_PALETTE_LENGTH

		jmp .end0

	@@:

		mov cl,byte[edi+png_struct.bit_depth]

		xor eax,eax

		inc eax

		shl eax,cl

		;mov [max_palette_length],eax

	.end0:

	cmp [num_pal],eax

	jg @f

	mov eax,[edi+png_struct.mng_features_permitted]

	and eax,PNG_FLAG_MNG_EMPTY_PLTE

	cmp eax,0

	jne .end1

	cmp [num_pal],0

	jne .end1

	@@:

end if

	jne @f

		png_error edi, 'Invalid number of colors in palette'

		jmp .end1

	@@: ;else

		png_warning edi, 'Invalid number of colors in palette'

		jmp .end_f

	.end1:

	and eax,PNG_COLOR_MASK_COLOR

	cmp eax,0

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

		png_warning edi, 'Ignoring request to write a PLTE chunk in grayscale PNG'

		jmp .end_f

	@@:

	mov word[edi+png_struct.num_palette],ax

	png_debug1 3, 'num_palette = %d', eax