WebSVN – Kolibri OS – Diff – /programs/develop/libraries/libs-dev/libimg/png/libpng/pngwrite.asm


; pngwrite.asm - general routines to write a PNG file
 
; 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.)
 
; This code is released under the libpng license.
; For conditions of distribution and use, see the disclaimer
; and license in png.inc
 
; Write out all the unknown chunks for the current given location
;void (png_structrp png_ptr, png_const_inforp info_ptr, unsigned int where)
align 4
proc write_unknown_chunks, png_ptr:dword, info_ptr:dword, where:dword
pushad
	mov esi,[info_ptr]
	cmp dword[esi+png_info_def.unknown_chunks_num],0
	je .end_f ;if(..!=0)
		mov edi,[png_ptr]
		;ecx = up
 
		png_debug 5, 'writing extra chunks'
 
		mov ecx,[esi+png_info_def.unknown_chunks]
		mov edx,[esi+png_info_def.unknown_chunks_num]
		imul edx,sizeof.png_unknown_chunk
		add edx,ecx
		.cycle0: ;for (..;..<..;..)
			cmp ecx,edx
			jge .end_f
			movzx eax,byte[ecx+png_unknown_chunk.location]
			and eax,[where]
			jz .end0 ;if (..!=0)
			; If per-chunk unknown chunk handling is enabled use it, otherwise
			; just write the chunks the application has set.
 
if PNG_SET_UNKNOWN_CHUNKS_SUPPORTED eq 1
			mov eax,ecx
			add eax,png_unknown_chunk.name
			stdcall png_handle_as_unknown, edi, eax
 
			; NOTE: this code is radically different from the read side in the
			; matter of handling an ancillary unknown chunk.  In the read side
			; the default behavior is to discard it, in the code below the default
			; behavior is to write it.  Critical chunks are, however, only
			; written if explicitly listed or if the default is set to write all
			; unknown chunks.
 
			; The default handling is also slightly weird - it is not possible to
			; stop the writing of all unsafe-to-copy chunks!
 
			; TODO: REVIEW: this would seem to be a bug.
 
			cmp eax,PNG_HANDLE_CHUNK_NEVER
			je .end0
			mov bl,byte[ecx+png_unknown_chunk.name+3]
			and bl,0x20
			cmp bl,0
			jne .beg0
			cmp eax,PNG_HANDLE_CHUNK_ALWAYS
			je .beg0
			cmp eax,PNG_HANDLE_CHUNK_AS_DEFAULT
			jne .end0
			cmp dword[edi+png_struct.unknown_default],PNG_HANDLE_CHUNK_ALWAYS
			jne .end0
end if
			.beg0: ;if (..!=.. && (.. safe-to-copy overrides everything || ..==.. || (..==.. && ..==..)))
				; TODO: review, what is wrong with a zero length unknown chunk?
				cmp dword[ecx+png_unknown_chunk.size],0
				jne @f ;if (..==0)
					png_warning [png_ptr], 'Writing zero-length unknown chunk'
				@@:
				mov eax,dword[ecx+png_unknown_chunk.name]
				stdcall png_write_chunk, edi, eax, [ecx+png_unknown_chunk.podata], [ecx+png_unknown_chunk.size]
			.end0:
			add ecx,sizeof.png_unknown_chunk
			jmp .cycle0
		;.cycle0end:
.end_f:
popad
	ret
endp
 
; Writes all the PNG information.  This is the suggested way to use the
; library.  If you have a new chunk to add, make a function to write it,
; and put it in the correct location here.  If you want the chunk written
; after the image data, put it in png_write_end().  I strongly encourage
; you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing
; the chunk, as that will keep the code from breaking if you want to just
; write a plain PNG file.  If you have long comments, I suggest writing
; them in png_write_end(), and compressing them.
 
;void (png_structrp png_ptr, png_const_inforp info_ptr)
align 4
proc png_write_info_before_PLTE, png_ptr:dword, info_ptr:dword
	png_debug 1, 'in png_write_info_before_PLTE'
 
pushad
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f
	mov esi,[info_ptr]
	cmp esi,0
	je .end_f ;if(..==0 || ..==0) return
 
	mov eax,[edi+png_struct.mode]
	and eax,PNG_WROTE_INFO_BEFORE_PLTE
	jnz .end_f ;if (..==0)
 
		; Write PNG signature
		stdcall png_write_sig, edi
 
if PNG_MNG_FEATURES_SUPPORTED eq 1
		mov eax,[edi+png_struct.mode]
		and eax,PNG_HAVE_PNG_SIGNATURE
		jz @f
		cmp dword[edi+png_struct.mng_features_permitted],0
		je @f ;if(..!=0 && ..!=0)
			png_warning edi, 'MNG features are not allowed in a PNG datastream'
			mov dword[edi+png_struct.mng_features_permitted],0
		@@:
end if
 
	; Write IHDR information.
if PNG_WRITE_INTERLACING_SUPPORTED eq 1
	movzx eax,byte[esi+png_info_def.interlace_type]
	push eax
else
	push dword 0
end if
	movzx eax,byte[esi+png_info_def.filter_type]
	push eax
	movzx eax,byte[esi+png_info_def.compression_type]
	push eax
	movzx eax,byte[esi+png_info_def.color_type]
	push eax
	movzx eax,byte[esi+png_info_def.bit_depth]
	stdcall png_write_IHDR, edi,\
		dword[esi+png_info_def.width], dword[esi+png_info_def.height], eax
 
; The rest of these check to see if the valid field has the appropriate
; flag set, and if it does, writes the chunk.
 
; 1.6.0: COLORSPACE support controls the writing of these chunks too, and
; the chunks will be written if the WRITE routine is there and
; information * is available in the COLORSPACE. (See
; png_colorspace_sync_info in png.c for where the valid flags get set.)
 
; Under certain circumstances the colorspace can be invalidated without
; syncing the info_struct 'valid' flags; this happens if libpng detects
; an error and calls png_error while the color space is being set, yet
; the application continues writing the PNG.  So check the 'invalid'
; flag here too.
 
if PNG_GAMMA_SUPPORTED eq 1
if PNG_WRITE_gAMA_SUPPORTED eq 1
	movzx eax,word[esi+png_info_def.colorspace.flags]
	and eax,PNG_COLORSPACE_INVALID
	jnz @f
	movzx eax,word[esi+png_info_def.colorspace.flags]
	and eax,PNG_COLORSPACE_FROM_gAMA
	jz @f
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_gAMA
	jz @f ;if (..==0 && ..!=0 && ..!=0)
		stdcall png_write_gAMA_fixed, edi, [esi+png_info_def.colorspace.gamma]
	@@:
end if
end if
 
if PNG_COLORSPACE_SUPPORTED eq 1
	; Write only one of sRGB or an ICC profile.  If a profile was supplied
	; and it matches one of the known sRGB ones issue a warning.
 
if PNG_WRITE_iCCP_SUPPORTED eq 1
	movzx eax,word[esi+png_info_def.colorspace.flags]
	and eax,PNG_COLORSPACE_INVALID
	jnz .end0
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_iCCP
	jz .end0 ;if (..==0 && ..!=0)
if PNG_WRITE_sRGB_SUPPORTED eq 1
		mov eax,[esi+png_info_def.valid]
		and eax,PNG_INFO_sRGB
		jz @f ;if (..!=0)
			png_app_warning edi, 'profile matches sRGB but writing iCCP instead'
		@@:
end if
		stdcall png_write_iCCP, edi, [esi+png_info_def.iccp_name],\
			[esi+png_info_def.iccp_profile]
if PNG_WRITE_sRGB_SUPPORTED eq 1
		jmp .end1
end if
	.end0: ;else
end if
 
if PNG_WRITE_sRGB_SUPPORTED eq 1
	movzx eax,word[esi+png_info_def.colorspace.flags]
	and eax,PNG_COLORSPACE_INVALID
	jnz .end1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_sRGB
	jz .end1 ;if (..==0 && ..!=0)
		movzx eax,word[esi+png_info_def.colorspace.rendering_intent]
		stdcall png_write_sRGB, edi, eax
	.end1:
end if ;sRGB
end if ;COLORSPACE
 
if PNG_WRITE_sBIT_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_sBIT
	jz @f ;if (..!=0)
		movzx eax,byte[esi+png_info_def.color_type]
		push eax
		mov eax,esi
		add eax,png_info_def.sig_bit
		stdcall png_write_sBIT, edi, eax ;, ...color_type
	@@:
end if
 
if PNG_COLORSPACE_SUPPORTED eq 1
if PNG_WRITE_cHRM_SUPPORTED eq 1
	movzx eax,word[esi+png_info_def.colorspace.flags]
	and eax,PNG_COLORSPACE_INVALID
	jnz @f
	movzx eax,word[esi+png_info_def.colorspace.flags]
	and eax,PNG_COLORSPACE_FROM_cHRM
	jz @f
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_cHRM
	jz @f ;if (..==0 && ..!=0 && ..!=0)
		stdcall png_write_cHRM_fixed, edi, [esi+png_info_def.colorspace.end_points_xy]
	@@:
end if
end if
 
if PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED eq 1
		stdcall write_unknown_chunks, edi, esi, PNG_HAVE_IHDR
end if
		or dword[edi+png_struct.mode],PNG_WROTE_INFO_BEFORE_PLTE
	.end_f:
popad
	ret
endp
 
;void (png_structrp png_ptr, png_const_inforp info_ptr)
align 4
proc png_write_info, png_ptr:dword, info_ptr:dword
if (PNG_WRITE_TEXT_SUPPORTED eq 1) | (PNG_WRITE_sPLT_SUPPORTED eq 1)
;   int i;
end if
pushad
	png_debug 1, 'in png_write_info'
 
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f
	mov esi,[info_ptr]
	cmp esi,0
	je .end_f ;if (..==0 || ..==0) return
 
	stdcall png_write_info_before_PLTE, edi, esi
 
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_PLTE
	jz @f ;if (..!=0)
		movzx eax,word[esi+png_info_def.num_palette]
		stdcall png_write_PLTE, edi, [esi+png_info_def.palette], eax
		jmp .end_0
	@@:
	mov al,byte[esi+png_info_def.color_type]
	cmp al,PNG_COLOR_TYPE_PALETTE
	jne .end_0 ;else if (..==..)
		png_error edi, 'Valid palette required for paletted images'
	.end_0:
 
if PNG_WRITE_tRNS_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_tRNS
	jz .end_1 ;if (..!=0)
if PNG_WRITE_INVERT_ALPHA_SUPPORTED eq 1
	; Invert the alpha channel (in tRNS)
;      if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 &&
;          info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
;      {
;         int j, jend;
 
;         jend = info_ptr->num_trans;
;         if (jend > PNG_MAX_PALETTE_LENGTH)
;            jend = PNG_MAX_PALETTE_LENGTH;
 
;         for (j = 0; j
;            info_ptr->trans_alpha[j] =
;               (byte)(255 - info_ptr->trans_alpha[j]);
;      }
end if
		mov eax,esi
		add eax,png_info_def.trans_color
		movzx ebx,word[esi+png_info_def.num_trans]
		movzx ecx,byte[esi+png_info_def.color_type]
		stdcall png_write_tRNS, edi, dword[esi+png_info_def.trans_alpha], eax, ebx, ecx
	.end_1:
end if
if PNG_WRITE_bKGD_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_bKGD
	jz @f ;if (..!=0)
		mov eax,esi
		add eax,png_info_def.background
		movzx ebx,byte[esi+png_info_def.color_type]
		stdcall png_write_bKGD, edi, eax, ebx
	@@:
end if
 
if PNG_WRITE_hIST_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_hIST
	jz @f ;if (..!=0)
		movzx ebx,word[esi+png_info_def.num_palette]
		stdcall png_write_hIST, edi, [esi+png_info_def.hist], ebx
	@@:
end if
 
if PNG_WRITE_oFFs_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_oFFs
	jz @f ;if (..!=0)
		movzx ebx,byte[esi+png_info_def.offset_unit_type]
		stdcall png_write_oFFs, edi, [esi+png_info_def.x_offset], [esi+png_info_def.y_offset], ebx
	@@:
end if
 
if PNG_WRITE_pCAL_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_pCAL
	jz @f ;if (..!=0)
		movzx ebx,byte[esi+png_info_def.pcal_type]
		movzx ecx,byte[esi+png_info_def.pcal_nparams]
		stdcall png_write_pCAL, edi, [esi+png_info_def.pcal_purpose], [esi+png_info_def.pcal_X0], [esi+png_info_def.pcal_X1], ebx, ecx, [esi+png_info_def.pcal_units], [esi+png_info_def.pcal_params]
	@@:
end if
 
if PNG_WRITE_sCAL_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_sCAL
	jz @f ;if (..!=0)
		movzx ebx,byte[esi+png_info_def.scal_unit]
		stdcall png_write_sCAL_s, edi, ebx, [esi+png_info_def.scal_s_width], [esi+png_info_def.scal_s_height]
	@@:
end if ;sCAL
 
if PNG_WRITE_pHYs_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_pHYs
	jz @f ;if (..!=0)
		movzx ebx,byte[esi+png_info_def.phys_unit_type]
		stdcall png_write_pHYs, edi, [esi+png_info_def.x_pixels_per_unit], [esi+png_info_def.y_pixels_per_unit], ebx
	@@:
end if ;pHYs
 
if PNG_WRITE_tIME_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_tIME
	jz @f ;if (..!=0)
		mov eax,esi
		add eax,png_info_def.mod_time
		stdcall png_write_tIME, edi, eax
		or [edi+png_struct.mode],PNG_WROTE_tIME
	@@:
end if ;tIME
 
if PNG_WRITE_sPLT_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_sPLT
	jz @f ;if (..!=0)
		mov eax,[esi+png_info_def.splt_palettes]
		mov ecx,[esi+png_info_def.splt_palettes_num]
		cmp ecx,1
		jl @f
		.cycle0:
			stdcall png_write_sPLT, edi, eax
			add eax,4
			loop .cycle0
	@@:
end if ;sPLT
 
if PNG_WRITE_TEXT_SUPPORTED eq 1
	; Check to see if we need to write text chunks
;   for (i = 0; i < info_ptr->num_text; i++)
;   {
;      png_debug2(2, "Writing header text chunk %d, type %d", i,
;          info_ptr->text[i].compression);
	; An internationalized chunk?
;      if (info_ptr->text[i].compression > 0)
;      {
if PNG_WRITE_iTXt_SUPPORTED eq 1
	; Write international chunk
;         png_write_iTXt(png_ptr,
;             info_ptr->text[i].compression,
;             info_ptr->text[i].key,
;             info_ptr->text[i].lang,
;             info_ptr->text[i].lang_key,
;             info_ptr->text[i].text);
	; Mark this chunk as written
;         if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
;            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
;         else
;            info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
else
	png_warning edi, 'Unable to write international text'
end if
;      }
 
	; If we want a compressed text chunk
;      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
;      {
if PNG_WRITE_zTXt_SUPPORTED eq 1
	; Write compressed chunk
;         png_write_zTXt(png_ptr, info_ptr->text[i].key,
;             info_ptr->text[i].text, info_ptr->text[i].compression);
	; Mark this chunk as written
;         info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
else
	png_warning edi, 'Unable to write compressed text'
end if
;      }
 
;      else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
;      {
if PNG_WRITE_tEXt_SUPPORTED eq 1
	; Write uncompressed chunk
;         png_write_tEXt(png_ptr, info_ptr->text[i].key,
;             info_ptr->text[i].text,
;             0);
	; Mark this chunk as written
;         info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
else
	; Can't get here
	png_warning edi, 'Unable to write uncompressed text'
end if
;      }
;   }
end if ;tEXt
 
if PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED eq 1
	stdcall write_unknown_chunks, edi, esi, PNG_HAVE_PLTE
end if
	.end_f:
popad
	ret
endp
 
; Writes the end of the PNG file.  If you don't want to write comments or
; time information, you can pass NULL for info.  If you already wrote these
; in png_write_info(), do not write them again here.  If you have long
; comments, I suggest writing them here, and compressing them.
 
;void (png_structrp png_ptr, png_inforp info_ptr)
align 4
proc png_write_end, png_ptr:dword, info_ptr:dword
pushad
	png_debug 1, 'in png_write_end'
 
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
	mov eax,[edi+png_struct.mode]
	and eax,PNG_HAVE_IDAT
	jnz @f ;if (..==0)
		png_error edi, 'No IDATs written into file'
	@@:
 
if PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED eq 1
	mov eax,[edi+png_struct.num_palette_max]
	cmp ax,[edi+png_struct.num_palette]
	jle @f ;if (..>..)
		png_benign_error edi, 'Wrote palette index exceeding num_palette'
	@@:
end if
 
	; See if user wants us to write information chunks
	mov esi,[info_ptr]
	cmp esi,0 
	je .end0 ;if (..!=0)
if PNG_WRITE_TEXT_SUPPORTED eq 1
;      int i; /* local index variable */
end if
if PNG_WRITE_tIME_SUPPORTED eq 1
		; Check to see if user has supplied a time chunk
		mov eax,[esi+png_info_def.valid]
		and eax,PNG_INFO_tIME
		jz @f
		mov eax,[edi+png_struct.mode]
		and eax,PNG_WROTE_tIME
		jnz @f ;if (..!=0 && ..==0)
			mov eax,esi
			add eax,png_info_def.mod_time
			stdcall png_write_tIME, edi, eax
		@@:
 
end if
if PNG_WRITE_TEXT_SUPPORTED eq 1
		; Loop through comment chunks
		cmp dword[esi+png_info_def.num_text],0
		jle .cycle0end
		xor ecx,ecx
align 4
		.cycle0: ;for (i = 0; i < info_ptr->num_text; i++)
 
;         png_debug2(2, "Writing trailer text chunk %d, type %d", i,
;             info_ptr->text[i].compression);
			; An internationalized chunk?
			mov eax,ecx
			shl eax,2
			add eax,[esi+png_info_def.text] ;eax = info_ptr.text[i]
			cmp dword[eax+png_text.compression],0
			jle .end1 ;if (info_ptr.text[i].compression > 0)
if PNG_WRITE_iTXt_SUPPORTED eq 1
				; Write international chunk
				stdcall png_write_iTXt, edi,\
					[eax+png_text.compression],\
					[eax+png_text.key],\
					[eax+png_text.lang],\
					[eax+png_text.lang_key],\
					[eax+png_text.text]
				; Mark this chunk as written
				mov ebx,PNG_TEXT_COMPRESSION_zTXt_WR
				cmp dword[eax+png_text.compression],PNG_TEXT_COMPRESSION_NONE
				jne @f
					mov ebx,PNG_TEXT_COMPRESSION_NONE_WR
				@@:
				mov dword[eax+png_text.compression],ebx
else
				png_warning edi, 'Unable to write international text'
end if
				jmp .end3
			.end1:
			cmp dword[eax+png_text.compression],PNG_TEXT_COMPRESSION_zTXt
			jl .end2 ;else if (info_ptr.text[i].compression >= ..)
if PNG_WRITE_zTXt_SUPPORTED eq 1
				; Write compressed chunk
				stdcall png_write_zTXt, edi, [eax+png_text.key],\
					[eax+png_text.text], [eax+png_text.compression]
				; Mark this chunk as written
				mov dword[eax+png_text.compression],PNG_TEXT_COMPRESSION_zTXt_WR
else
				png_warning edi, 'Unable to write compressed text'
end if
				jmp .end3
			.end2:
			cmp dword[eax+png_text.compression],PNG_TEXT_COMPRESSION_NONE
			jl .end3 ;else if (info_ptr.text[i].compression == ..)
if PNG_WRITE_tEXt_SUPPORTED eq 1
				; Write uncompressed chunk
				stdcall png_write_tEXt, edi, [eax+png_text.key],\
					[eax+png_text.text], 0
				; Mark this chunk as written
				mov dword[eax+png_text.compression],PNG_TEXT_COMPRESSION_NONE_WR
else
				png_warning edi, 'Unable to write uncompressed text'
end if
			.end3:
 
			inc ecx
			cmp ecx,[esi+png_info_def.num_text]
			jl .cycle0
		.cycle0end:
end if
if PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED eq 1
		stdcall write_unknown_chunks, edi, esi, PNG_AFTER_IDAT
end if
	.end0:
 
	or dword[edi+png_struct.mode], PNG_AFTER_IDAT
 
	; Write end of PNG file
	stdcall png_write_IEND, edi
 
; This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,
; and restored again in libpng-1.2.30, may cause some applications that
; do not set png_ptr->output_flush_fn to crash.  If your application
; experiences a problem, please try building libpng with
; PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to
; png-mng-implement at lists.sf.net .
 
if PNG_WRITE_FLUSH_SUPPORTED eq 1
if PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED eq 1
	stdcall png_flush, edi
end if
end if
.end_f:
popad
	ret
endp
 
;void (png_timep ptime, struct tm * ttime)
align 4
proc png_convert_from_struct_tm, ptime:dword, ttime:dword
	png_debug 1, 'in png_convert_from_struct_tm'
 
;   ptime->year = (uint_16)(1900 + ttime->tm_year);
;   ptime->month = (byte)(ttime->tm_mon + 1);
;   ptime->day = (byte)ttime->tm_mday;
;   ptime->hour = (byte)ttime->tm_hour;
;   ptime->minute = (byte)ttime->tm_min;
;   ptime->second = (byte)ttime->tm_sec;
	ret
endp
 
;void (png_timep ptime, time_t ttime)
align 4
proc png_convert_from_time_t, ptime:dword, ttime:dword
;   struct tm *tbuf;
 
	png_debug 1, 'in png_convert_from_time_t'
 
;   tbuf = gmtime(&ttime);
;   png_convert_from_struct_tm(ptime, tbuf);
	ret
endp
 
; Initialize png_ptr structure, and allocate any memory needed
;png_structp (charp user_png_ver, voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn)
align 4
proc png_create_write_struct, user_png_ver:dword, error_ptr:dword, error_fn:dword, warn_fn:dword
if PNG_USER_MEM_SUPPORTED eq 1
	stdcall png_create_png_struct, [user_png_ver], [error_ptr], [error_fn], [warn_fn], 0, 0, 0
	;eax = png_ptr
end if ;USER_MEM
	cmp eax,0
	je .end0 ;if (..!=0)
		; Set the zlib control values to defaults; they can be overridden by the
		; application after the struct has been created.
 
		mov dword[eax+png_struct.zbuffer_size], PNG_ZBUF_SIZE
 
		; The 'zlib_strategy' setting is irrelevant because png_default_claim in
		; pngwutil.asm defaults it according to whether or not filters will be
		; used, and ignores this setting.
 
		mov dword[eax+png_struct.zlib_strategy], PNG_Z_DEFAULT_STRATEGY
		mov dword[eax+png_struct.zlib_level], PNG_Z_DEFAULT_COMPRESSION
		mov dword[eax+png_struct.zlib_mem_level], 8
		mov dword[eax+png_struct.zlib_window_bits], 15
		mov dword[eax+png_struct.zlib_method], 8
 
if PNG_WRITE_COMPRESSED_TEXT_SUPPORTED eq 1
		mov dword[eax+png_struct.zlib_text_strategy], PNG_TEXT_Z_DEFAULT_STRATEGY
		mov dword[eax+png_struct.zlib_text_level], PNG_TEXT_Z_DEFAULT_COMPRESSION
		mov dword[eax+png_struct.zlib_text_mem_level], 8
		mov dword[eax+png_struct.zlib_text_window_bits], 15
		mov dword[eax+png_struct.zlib_text_method], 8
end if
		; This is a highly dubious configuration option; by default it is off,
		; but it may be appropriate for private builds that are testing
		; extensions not conformant to the current specification, or of
		; applications that must not fail to write at all costs!
 
if PNG_BENIGN_WRITE_ERRORS_SUPPORTED eq 1
		; In stable builds only warn if an application error can be completely
		; handled.
 
		or dword[eax+png_struct.flags], PNG_FLAG_BENIGN_ERRORS_WARN
end if
		; App warnings are warnings in release (or release candidate) builds but
		; are errors during development.
 
if PNG_RELEASE_BUILD eq 1
		or dword[eax+png_struct.flags], PNG_FLAG_APP_WARNINGS_WARN
end if
		; TODO: delay this, it can be done in png_init_io() (if the app doesn't
		; do it itself) avoiding setting the default function if it is not
		; required.
 
		stdcall png_set_write_fn, eax, 0, 0, 0
	.end0:
	ret
endp
 
 
; Write a few rows of image data.  If the image is interlaced,
; either you will have to write the 7 sub images, or, if you
; have called png_set_interlace_handling(), you will have to
; "write" the image seven times.
 
;void (png_structrp png_ptr, bytepp row, uint_32 num_rows)
align 4
proc png_write_rows uses ebx ecx edi, png_ptr:dword, row:dword, num_rows:dword
;locals
	;i dd ? ;uint_32 ;row counter
	;rp dd ? ;bytepp ;row pointer
;endl
	png_debug 1, 'in png_write_rows'
 
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if(..==0) return
 
	; Loop through the rows
	mov ecx,[num_rows]
	cmp ecx,1
	jl .end_f
	mov ebx,[row]
	@@: ;for (i = 0, rp = row; i < num_rows; i++, rp++)
		stdcall png_write_row, edi, [ebx]
		add ebx,4
		loop @b
.end_f:
	ret
endp
 
; Write the image.  You only need to call this function once, even
; if you are writing an interlaced image.
 
;void (png_structrp png_ptr, bytepp image)
align 4
proc png_write_image, png_ptr:dword, image:dword
pushad
;ebx ;bytepp ;points to current row
;ecx ;uint_32 ;row index
;edx ;int ;pass
;esi ;int ;num_pass
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
	png_debug 1, 'in png_write_image'
 
if PNG_WRITE_INTERLACING_SUPPORTED eq 1
	; Initialize interlace handling.  If image is not interlaced,
	; this will set pass to 1
 
	stdcall png_set_interlace_handling, edi
	mov esi,eax
else
	xor esi,esi
	inc esi
end if
	; Loop through passes
	xor edx,edx
	.cycle0: ;for (edx = 0; edx < esi; edx++)
		cmp edx,esi
		jge .cycle0end
		; Loop through image
		mov ebx,[image]
		xor ecx,ecx
		.cycle1: ;for (ecx = 0, ebx = image; ecx < png_ptr.height; ecx++, ebx++)
			stdcall png_write_row, edi,[ebx]
			inc ecx
			add ebx,4
			cmp ecx,[edi+png_struct.height]
			jl .cycle1
		;.cycle1end:
		inc edx
		jmp .cycle0
	.cycle0end:
.end_f:
popad
	ret
endp
 
; Performs intrapixel differencing
;void (png_row_infop row_info, bytep row)
align 4
proc png_do_write_intrapixel uses eax ebx ecx edx edi, row_info:dword, row:dword
	png_debug 1, 'in png_do_write_intrapixel'
 
	mov ebx,[row_info]
	movzx eax,byte[ebx+png_row_info.color_type]
	and eax,PNG_COLOR_MASK_COLOR
	jz .end_f ;if (..!=0)
		;edx = bytes_per_pixel
		mov ecx,[ebx+png_row_info.width] ;ecx = row_width
		cmp byte[ebx+png_row_info.bit_depth],8 ;if (..==8)
		jne .end0
;         bytep rp;
;         uint_32 i;
 
			cmp byte[ebx+png_row_info.color_type],PNG_COLOR_TYPE_RGB
			jne @f ;if (..==..)
				mov edx,3-1 ;(-1) for stosb
				jmp .end2
			@@:
			cmp byte[ebx+png_row_info.color_type],PNG_COLOR_TYPE_RGB_ALPHA
			jne @f ;else if (..==..)
				mov edx,4-1 ;(-1) for stosb
				jmp .end2
			@@:
				jmp .end_f ;else return
			.end2:
 
			mov edi,[row]
align 4
			.cycle0: ;for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
				mov ax,word[edi]
				sub al,ah
				stosb ;*(rp) = (byte)(*rp - *(rp + 1))
				mov ax,word[edi]
				sub ah,al
				mov byte[edi+1],ah ;*(rp + 2) = (byte)(*(rp + 2) - *(rp + 1))
				add edi,edx
				loop .cycle0
			.cycle0end:
			jmp .end_f
		.end0:
 
if PNG_WRITE_16BIT_SUPPORTED eq 1
		cmp byte[ebx+png_row_info.bit_depth],16 ;else if (..==16)
		jne .end1
;         bytep rp;
;         uint_32 i;
 
			cmp byte[ebx+png_row_info.color_type],PNG_COLOR_TYPE_RGB
			jne @f ;if (..==..)
				mov edx,6
				jmp .end3
			@@:
			cmp byte[ebx+png_row_info.color_type],PNG_COLOR_TYPE_RGB_ALPHA
			jne @f ;else if (..==..)
				mov edx,8
				jmp .end3
			@@:
				jmp .end_f ;else return
			.end3:
 
			mov edi,[row]
align 4
			.cycle1: ;for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
;            uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);
;            uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);
;            uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);
;            uint_32 red  = (uint_32)((s0 - s1) & 0xffffL);
;            uint_32 blue = (uint_32)((s2 - s1) & 0xffffL);
;            *(rp    ) = (byte)(red >> 8);
;            *(rp + 1) = (byte)red;
;            *(rp + 4) = (byte)(blue >> 8);
;            *(rp + 5) = (byte)blue;
				add edi,edx
				loop .cycle1
			.cycle1end:
		.end1:
end if ;WRITE_16BIT
.end_f:
	ret
endp
 
; Called by user to write a row of image data
;void (png_structrp png_ptr, bytep row)
align 4
proc png_write_row, png_ptr:dword, row:dword
locals
	; 1.5.6: moved from png_struct to be a local structure:
	row_info png_row_info
endl
pushad
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if(..==0) return
 
;   png_debug2(1, "in png_write_row (row %u, pass %d)",
;       png_ptr->row_number, png_ptr->pass);
png_debug1 1, 'in png_write_row (row %u)',[edi+png_struct.row_number]
 
	; Initialize transformations and other stuff if first time
	cmp dword[edi+png_struct.row_number],0
	jne .end0
	cmp byte[edi+png_struct.pass],0
	jne .end0 ;if(..==0 && ..==0)
 
	; Make sure we wrote the header info
	mov eax,[edi+png_struct.mode]
	and eax,PNG_WROTE_INFO_BEFORE_PLTE
	jnz @f ;if(..==0)
		png_error edi, 'png_write_info was never called before png_write_row'
	@@:
 
	; Check for transforms that have been set but were defined out
if (PNG_WRITE_INVERT_SUPPORTED eq 0) & (PNG_READ_INVERT_SUPPORTED eq 1)
	mov eax,[edi+png_struct.transformations]
	and eax,PNG_INVERT_MONO
	jz @f ;if(..!=0)
		png_warning edi, 'PNG_WRITE_INVERT_SUPPORTED is not defined'
	@@:
end if
 
if (PNG_WRITE_FILLER_SUPPORTED eq 0) & (PNG_READ_FILLER_SUPPORTED eq 1)
	mov eax,[edi+png_struct.transformations]
	and eax,PNG_FILLER
	jz @f ;if(..!=0)
		png_warning edi, 'PNG_WRITE_FILLER_SUPPORTED is not defined'
	@@:
end if
 
if (PNG_WRITE_PACKSWAP_SUPPORTED eq 0) & (PNG_READ_PACKSWAP_SUPPORTED eq 1)
	mov eax,[edi+png_struct.transformations]
	and eax,PNG_PACKSWAP
	jz @f ;if(..!=0)
		png_warning edi, 'PNG_WRITE_PACKSWAP_SUPPORTED is not defined'
	@@:
end if
 
if (PNG_WRITE_PACK_SUPPORTED eq 0) & (PNG_READ_PACK_SUPPORTED eq 1)
	mov eax,[edi+png_struct.transformations]
	and eax,PNG_PACK
	jz @f ;if(..!=0)
		png_warning edi, 'PNG_WRITE_PACK_SUPPORTED is not defined'
	@@:
end if
 
if (PNG_WRITE_SHIFT_SUPPORTED eq 0) & (PNG_READ_SHIFT_SUPPORTED eq 1)
	mov eax,[edi+png_struct.transformations]
	and eax,PNG_SHIFT
	jz @f ;if(..!=0)
		png_warning edi, 'PNG_WRITE_SHIFT_SUPPORTED is not defined'
	@@:
end if
 
if (PNG_WRITE_BGR_SUPPORTED eq 0) & (PNG_READ_BGR_SUPPORTED eq 1)
	mov eax,[edi+png_struct.transformations]
	and eax,PNG_BGR
	jz @f ;if(..!=0)
		png_warning edi, 'PNG_WRITE_BGR_SUPPORTED is not defined'
	@@:
end if
 
if (PNG_WRITE_SWAP_SUPPORTED eq 0) & (PNG_READ_SWAP_SUPPORTED eq 1)
	mov eax,[edi+png_struct.transformations]
	and eax,PNG_SWAP_BYTES
	jz @f ;if(..!=0)
		png_warning edi, 'PNG_WRITE_SWAP_SUPPORTED is not defined'
	@@:
end if
 
	stdcall png_write_start_row, edi
	.end0:
 
if PNG_WRITE_INTERLACING_SUPPORTED eq 1
	; If interlaced and not interested in row, return
	cmp byte[edi+png_struct.interlaced],0
	je .end1
	mov eax,[edi+png_struct.transformations]
	and eax,PNG_INTERLACE
	jz .end1 ;if(..!=0 && ..!=0)
		cmp byte[edi+png_struct.pass],0
		jne @f
			mov eax,[edi+png_struct.row_number]
			and eax,0x07
			jz .end1 ;if (..!=0)
				stdcall png_write_finish_row, edi
				jmp .end_f
		@@:
		cmp byte[edi+png_struct.pass],1
		jne @f
			mov eax,[edi+png_struct.row_number]
			and eax,0x07
			jnz .end2
			cmp dword[edi+png_struct.width],5
			jge .end1 ;if (..!=0 || ..<..)
			.end2:
				stdcall png_write_finish_row, edi
				jmp .end_f
		@@:
		cmp byte[edi+png_struct.pass],2
		jne @f
			mov eax,[edi+png_struct.row_number]
			and eax,0x07
			cmp eax,4
			je .end1 ;if (..!=..)
				stdcall png_write_finish_row, edi
				jmp .end_f
		@@:
		cmp byte[edi+png_struct.pass],3
		jne @f
			mov eax,[edi+png_struct.row_number]
			and eax,0x03
			jnz .end3
			cmp dword[edi+png_struct.width],3
			jge .end1 ;if (..!=0 || ..<..)
			.end3:
				stdcall png_write_finish_row, edi
				jmp .end_f
		@@:
		cmp byte[edi+png_struct.pass],4
		jne @f
			mov eax,[edi+png_struct.row_number]
			and eax,0x03
			cmp eax,2
			je .end1 ;if (..!=..)
				stdcall png_write_finish_row, edi
				jmp .end_f
		@@:
		cmp byte[edi+png_struct.pass],5
		jne @f
			mov eax,[edi+png_struct.row_number]
			and eax,0x01
			jnz .end4
			cmp dword[edi+png_struct.width],2
			jge .end1 ;if (..!=0 || ..<..)
			.end4:
				stdcall png_write_finish_row, edi
				jmp .end_f
		@@:
		cmp byte[edi+png_struct.pass],6
		jne .end1
			mov eax,[edi+png_struct.row_number]
			and eax,0x01
			jnz .end1 ;if (..==0)
				stdcall png_write_finish_row, edi
				jmp .end_f
	.end1:
end if
 
	; Set up row info for transformations
	mov ebx,ebp
	sub ebx,sizeof.png_row_info
	mov al,byte[edi+png_struct.color_type]
	mov byte[ebx+png_row_info.color_type],al
	mov eax,[edi+png_struct.usr_width]
	mov [ebx+png_row_info.width],eax
	movzx eax,byte[edi+png_struct.usr_channels]
	mov byte[ebx+png_row_info.channels],al
	movzx ecx,byte[edi+png_struct.usr_bit_depth]
	mov byte[ebx+png_row_info.bit_depth],cl
	imul eax,ecx ;.bit_depth * .channels
	mov byte[ebx+png_row_info.pixel_depth],al
	PNG_ROWBYTES eax, [ebx+png_row_info.width]
	mov [ebx+png_row_info.rowbytes], eax
 
	push eax
	movzx eax,byte[ebx+png_row_info.color_type]
	png_debug1 3, 'row_info->color_type = %d', eax
	png_debug1 3, 'row_info->width = %u', [ebx+png_row_info.width]
	movzx eax,byte[ebx+png_row_info.channels]
	png_debug1 3, 'row_info->channels = %d', eax
	movzx eax,byte[ebx+png_row_info.bit_depth]
	png_debug1 3, 'row_info->bit_depth = %d', eax
	movzx eax,byte[ebx+png_row_info.pixel_depth]
	png_debug1 3, 'row_info->pixel_depth = %d', eax
	png_debug1 3, 'row_info->rowbytes = %lu', [ebx+png_row_info.rowbytes]
	pop eax
 
	; Copy user's row into buffer, leaving room for filter byte.
	push edi
	mov edi,[edi+png_struct.row_buf]
	inc edi
	mov esi,[row]
	mov ecx,eax
	rep movsb ;memcpy(...
	pop edi
 
if PNG_WRITE_INTERLACING_SUPPORTED eq 1
	; Handle interlacing
	cmp byte[edi+png_struct.interlaced],0
	je @f
	cmp byte[edi+png_struct.pass],6
	jge @f
	mov eax,[edi+png_struct.transformations]
	and eax,PNG_INTERLACE
	jz @f ;if (.. && ..<.. && ..!=0)
		movzx eax,byte[edi+png_struct.pass]
		push eax
		mov eax,[edi+png_struct.row_buf]
		inc eax
		stdcall png_do_write_interlace, ebx, eax ;, ...pass
		; This should always get caught above, but still ...
		cmp dword[ebx+png_row_info.width],0
		jne @f ;if (..==0)
			stdcall png_write_finish_row, edi
			jmp .end_f
	@@:
end if
 
if PNG_WRITE_TRANSFORMS_SUPPORTED eq 1
	; Handle other transformations
	cmp dword[edi+png_struct.transformations],0
	je @f ;if (..!=0)
		stdcall png_do_write_transformations, edi, ebx
	@@:
end if
 
	; At this point the row_info pixel depth must match the 'transformed' depth,
	; which is also the output depth.
 
	mov al,[ebx+png_row_info.pixel_depth]
	cmp al,[edi+png_struct.pixel_depth]
	jne @f
	cmp al,[edi+png_struct.transformed_pixel_depth]
	je .end5
	@@: ;if (..!=.. || ..!=..)
		png_error edi, 'internal write transform logic error'
	.end5:
 
if PNG_MNG_FEATURES_SUPPORTED eq 1
	; Write filter_method 64 (intrapixel differencing) only if
	; 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
	; 2. Libpng did not write a PNG signature (this filter_method is only
	;    used in PNG datastreams that are embedded in MNG datastreams) and
	; 3. The application called png_permit_mng_features with a mask that
	;    included PNG_FLAG_MNG_FILTER_64 and
	; 4. The filter_method is 64 and
	; 5. The color_type is RGB or RGBA
 
	mov eax,[edi+png_struct.mng_features_permitted]
	and eax,PNG_FLAG_MNG_FILTER_64
	jz @f
	cmp byte[edi+png_struct.filter_type],PNG_INTRAPIXEL_DIFFERENCING
	jne @f ;if (..!=0 && ..==..)
		; Intrapixel differencing
		mov eax,[edi+png_struct.row_buf]
		inc eax
		stdcall png_do_write_intrapixel, ebx, eax
	@@:
end if
 
; Added at libpng-1.5.10
if PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED eq 1
	; Check for out-of-range palette index
	cmp byte[ebx+png_row_info.color_type],PNG_COLOR_TYPE_PALETTE
	jne @f
	cmp dword[edi+png_struct.num_palette_max],0
	jl @f ;if (..==.. && ..>=0)
		stdcall png_do_check_palette_indexes, edi, ebx
	@@:
end if
 
	; Find a filter if necessary, filter the row and write it out.
	mov ebx,ebp
	sub ebx,sizeof.png_row_info
	stdcall png_write_find_filter, edi, ebx
 
	cmp dword[edi+png_struct.write_row_fn],0
	je .end_f ;if (..!=0)
		movzx eax,byte[edi+png_struct.pass]
		stdcall dword[edi+png_struct.write_row_fn], edi, [edi+png_struct.row_number], eax
.end_f:
popad
	ret
endp
 
; Set the automatic flush interval or 0 to turn flushing off
;void (png_structrp png_ptr, int nrows)
align 4
proc png_set_flush uses eax edi, png_ptr:dword, nrows:dword
	png_debug 1, 'in png_set_flush'
 
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
	mov eax,[nrows]
	cmp eax,0
	jge @f ;(nrows < 0 ? 0 : nrows)
		xor eax,eax
	@@: 
	mov [edi+png_struct.flush_dist],eax
.end_f:
	ret
endp
 
; Flush the current output buffers now
;void (png_structrp png_ptr)
align 4
proc png_write_flush uses eax edi, png_ptr:dword
	png_debug 1, 'in png_write_flush'
 
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
	; We have already written out all of the data
	mov eax,[edi+png_struct.num_rows]
	cmp [edi+png_struct.row_number],eax
	jge .end_f ;if (..>=..) return
 
	stdcall png_compress_IDAT, 0, 0, Z_SYNC_FLUSH
	mov dword[edi+png_struct.flush_rows],0
	stdcall png_flush, edi
.end_f:
popad
	ret
endp
 
; Free any memory used in png_ptr struct without freeing the struct itself.
;void (png_structrp png_ptr)
align 4
proc png_write_destroy uses eax edi, png_ptr:dword
	png_debug 1, 'in png_write_destroy'
 
	; Free any memory zlib uses
	mov edi,[png_ptr]
	mov eax,[edi+png_struct.flags]
	and eax,PNG_FLAG_ZSTREAM_INITIALIZED
	jz @f ;if (..!=0)
		mov eax,edi
		add eax,png_struct.zstream
		stdcall [deflateEnd], eax
	@@:
 
	; Free our memory.  png_free checks NULL for us.
	mov eax,edi
	add eax,png_struct.zbuffer_list
	stdcall png_free_buffer_list, edi, eax
	stdcall png_free, edi, [edi+png_struct.row_buf]
	mov dword[edi+png_struct.row_buf],0
if PNG_WRITE_FILTER_SUPPORTED eq 1
	stdcall png_free, edi, [edi+png_struct.prev_row]
	stdcall png_free, edi, [edi+png_struct.try_row]
	stdcall png_free, edi, [edi+png_struct.tst_row]
	mov dword[edi+png_struct.prev_row],0
	mov dword[edi+png_struct.try_row],0
	mov dword[edi+png_struct.tst_row],0
end if
 
if PNG_SET_UNKNOWN_CHUNKS_SUPPORTED eq 1
	stdcall png_free, edi, [edi+png_struct.chunk_list]
	mov dword[edi+png_struct.chunk_list],0
end if
 
	; The error handling and memory handling information is left intact at this
	; point: the jmp_buf may still have to be freed.  See png_destroy_png_struct
	; for how this happens.
	ret
endp
 
; Free all memory used by the write.
; In libpng 1.6.0 this API changed quietly to no longer accept a NULL value for
; *png_ptr_ptr.  Prior to 1.6.0 it would accept such a value and it would free
; the passed in info_structs but it would quietly fail to free any of the data
; inside them.  In 1.6.0 it quietly does nothing (it has to be quiet because it
; has no png_ptr.)
 
;void (png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
align 4
proc png_destroy_write_struct uses edi esi, png_ptr_ptr:dword, info_ptr_ptr:dword
	png_debug 1, 'in png_destroy_write_struct'
 
	mov esi,[png_ptr_ptr]
	cmp esi,0
	je @f ;if (..!=0)
		mov edi,[esi]
 
		cmp edi,0
		je @f ;if (..!=0) ;added in libpng 1.6.0
			stdcall png_destroy_info_struct, edi, [info_ptr_ptr]
 
			mov dword[esi],0
			stdcall png_write_destroy, edi
			stdcall png_destroy_png_struct, edi
	@@:
	ret
endp
 
; Allow the application to select one or more row filters to use.
;void (png_structrp png_ptr, int method, int filters)
align 4
proc png_set_filter uses eax ebx ecx edi, png_ptr:dword, method:dword, filters:dword
	png_debug 1, 'in png_set_filter'
pushad
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
if PNG_MNG_FEATURES_SUPPORTED eq 1
	mov eax,[edi+png_struct.mng_features_permitted]
	and eax,PNG_FLAG_MNG_FILTER_64
	je @f
	cmp dword[method], PNG_INTRAPIXEL_DIFFERENCING
	jne @f ;if (..!=0 && ..==..)
		mov dword[method], PNG_FILTER_TYPE_BASE
	@@:
end if
	cmp dword[method], PNG_FILTER_TYPE_BASE
	jne .end0 ;if (..==..)
	mov ebx,[filters]
	and ebx,PNG_ALL_FILTERS or 0x07 ;switch (..)
 
if PNG_WRITE_FILTER_SUPPORTED eq 1
	cmp ebx,5
	je .end2
	cmp ebx,6
	je .end2
	cmp ebx,7
	je .end2
		jmp @f
	.end2:
		cStr ,'Unknown row filter for method 0'
		stdcall png_app_error, edi, eax
		; FALL THROUGH
	@@:
end if ;WRITE_FILTER
	cmp ebx,PNG_FILTER_VALUE_NONE
	jne @f
		mov byte[edi+png_struct.do_filter],PNG_FILTER_NONE
		jmp .end1
	@@:
if PNG_WRITE_FILTER_SUPPORTED eq 1
	cmp ebx,PNG_FILTER_VALUE_SUB
	jne @f
		mov byte[edi+png_struct.do_filter],PNG_FILTER_SUB
		jmp .end1
	@@:
	cmp ebx,PNG_FILTER_VALUE_UP
	jne @f
		mov byte[edi+png_struct.do_filter],PNG_FILTER_UP
		jmp .end1
	@@:
	cmp ebx,PNG_FILTER_VALUE_AVG
	jne @f
		mov byte[edi+png_struct.do_filter],PNG_FILTER_AVG
		jmp .end1
	@@:
	cmp ebx,PNG_FILTER_VALUE_PAETH
	jne @f
		mov byte[edi+png_struct.do_filter],PNG_FILTER_PAETH
		jmp .end1
	@@: ;default:
		mov eax,[filters]
		mov byte[edi+png_struct.do_filter],al
		jmp .end1
else
	@@: ;default:
		cStr ,'Unknown row filter for method 0'
		stdcall png_app_error edi, eax
end if ;WRITE_FILTER
	.end1:
 
if PNG_WRITE_FILTER_SUPPORTED eq 1
	; If we have allocated the row_buf, this means we have already started
	; with the image and we should have allocated all of the filter buffers
	; that have been selected.  If prev_row isn't already allocated, then
	; it is too late to start using the filters that need it, since we
	; will be missing the data in the previous row.  If an application
	; wants to start and stop using particular filters during compression,
	; it should start out with all of the filters, and then remove them
	; or add them back after the start of compression.
 
		; NOTE: this is a nasty constraint on the code, because it means that the
		; prev_row buffer must be maintained even if there are currently no
		; 'prev_row' requiring filters active.
 
		cmp dword[edi+png_struct.row_buf],0
		je .end3 ;if (..!=0)
			;ebx = num_filters
			;ecx = buf_size
 
			; Repeat the checks in png_write_start_row; 1 pixel high or wide
			; images cannot benefit from certain filters.  If this isn't done here
			; the check below will fire on 1 pixel high images.
 
			cmp dword[edi+png_struct.height],1
			jne @f ;if (..==..)
				and dword[filters],not (PNG_FILTER_UP or PNG_FILTER_AVG or PNG_FILTER_PAETH)
			@@:
			cmp dword[edi+png_struct.width],1
			jne @f ;if (..==..)
				and dword[filters],not (PNG_FILTER_SUB or PNG_FILTER_AVG or PNG_FILTER_PAETH)
			@@:
			mov eax,[filters]
			and eax,PNG_FILTER_UP or PNG_FILTER_AVG or PNG_FILTER_PAETH
			jz @f
			cmp dword[edi+png_struct.prev_row],0
			je @f;if (..!=0 && ..==0)
				; This is the error case, however it is benign - the previous row
				; is not available so the filter can't be used.  Just warn here.
 
				png_app_warning edi, 'png_set_filter: UP/AVG/PAETH cannot be added after start'
				and dword[filters],not (PNG_FILTER_UP or PNG_FILTER_AVG or PNG_FILTER_PAETH)
			@@:
 
			xor ebx,ebx
 
			mov eax,[filters]
			and eax,PNG_FILTER_SUB
			jz @f ;if (..)
				inc ebx
			@@:
			mov eax,[filters]
			and eax,PNG_FILTER_UP
			jz @f ;if (..)
				inc ebx
			@@:
			mov eax,[filters]
			and eax,PNG_FILTER_AVG
			jz @f ;if (..)
				inc ebx
			@@:
			mov eax,[filters]
			and eax,PNG_FILTER_PAETH
			jz @f ;if (..)
				inc ebx
			@@:
			; Allocate needed row buffers if they have not already been
			; allocated.
 
			movzx eax,byte[edi+png_struct.usr_channels]
			movzx ecx,byte[edi+png_struct.usr_bit_depth]
			imul eax,ecx ;.bit_depth * .channels
			mov ecx,[edi+png_struct.width]
			inc ecx
			PNG_ROWBYTES eax, ecx
			mov ecx, eax
 
			cmp dword[edi+png_struct.try_row],0
			jne @f ;if (..==0)
				stdcall png_malloc, edi, ecx
				mov [edi+png_struct.try_row],eax
			@@:
 
			cmp ebx,1
			jle .end3 ;if (..>..)
			cmp dword[edi+png_struct.tst_row],0
			jne .end3 ;if (..==0)
				stdcall png_malloc, edi, ecx
				mov [edi+png_struct.tst_row],eax
		.end3:
		mov eax,[filters]
		mov byte[edi+png_struct.do_filter],al
end if
		jmp .end_f
	.end0: ;else
		png_error edi, 'Unknown custom filter method'
.end_f:
popad
	ret
endp
 
; Provide floating and fixed point APIs
;void (png_structrp png_ptr, int heuristic_method,
;    int num_weights, png_const_doublep filter_weights, png_const_doublep filter_costs)
align 4
proc png_set_filter_heuristics, png_ptr:dword, heuristic_method:dword, num_weights:dword, filter_weights:dword, filter_costs:dword
	ret
endp
 
;void (png_structrp png_ptr, int heuristic_method,
;    int num_weights, png_const_fixed_point_p filter_weights,
;    png_const_fixed_point_p filter_costs)
align 4
proc png_set_filter_heuristics_fixed, png_ptr:dword, heuristic_method:dword, num_weights:dword, filter_weights:dword, filter_costs:dword
	ret
endp
 
;void (png_structrp png_ptr, int level)
align 4
proc png_set_compression_level uses edi, png_ptr:dword, level:dword
	png_debug 1, 'in png_set_compression_level'
 
	mov edi,[png_ptr]
	cmp edi,0
	je @f ;if (..==0) return
 
	m2m [edi+png_struct.zlib_level], [level]
	@@:
	ret
endp
 
;void (png_structrp png_ptr, int mem_level)
align 4
proc png_set_compression_mem_level uses edi, png_ptr:dword, mem_level:dword
	png_debug 1, 'in png_set_compression_mem_level'
 
	mov edi,[png_ptr]
	cmp edi,0
	je @f ;if (..==0) return
 
	m2m [edi+png_struct.zlib_mem_level], [mem_level]
	@@:
	ret
endp
 
;void (png_structrp png_ptr, int strategy)
align 4
proc png_set_compression_strategy uses edi, png_ptr:dword, strategy:dword
	png_debug 1, 'in png_set_compression_strategy'
 
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
	; The flag setting here prevents the libpng dynamic selection of strategy.
 
	or dword[edi+png_struct.flags], PNG_FLAG_ZLIB_CUSTOM_STRATEGY
	m2m [edi+png_struct.zlib_strategy], [strategy]
.end_f:
	ret
endp
 
; If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
; smaller value of window_bits if it can do so safely.
 
;void (png_structrp png_ptr, int window_bits)
align 4
proc png_set_compression_window_bits uses eax edi, png_ptr:dword, window_bits:dword
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
	; Prior to 1.6.0 this would warn but then set the window_bits value. This
	; meant that negative window bits values could be selected that would cause
	; libpng to write a non-standard PNG file with raw deflate or gzip
	; compressed IDAT or ancillary chunks.  Such files can be read and there is
	; no warning on read, so this seems like a very bad idea.
 
	mov eax,[window_bits]
	cmp eax,15
	jle @f ;if (..>..)
		png_warning edi, 'Only compression windows <= 32k supported by PNG'
		mov eax,15
		jmp .end0
	@@: ;else if (..<..)
	cmp eax,8
	jge @f
		png_warning edi, 'Only compression windows >= 256 supported by PNG'
		mov eax,8
	.end0:
 
	mov [edi+png_struct.zlib_window_bits],eax
.end_f:
	ret
endp
 
;void (png_structrp png_ptr, int method)
align 4
proc png_set_compression_method uses eax edi, png_ptr:dword, method:dword
	png_debug 1, 'in png_set_compression_method'
 
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
	; This would produce an invalid PNG file if it worked, but it doesn't and
	; deflate will fault it, so it is harmless to just warn here.
 
	mov eax,[method]
	cmp eax,8
	je @f ;if (..!=..)
		png_warning edi, 'Only compression method 8 is supported by PNG'
	@@:
	mov [edi+png_struct.zlib_method],eax
.end_f:
	ret
endp
 
; The following were added to libpng-1.5.4
if PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED eq 1
;void (png_structrp png_ptr, int level)
align 4
proc png_set_text_compression_level uses edi, png_ptr:dword, level:dword
	png_debug 1, 'in png_set_text_compression_level'
 
	mov edi,[png_ptr]
	cmp edi,0
	je @f ;if (..==0) return
 
	m2m [edi+png_struct.zlib_text_level], [level]
	@@:
	ret
endp
 
;void (png_structrp png_ptr, int mem_level)
align 4
proc png_set_text_compression_mem_level uses edi, png_ptr:dword, mem_level:dword
	png_debug 1, 'in png_set_text_compression_mem_level'
 
	mov edi,[png_ptr]
	cmp edi,0
	je @f ;if (..==0) return
 
	m2m [edi+png_struct.zlib_text_mem_level], [mem_level]
	@@:
	ret
endp
 
;void (png_structrp png_ptr, int strategy)
align 4
proc png_set_text_compression_strategy uses edi, png_ptr:dword, strategy:dword
	png_debug 1, 'in png_set_text_compression_strategy'
 
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
	m2m [edi+png_struct.zlib_text_strategy], [strategy]
.end_f:
	ret
endp
 
; If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
; smaller value of window_bits if it can do so safely.
 
;void (png_structrp png_ptr, int window_bits)
align 4
proc png_set_text_compression_window_bits uses eax edi, png_ptr:dword, window_bits:dword
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
	mov eax,[window_bits]
	cmp eax,15
	jle @f ;if (..>..)
		png_warning edi, 'Only compression windows <= 32k supported by PNG'
		mov eax,15
		jmp .end0
	@@: ;else if (..<..)
	cmp eax,8
	jge @f
		png_warning edi, 'Only compression windows >= 256 supported by PNG'
		mov eax,8
	.end0:
 
	mov [edi+png_struct.zlib_text_window_bits],eax
.end_f:
	ret
endp
 
;void (png_structrp png_ptr, int method)
align 4
proc png_set_text_compression_method uses edi, png_ptr:dword, method:dword
	png_debug 1, 'in png_set_text_compression_method'
 
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f ;if (..==0) return
 
	cmp dword[method],8
	je @f ;if (..!=..)
		png_warning edi, 'Only compression method 8 is supported by PNG'
	@@:
	m2m [edi+png_struct.zlib_text_method], [method]
.end_f:
	ret
endp
end if ;WRITE_CUSTOMIZE_ZTXT_COMPRESSION
; end of API added to libpng-1.5.4
 
;void (png_structrp png_ptr, png_write_status_ptr write_row_fn)
align 4
proc png_set_write_status_fn uses edi, png_ptr:dword, write_row_fn:dword
	mov edi,[png_ptr]
	cmp edi,0
	je @f ;if (..==0) return
		m2m [edi+png_struct.write_row_fn], [write_row_fn]
	@@:
	ret
endp
 
;void (png_structrp png_ptr, png_user_transform_ptr write_user_transform_fn)
align 4
proc png_set_write_user_transform_fn uses edi, png_ptr:dword, write_user_transform_fn:dword
	png_debug 1, 'in png_set_write_user_transform_fn'
 
	mov edi,[png_ptr]
	cmp edi,0
	je @f ;if (..==0) return
		or dword[edi+png_struct.transformations], PNG_USER_TRANSFORM
		m2m [edi+png_struct.write_user_transform_fn], [write_user_transform_fn]
	@@:
	ret
endp
 
;void (png_structrp png_ptr, png_inforp info_ptr, int transforms, voidp params)
align 4
proc png_write_png, png_ptr:dword, info_ptr:dword, transforms:dword, params:dword
pushad
	mov edi,[png_ptr]
	cmp edi,0
	je .end_f
	mov esi,[info_ptr]
	cmp esi,0
	je .end_f ;if(..==0 || ..==0) return
 
	and dword[esi+png_info_def.valid],PNG_INFO_IDAT
	cmp esi,0 ;if(..==0)
	jne @f
		cStr ,'no rows for png_write_image to write'
		stdcall png_app_error edi, eax
		jmp .end_f ;return
	@@:
 
	; Write the file header information.
	stdcall png_write_info, edi, esi
 
	; ------ these transformations don't touch the info structure -------
 
	; Invert monochrome pixels
	mov eax,[transforms]
	and eax,PNG_TRANSFORM_INVERT_MONO
	jz @f ;if(..!=0)
if PNG_WRITE_INVERT_SUPPORTED eq 1
		stdcall png_set_invert_mono,edi
else
		cStr ,'PNG_TRANSFORM_INVERT_MONO not supported'
		stdcall png_app_error edi, eax
end if
	@@:
 
	; Shift the pixels up to a legal bit depth and fill in
	; as appropriate to correctly scale the image.
 
	mov eax,[transforms]
	and eax,PNG_TRANSFORM_SHIFT
	jz @f ;if(..!=0)
if PNG_WRITE_SHIFT_SUPPORTED eq 1
	mov eax,[esi+png_info_def.valid]
	and eax,PNG_INFO_sBIT
	jz @f ;if(..!=0)
		mov eax,esi
		add eax,png_info_def.sig_bit
		stdcall png_set_shift, edi, eax
else
		cStr ,'PNG_TRANSFORM_SHIFT not supported'
		stdcall png_app_error edi, eax
end if
	@@:
 
	; Pack pixels into bytes
	mov eax,[transforms]
	and eax,PNG_TRANSFORM_PACKING
	jz @f ;if(..!=0)
if PNG_WRITE_PACK_SUPPORTED eq 1
		stdcall png_set_packing, edi
else
		cStr ,'PNG_TRANSFORM_PACKING not supported'
		stdcall png_app_error edi, eax
end if
	@@:
 
	; Swap location of alpha bytes from ARGB to RGBA
	mov eax,[transforms]
	and eax,PNG_TRANSFORM_SWAP_ALPHA
	jz @f ;if(..!=0)
if PNG_WRITE_SWAP_ALPHA_SUPPORTED eq 1
		stdcall png_set_swap_alpha, edi
else
		cStr ,'PNG_TRANSFORM_SWAP_ALPHA not supported'
		stdcall png_app_error edi, eax
end if
	@@:
 
	; Remove a filler (X) from XRGB/RGBX/AG/GA into to convert it into
	; RGB, note that the code expects the input color type to be G or RGB; no
	; alpha channel.
 
	mov eax,[transforms]
	and eax,PNG_TRANSFORM_STRIP_FILLER_AFTER or PNG_TRANSFORM_STRIP_FILLER_BEFORE
	jz .end_0 ;if(..!=0)
if PNG_WRITE_FILLER_SUPPORTED eq 1
	and eax,PNG_TRANSFORM_STRIP_FILLER_AFTER
	jz .end_1 ;if(..!=0)
		mov eax,[transforms]
		and eax,PNG_TRANSFORM_STRIP_FILLER_BEFORE
		jz @f ;if(..!=0)
            cStr ,'PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported'
			stdcall png_app_error edi, eax
		@@:
 
		; Continue if ignored - this is the pre-1.6.10 behavior
		stdcall png_set_filler, edi, 0, PNG_FILLER_AFTER
		jmp .end_0
	.end_1: ;else if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
		stdcall png_set_filler, edi, 0, PNG_FILLER_BEFORE
else
		cStr ,'PNG_TRANSFORM_STRIP_FILLER not supported'
		stdcall png_app_error edi, eax
end if
	.end_0:
 
	; Flip BGR pixels to RGB
	mov eax,[transforms]
	and eax,PNG_TRANSFORM_BGR
	jz @f ;if(..!=0)
if PNG_WRITE_BGR_SUPPORTED eq 1
		stdcall png_set_bgr, edi
else
		cStr ,'PNG_TRANSFORM_BGR not supported'
		stdcall png_app_error edi, eax
end if
	@@:
 
	; Swap bytes of 16-bit files to most significant byte first
	mov eax,[transforms]
	and eax,PNG_TRANSFORM_SWAP_ENDIAN
	jz @f ;if(..!=0)
if PNG_WRITE_SWAP_SUPPORTED eq 1
		stdcall png_set_swap, edi
else
		cStr ,'PNG_TRANSFORM_SWAP_ENDIAN not supported'
		stdcall png_app_error edi, eax
end if
	@@:
 
	; Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats
	mov eax,[transforms]
	and eax,PNG_TRANSFORM_PACKSWAP
	jz @f ;if(..!=0)
if PNG_WRITE_PACKSWAP_SUPPORTED eq 1
		stdcall png_set_packswap, edi
else
		cStr ,'PNG_TRANSFORM_PACKSWAP not supported'
		stdcall png_app_error edi, eax
end if
	@@:
 
	; Invert the alpha channel from opacity to transparency
	mov eax,[transforms]
	and eax,PNG_TRANSFORM_INVERT_ALPHA
	jz @f ;if(..!=0)
if PNG_WRITE_INVERT_ALPHA_SUPPORTED eq 1
		stdcall png_set_invert_alpha, edi
else
		cStr ,'PNG_TRANSFORM_INVERT_ALPHA not supported'
		stdcall png_app_error edi, eax
end if
	@@:
 
	; ----------------------- end of transformations -------------------
 
	; Write the bits
	stdcall png_write_image, edi, dword[esi+png_info_def.row_pointers]
 
	; It is REQUIRED to call this to finish writing the rest of the file
	stdcall png_write_end, edi, esi
 
.end_f:
popad
	ret
endp
 
if PNG_SIMPLIFIED_WRITE_SUPPORTED eq 1
; Initialize the write structure - general purpose utility.
;int (png_imagep image)
align 4
proc png_image_write_init uses ebx ecx edx edi esi, image:dword
	mov ebx,[image]
	stdcall png_create_write_struct, PNG_LIBPNG_VER_STRING, ebx, png_safe_error, png_safe_warning
	;eax = png_ptr
 
	cmp eax,0
	je .end0 ;if (..!=0)
		mov edi,eax
		stdcall png_create_info_struct, edi
		;eax = info_ptr
 
		cmp eax,0
		je .end1 ;if (..!=0)
			mov esi,eax
			stdcall png_malloc_warn, edi, sizeof.png_control
			;control = eax
 
			cmp eax,0
			je .end2 ;if (..!=0)
				push eax
				mov edx,edi ; edx = png_ptr
				mov ecx,sizeof.png_control
				mov edi,eax
				xor eax,eax
				rep stosb ;memset(control, 0, (sizeof.control))
				pop eax
 
				mov [eax+png_control.png_ptr], edx
				mov [eax+png_control.info_ptr], esi
				mov [eax+png_control.for_write], 1
 
				mov [ebx+png_image.opaque], eax
				xor eax,eax
				inc eax
				jmp .end_f
			.end2:
 
			; Error clean up
			push esi
			mov esi,esp
			stdcall png_destroy_info_struct, edi, esi
			add esp,4
		.end1:
 
		push edi
		mov edi,esp
		stdcall png_destroy_write_struct, edi, 0
		add esp,4
	.end0:
 
	std_png_image_error ebx, 'png_image_write_: out of memory'
.end_f:
	ret
endp
 
; Arguments to png_image_write_main:
struct png_image_write_control
	; Arguments:
	image  dd ? ;png_imagep
	buffer dd ? ;png_const_voidp
	row_stride dd ? ;int_32
	colormap   dd ? ;png_const_voidp
	convert_to_8bit dd ? ;int
	; Local variables:
	first_row dd ? ;png_const_voidp
	row_bytes dd ? ;ptrdiff_t
	local_row dd ? ;voidp
	; Byte count for memory writing
	memory    dd ? ;bytep
	memory_bytes dd ? ;png_alloc_size_t ;not used for STDIO
	output_bytes dd ? ;png_alloc_size_t ;running total
ends
 
; Write uint_16 input to a 16-bit PNG; the png_ptr has already been set to
; do any necessary byte swapping.  The component order is defined by the
; png_image format value.
 
;int (voidp argument)
align 4
proc png_write_image_16bit uses ebx ecx edx, argument:dword
locals
	display dd ? ;png_image_write_control* ;= argument
	image   dd ? ;png_imagep ;= display->image
	png_ptr dd ? ;png_structrp ;= image->opaque->png_ptr
	input_row  dd ? ;const_uint_16p ;= display->first_row
	output_row dd ? ;uint_16p ;= display->local_row
	row_end  dd ? ;uint_16p
	channels dd ? ;const int ;= (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
	aindex   dd 0 ;int  ;= 0
	y dd ? ;uint_32 ;= image->height
endl
	mov ebx,[argument]
	mov [display],ebx
	mov edx,[ebx+png_image_write_control.image]
	mov [image],edx
	mov ecx,[edx+png_image.opaque]
	mov ecx,[ecx+png_control.png_ptr]
	mov [png_ptr],ecx
	mov ecx,[ebx+png_image_write_control.first_row]
	mov [input_row],ecx
	mov ecx,[ebx+png_image_write_control.local_row]
	mov [output_row],ecx
 
	mov ecx,1
	mov eax,[edx+png_image.format]
	and eax,PNG_FORMAT_FLAG_COLOR
	jz @f
		mov ecx,3
	@@:
	mov [channels],ecx
	mov eax,[edx+png_image.height]
	mov [y],eax
 
	mov eax,[edx+png_image.format]
	and eax,PNG_FORMAT_FLAG_ALPHA
	jz .end0 ;if (..!=0)
if PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1
	mov eax,[edx+png_image.format]
	and eax,PNG_FORMAT_FLAG_AFIRST
	jz @f ;if (..!=0)
		mov dword[aindex],-1
		inc dword[input_row] ;To point to the first component
		inc dword[output_row]
		jmp .end1
	@@: ;else
end if
		mov eax,[channels]
		mov [aindex],eax
		jmp .end1
	.end0: ;else
		png_error [png_ptr], 'png_write_image: internal call error'
	.end1:
 
	; Work out the output row end and count over this, note that the increment
	; above to 'row' means that row_end can actually be beyond the end of the
	; row; this is correct.
 
	mov eax,[channels]
	inc eax
	imul eax,[edx+png_image.width]
	add eax,[output_row]
	mov [row_end],eax
 
;   while (y-- > 0)
;   {
;      const_uint_16p in_ptr = input_row;
;      uint_16p out_ptr = output_row;
 
;      while (out_ptr < row_end)
;      {
;         const uint_16 alpha = in_ptr[aindex];
;         uint_32 reciprocal = 0;
;         int c;
 
;         out_ptr[aindex] = alpha;
 
	; Calculate a reciprocal.  The correct calculation is simply
	; component/alpha*65535 << 15. (I.e. 15 bits of precision); this
	; allows correct rounding by adding .5 before the shift.  'reciprocal'
	; is only initialized when required.
 
;         if (alpha > 0 && alpha < 65535)
;            reciprocal = ((0xffff<<15)+(alpha>>1))/alpha;
 
;         c = channels;
;         do /* always at least one channel */
;         {
;            uint_16 component = *in_ptr++;
 
	; The following gives 65535 for an alpha of 0, which is fine,
	; otherwise if 0/0 is represented as some other value there is more
	; likely to be a discontinuity which will probably damage
	; compression when moving from a fully transparent area to a
	; nearly transparent one.  (The assumption here is that opaque
	; areas tend not to be 0 intensity.)
 
;            if (component >= alpha)
;               component = 65535;
 
	; component
	; component*reciprocal is less than 2^31.
 
;            else if (component > 0 && alpha < 65535)
;            {
;               uint_32 calc = component * reciprocal;
;               calc += 16384; /* round to nearest */
;               component = (uint_16)(calc >> 15);
;            }
 
;            *out_ptr++ = component;
;         }
;         while (--c > 0);
 
	; Skip to next component (skip the intervening alpha channel)
;         ++in_ptr;
;         ++out_ptr;
;      }
 
;      png_write_row(png_ptr, display->local_row);
;      input_row += display->row_bytes/(sizeof (uint_16));
;   }
 
	xor eax,eax
	inc eax ;return 1
	ret
endp
 
; Given 16-bit input (1 to 4 channels) write 8-bit output.  If an alpha channel
; is present it must be removed from the components, the components are then
; written in sRGB encoding.  No components are added or removed.
 
; Calculate an alpha reciprocal to reverse pre-multiplication.  As above the
; calculation can be done to 15 bits of accuracy; however, the output needs to
; be scaled in the range 0..255*65535, so include that scaling here.
 
;#   define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha)
 
;byte (uint_32 component, uint_32 alpha, uint_32 reciprocal/*from the above macro*/)
align 4
proc png_unpremultiply, component:dword, alpha:dword, reciprocal:dword
	; The following gives 1.0 for an alpha of 0, which is fine, otherwise if 0/0
	; is represented as some other value there is more likely to be a
	; discontinuity which will probably damage compression when moving from a
	; fully transparent area to a nearly transparent one.  (The assumption here
	; is that opaque areas tend not to be 0 intensity.)
 
	; There is a rounding problem here; if alpha is less than 128 it will end up
	; as 0 when scaled to 8 bits.  To avoid introducing spurious colors into the
	; output change for this too.
 
	mov eax,[alpha]
	cmp [component],eax
	jge @f
	cmp eax,128
	jge .end0
	@@: ;if (..>=.. || ..<..)
		mov eax,255
		jmp .end_f
		; component
		; component*reciprocal is less than 2^31.
 
	.end0: ;else if (component > 0)
	cmp dword[component],0
	jle .end1
		; The test is that alpha/257 (rounded) is less than 255, the first value
		; that becomes 255 is 65407.
		; NOTE: this must agree with the PNG_DIV257 macro (which must, therefore,
		; be exact!)  [Could also test reciprocal != 0]
 
;      if (alpha < 65407)
;      {
;         component *= reciprocal;
;         component += 64; /* round to nearest */
;         component >>= 7;
;      }
 
;      else
;         component *= 255;
 
		; Convert the component to sRGB.
		PNG_sRGB_FROM_LINEAR [component]
		and eax,0xff
		jmp .end_f
	.end1: ;else
		xor eax,eax
.end_f:
	ret
endp
 
;int (voidp argument)
align 4
proc png_write_image_8bit uses ebx ecx edx edi esi, argument:dword
locals
	display dd ? ;png_image_write_control* ;= argument
	image   dd ? ;png_imagep ;= display->image
	png_ptr dd ? ;png_structrp ;= image->opaque->png_ptr
	input_row  dd ? ;const_uint_16p ;= display->first_row
	output_row dd ? ;uint_16p ;= display->local_row
	row_end  dd ? ;uint_16p
	channels dd ? ;const int ;= (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
	aindex   dd 0 ;int  ;= 0
	y dd ? ;uint_32 ;= image->height
	component dd ? ;uint_32
endl
	mov ebx,[argument]
	mov [display],ebx
	mov edx,[ebx+png_image_write_control.image]
	mov [image],edx
	mov ecx,[edx+png_image.opaque]
	mov ecx,[ecx+png_control.png_ptr]
	mov [png_ptr],ecx
	mov ecx,[ebx+png_image_write_control.first_row]
	mov [input_row],ecx
	mov ecx,[ebx+png_image_write_control.local_row]
	mov [output_row],ecx
 
	mov ecx,1
	mov eax,[edx+png_image.format]
	and eax,PNG_FORMAT_FLAG_COLOR
	jz @f
		mov ecx,3
	@@:
	mov [channels],ecx
	mov eax,[edx+png_image.height]
	mov [y],eax
 
	mov eax,[edx+png_image.format]
	and eax,PNG_FORMAT_FLAG_ALPHA
	jz .end0 ;if (..!=0)
;      bytep row_end;
;      int aindex;
 
if PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1
;      if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
;      {
;         aindex = -1;
;         ++input_row; /* To point to the first component */
;         ++output_row;
;      }
 
;      else
end if
;      aindex = channels;
 
	; Use row_end in place of a loop counter:
;      row_end = output_row + image->width * (channels+1);
 
;      while (y-- > 0)
;      {
;         const_uint_16p in_ptr = input_row;
;         bytep out_ptr = output_row;
 
;         while (out_ptr < row_end)
;         {
;            uint_16 alpha = in_ptr[aindex];
;            byte alphabyte = (byte)PNG_DIV257(alpha);
;            uint_32 reciprocal = 0;
;            int c;
 
	; Scale and write the alpha channel.
;            out_ptr[aindex] = alphabyte;
 
;            if (alphabyte > 0 && alphabyte < 255)
;               reciprocal = UNP_RECIPROCAL(alpha);
 
;            c = channels;
;            do /* always at least one channel */
;               *out_ptr++ = png_unpremultiply(*in_ptr++, alpha, reciprocal);
;            while (--c > 0);
 
	; Skip to next component (skip the intervening alpha channel)
;            ++in_ptr;
;            ++out_ptr;
;         } /* while out_ptr < row_end */
 
;         png_write_row(png_ptr, display->local_row);
;         input_row += display->row_bytes/(sizeof (uint_16));
;      } /* while y */
		jmp .end1
	.end0: ;else
		; No alpha channel, so the row_end really is the end of the row and it
		; is sufficient to loop over the components one by one.
 
		mov ecx,[edx+png_image.width]
		imul ecx,[channels]
		add ecx,[output_row]
		;ecx = row_end
 
		.cycle2: ;while (y-- > 0)
			cmp dword[y],0
			jle .cycle2end
			mov esi,[input_row]
			mov edi,[output_row]
			;esi = in_ptr
			;edi = out_ptr
 
			.cycle3: ;while (..<..)
				cmp edi,ecx
				jge .cycle3end
				xor eax,eax
				lodsw
 
				imul eax,255
				mov [component],eax
				PNG_sRGB_FROM_LINEAR [component]
				stosb
				jmp .cycle3
align 4
			.cycle3end:
 
			stdcall png_write_row, [png_ptr], [output_row]
			mov eax,[ebx+png_image_write_control.row_bytes]
			shr eax,1 ;sizeof.uint_16
			add [input_row],eax
			dec dword[y]
			jmp .cycle2
align 4
		.cycle2end:
	.end1:
 
	xor eax,eax
	inc eax
	ret
endp
 
;void (png_image_write_control *display)
align 4
proc png_image_set_PLTE, display:dword
locals
	image dd ? ;png_imagep ;= display->image
	cmap dd ? ;void * ;= display->colormap
	entries dd ? ;int
 
	; NOTE: the caller must check for cmap != NULL and entries != 0
	format dd ? ;uint_32 ;= image->format
	channels dd ? ;int
	afirst dd 0
	bgr dd 0
	num_trans dd 0
	palette rb 256*sizeof.png_color
	tRNS rb 256 ;byte[]
endl
pushad
	mov edx,[display]
	mov ebx,[edx+png_image_write_control.image]
	mov [image],ebx
	mov eax,[edx+png_image_write_control.colormap]
	mov [cmap],eax
	mov eax,[ebx+png_image.colormap_entries]
	cmp eax,256
	jle @f
		mov eax,256
	@@:
	mov [entries],eax
	mov ecx,[ebx+png_image.format]
	mov [format],ecx
	PNG_IMAGE_SAMPLE_CHANNELS ecx
	mov [channels],eax
 
if (PNG_FORMAT_BGR_SUPPORTED eq 1) & (PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1)
	mov eax,ecx
	and eax,PNG_FORMAT_FLAG_AFIRST
	jz @f
	mov eax,ecx
	and eax,PNG_FORMAT_FLAG_ALPHA
	jz @f
		mov dword[afirst],-1
	@@:
end if
 
if PNG_FORMAT_BGR_SUPPORTED eq 1
	mov eax,ecx
	and eax,PNG_FORMAT_FLAG_BGR
	jz @f
		mov dword[bgr],2
	@@:
end if
 
;   int i;
 
	xor eax,eax
	mov ecx,(256*sizeof.png_color)/4
	mov edi,ebp
	sub edi,256+256*sizeof.png_color
	rep stosd ;memset(palette, 0, ...
	not eax
	mov ecx,256/4
	;;mov edi,ebp ;if 'tRNS' after 'palette' this code can be comment
	;;sub edi,256
	rep stosd ;memset(tRNS, 255, ...
 
 
;   for (i=num_trans=0; i
;   {
		; This gets automatically converted to sRGB with reversal of the
		; pre-multiplication if the color-map has an alpha channel.
 
;      if ((format & PNG_FORMAT_FLAG_LINEAR) != 0)
;      {
;         png_const_uint_16p entry = cmap;
 
;         entry += i * channels;
 
;         if ((channels & 1) != 0) /* no alpha */
;         {
;            if (channels >= 3) /* RGB */
;            {
;               palette[i].blue = (byte)PNG_sRGB_FROM_LINEAR(255 *
;                   entry[(2 ^ bgr)]);
;               palette[i].green = (byte)PNG_sRGB_FROM_LINEAR(255 *
;                   entry[1]);
;               palette[i].red = (byte)PNG_sRGB_FROM_LINEAR(255 *
;                   entry[bgr]);
;            }
 
;            else /* Gray */
;               palette[i].blue = palette[i].red = palette[i].green =
;                  (byte)PNG_sRGB_FROM_LINEAR(255 * *entry);
;         }
 
;         else /* alpha */
;         {
;            uint_16 alpha = entry[afirst ? 0 : channels-1];
;            byte alphabyte = (byte)PNG_DIV257(alpha);
;            uint_32 reciprocal = 0;
 
		; Calculate a reciprocal, as in the png_write_image_8bit code above
		; this is designed to produce a value scaled to 255*65535 when
		; divided by 128 (i.e. asr 7).
 
;            if (alphabyte > 0 && alphabyte < 255)
;               reciprocal = (((0xffff*0xff)<<7)+(alpha>>1))/alpha;
 
;            tRNS[i] = alphabyte;
;            if (alphabyte < 255)
;               num_trans = i+1;
 
;            if (channels >= 3) /* RGB */
;            {
;               palette[i].blue = png_unpremultiply(entry[afirst + (2 ^ bgr)],
;                   alpha, reciprocal);
;               palette[i].green = png_unpremultiply(entry[afirst + 1], alpha,
;                   reciprocal);
;               palette[i].red = png_unpremultiply(entry[afirst + bgr], alpha,
;                   reciprocal);
;            }
 
;            else /* gray */
;               palette[i].blue = palette[i].red = palette[i].green =
;                   png_unpremultiply(entry[afirst], alpha, reciprocal);
;         }
;      }
 
;      else /* Color-map has sRGB values */
;      {
;         bytep entry = cmap;
 
;         entry += i * channels;
 
;         switch (channels)
;         {
;            case 4:
;               tRNS[i] = entry[afirst ? 0 : 3];
;               if (tRNS[i] < 255)
;                  num_trans = i+1;
;               /* FALL THROUGH */
;            case 3:
;               palette[i].blue = entry[afirst + (2 ^ bgr)];
;               palette[i].green = entry[afirst + 1];
;               palette[i].red = entry[afirst + bgr];
;               break;
 
;            case 2:
;               tRNS[i] = entry[1 ^ afirst];
;               if (tRNS[i] < 255)
;                  num_trans = i+1;
;               /* FALL THROUGH */
;            case 1:
;               palette[i].blue = palette[i].red = palette[i].green =
;                  entry[afirst];
;               break;
 
;            default:
;               break;
;         }
;      }
;   }
 
	mov ecx,[ebx+png_image.opaque]
	mov eax,ebp
	sub eax,256+256*sizeof.png_color
	stdcall png_set_PLTE, [ecx+png_control.png_ptr], [ecx+png_control.info_ptr], eax, [entries]
 
	cmp dword[num_trans],0
	jle @f ;if (..>0)
		mov eax,ebp
		sub eax,256
		stdcall png_set_tRNS, [ecx+png_control.png_ptr], [ecx+png_control.info_ptr], eax, [num_trans], 0
	@@:
 
	mov eax,[entries]
	mov [ebx+png_image.colormap_entries],eax
popad
	ret
endp
 
;int (voidp argument)
align 4
proc png_image_write_main uses ebx ecx edx esi edi, argument:dword
locals
	display dd ? ;= png_image_write_control * = argument
	image dd ? ;= display->image
	png_ptr dd ? ;= image->opaque->png_ptr
	info_ptr dd ? ;= image->opaque->info_ptr
	format dd ? ;= image->format
 
	colormap dd ?
	linear dd ?
	alpha dd ?
	write_16bit dd ? ;= linear && !colormap && (display->convert_to_8bit == 0)
endl
	mov edx,[argument]
	mov [display],edx
	mov ebx,[edx+png_image_write_control.image]
	mov [image],ebx
	mov ecx,[ebx+png_image.format]
	mov [format],ecx
	mov eax,[ebx+png_image.opaque]
	mov edi,[eax+png_control.png_ptr]
	mov [png_ptr],edi
	mov esi,[eax+png_control.info_ptr]
	mov [info_ptr],esi
 
	; The following four ints are actually booleans
	and ecx,PNG_FORMAT_FLAG_COLORMAP
	mov [colormap],ecx
	not ecx
	mov eax,[format]
	and eax,PNG_FORMAT_FLAG_LINEAR
	mov [linear],eax
	mov eax,[format]
	and eax,ecx
	and eax,PNG_FORMAT_FLAG_ALPHA
	and eax,ecx
	mov [alpha],eax
	xor eax,eax ;false
	cmp dword[edx+png_image_write_control.convert_to_8bit],0
	jne @f
		not eax ;true
	@@:
	and eax,[linear]
	and eax,ecx
	mov [write_16bit],eax
 
if PNG_BENIGN_ERRORS_SUPPORTED eq 1
	; Make sure we error out on any bad situation
	stdcall png_set_benign_errors, edi, 0 ;error
end if
 
	; 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.
 
	PNG_IMAGE_PIXEL_CHANNELS [ebx+png_image.format]
	;eax = channels 
 
	push edx
	mov ecx,eax
	mov eax,0x7FFFFFFF
	xor edx,edx
	div ecx
	pop edx
	cmp [ebx+png_image.width],eax
	jg .end0 ;if (..<=..) ;no overflow
		imul ecx,[ebx+png_image.width]
 
		cmp dword[edx+png_image_write_control.row_stride],0
		jne @f ;if (..==0)
			mov [edx+png_image_write_control.row_stride],ecx
		@@:
		mov eax,[edx+png_image_write_control.row_stride]
		cmp eax,0
		jge .end2 ;if (..<0)
			neg eax
			inc eax
		.end2:
 
		cmp eax,ecx
		jl .end3 ;if (..>=..)
			; 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.
 
			push edx
			mov eax,0xFFFFFFFF
			xor edx,edx
			div ecx
			pop edx
			cmp [ebx+png_image.height],eax
			jle @f ;if (..>..)
				mov eax,[ebx+png_image.opaque]
				mov eax,[eax+png_control.png_ptr]
				png_error eax, 'memory image too large'
			@@:
			jmp .end1
		.end3: ;else
			mov eax,[ebx+png_image.opaque]
			mov eax,[eax+png_control.png_ptr]
			png_error eax, 'supplied row stride too small'
		jmp .end1
	.end0: ;else
		mov eax,[ebx+png_image.opaque]
		mov eax,[eax+png_control.png_ptr]
		png_error eax, 'image row stride too large'
	.end1:
 
	; Set the required transforms then write the rows in the correct order.
	mov eax,[format]
	and eax,PNG_FORMAT_FLAG_COLORMAP
	jz .end4 ;if (..!=0)
		cmp dword[edx+png_image_write_control.colormap],0
		je .end6
		mov eax,[ebx+png_image.colormap_entries]
		cmp eax,0
		jle .end6 ;if (..!=0 && ..>0)
			;eax = entries
			xor ecx,ecx
			inc ecx ;=1
			cmp eax,2
			jle @f
				shl ecx,1 ;=2
			cmp eax,4
			jle @f
				shl ecx,1 ;=4
			cmp eax,16
			jle @f
				shl ecx,1 ;=8
			@@:
			stdcall png_set_IHDR, edi, esi, [ebx+png_image.width], [ebx+png_image.height],\
				ecx, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,\
				PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE
 
			stdcall png_image_set_PLTE, edx
			jmp .end5
		.end6: ;else
			mov eax,[ebx+png_image.opaque]
			mov eax,[eax+png_control.png_ptr]
			png_error eax, 'no color-map for color-mapped image'
		jmp .end5
	.end4: ;else
		xor ecx,ecx
		mov eax,[format]
		and eax,PNG_FORMAT_FLAG_COLOR
		jz @f
			or ecx,PNG_COLOR_MASK_COLOR
		@@:
		mov eax,[format]
		and eax,PNG_FORMAT_FLAG_ALPHA
		jz @f
			or ecx,PNG_COLOR_MASK_ALPHA
		@@:
		mov eax,8
		cmp dword[write_16bit],0
		je @f
			mov eax,16
		@@:
		stdcall png_set_IHDR, edi, esi, [ebx+png_image.width], [ebx+png_image.height],\
			eax, ecx, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE
	.end5:
 
	; Counter-intuitively the data transformations must be called *after*
	; png_write_info, not before as in the read code, but the 'set' functions
	; must still be called before.  Just set the color space information, never
	; write an interlaced image.
 
	cmp dword[write_16bit],0
	je @f ;if (..!=0)
		; The gamma here is 1.0 (linear) and the cHRM chunk matches sRGB.
		stdcall png_set_gAMA_fixed, edi, esi, PNG_GAMMA_LINEAR
 
		mov eax,[ebx+png_image.flags]
		and eax,PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB
		jnz @f ;if (..==0)
			stdcall png_set_cHRM_fixed, edi, esi,\
			31270, 32900,\ ;white
			64000, 33000,\ ;red
			30000, 60000,\ ;green
			15000,  6000   ;blue
		jmp .end7
	@@:
	mov eax,[ebx+png_image.flags]
	and eax,PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB
	jnz @f ;else if (..==0)
		stdcall png_set_sRGB, edi, esi, PNG_sRGB_INTENT_PERCEPTUAL
		jmp .end7
	@@: ;else
		; Else writing an 8-bit file and the *colors* aren't sRGB, but the 8-bit
		; space must still be gamma encoded.
		stdcall png_set_gAMA_fixed, edi, esi, PNG_GAMMA_sRGB_INVERSE
	.end7:
 
	; Write the file header.
	stdcall png_write_info, edi, esi
 
	; Now set up the data transformations (*after* the header is written),
	; remove the handled transformations from the 'format' flags for checking.
 
	; First check for a little endian system if writing 16-bit files.
 
	cmp dword[write_16bit],0
	je @f ;if (..!=0)
;      uint_16 le = 0x0001;
 
;      if ((*(bytep) & le) != 0)
		stdcall png_set_swap, edi
	@@:
 
if PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED eq 1
	mov eax,[format]
	and eax,PNG_FORMAT_FLAG_BGR
	jz .end12 ;if (..!=0)
		cmp dword[colormap],0
		jne @f
		mov eax,[format]
		and eax,PNG_FORMAT_FLAG_COLOR
		jz @f ;if (..==0 && ..!=0)
			stdcall png_set_bgr, edi
		@@:
		and dword[format], not PNG_FORMAT_FLAG_BGR
	.end12:
end if
 
if PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED eq 1
	mov eax,[format]
	and eax,PNG_FORMAT_FLAG_AFIRST
	jz .end13 ;if (..!=0)
		cmp dword[colormap],0
		jne @f
		mov eax,[format]
		and eax,PNG_FORMAT_FLAG_ALPHA
		jz @f ;if (..==0 && ..!=0)
			stdcall png_set_swap_alpha, edi
		@@:
		and dword[format], not PNG_FORMAT_FLAG_AFIRST
	.end13:
end if
 
	; If there are 16 or fewer color-map entries we wrote a lower bit depth
	; above, but the application data is still byte packed.
 
	cmp dword[colormap],0
	je @f
	cmp dword[ebx+png_image.colormap_entries],16
	jg @f ;if (..!=0 && ..<=16)
		stdcall png_set_packing, edi
	@@:
 
	; That should have handled all (both) the transforms.
	mov eax,[format]
	and eax, not (PNG_FORMAT_FLAG_COLOR or PNG_FORMAT_FLAG_LINEAR or PNG_FORMAT_FLAG_ALPHA or PNG_FORMAT_FLAG_COLORMAP)
	jz @f ;if (..!=0)
		png_error edi, 'png_write_image: unsupported transformation'
	@@:
 
	push esi
	;ecx - row ;bytep
	;esi - row_bytes
	mov ecx,[edx+png_image_write_control.buffer]
	mov esi,[edx+png_image_write_control.row_stride]
 
	cmp dword[linear],0
	je @f ;if (..!=0)
		shl esi,1 ;*= sizeof.uint_16
	@@:
	cmp esi,0
	jge @f ;if (..<0)
		mov eax,[ebx+png_image.height]
		dec eax
		imul eax,esi
		sub ecx,eax
	@@:
	mov [edx+png_image_write_control.first_row],ecx
	mov [edx+png_image_write_control.row_bytes],esi
	pop esi
 
	; Apply 'fast' options if the flag is set.
	mov eax,[ebx+png_image.flags]
	and eax,PNG_IMAGE_FLAG_FAST
	jz @f ;if (..!=0)
		stdcall png_set_filter, edi, PNG_FILTER_TYPE_BASE, PNG_NO_FILTERS
		; NOTE: determined by experiment using pngstest, this reflects some
		; balance between the time to write the image once and the time to read
		; it about 50 times.  The speed-up in pngstest was about 10-20% of the
		; total (user) time on a heavily loaded system.
 
if PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED eq 1
		stdcall png_set_compression_level, edi, 3
end if
	@@:
 
	; Check for the cases that currently require a pre-transform on the row
	; before it is written.  This only applies when the input is 16-bit and
	; either there is an alpha channel or it is converted to 8-bit.
 
	cmp dword[linear],0
	je @f
	cmp dword[alpha],0
	je @f
		jmp .end10
	@@:
	cmp dword[colormap],0
	jne .end9
	cmp dword[edx+png_image_write_control.convert_to_8bit],0
	je .end9
	.end10: ;if ((..!=0 && ..!=0 ) || (..==0 && ..!=0))
		stdcall png_get_rowbytes, edi, esi
		stdcall png_malloc, edi, eax
		mov ecx,eax ;ecx = row
		
		mov [edx+png_image_write_control.local_row],ecx
		cmp dword[write_16bit],0
		je @f ;if (..!=0)
			stdcall png_safe_execute, ebx, png_write_image_16bit, edx
			jmp .end11
		@@: ;else
			stdcall png_safe_execute, ebx, png_write_image_8bit, edx
		.end11:
		mov dword[edx+png_image_write_control.local_row],0
 
		stdcall png_free, edi, ecx
 
		; Skip the 'write_end' on error:
		cmp eax,0
		je .end_f ;if (..==0) return 0
		jmp .end8
 
	; Otherwise this is the case where the input is in a format currently
	; supported by the rest of the libpng write code; call it directly.
 
	.end9: ;else
if 1 ;;; IDAT compress all
		mov ecx,[edx+png_image_write_control.row_bytes]
		inc ecx
		imul ecx,[ebx+png_image.height]
		cmp ecx,1
		jl .end8
		stdcall create_compress_IDAT, edi, [edx+png_image_write_control.first_row], ecx, [ebx+png_image.width], [ebx+png_image.height]
else ;;; not work, IDAT compress by lines
		mov ecx,[ebx+png_image.height]
		cmp ecx,1
		jl .end8
		mov eax,[edx+png_image_write_control.first_row]
		mov ebx,[edx+png_image_write_control.row_bytes]
		@@:
			stdcall png_write_row, edi, eax
			add eax, ebx
			loop @b
end if
	.end8:
 
	stdcall png_write_end, edi, esi
	xor eax,eax
	inc eax
.end_f:
	ret
endp
 
align 16
proc create_compress_IDAT, png_ptr:dword, buf:dword, len:dword, width:dword, height:dword
locals
	m1 dd ? ;memory for compress IDAT
	buf_f dd ? ;memory for IDAT
	mins dd ? ;minimum sum
endl
pushad
	mov edi,[png_ptr]
png_debug 1, 'IDAT compress all'
 
	;create buffer with filters
	stdcall png_zalloc, edi, 1, [len]
	cmp eax,0
	je .end_f
	mov [buf_f],eax
 
	mov eax,ZLIB_IO_MAX
	cmp eax,[len]
	jge @f
		mov eax,[len]
	@@:
	stdcall png_zalloc, edi, 1, eax
	cmp eax,0
	je .end0
	mov [m1],eax
 
	;init buffer with filters
	mov ebx,[width]
	mov edx,[height]
	mov edi,[buf_f]
	mov esi,[buf]
	.cycle0:
	cmp edx,1
	jl .cycle0end
		mov ecx,ebx
		xor al,al
		stosb ;insert filter (0 - none)
align 4
		.cycle1:
			lodsb   ;1
			inc edi ;
			movsb   ;2
			stosb   ;3
			lodsb   ;
			mov [edi-3],al
			loop .cycle1
		dec edx
		jmp .cycle0
	.cycle0end:
 
	;make filters
	mov edx,[height]
	mov esi,[width]
	imul esi,3 ;esi - rowbytes
 
	inc esi
	mov edi,[png_ptr]
	cmp dword[edi+png_struct.try_row],0
	jne @f ;if (..==0)
		stdcall png_malloc, edi, esi
		mov [edi+png_struct.try_row],eax
	@@:
	cmp dword[edi+png_struct.tst_row],0
	jne @f ;if (..==0)
		stdcall png_malloc, edi, esi
		mov [edi+png_struct.tst_row],eax
	@@:
	dec esi
 
	mov edi,[buf_f]
	add edi,[len]
	.cycle3:
		dec edx
		cmp edx,1
		jl .cycle3end
		sub edi,esi
		dec edi ;move in perv row
 
		;init pointers for function png_setup_up_row
		mov ebx,[png_ptr]
		mov [ebx+png_struct.row_buf],edi
		mov [ebx+png_struct.prev_row],edi
		sub [ebx+png_struct.prev_row],esi
		dec dword[ebx+png_struct.prev_row]
 
		;calculate start minimum sum
		push esi
		xor eax,eax
		xor ebx,ebx
		mov ecx,esi
		mov esi,edi
		inc esi
		.cycle2:
			lodsb
			png_setup_abs ebx
			loop .cycle2
		pop esi
		mov [mins],ebx
 
		push edx
		mov edx,[png_ptr]
		mov eax,[edx+png_struct.tst_row]
		mov byte[eax],0 ;not filter
 
		; Up filter
		stdcall png_setup_up_row, edx, esi, [mins]
		cmp eax,[mins]
		jge @f ;if (..<..)
			mov [mins],eax
			stdcall copy_row_mins, [edx+png_struct.tst_row], [edx+png_struct.try_row]
		@@:
 
		; Find out how many bytes offset each pixel is
		movzx ebx,byte[edx+png_struct.pixel_depth]
		add ebx,7
		shr ebx,3
 
		; Sub filter
		stdcall png_setup_sub_row, edx, ebx, esi, [mins]
		cmp eax,[mins]
		jge @f ;if (..<..)
			mov [mins],eax
			stdcall copy_row_mins, [edx+png_struct.tst_row], [edx+png_struct.try_row]
		@@:
 
		; Avg filter
		stdcall png_setup_avg_row, edx, ebx, esi, [mins]
		cmp eax,[mins]
		jge @f ;if (..<..)
			mov [mins],eax
			stdcall copy_row_mins, [edx+png_struct.tst_row], [edx+png_struct.try_row]
		@@:
 
		; Copy best row
		mov eax,[edx+png_struct.tst_row]
		cmp byte[eax],0
		je @f
			stdcall copy_row_mins, edi, [edx+png_struct.tst_row]
		@@:
		pop edx
		jmp .cycle3
	.cycle3end:
	
	mov edi,[png_ptr]
	mov esi,edi
	add esi,png_struct.zstream
	stdcall [deflateInit2], esi,\
		-1, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY
 
	mov eax,[buf_f]
	mov [edi+png_struct.zstream.next_in],eax
	mov eax,[len]
	mov [edi+png_struct.zstream.avail_in],eax
	mov eax,[m1]
	mov [edi+png_struct.zstream.next_out],eax
	xor ecx,ecx
align 4
	.cycle4:
		mov dword[edi+png_struct.zstream.avail_out],16*1024
 
		stdcall [deflate], esi, Z_FINISH ;Z_NO_FLUSH
		cmp eax,Z_STREAM_ERROR
		je .end1
 
		add ecx,16*1024
		sub ecx,[edi+png_struct.zstream.avail_out]
		cmp dword[edi+png_struct.zstream.avail_out],0
	je .cycle4 ;while (strm.avail_out == 0)
if 0
	mov dword[edi+png_struct.zstream.avail_out],16*1024
	stdcall [deflate], esi, Z_FINISH
	add ecx,16*1024
	sub ecx,[edi+png_struct.zstream.avail_out]
	cmp eax,Z_STREAM_ERROR
	je .end1
end if
	stdcall [deflateEnd], esi
 
if PNG_WRITE_OPTIMIZE_CMF_SUPPORTED eq 1
	mov eax,[edi+png_struct.mode]
	and eax,PNG_HAVE_IDAT
	jnz @f
	cmp byte[edi+png_struct.compression_type],PNG_COMPRESSION_TYPE_BASE
	jne @f ;if (..==0 && ..==..)
		stdcall png_image_size, edi
		stdcall optimize_cmf, [m1], eax
	@@:
end if
	stdcall png_write_complete_chunk, edi, png_IDAT, [m1], ecx
	or dword[edi+png_struct.mode],PNG_HAVE_IDAT
 
	jmp @f
	.end1:
		png_debug 1, 'Z_STREAM_ERROR'
	@@:
 
	;free memory
	cmp dword[edi+png_struct.try_row],0
	je @f ;if (..!=0)
		stdcall png_free, edi, [edi+png_struct.try_row]
		mov dword[edi+png_struct.try_row],0
	@@:
	cmp dword[edi+png_struct.tst_row],0
	je @f ;if (..!=0)
		stdcall png_free, edi, [edi+png_struct.tst_row]
		mov dword[edi+png_struct.tst_row],0
	@@:
	stdcall png_free, edi, [m1]
.end0:
	stdcall png_free, edi, [buf_f]
.end_f:
popad
	ret
endp
 
;input:
; esi - rowbytes
align 4
proc copy_row_mins uses edi esi, dest:dword, sour:dword
	mov ecx,esi
	inc ecx
	mov edi,[dest]
	mov esi,[sour]
	rep movsb
	ret
endp
 
;void (png_structp png_ptr, bytep/*const*/ data, png_size_t size)
align 4
proc image_memory_write uses eax ebx ecx edi esi, png_ptr:dword, p2data:dword, size:dword
	mov edi,[png_ptr]
	mov esi,[edi+png_struct.io_ptr] ;esi = png_image_write_control *display
	mov ebx,[esi+png_image_write_control.output_bytes] ;ebx = ob
 
	; Check for overflow; this should never happen:
	mov eax,PNG_SIZE_MAX
	sub eax,ebx
	mov ecx,[size]
	cmp ecx,eax
	jg .end1 ;if (..<=..)
		; I don't think libpng ever does this, but just in case:
		cmp ecx,0
		jle .end0 ;if (..>0)
			mov eax,ebx
			add eax,ecx
			cmp [esi+png_image_write_control.memory_bytes],eax
			jl @f ;if (..>=..) ;writing
				push esi
				mov edi,[esi+png_image_write_control.memory]
				add edi,ebx
				mov esi,[p2data]
				rep movsb ;memcpy(...
				pop esi
			@@:
 
			; Always update the size:
			add ebx,[size]
			mov [esi+png_image_write_control.output_bytes],ebx
		.end0:
		jmp .end2
	.end1: ;else
		png_error edi, 'png_image_write_to_memory: PNG too big'
	.end2:
	ret
endp
 
;void (png_structp png_ptr)
align 4
proc image_memory_flush, png_ptr:dword
	ret
endp
 
;int (voidp argument)
align 4
proc png_image_write_memory uses ebx, argument:dword
	; 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.
 
	mov eax,[argument]
	mov ebx,[eax+png_image_write_control.image]
	mov ebx,[ebx+png_image.opaque]
	stdcall png_set_write_fn, [ebx+png_control.png_ptr], eax, image_memory_write, image_memory_flush
 
	stdcall png_image_write_main, [argument]
	ret
endp
 
;int (png_imagep image, void *memory,
;    png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8bit,
;    const void *buffer, int_32 row_stride, const void *colormap)
align 4
proc png_image_write_to_memory uses ebx ecx edx edi esi, image:dword, memory:dword,\
	memory_bytes:dword, convert_to_8bit:dword, buffer:dword, row_stride:dword, colormap:dword
locals
	display png_image_write_control ;local struct
endl
;edi - display png_image_write_control
 
	; Write the image to the given buffer, or count the bytes if it is NULL
	mov ebx,[image]
	cmp ebx,0
	je .end0
	cmp dword[ebx+png_image.version],PNG_IMAGE_VERSION
	jne .end0 ;if (..!=0 && ..==..)
		cmp dword[memory_bytes],0
		je .end2
		cmp dword[buffer],0
		je .end2 ;if (..!=0 && ..!=0)
			; This is to give the caller an easier error detection in the NULL
			; case and guard against uninitialized variable problems:
 
			cmp dword[memory],0
			jne @f ;if(..==0)
				mov eax,[memory_bytes]
				mov dword[eax],0
			@@:
 
			stdcall png_image_write_init, ebx
			cmp eax,0
			je .end3 ;if (..!=0)
				mov ecx,sizeof.png_image_write_control
				mov edi,ebp
				sub edi,ecx
				xor eax,eax
				rep stosb ;memset(&display, 0, sizeof.display))
				sub edi,sizeof.png_image_write_control
				mov [edi+png_image_write_control.image],ebx
				mov eax,[buffer]
				mov [edi+png_image_write_control.buffer],eax
				mov eax,[row_stride]
				mov [edi+png_image_write_control.row_stride],eax
				mov eax,[colormap]
				mov [edi+png_image_write_control.colormap],eax
				mov eax,[convert_to_8bit]
				mov [edi+png_image_write_control.convert_to_8bit],eax
				mov eax,[memory]
				mov [edi+png_image_write_control.memory],eax
				mov eax,[memory_bytes]
				mov eax,[eax]
				mov [edi+png_image_write_control.memory_bytes],eax
				mov dword[edi+png_image_write_control.output_bytes], 0
 
				stdcall png_safe_execute, ebx, png_image_write_memory, edi
				mov ecx,eax ;ecx = result
				stdcall png_image_free, ebx
 
				; write_memory returns true even if we ran out of buffer.
				cmp ecx,0 ;if (..)
				je .end4
					; On out-of-buffer this function returns '0' but still updates
					; memory_bytes:
 
					mov edx,[edi+png_image_write_control.output_bytes]
					mov eax,[memory_bytes]
					cmp dword[memory],0
					je @f ;if (..!=0 && ..>..)
					cmp edx,[eax]
					jle @f
						xor ecx,ecx
					@@:
					mov [eax],edx
				.end4:
 
				mov eax,ecx
				jmp .end_f
			.end3: ;else
			xor eax,eax
			jmp .end_f
		.end2: ;else
			std_png_image_error ebx, 'png_image_write_to_memory: invalid argument'
			jmp .end_f
	.end0:
	cmp ebx,0
	je .end1 ;else if (..!=0)
		std_png_image_error ebx, 'png_image_write_to_memory: incorrect PNG_IMAGE_VERSION'
		jmp .end_f
	.end1: ;else
		xor eax,eax
.end_f:
	ret
endp
 
;int (png_imagep image, FILE *file, int convert_to_8bit,
;    const void *buffer, int_32 row_stride, const void *colormap)
align 4
proc png_image_write_to_stdio, image:dword, file:dword, convert_to_8bit:dword, buffer:dword, row_stride:dword, colormap:dword
	; Write the image to the given (FILE*).
;   if (image != NULL && image->version == PNG_IMAGE_VERSION)
;   {
;      if (file != NULL && buffer != NULL)
;      {
;         if (png_image_write_init(image) != 0)
;         {
;            png_image_write_control display;
;            int result;
 
	; This is slightly evil, but png_init_io doesn't do anything other
	; than this and we haven't changed the standard IO functions so
	; this saves a 'safe' function.
 
;            image->opaque->png_ptr->io_ptr = file;
 
;            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;
 
;            result = png_safe_execute(image, png_image_write_main, &display);
;            png_image_free(image);
;            return result;
;         }
 
;         else
;            return 0;
;      }
 
;      else
;         return png_image_error(image,
;             "png_image_write_to_stdio: invalid argument");
;   }
 
;   else if (image != NULL)
;      return png_image_error(image,
;          "png_image_write_to_stdio: incorrect PNG_IMAGE_VERSION");
 
;   else
;      return 0;
	ret
endp
 
;int (png_imagep image, const char *file_name,
;    int convert_to_8bit, const void *buffer, int_32 row_stride,
;    const void *colormap)
align 4
proc png_image_write_to_file, image:dword, file_name:dword, convert_to_8bit:dword, buffer:dword, row_stride:dword, colormap:dword
	; Write the image to the named file.
;   if (image != NULL && image->version == PNG_IMAGE_VERSION)
;   {
;      if (file_name != NULL && buffer != NULL)
;      {
;         FILE *fp = fopen(file_name, "wb");
 
;         if (fp != NULL)
;         {
;            if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer,
;                row_stride, colormap) != 0)
;            {
;               int error; /* from fflush/fclose */
 
	; Make sure the file is flushed correctly.
;               if (fflush(fp) == 0 && ferror(fp) == 0)
;               {
;                  if (fclose(fp) == 0)
;                     return 1;
 
;                  error = errno; /* from fclose */
;               }
 
;               else
;               {
;                  error = errno; /* from fflush or ferror */
;                  (void)fclose(fp);
;               }
 
;               (void)remove(file_name);
	; The image has already been cleaned up; this is just used to
	; set the error (because the original write succeeded).
 
;               return png_image_error(image, strerror(error));
;            }
 
;            else
;            {
	; Clean up: just the opened file.
;               (void)fclose(fp);
;               (void)remove(file_name);
;               return 0;
;            }
;         }
 
;         else
;            return png_image_error(image, strerror(errno));
;      }
 
;      else
;         return png_image_error(image,
;             "png_image_write_to_file: invalid argument");
;   }
 
;   else if (image != NULL)
;      return png_image_error(image,
;          "png_image_write_to_file: incorrect PNG_IMAGE_VERSION");
 
;   else
;      return 0;
	ret
endp
end if ;SIMPLIFIED_WRITE
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>

Rev 6870	Rev 6873
1	; pngwrite.asm - general routines to write a PNG file	1	; pngwrite.asm - general routines to write a PNG file
2		2
3	; Last changed in libpng 1.6.24 [August 4, 2016]	3	; Last changed in libpng 1.6.24 [August 4, 2016]
4	; Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson	4	; Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson
5	; (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)	5	; (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
6	; (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)	6	; (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
7		7
8	; This code is released under the libpng license.	8	; This code is released under the libpng license.
9	; For conditions of distribution and use, see the disclaimer	9	; For conditions of distribution and use, see the disclaimer
10	; and license in png.inc	10	; and license in png.inc
11		11
12	; Write out all the unknown chunks for the current given location	12	; Write out all the unknown chunks for the current given location
13	;void (png_structrp png_ptr, png_const_inforp info_ptr, unsigned int where)	13	;void (png_structrp png_ptr, png_const_inforp info_ptr, unsigned int where)
14	align 4	14	align 4
15	proc write_unknown_chunks, png_ptr:dword, info_ptr:dword, where:dword	15	proc write_unknown_chunks, png_ptr:dword, info_ptr:dword, where:dword
16	pushad	16	pushad
17	mov esi,[info_ptr]	17	mov esi,[info_ptr]
18	cmp dword[esi+png_info_def.unknown_chunks_num],0	18	cmp dword[esi+png_info_def.unknown_chunks_num],0
19	je .end_f ;if(..!=0)	19	je .end_f ;if(..!=0)
20	mov edi,[png_ptr]	20	mov edi,[png_ptr]
21	;ecx = up	21	;ecx = up
22		22
23	png_debug 5, 'writing extra chunks'	23	png_debug 5, 'writing extra chunks'
24		24
25	mov ecx,[esi+png_info_def.unknown_chunks]	25	mov ecx,[esi+png_info_def.unknown_chunks]
26	mov edx,[esi+png_info_def.unknown_chunks_num]	26	mov edx,[esi+png_info_def.unknown_chunks_num]
27	imul edx,sizeof.png_unknown_chunk	27	imul edx,sizeof.png_unknown_chunk
28	add edx,ecx	28	add edx,ecx
29	.cycle0: ;for (..;..<..;..)	29	.cycle0: ;for (..;..<..;..)
30	cmp ecx,edx	30	cmp ecx,edx
31	jge .end_f	31	jge .end_f
32	movzx eax,byte[ecx+png_unknown_chunk.location]	32	movzx eax,byte[ecx+png_unknown_chunk.location]
33	and eax,[where]	33	and eax,[where]
34	jz .end0 ;if (..!=0)	34	jz .end0 ;if (..!=0)
35	; If per-chunk unknown chunk handling is enabled use it, otherwise	35	; If per-chunk unknown chunk handling is enabled use it, otherwise
36	; just write the chunks the application has set.	36	; just write the chunks the application has set.
37		37
38	if PNG_SET_UNKNOWN_CHUNKS_SUPPORTED eq 1	38	if PNG_SET_UNKNOWN_CHUNKS_SUPPORTED eq 1
39	mov eax,ecx	39	mov eax,ecx
40	add eax,png_unknown_chunk.name	40	add eax,png_unknown_chunk.name
41	stdcall png_handle_as_unknown, edi, eax	41	stdcall png_handle_as_unknown, edi, eax
42		42
43	; NOTE: this code is radically different from the read side in the	43	; NOTE: this code is radically different from the read side in the
44	; matter of handling an ancillary unknown chunk. In the read side	44	; matter of handling an ancillary unknown chunk. In the read side
45	; the default behavior is to discard it, in the code below the default	45	; the default behavior is to discard it, in the code below the default
46	; behavior is to write it. Critical chunks are, however, only	46	; behavior is to write it. Critical chunks are, however, only
47	; written if explicitly listed or if the default is set to write all	47	; written if explicitly listed or if the default is set to write all
48	; unknown chunks.	48	; unknown chunks.
49		49
50	; The default handling is also slightly weird - it is not possible to	50	; The default handling is also slightly weird - it is not possible to
51	; stop the writing of all unsafe-to-copy chunks!	51	; stop the writing of all unsafe-to-copy chunks!
52		52
53	; TODO: REVIEW: this would seem to be a bug.	53	; TODO: REVIEW: this would seem to be a bug.
54		54
55	cmp eax,PNG_HANDLE_CHUNK_NEVER	55	cmp eax,PNG_HANDLE_CHUNK_NEVER
56	je .end0	56	je .end0
57	mov bl,byte[ecx+png_unknown_chunk.name+3]	57	mov bl,byte[ecx+png_unknown_chunk.name+3]
58	and bl,0x20	58	and bl,0x20
59	cmp bl,0	59	cmp bl,0
60	jne .beg0	60	jne .beg0
61	cmp eax,PNG_HANDLE_CHUNK_ALWAYS	61	cmp eax,PNG_HANDLE_CHUNK_ALWAYS
62	je .beg0	62	je .beg0
63	cmp eax,PNG_HANDLE_CHUNK_AS_DEFAULT	63	cmp eax,PNG_HANDLE_CHUNK_AS_DEFAULT
64	jne .end0	64	jne .end0
65	cmp dword[edi+png_struct.unknown_default],PNG_HANDLE_CHUNK_ALWAYS	65	cmp dword[edi+png_struct.unknown_default],PNG_HANDLE_CHUNK_ALWAYS
66	jne .end0	66	jne .end0
67	end if	67	end if
68	.beg0: ;if (..!=.. && (.. safe-to-copy overrides everything \|\| ..==.. \|\| (..==.. && ..==..)))	68	.beg0: ;if (..!=.. && (.. safe-to-copy overrides everything \|\| ..==.. \|\| (..==.. && ..==..)))
69	; TODO: review, what is wrong with a zero length unknown chunk?	69	; TODO: review, what is wrong with a zero length unknown chunk?
70	cmp dword[ecx+png_unknown_chunk.size],0	70	cmp dword[ecx+png_unknown_chunk.size],0
71	jne @f ;if (..==0)	71	jne @f ;if (..==0)
72	png_warning [png_ptr], 'Writing zero-length unknown chunk'	72	png_warning [png_ptr], 'Writing zero-length unknown chunk'
73	@@:	73	@@:
74	mov eax,dword[ecx+png_unknown_chunk.name]	74	mov eax,dword[ecx+png_unknown_chunk.name]
75	stdcall png_write_chunk, edi, eax, [ecx+png_unknown_chunk.podata], [ecx+png_unknown_chunk.size]	75	stdcall png_write_chunk, edi, eax, [ecx+png_unknown_chunk.podata], [ecx+png_unknown_chunk.size]
76	.end0:	76	.end0:
77	add ecx,sizeof.png_unknown_chunk	77	add ecx,sizeof.png_unknown_chunk
78	jmp .cycle0	78	jmp .cycle0
79	;.cycle0end:	79	;.cycle0end:
80	.end_f:	80	.end_f:
81	popad	81	popad
82	ret	82	ret
83	endp	83	endp
84		84
85	; Writes all the PNG information. This is the suggested way to use the	85	; Writes all the PNG information. This is the suggested way to use the
86	; library. If you have a new chunk to add, make a function to write it,	86	; library. If you have a new chunk to add, make a function to write it,
87	; and put it in the correct location here. If you want the chunk written	87	; and put it in the correct location here. If you want the chunk written
88	; after the image data, put it in png_write_end(). I strongly encourage	88	; after the image data, put it in png_write_end(). I strongly encourage
89	; you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing	89	; you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing
90	; the chunk, as that will keep the code from breaking if you want to just	90	; the chunk, as that will keep the code from breaking if you want to just
91	; write a plain PNG file. If you have long comments, I suggest writing	91	; write a plain PNG file. If you have long comments, I suggest writing
92	; them in png_write_end(), and compressing them.	92	; them in png_write_end(), and compressing them.
93		93
94	;void (png_structrp png_ptr, png_const_inforp info_ptr)	94	;void (png_structrp png_ptr, png_const_inforp info_ptr)
95	align 4	95	align 4
96	proc png_write_info_before_PLTE, png_ptr:dword, info_ptr:dword	96	proc png_write_info_before_PLTE, png_ptr:dword, info_ptr:dword
97	png_debug 1, 'in png_write_info_before_PLTE'	97	png_debug 1, 'in png_write_info_before_PLTE'
98		98
99	pushad	99	pushad
100	mov edi,[png_ptr]	100	mov edi,[png_ptr]
101	cmp edi,0	101	cmp edi,0
102	je .end_f	102	je .end_f
103	mov esi,[info_ptr]	103	mov esi,[info_ptr]
104	cmp esi,0	104	cmp esi,0
105	je .end_f ;if(..==0 \|\| ..==0) return	105	je .end_f ;if(..==0 \|\| ..==0) return
106		106
107	mov eax,[edi+png_struct.mode]	107	mov eax,[edi+png_struct.mode]
108	and eax,PNG_WROTE_INFO_BEFORE_PLTE	108	and eax,PNG_WROTE_INFO_BEFORE_PLTE
109	jnz .end_f ;if (..==0)	109	jnz .end_f ;if (..==0)
110		110
111	; Write PNG signature	111	; Write PNG signature
112	stdcall png_write_sig, edi	112	stdcall png_write_sig, edi
113		113
114	if PNG_MNG_FEATURES_SUPPORTED eq 1	114	if PNG_MNG_FEATURES_SUPPORTED eq 1
115	mov eax,[edi+png_struct.mode]	115	mov eax,[edi+png_struct.mode]
116	and eax,PNG_HAVE_PNG_SIGNATURE	116	and eax,PNG_HAVE_PNG_SIGNATURE
117	jz @f	117	jz @f
118	cmp dword[edi+png_struct.mng_features_permitted],0	118	cmp dword[edi+png_struct.mng_features_permitted],0
119	je @f ;if(..!=0 && ..!=0)	119	je @f ;if(..!=0 && ..!=0)
120	png_warning edi, 'MNG features are not allowed in a PNG datastream'	120	png_warning edi, 'MNG features are not allowed in a PNG datastream'
121	mov dword[edi+png_struct.mng_features_permitted],0	121	mov dword[edi+png_struct.mng_features_permitted],0
122	@@:	122	@@:
123	end if	123	end if
124		124
125	; Write IHDR information.	125	; Write IHDR information.
126	if PNG_WRITE_INTERLACING_SUPPORTED eq 1	126	if PNG_WRITE_INTERLACING_SUPPORTED eq 1
127	movzx eax,byte[esi+png_info_def.interlace_type]	127	movzx eax,byte[esi+png_info_def.interlace_type]
128	push eax	128	push eax
129	else	129	else
130	push dword 0	130	push dword 0
131	end if	131	end if
132	movzx eax,byte[esi+png_info_def.filter_type]	132	movzx eax,byte[esi+png_info_def.filter_type]
133	push eax	133	push eax
134	movzx eax,byte[esi+png_info_def.compression_type]	134	movzx eax,byte[esi+png_info_def.compression_type]
135	push eax	135	push eax
136	movzx eax,byte[esi+png_info_def.color_type]	136	movzx eax,byte[esi+png_info_def.color_type]
137	push eax	137	push eax
138	movzx eax,byte[esi+png_info_def.bit_depth]	138	movzx eax,byte[esi+png_info_def.bit_depth]
139	stdcall png_write_IHDR, edi,\	139	stdcall png_write_IHDR, edi,\
140	dword[esi+png_info_def.width], dword[esi+png_info_def.height], eax	140	dword[esi+png_info_def.width], dword[esi+png_info_def.height], eax
141		141
142	; The rest of these check to see if the valid field has the appropriate	142	; The rest of these check to see if the valid field has the appropriate
143	; flag set, and if it does, writes the chunk.	143	; flag set, and if it does, writes the chunk.
144		144
145	; 1.6.0: COLORSPACE support controls the writing of these chunks too, and	145	; 1.6.0: COLORSPACE support controls the writing of these chunks too, and
146	; the chunks will be written if the WRITE routine is there and	146	; the chunks will be written if the WRITE routine is there and
147	; information * is available in the COLORSPACE. (See	147	; information * is available in the COLORSPACE. (See
148	; png_colorspace_sync_info in png.c for where the valid flags get set.)	148	; png_colorspace_sync_info in png.c for where the valid flags get set.)
149		149
150	; Under certain circumstances the colorspace can be invalidated without	150	; Under certain circumstances the colorspace can be invalidated without
151	; syncing the info_struct 'valid' flags; this happens if libpng detects	151	; syncing the info_struct 'valid' flags; this happens if libpng detects
152	; an error and calls png_error while the color space is being set, yet	152	; an error and calls png_error while the color space is being set, yet
153	; the application continues writing the PNG. So check the 'invalid'	153	; the application continues writing the PNG. So check the 'invalid'
154	; flag here too.	154	; flag here too.
155		155
156	if PNG_GAMMA_SUPPORTED eq 1	156	if PNG_GAMMA_SUPPORTED eq 1
157	if PNG_WRITE_gAMA_SUPPORTED eq 1	157	if PNG_WRITE_gAMA_SUPPORTED eq 1
158	movzx eax,word[esi+png_info_def.colorspace.flags]	158	movzx eax,word[esi+png_info_def.colorspace.flags]
159	and eax,PNG_COLORSPACE_INVALID	159	and eax,PNG_COLORSPACE_INVALID
160	jnz @f	160	jnz @f
161	movzx eax,word[esi+png_info_def.colorspace.flags]	161	movzx eax,word[esi+png_info_def.colorspace.flags]
162	and eax,PNG_COLORSPACE_FROM_gAMA	162	and eax,PNG_COLORSPACE_FROM_gAMA
163	jz @f	163	jz @f
164	mov eax,[esi+png_info_def.valid]	164	mov eax,[esi+png_info_def.valid]
165	and eax,PNG_INFO_gAMA	165	and eax,PNG_INFO_gAMA
166	jz @f ;if (..==0 && ..!=0 && ..!=0)	166	jz @f ;if (..==0 && ..!=0 && ..!=0)
167	stdcall png_write_gAMA_fixed, edi, [esi+png_info_def.colorspace.gamma]	167	stdcall png_write_gAMA_fixed, edi, [esi+png_info_def.colorspace.gamma]
168	@@:	168	@@:
169	end if	169	end if
170	end if	170	end if
171		171
172	if PNG_COLORSPACE_SUPPORTED eq 1	172	if PNG_COLORSPACE_SUPPORTED eq 1
173	; Write only one of sRGB or an ICC profile. If a profile was supplied	173	; Write only one of sRGB or an ICC profile. If a profile was supplied
174	; and it matches one of the known sRGB ones issue a warning.	174	; and it matches one of the known sRGB ones issue a warning.
175		175
176	if PNG_WRITE_iCCP_SUPPORTED eq 1	176	if PNG_WRITE_iCCP_SUPPORTED eq 1
177	movzx eax,word[esi+png_info_def.colorspace.flags]	177	movzx eax,word[esi+png_info_def.colorspace.flags]
178	and eax,PNG_COLORSPACE_INVALID	178	and eax,PNG_COLORSPACE_INVALID
179	jnz .end0	179	jnz .end0
180	mov eax,[esi+png_info_def.valid]	180	mov eax,[esi+png_info_def.valid]
181	and eax,PNG_INFO_iCCP	181	and eax,PNG_INFO_iCCP
182	jz .end0 ;if (..==0 && ..!=0)	182	jz .end0 ;if (..==0 && ..!=0)
183	if PNG_WRITE_sRGB_SUPPORTED eq 1	183	if PNG_WRITE_sRGB_SUPPORTED eq 1
184	mov eax,[esi+png_info_def.valid]	184	mov eax,[esi+png_info_def.valid]
185	and eax,PNG_INFO_sRGB	185	and eax,PNG_INFO_sRGB
186	jz @f ;if (..!=0)	186	jz @f ;if (..!=0)
187	png_app_warning edi, 'profile matches sRGB but writing iCCP instead'	187	png_app_warning edi, 'profile matches sRGB but writing iCCP instead'
188	@@:	188	@@:
189	end if	189	end if
190	stdcall png_write_iCCP, edi, [esi+png_info_def.iccp_name],\	190	stdcall png_write_iCCP, edi, [esi+png_info_def.iccp_name],\
191	[esi+png_info_def.iccp_profile]	191	[esi+png_info_def.iccp_profile]
192	if PNG_WRITE_sRGB_SUPPORTED eq 1	192	if PNG_WRITE_sRGB_SUPPORTED eq 1
193	jmp .end1	193	jmp .end1
194	end if	194	end if
195	.end0: ;else	195	.end0: ;else
196	end if	196	end if
197		197
198	if PNG_WRITE_sRGB_SUPPORTED eq 1	198	if PNG_WRITE_sRGB_SUPPORTED eq 1
199	movzx eax,word[esi+png_info_def.colorspace.flags]	199	movzx eax,word[esi+png_info_def.colorspace.flags]
200	and eax,PNG_COLORSPACE_INVALID	200	and eax,PNG_COLORSPACE_INVALID
201	jnz .end1	201	jnz .end1
202	mov eax,[esi+png_info_def.valid]	202	mov eax,[esi+png_info_def.valid]
203	and eax,PNG_INFO_sRGB	203	and eax,PNG_INFO_sRGB
204	jz .end1 ;if (..==0 && ..!=0)	204	jz .end1 ;if (..==0 && ..!=0)
205	movzx eax,word[esi+png_info_def.colorspace.rendering_intent]	205	movzx eax,word[esi+png_info_def.colorspace.rendering_intent]
206	stdcall png_write_sRGB, edi, eax	206	stdcall png_write_sRGB, edi, eax
207	.end1:	207	.end1:
208	end if ;sRGB	208	end if ;sRGB
209	end if ;COLORSPACE	209	end if ;COLORSPACE
210		210
211	if PNG_WRITE_sBIT_SUPPORTED eq 1	211	if PNG_WRITE_sBIT_SUPPORTED eq 1
212	mov eax,[esi+png_info_def.valid]	212	mov eax,[esi+png_info_def.valid]
213	and eax,PNG_INFO_sBIT	213	and eax,PNG_INFO_sBIT
214	jz @f ;if (..!=0)	214	jz @f ;if (..!=0)
215	movzx eax,byte[esi+png_info_def.color_type]	215	movzx eax,byte[esi+png_info_def.color_type]
216	push eax	216	push eax
217	mov eax,esi	217	mov eax,esi
218	add eax,png_info_def.sig_bit	218	add eax,png_info_def.sig_bit
219	stdcall png_write_sBIT, edi, eax ;, ...color_type	219	stdcall png_write_sBIT, edi, eax ;, ...color_type
220	@@:	220	@@:
221	end if	221	end if
222		222
223	if PNG_COLORSPACE_SUPPORTED eq 1	223	if PNG_COLORSPACE_SUPPORTED eq 1
224	if PNG_WRITE_cHRM_SUPPORTED eq 1	224	if PNG_WRITE_cHRM_SUPPORTED eq 1
225	movzx eax,word[esi+png_info_def.colorspace.flags]	225	movzx eax,word[esi+png_info_def.colorspace.flags]
226	and eax,PNG_COLORSPACE_INVALID	226	and eax,PNG_COLORSPACE_INVALID
227	jnz @f	227	jnz @f
228	movzx eax,word[esi+png_info_def.colorspace.flags]	228	movzx eax,word[esi+png_info_def.colorspace.flags]
229	and eax,PNG_COLORSPACE_FROM_cHRM	229	and eax,PNG_COLORSPACE_FROM_cHRM
230	jz @f	230	jz @f
231	mov eax,[esi+png_info_def.valid]	231	mov eax,[esi+png_info_def.valid]
232	and eax,PNG_INFO_cHRM	232	and eax,PNG_INFO_cHRM
233	jz @f ;if (..==0 && ..!=0 && ..!=0)	233	jz @f ;if (..==0 && ..!=0 && ..!=0)
234	stdcall png_write_cHRM_fixed, edi, [esi+png_info_def.colorspace.end_points_xy]	234	stdcall png_write_cHRM_fixed, edi, [esi+png_info_def.colorspace.end_points_xy]
235	@@:	235	@@:
236	end if	236	end if
237	end if	237	end if
238		238
239	if PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED eq 1	239	if PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED eq 1
240	stdcall write_unknown_chunks, edi, esi, PNG_HAVE_IHDR	240	stdcall write_unknown_chunks, edi, esi, PNG_HAVE_IHDR
241	end if	241	end if
242	or dword[edi+png_struct.mode],PNG_WROTE_INFO_BEFORE_PLTE	242	or dword[edi+png_struct.mode],PNG_WROTE_INFO_BEFORE_PLTE
243	.end_f:	243	.end_f:
244	popad	244	popad
245	ret	245	ret
246	endp	246	endp
247		247
248	;void (png_structrp png_ptr, png_const_inforp info_ptr)	248	;void (png_structrp png_ptr, png_const_inforp info_ptr)
249	align 4	249	align 4
250	proc png_write_info, png_ptr:dword, info_ptr:dword	250	proc png_write_info, png_ptr:dword, info_ptr:dword
251	if (PNG_WRITE_TEXT_SUPPORTED eq 1) \| (PNG_WRITE_sPLT_SUPPORTED eq 1)	251	if (PNG_WRITE_TEXT_SUPPORTED eq 1) \| (PNG_WRITE_sPLT_SUPPORTED eq 1)
252	; int i;	252	; int i;
253	end if	253	end if
254	pushad	254	pushad
255	png_debug 1, 'in png_write_info'	255	png_debug 1, 'in png_write_info'
256		256
257	mov edi,[png_ptr]	257	mov edi,[png_ptr]
258	cmp edi,0	258	cmp edi,0
259	je .end_f	259	je .end_f
260	mov esi,[info_ptr]	260	mov esi,[info_ptr]
261	cmp esi,0	261	cmp esi,0
262	je .end_f ;if (..==0 \|\| ..==0) return	262	je .end_f ;if (..==0 \|\| ..==0) return
263		263
264	stdcall png_write_info_before_PLTE, edi, esi	264	stdcall png_write_info_before_PLTE, edi, esi
265		265
266	mov eax,[esi+png_info_def.valid]	266	mov eax,[esi+png_info_def.valid]
267	and eax,PNG_INFO_PLTE	267	and eax,PNG_INFO_PLTE
268	jz @f ;if (..!=0)	268	jz @f ;if (..!=0)
269	movzx eax,word[esi+png_info_def.num_palette]	269	movzx eax,word[esi+png_info_def.num_palette]
270	stdcall png_write_PLTE, edi, [esi+png_info_def.palette], eax	270	stdcall png_write_PLTE, edi, [esi+png_info_def.palette], eax
271	jmp .end_0	271	jmp .end_0
272	@@:	272	@@:
273	mov al,byte[esi+png_info_def.color_type]	273	mov al,byte[esi+png_info_def.color_type]
274	cmp al,PNG_COLOR_TYPE_PALETTE	274	cmp al,PNG_COLOR_TYPE_PALETTE
275	jne .end_0 ;else if (..==..)	275	jne .end_0 ;else if (..==..)
276	png_error edi, 'Valid palette required for paletted images'	276	png_error edi, 'Valid palette required for paletted images'
277	.end_0:	277	.end_0:
278		278
279	if PNG_WRITE_tRNS_SUPPORTED eq 1	279	if PNG_WRITE_tRNS_SUPPORTED eq 1
280	mov eax,[esi+png_info_def.valid]	280	mov eax,[esi+png_info_def.valid]
281	and eax,PNG_INFO_tRNS	281	and eax,PNG_INFO_tRNS
282	jz .end_1 ;if (..!=0)	282	jz .end_1 ;if (..!=0)
283	if PNG_WRITE_INVERT_ALPHA_SUPPORTED eq 1	283	if PNG_WRITE_INVERT_ALPHA_SUPPORTED eq 1
284	; Invert the alpha channel (in tRNS)	284	; Invert the alpha channel (in tRNS)
285	; if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 &&	285	; if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 &&
286	; info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)	286	; info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
287	; {	287	; {
288	; int j, jend;	288	; int j, jend;
289		289
290	; jend = info_ptr->num_trans;	290	; jend = info_ptr->num_trans;
291	; if (jend > PNG_MAX_PALETTE_LENGTH)	291	; if (jend > PNG_MAX_PALETTE_LENGTH)
292	; jend = PNG_MAX_PALETTE_LENGTH;	292	; jend = PNG_MAX_PALETTE_LENGTH;
293		293
294	; for (j = 0; j	294	; for (j = 0; j
295	; info_ptr->trans_alpha[j] =	295	; info_ptr->trans_alpha[j] =
296	; (byte)(255 - info_ptr->trans_alpha[j]);	296	; (byte)(255 - info_ptr->trans_alpha[j]);
297	; }	297	; }
298	end if	298	end if
299	mov eax,esi	299	mov eax,esi
300	add eax,png_info_def.trans_color	300	add eax,png_info_def.trans_color
301	movzx ebx,word[esi+png_info_def.num_trans]	301	movzx ebx,word[esi+png_info_def.num_trans]
302	movzx ecx,byte[esi+png_info_def.color_type]	302	movzx ecx,byte[esi+png_info_def.color_type]
303	stdcall png_write_tRNS, edi, dword[esi+png_info_def.trans_alpha], eax, ebx, ecx	303	stdcall png_write_tRNS, edi, dword[esi+png_info_def.trans_alpha], eax, ebx, ecx
304	.end_1:	304	.end_1:
305	end if	305	end if
306	if PNG_WRITE_bKGD_SUPPORTED eq 1	306	if PNG_WRITE_bKGD_SUPPORTED eq 1
307	mov eax,[esi+png_info_def.valid]	307	mov eax,[esi+png_info_def.valid]
308	and eax,PNG_INFO_bKGD	308	and eax,PNG_INFO_bKGD
309	jz @f ;if (..!=0)	309	jz @f ;if (..!=0)
310	mov eax,esi	310	mov eax,esi
311	add eax,png_info_def.background	311	add eax,png_info_def.background
312	movzx ebx,byte[esi+png_info_def.color_type]	312	movzx ebx,byte[esi+png_info_def.color_type]
313	stdcall png_write_bKGD, edi, eax, ebx	313	stdcall png_write_bKGD, edi, eax, ebx
314	@@:	314	@@:
315	end if	315	end if
316		316
317	if PNG_WRITE_hIST_SUPPORTED eq 1	317	if PNG_WRITE_hIST_SUPPORTED eq 1
318	mov eax,[esi+png_info_def.valid]	318	mov eax,[esi+png_info_def.valid]
319	and eax,PNG_INFO_hIST	319	and eax,PNG_INFO_hIST
320	jz @f ;if (..!=0)	320	jz @f ;if (..!=0)
321	movzx ebx,word[esi+png_info_def.num_palette]	321	movzx ebx,word[esi+png_info_def.num_palette]
322	stdcall png_write_hIST, edi, [esi+png_info_def.hist], ebx	322	stdcall png_write_hIST, edi, [esi+png_info_def.hist], ebx
323	@@:	323	@@:
324	end if	324	end if
325		325
326	if PNG_WRITE_oFFs_SUPPORTED eq 1	326	if PNG_WRITE_oFFs_SUPPORTED eq 1
327	mov eax,[esi+png_info_def.valid]	327	mov eax,[esi+png_info_def.valid]
328	and eax,PNG_INFO_oFFs	328	and eax,PNG_INFO_oFFs
329	jz @f ;if (..!=0)	329	jz @f ;if (..!=0)
330	movzx ebx,byte[esi+png_info_def.offset_unit_type]	330	movzx ebx,byte[esi+png_info_def.offset_unit_type]
331	stdcall png_write_oFFs, edi, [esi+png_info_def.x_offset], [esi+png_info_def.y_offset], ebx	331	stdcall png_write_oFFs, edi, [esi+png_info_def.x_offset], [esi+png_info_def.y_offset], ebx
332	@@:	332	@@:
333	end if	333	end if
334		334
335	if PNG_WRITE_pCAL_SUPPORTED eq 1	335	if PNG_WRITE_pCAL_SUPPORTED eq 1
336	mov eax,[esi+png_info_def.valid]	336	mov eax,[esi+png_info_def.valid]
337	and eax,PNG_INFO_pCAL	337	and eax,PNG_INFO_pCAL
338	jz @f ;if (..!=0)	338	jz @f ;if (..!=0)
339	movzx ebx,byte[esi+png_info_def.pcal_type]	339	movzx ebx,byte[esi+png_info_def.pcal_type]
340	movzx ecx,byte[esi+png_info_def.pcal_nparams]	340	movzx ecx,byte[esi+png_info_def.pcal_nparams]
341	stdcall png_write_pCAL, edi, [esi+png_info_def.pcal_purpose], [esi+png_info_def.pcal_X0], [esi+png_info_def.pcal_X1], ebx, ecx, [esi+png_info_def.pcal_units], [esi+png_info_def.pcal_params]	341	stdcall png_write_pCAL, edi, [esi+png_info_def.pcal_purpose], [esi+png_info_def.pcal_X0], [esi+png_info_def.pcal_X1], ebx, ecx, [esi+png_info_def.pcal_units], [esi+png_info_def.pcal_params]
342	@@:	342	@@:
343	end if	343	end if
344		344
345	if PNG_WRITE_sCAL_SUPPORTED eq 1	345	if PNG_WRITE_sCAL_SUPPORTED eq 1
346	mov eax,[esi+png_info_def.valid]	346	mov eax,[esi+png_info_def.valid]
347	and eax,PNG_INFO_sCAL	347	and eax,PNG_INFO_sCAL
348	jz @f ;if (..!=0)	348	jz @f ;if (..!=0)
349	movzx ebx,byte[esi+png_info_def.scal_unit]	349	movzx ebx,byte[esi+png_info_def.scal_unit]
350	stdcall png_write_sCAL_s, edi, ebx, [esi+png_info_def.scal_s_width], [esi+png_info_def.scal_s_height]	350	stdcall png_write_sCAL_s, edi, ebx, [esi+png_info_def.scal_s_width], [esi+png_info_def.scal_s_height]
351	@@:	351	@@:
352	end if ;sCAL	352	end if ;sCAL
353		353
354	if PNG_WRITE_pHYs_SUPPORTED eq 1	354	if PNG_WRITE_pHYs_SUPPORTED eq 1
355	mov eax,[esi+png_info_def.valid]	355	mov eax,[esi+png_info_def.valid]
356	and eax,PNG_INFO_pHYs	356	and eax,PNG_INFO_pHYs
357	jz @f ;if (..!=0)	357	jz @f ;if (..!=0)
358	movzx ebx,byte[esi+png_info_def.phys_unit_type]	358	movzx ebx,byte[esi+png_info_def.phys_unit_type]
359	stdcall png_write_pHYs, edi, [esi+png_info_def.x_pixels_per_unit], [esi+png_info_def.y_pixels_per_unit], ebx	359	stdcall png_write_pHYs, edi, [esi+png_info_def.x_pixels_per_unit], [esi+png_info_def.y_pixels_per_unit], ebx
360	@@:	360	@@:
361	end if ;pHYs	361	end if ;pHYs
362		362
363	if PNG_WRITE_tIME_SUPPORTED eq 1	363	if PNG_WRITE_tIME_SUPPORTED eq 1
364	mov eax,[esi+png_info_def.valid]	364	mov eax,[esi+png_info_def.valid]
365	and eax,PNG_INFO_tIME	365	and eax,PNG_INFO_tIME
366	jz @f ;if (..!=0)	366	jz @f ;if (..!=0)
367	mov eax,esi	367	mov eax,esi
368	add eax,png_info_def.mod_time	368	add eax,png_info_def.mod_time
369	stdcall png_write_tIME, edi, eax	369	stdcall png_write_tIME, edi, eax
370	or [edi+png_struct.mode],PNG_WROTE_tIME	370	or [edi+png_struct.mode],PNG_WROTE_tIME
371	@@:	371	@@:
372	end if ;tIME	372	end if ;tIME
373		373
374	if PNG_WRITE_sPLT_SUPPORTED eq 1	374	if PNG_WRITE_sPLT_SUPPORTED eq 1
375	mov eax,[esi+png_info_def.valid]	375	mov eax,[esi+png_info_def.valid]
376	and eax,PNG_INFO_sPLT	376	and eax,PNG_INFO_sPLT
377	jz @f ;if (..!=0)	377	jz @f ;if (..!=0)
378	mov eax,[esi+png_info_def.splt_palettes]	378	mov eax,[esi+png_info_def.splt_palettes]
379	mov ecx,[esi+png_info_def.splt_palettes_num]	379	mov ecx,[esi+png_info_def.splt_palettes_num]
380	cmp ecx,1	380	cmp ecx,1
381	jl @f	381	jl @f
382	.cycle0:	382	.cycle0:
383	stdcall png_write_sPLT, edi, eax	383	stdcall png_write_sPLT, edi, eax
384	add eax,4	384	add eax,4
385	loop .cycle0	385	loop .cycle0
386	@@:	386	@@:
387	end if ;sPLT	387	end if ;sPLT
388		388
389	if PNG_WRITE_TEXT_SUPPORTED eq 1	389	if PNG_WRITE_TEXT_SUPPORTED eq 1
390	; Check to see if we need to write text chunks	390	; Check to see if we need to write text chunks
391	; for (i = 0; i < info_ptr->num_text; i++)	391	; for (i = 0; i < info_ptr->num_text; i++)
392	; {	392	; {
393	; png_debug2(2, "Writing header text chunk %d, type %d", i,	393	; png_debug2(2, "Writing header text chunk %d, type %d", i,
394	; info_ptr->text[i].compression);	394	; info_ptr->text[i].compression);
395	; An internationalized chunk?	395	; An internationalized chunk?
396	; if (info_ptr->text[i].compression > 0)	396	; if (info_ptr->text[i].compression > 0)
397	; {	397	; {
398	if PNG_WRITE_iTXt_SUPPORTED eq 1	398	if PNG_WRITE_iTXt_SUPPORTED eq 1
399	; Write international chunk	399	; Write international chunk
400	; png_write_iTXt(png_ptr,	400	; png_write_iTXt(png_ptr,
401	; info_ptr->text[i].compression,	401	; info_ptr->text[i].compression,
402	; info_ptr->text[i].key,	402	; info_ptr->text[i].key,
403	; info_ptr->text[i].lang,	403	; info_ptr->text[i].lang,
404	; info_ptr->text[i].lang_key,	404	; info_ptr->text[i].lang_key,
405	; info_ptr->text[i].text);	405	; info_ptr->text[i].text);
406	; Mark this chunk as written	406	; Mark this chunk as written
407	; if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)	407	; if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
408	; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;	408	; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
409	; else	409	; else
410	; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;	410	; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
411	else	411	else
412	png_warning edi, 'Unable to write international text'	412	png_warning edi, 'Unable to write international text'
413	end if	413	end if
414	; }	414	; }
415		415
416	; If we want a compressed text chunk	416	; If we want a compressed text chunk
417	; else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)	417	; else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
418	; {	418	; {
419	if PNG_WRITE_zTXt_SUPPORTED eq 1	419	if PNG_WRITE_zTXt_SUPPORTED eq 1
420	; Write compressed chunk	420	; Write compressed chunk
421	; png_write_zTXt(png_ptr, info_ptr->text[i].key,	421	; png_write_zTXt(png_ptr, info_ptr->text[i].key,
422	; info_ptr->text[i].text, info_ptr->text[i].compression);	422	; info_ptr->text[i].text, info_ptr->text[i].compression);
423	; Mark this chunk as written	423	; Mark this chunk as written
424	; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;	424	; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
425	else	425	else
426	png_warning edi, 'Unable to write compressed text'	426	png_warning edi, 'Unable to write compressed text'
427	end if	427	end if
428	; }	428	; }
429		429
430	; else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)	430	; else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
431	; {	431	; {
432	if PNG_WRITE_tEXt_SUPPORTED eq 1	432	if PNG_WRITE_tEXt_SUPPORTED eq 1
433	; Write uncompressed chunk	433	; Write uncompressed chunk
434	; png_write_tEXt(png_ptr, info_ptr->text[i].key,	434	; png_write_tEXt(png_ptr, info_ptr->text[i].key,
435	; info_ptr->text[i].text,	435	; info_ptr->text[i].text,
436	; 0);	436	; 0);
437	; Mark this chunk as written	437	; Mark this chunk as written
438	; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;	438	; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
439	else	439	else
440	; Can't get here	440	; Can't get here
441	png_warning edi, 'Unable to write uncompressed text'	441	png_warning edi, 'Unable to write uncompressed text'
442	end if	442	end if
443	; }	443	; }
444	; }	444	; }
445	end if ;tEXt	445	end if ;tEXt
446		446
447	if PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED eq 1	447	if PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED eq 1
448	stdcall write_unknown_chunks, edi, esi, PNG_HAVE_PLTE	448	stdcall write_unknown_chunks, edi, esi, PNG_HAVE_PLTE
449	end if	449	end if
450	.end_f:	450	.end_f:
451	popad	451	popad
452	ret	452	ret
453	endp	453	endp
454		454
455	; Writes the end of the PNG file. If you don't want to write comments or	455	; Writes the end of the PNG file. If you don't want to write comments or
456	; time information, you can pass NULL for info. If you already wrote these	456	; time information, you can pass NULL for info. If you already wrote these
457	; in png_write_info(), do not write them again here. If you have long	457	; in png_write_info(), do not write them again here. If you have long
458	; comments, I suggest writing them here, and compressing them.	458	; comments, I suggest writing them here, and compressing them.
459		459
460	;void (png_structrp png_ptr, png_inforp info_ptr)	460	;void (png_structrp png_ptr, png_inforp info_ptr)
461	align 4	461	align 4
462	proc png_write_end, png_ptr:dword, info_ptr:dword	462	proc png_write_end, png_ptr:dword, info_ptr:dword
463	pushad	463	pushad
464	png_debug 1, 'in png_write_end'	464	png_debug 1, 'in png_write_end'
465		465
466	mov edi,[png_ptr]	466	mov edi,[png_ptr]
467	cmp edi,0	467	cmp edi,0
468	je .end_f ;if (..==0) return	468	je .end_f ;if (..==0) return
469		469
470	mov eax,[edi+png_struct.mode]	470	mov eax,[edi+png_struct.mode]
471	and eax,PNG_HAVE_IDAT	471	and eax,PNG_HAVE_IDAT
472	jnz @f ;if (..==0)	472	jnz @f ;if (..==0)
473	png_error edi, 'No IDATs written into file'	473	png_error edi, 'No IDATs written into file'
474	@@:	474	@@:
475		475
476	if PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED eq 1	476	if PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED eq 1
477	mov eax,[edi+png_struct.num_palette_max]	477	mov eax,[edi+png_struct.num_palette_max]
478	cmp ax,[edi+png_struct.num_palette]	478	cmp ax,[edi+png_struct.num_palette]
479	jle @f ;if (..>..)	479	jle @f ;if (..>..)
480	png_benign_error edi, 'Wrote palette index exceeding num_palette'	480	png_benign_error edi, 'Wrote palette index exceeding num_palette'
481	@@:	481	@@:
482	end if	482	end if
483		483
484	; See if user wants us to write information chunks	484	; See if user wants us to write information chunks
485	mov esi,[info_ptr]	485	mov esi,[info_ptr]
486	cmp esi,0	486	cmp esi,0
487	je .end0 ;if (..!=0)	487	je .end0 ;if (..!=0)
488	if PNG_WRITE_TEXT_SUPPORTED eq 1	488	if PNG_WRITE_TEXT_SUPPORTED eq 1
489	; int i; /* local index variable */	489	; int i; /* local index variable */
490	end if	490	end if
491	if PNG_WRITE_tIME_SUPPORTED eq 1	491	if PNG_WRITE_tIME_SUPPORTED eq 1
492	; Check to see if user has supplied a time chunk	492	; Check to see if user has supplied a time chunk
493	mov eax,[esi+png_info_def.valid]	493	mov eax,[esi+png_info_def.valid]
494	and eax,PNG_INFO_tIME	494	and eax,PNG_INFO_tIME
495	jz @f	495	jz @f
496	mov eax,[edi+png_struct.mode]	496	mov eax,[edi+png_struct.mode]
497	and eax,PNG_WROTE_tIME	497	and eax,PNG_WROTE_tIME
498	jnz @f ;if (..!=0 && ..==0)	498	jnz @f ;if (..!=0 && ..==0)
499	mov eax,esi	499	mov eax,esi
500	add eax,png_info_def.mod_time	500	add eax,png_info_def.mod_time

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/libs-dev/libimg/png/libpng/pngwrite.asm – Rev 6870 → 6873