Subversion Repositories Kolibri OS

; Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson

; (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

; (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

; For conditions of distribution and use, see the disclaimer

; and license in png.inc

;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

		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.

			mov eax,ecx

			add eax,png_unknown_chunk.name

			stdcall png_handle_as_unknown, edi, eax

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

			; stop the writing of all unsafe-to-copy chunks!

			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

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

align 4

proc png_write_info_before_PLTE, png_ptr:dword, info_ptr:dword

	png_debug 1, 'in png_write_info_before_PLTE'

	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 eax,PNG_WROTE_INFO_BEFORE_PLTE

	jnz .end_f ;if (..==0)

		stdcall png_write_sig, edi

		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

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

; flag set, and if it does, writes the chunk.

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

; 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_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

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

	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

	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

	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_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

		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

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'

	cmp edi,0

	je .end_f

	mov esi,[info_ptr]

	cmp esi,0

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

	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:

	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;

;         if (jend > PNG_MAX_PALETTE_LENGTH)

;            jend = PNG_MAX_PALETTE_LENGTH;

;            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

	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

	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

	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

	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

	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

	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

	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

	; 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

;      }

;      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

;      }

;      {

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

	stdcall write_unknown_chunks, edi, esi, PNG_HAVE_PLTE

end if

	.end_f:

popad

	ret

endp

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

align 4

proc png_write_end, png_ptr:dword, info_ptr:dword

pushad

	png_debug 1, 'in png_write_end'

	cmp edi,0

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

	and eax,PNG_HAVE_IDAT

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

		png_error edi, 'No IDATs written into file'

	@@:

	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

	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

		@@:

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++)

;             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:

			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:

	stdcall png_write_IEND, edi

; 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_AFTER_IEND_SUPPORTED eq 1

	stdcall png_flush, edi

end if

end if

.end_f:

popad

	ret

endp

align 4

proc png_convert_from_struct_tm, ptime:dword, ttime:dword

	png_debug 1, 'in png_convert_from_struct_tm'

;   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

align 4

proc png_convert_from_time_t, ptime:dword, ttime:dword

;   struct tm *tbuf;

;   png_convert_from_struct_tm(ptime, tbuf);

	ret

endp

;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

	test eax,eax

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

		; Set the zlib control values to defaults; they can be overridden by the

		; application after the struct has been created.

		; pngwutil.asm defaults it according to whether or not filters will be

		; used, and ignores this setting.

		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

		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!

		; In stable builds only warn if an application error can be completely

		; handled.

end if

		; App warnings are warnings in release (or release candidate) builds but

		; are errors during development.

		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.

	.end0:

	ret

endp

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

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'

	cmp edi,0

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

	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

; if you are writing an interlaced 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

	; Initialize interlace handling.  If image is not interlaced,

	; this will set pass to 1

	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

;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'

	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;

			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:

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:

		cmp byte[ebx+png_row_info.bit_depth],16 ;else if (..==16)

		jne .end1

;         bytep rp;

;         uint_32 i;

			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:

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

;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_ptr->row_number, png_ptr->pass);

png_debug1 1, 'in png_write_row (row %u)',[edi+png_struct.row_number]

	cmp dword[edi+png_struct.row_number],0

	jne .end0

	cmp byte[edi+png_struct.pass],0

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

	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'

	@@:

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

	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

	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

	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

	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

	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

	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

	.end0:

	; 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

	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

	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

	push edi

	mov edi,[edi+png_struct.row_buf]

	inc edi

	mov esi,[row]

	mov ecx,eax

	rep movsb ;memcpy(...

	pop edi

	; 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

	; Handle other transformations

	cmp dword[edi+png_struct.transformations],0

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

		stdcall png_do_write_transformations, edi, ebx

	@@:

end if

	; which is also the output 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:

	; 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

	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

	@@: