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


;;================================================================================================;;
;;//// png.asm //// (c) diamond, 2009 ////////////////////////////////////////////////////////////;;
;;================================================================================================;;
;;                                                                                                ;;
;; This file is part of Common development libraries (Libs-Dev).                                  ;;
;;                                                                                                ;;
;; Libs-Dev is free software: you can redistribute it and/or modify it under the terms of the GNU ;;
;; Lesser General Public License as published by the Free Software Foundation, either version 2.1 ;;
;; of the License, or (at your option) any later version.                                         ;;
;;                                                                                                ;;
;; Libs-Dev is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without  ;;
;; even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU  ;;
;; Lesser General Public License for more details.                                                ;;
;;                                                                                                ;;
;; You should have received a copy of the GNU Lesser General Public License along with Libs-Dev.  ;;
;; If not, see .                                                    ;;
;;                                                                                                ;;
;;================================================================================================;;
 
include 'libpng/png.asm'
 
;;================================================================================================;;
;;proc img.is.png _data, _length ;////////////////////////////////////////////////////////////////;;
img.is.png:
;;------------------------------------------------------------------------------------------------;;
;? Determine if raw data could be decoded (is in PNG format)                                      ;;
;;------------------------------------------------------------------------------------------------;;
;> _data = raw data as read from file/stream                                                      ;;
;> _length = data length                                                                          ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = false / true                                                                             ;;
;;================================================================================================;;
; test 1 (length of data)
	cmp	dword [esp+8], 8
	jb	.nope
; test 2: signature
	mov	eax, [esp+4]
	cmp	dword [eax], 0x474E5089
	jne	.nope
	cmp	dword [eax+4], 0x0A1A0A0D
	je	.yep
 
  .nope:
	xor	eax, eax
	ret	8
 
  .yep:
	xor	eax, eax
	inc	eax
	ret	8
;endp
 
;;================================================================================================;;
;;proc img.decode.png _data, _length, _options ;//////////////////////////////////////////////////;;
img.decode.png:
	xor	eax, eax	; .image = 0
	pushad
	mov	ebp, esp
.localsize = 29*4
virtual at ebp - .localsize
.width		dd	?
.height		dd	?
.bit_depth	dd	?
.color_type	dd	?
.bytes_per_pixel dd	?
.scanline_len	dd	?
.bits_per_pixel dd	?
.size_rest	dd	?
.cur_chunk_ptr	dd	?
.cur_chunk_size	dd	?
.allocated	dd	?
.paeth_a	dd	?
.paeth_b	dd	?
.paeth_c	dd	?
.paeth_pa	dd	?
.paeth_pb	dd	?
.paeth_pc	dd	?
.i		dd	?
.j		dd	?
; variables to handle interlace
.row_distance	dd	?	; diff between two consecutives rows in destination
.col_distance	dd	?	; summand for moving to next row in source
.row_increment	dd	?
.col_increment	dd	?
.block_height	dd	?
.block_width	dd	?
.interlace	db	?	; 0 if not interlaced, 1 if interlaced
.row_increment_shift db	?
.col_increment_shift db	?
.shift		db	?	; shift for current src byte
.starting_row	dd	?
.starting_col	dd	?
.idat_read	dd	?
	rb	1Ch
.image		dd	?
	rd	1
.data		dd	?
.length		dd	?
.options	dd	?
end virtual
	push	eax	; .idat_read = 0
	push	eax	; .starting_col = 0
	push	eax	; .starting_row = 0
	push	eax	; .col_increment_shift, .row_increment_shift
	inc	eax
	push	eax	; .block_width
	push	eax	; .block_height
	push	eax	; .col_increment
	push	eax	; .row_increment
	sub	esp, .localsize-32
; load deflate unpacker, if not yet
; acquire mutex
@@:
	push	1
	pop	eax
	xchg	[deflate_loader_mutex], eax	; 'xchg' has an implicit 'lock' prefix
	test	eax, eax
	jz	@f
	mcall	5, 1
	jmp	@b
@@:
	cmp	[deflate_unpack2], __deflate_unpack2_import_name__
	jnz	.deflate_loaded
; do loading
	invoke	dll.load, @IMPORT
	test	eax, eax
	jz	.deflate_loaded
	add	esp, .localsize
	popad
	mov	[deflate_loader_mutex], eax
	ret	12
.deflate_loaded:
; release mutex
	mov	[deflate_loader_mutex], 0
; ok, continue
	mov	esi, [.data]		; esi -> data
	mov	ecx, [.length]		; ecx = length
; the signature has been already checked in img.is.png
	lodsd
	lodsd
	sub	ecx, 8
	xor	ebx, ebx	; no image allocated
.chunks_loop:
	sub	ecx, 12
	jc	.eof
	lodsd	; chunk length
	bswap	eax
	sub	ecx, eax
	jc	.eof
	push	ecx	; save length of data rest
	xchg	eax, ecx	; ecx = size of data in the chunk
	lodsd	; chunk type
	cmp	eax, 'IHDR'
	jz	.ihdr
	cmp	eax, 'IDAT'
	jz	.idat
	cmp	eax, 'IEND'
	jz	.iend
	cmp	eax, 'PLTE'
	jz	.palette
; unrecognized chunk, ignore
	lea	esi, [esi+ecx+4]
	pop	ecx
	jmp	.chunks_loop
; IHDR chunk
.ihdr:
	cmp	ecx, 13
	jnz	.invalid_chunk
	cmp	[.image], 0
	jnz	.invalid_chunk
; read image characteristics
	lodsd
	bswap	eax
	mov	[.width], eax
	lodsd
	bswap	eax
	mov	[.height], eax
	xor	eax, eax
	lea	ebx, [eax+1]
	lodsb
	cmp	al, 16
	ja	.invalid_chunk
	test	al, al
	jz	.invalid_chunk
	lea	edx, [eax-1]
	test	al, dl
	jnz	.invalid_chunk
	mov	[.bit_depth], eax
	lodsb
	test	al, not 7
	jnz	.invalid_chunk
	mov	[.color_type], eax
	lodsb
	test	al, al
	jnz	.invalid_chunk	; only compression method 0 is defined
	lodsb
	test	al, al
	jnz	.invalid_chunk	; only filtering method 0 is defined
	lodsb
	cmp	al, 1
	ja	.invalid_chunk	; only interlacing methods 0 and 1 are defined
	mov	[.interlace], al
; check for correctness and calculate bytes_per_pixel and scanline_len
	mov	eax, [.bit_depth]
	mov	edx, [.color_type]
	dec	edx
	js	.grayscale1
	dec	edx
	jz	.rgb1
	dec	edx
	jz	.palette1
	dec	edx
	jz	.grayscale_alpha1
	dec	edx
	dec	edx
	jnz	.invalid_chunk
.rgb_alpha1:
	inc	ebx
.rgb1:
	inc	ebx
.grayscale_alpha1:
	inc	ebx
	cmp	al, 8
	jb	.invalid_chunk
	jmp	@f
.palette1:
	cmp	al, 8
	ja	.invalid_chunk
.grayscale1:
@@:
	mul	ebx
	mov	[.bits_per_pixel], eax
	add	eax, 7
	shr	eax, 3
	mov	[.bytes_per_pixel], eax
; allocate image
	push	Image.bpp24
	pop	eax
	cmp	[.color_type], 2
	jz	@f
	mov	al, Image.bpp32
	cmp	[.color_type], 6
	jz	@f
	mov	al, Image.bpp8i
@@:
	stdcall	img.create, [.width], [.height], eax
	test	eax, eax
	jz	.invalid_chunk
	mov	[.image], eax
	jmp	.next_chunk
.invalid_chunk:
.iend:
	pop	ecx
.eof:
	add	esp, .localsize
	popad
	ret	12
; PLTE chunk
.palette:
	mov	eax, [.image]
	test	eax, eax
	jz	.invalid_chunk
	cmp	[.color_type], 3
	jz	.copy_palette
.ignore_chunk:
	add	esi, ecx
.next_chunk:
	lodsd
	pop	ecx
	jmp	.chunks_loop
.copy_palette:
	mov	edi, [eax + Image.Palette]
	xor	eax, eax
	cmp	ecx, 256*3
	ja	.next_chunk
@@:
	sub	ecx, 3
	jz	@f
	js	.invalid_chunk
	lodsd
	dec	esi
	bswap	eax
	shr	eax, 8
	stosd
	jmp	@b
@@:
	lodsd
	dec	esi
	bswap	eax
	shr	eax, 8
	stosd
	jmp	.next_chunk
.idat:
	jecxz	.next_chunk
	cmp	[.idat_read], 0
	jnz	@f
	lodsb
	inc	[.idat_read]
	and	al, 0xF
	cmp	al, 8
	jnz	.invalid_chunk
	dec	ecx
	jz	.next_chunk
@@:
	cmp	[.idat_read], 1
	jnz	@f
	lodsb
	inc	[.idat_read]
	test	al, 20h
	jnz	.invalid_chunk
	dec	ecx
	jz	.next_chunk
@@:
	mov	[.cur_chunk_ptr], esi
	mov	[.cur_chunk_size], ecx
	pop	[.length]
	push	eax
	push	esp
	push	ebp
	push	.deflate_callback
	call	[deflate_unpack2]
	pop	ecx
	test	eax, eax
	jz	.invalid_chunk
; convert PNG unpacked data to RAW data
	mov	esi, eax
	mov	[.allocated], eax
	mov	[.size_rest], ecx
; unfilter and deinterlace
; .interlace_pass, .starting_row and .starting_col have been already set to 0
; .block_width, .block_height, .col_increment, .row_increment were set
; to values for non-interlaced images; correct if necessary
	cmp	[.interlace], 0
	jz	.deinterlace_loop
	push	8
	pop	eax
	mov	[.row_increment], eax
	mov	[.col_increment], eax
	mov	[.block_height], eax
	mov	[.block_width], eax
	mov	[.row_increment_shift], 3
	mov	[.col_increment_shift], 3
.deinterlace_loop:
	mov	edx, [.height]
	cmp	edx, [.starting_row]
	jbe	.deinterlace_next
	mov	ebx, [.width]
	sub	ebx, [.starting_col]
	jbe	.deinterlace_next
	mov	cl, [.col_increment_shift]
	add	ebx, [.col_increment]
	dec	ebx
	shr	ebx, cl
	mov	eax, [.bits_per_pixel]
	imul	eax, ebx
	add	eax, 7
	shr	eax, 3
	mov	[.scanline_len], eax
	shl	ebx, cl
	mov	[.col_distance], ebx
; Unfilter
	mov	ecx, [.size_rest]
	push	esi
.unfilter_loop_e:
	mov	ebx, [.scanline_len]
	sub	ecx, 1
	jc	.unfilter_abort
	sub	ecx, ebx
	jc	.unfilter_abort
	movzx	eax, byte [esi]
	add	esi, 1
	cmp	eax, 4
	ja	.next_scanline
	jmp	dword [@f + eax*4]
align 4
@@:
	dd	.unfilter_none
	dd	.unfilter_sub
	dd	.unfilter_up
	dd	.unfilter_average
	dd	.unfilter_paeth
.unfilter_sub:
	mov	edi, [.bytes_per_pixel]
	add	esi, edi
	sub	ebx, edi
	jbe	.next_scanline
	neg	edi
@@:
	mov	al, [esi+edi]
	add	[esi], al
	add	esi, 1
	sub	ebx, 1
	jnz	@b
	jmp	.next_scanline
.unfilter_up:
	cmp	edx, [.height]
	jz	.unfilter_none
	lea	edi, [ebx+1]
	neg	edi
@@:
	mov	al, [esi+edi]
	add	[esi], al
	add	esi, 1
	sub	ebx, 1
	jnz	@b
	jmp	.next_scanline
.unfilter_average:
	mov	edi, [.bytes_per_pixel]
	cmp	edx, [.height]
	jz	.unfilter_average_firstline
	push	edx
	lea	edx, [ebx+1]
	neg	edx
	sub	ebx, edi
@@:
	mov	al, [esi+edx]
	shr	al, 1
	add	[esi], al
	add	esi, 1
	sub	edi, 1
	jnz	@b
	mov	edi, [.bytes_per_pixel]
	neg	edi
	test	ebx, ebx
	jz	.unfilter_average_done
@@:
	mov	al, [esi+edx]
	add	al, [esi+edi]
	rcr	al, 1
	add	[esi], al
	add	esi, 1
	sub	ebx, 1
	jnz	@b
.unfilter_average_done:
	pop	edx
	jmp	.next_scanline
.unfilter_average_firstline:
	mov	edi, [.bytes_per_pixel]
	add	esi, edi
	sub	ebx, edi
	jbe	.next_scanline
	neg	edi
@@:
	mov	al, [esi+edi]
	shr	al, 1
	add	[esi], al
	add	esi, 1
	sub	ebx, 1
	jnz	@b
	jmp	.unfilter_none
.unfilter_paeth:
	cmp	edx, [.height]
	jz	.unfilter_sub
	push	edx
	lea	edx, [ebx+1]
	mov	edi, [.bytes_per_pixel]
	neg	edx
	sub	ebx, edi
@@:
	mov	al, [esi+edx]
	add	[esi], al
	add	esi, 1
	sub	edi, 1
	jnz	@b
	mov	edi, [.bytes_per_pixel]
	neg	edi
	test	ebx, ebx
	jz	.unfilter_paeth_done
	push	ecx
@@:
	push	ebx
; PaethPredictor(Raw(x-bpp) = a, Prior(x) = b, Prior(x-bpp) = c)
	movzx	eax, byte [esi+edi]
	mov	[.paeth_a], eax
	movzx	ecx, byte [esi+edx]
	add	edi, edx
	mov	[.paeth_b], ecx
	add	ecx, eax
	movzx	eax, byte [esi+edi]
	mov	[.paeth_c], eax
	sub	ecx, eax	; ecx = a + b - c = p
; calculate pa = abs(p-a), pb = abs(p-b), pc = abs(p-c)
	mov	ebx, ecx
	sub	ebx, eax	; ebx = p - c
	cmp	ebx, 80000000h
	sbb	eax, eax	; eax = (p < c) ? 0 : 0xFFFFFFF
	not	eax		; eax = (p < c) ? 0xFFFFFFFF : 0
	and	eax, ebx	; eax = (p < c) ? p - c : 0
	sub	ebx, eax
	sub	ebx, eax	; ebx = abs(p-c)
	mov	[.paeth_pc], ebx
	mov	ebx, ecx
	sub	ebx, [.paeth_a]
	cmp	ebx, 80000000h
	sbb	eax, eax
	not	eax
	and	eax, ebx
	sub	ebx, eax
	sub	ebx, eax
	mov	[.paeth_pa], ebx
	mov	ebx, ecx
	sub	ebx, [.paeth_b]
	cmp	ebx, 80000000h
	sbb	eax, eax
	not	eax
	and	eax, ebx
	sub	ebx, eax
	sub	ebx, eax
	;mov	[.paeth_pb], ebx
; select closest value
	push	edx
	mov	edx, [.paeth_b]
	sub	edx, [.paeth_a]
	sub	ebx, [.paeth_pa]
	sbb	ecx, ecx	; ecx = (pa > pb) ? 0xFFFFFFFF : 0
	sbb	eax, eax	; eax = (pa > pb) ? 0xFFFFFFFF : 0
	and	ecx, ebx	; ecx = (pa > pb) ? pb - pa : 0
	and	eax, edx	; eax = (pa > pb) ? b - a : 0
	add	ecx, [.paeth_pa]	; ecx = (pa > pb) ? pb : pa = min(pa,pb)
	add	eax, [.paeth_a]		; eax = (pa > pb) ? b : a
	mov	edx, [.paeth_c]
	sub	edx, eax
	sub	[.paeth_pc], ecx
	sbb	ebx, ebx	; ebx = (min(pa,pb) <= pc) ? 0 : 0xFFFFFFFF
	and	ebx, edx	; ebx = (min(pa,pb) <= pc) ? 0 : c - eax
	add	eax, ebx
	pop	edx
	add	[esi], al
	pop	ebx
	sub	edi, edx
	add	esi, 1
	sub	ebx, 1
	jnz	@b
	pop	ecx
.unfilter_paeth_done:
	pop	edx
	jmp	.next_scanline
.unfilter_none:
	add	esi, ebx
.next_scanline:
	sub	edx, [.row_increment]
	jc	.unfilter_done
	cmp	edx, [.starting_row]
	jbe	.unfilter_done
	jmp	.unfilter_loop_e
.unfilter_abort:
	xor	ecx, ecx
.unfilter_done:
; unfiltering done, now convert to raw data
; with deinterlacing if needed
	pop	esi
	mov	ebx, [.image]
	mov	eax, [.width]
	call	img._.get_scanline_len
	mov	[.row_distance], eax
	mov	eax, [.row_increment]
	mul	[.width]
	sub	eax, [.col_distance]
	call	img._.get_scanline_len
	mov	[.col_distance], eax
	mov	edi, [ebx + Image.Data]
	mov	eax, [.starting_row]
	mul	[.width]
	add	eax, [.starting_col]
	call	img._.get_scanline_len
	add	edi, eax
	mov	eax, ebx
	mov	ebx, [.size_rest]
	mov	[.size_rest], ecx
	mov	edx, [.height]
	sub	edx, [.starting_row]
	mov	[.j], edx
	cmp	[.color_type], 0
	jz	.grayscale2
	cmp	[.color_type], 2
	jz	.rgb2
	cmp	[.color_type], 3
	jz	.palette2
	cmp	[.color_type], 4
	jz	.grayscale_alpha2
.rgb_alpha2:
	cmp	[.bit_depth], 16
	jz	.rgb_alpha2_16bit
.rgb_alpha2.next:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
.rgb_alpha2.extloop:
 
macro init_block
{
	push	ebx
	mov	eax, [.col_increment]
	mov	edx, [.j]
	cmp	edx, [.block_height]
	jb	@f
	mov	edx, [.block_height]
@@:
	mov	ebx, [.i]
	cmp	ebx, [.block_width]
	jb	@f
	mov	ebx, [.block_width]
@@:
}
 
	init_block
	lea	eax, [edi+eax*4]
	push	eax
.rgb_alpha2.innloop1:
	push	edi
	mov	ecx, ebx
.rgb_alpha2.innloop2:
	mov	al, [esi+2]
	mov	[edi], al
	mov	al, [esi+1]
	mov	[edi+1], al
	mov	al, [esi]
	mov	[edi+2], al
	mov	al, [esi+3]
	mov	[edi+3], al
	add	edi, 4
	dec	ecx
	jnz	.rgb_alpha2.innloop2
	pop	edi
	add	edi, [.row_distance]
	dec	edx
	jnz	.rgb_alpha2.innloop1
	pop	edi ebx
	add	esi, 4
	mov	eax, [.col_increment]
	sub	[.i], eax
	ja	.rgb_alpha2.extloop
	add	edi, [.col_distance]
	mov	eax, [.row_increment]
	sub	[.j], eax
	ja	.rgb_alpha2.next
	jmp	.convert_done
.rgb_alpha2_16bit:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
.rgb_alpha2_16bit.loop:
	init_block
	lea	eax, [edi+eax*4]
	push	eax
 
; convert 16 bit sample to 8 bit sample
macro convert_16_to_8
{
local .l1,.l2
	xor	ah, 0x80
	js	.l1
	cmp	al, ah
	adc	al, 0
	jmp	.l2
.l1:
	cmp	ah, al
	sbb	al, 0
.l2:
}
 
.rgb_alpha2_16bit.innloop1:
	push	edi
	mov	ecx, ebx
.rgb_alpha2_16bit.innloop2:
	mov	ax, [esi+4]
	convert_16_to_8
	mov	[edi], al
	mov	ax, [esi+2]
	convert_16_to_8
	mov	[edi+1], al
	mov	ax, [esi]
	convert_16_to_8
	mov	[edi+2], al
	;mov	ax, [esi+6]
	;convert_16_to_8
	;mov	[edi+3], al
	add	edi, 4
	dec	ecx
	jnz	.rgb_alpha2_16bit.innloop2
	pop	edi
	add	edi, [.row_distance]
	dec	edx
	jnz	.rgb_alpha2_16bit.innloop1
	pop	edi ebx
	add	esi, 8
	mov	eax, [.col_increment]
	sub	[.i], eax
	ja	.rgb_alpha2_16bit.loop
	add	edi, [.col_distance]
	mov	eax, [.row_increment]
	sub	[.j], eax
	ja	.rgb_alpha2_16bit
	jmp	.convert_done
.grayscale2:
	call	.create_grayscale_palette
	cmp	[.bit_depth], 16
	jz	.grayscale2_16bit
.palette2:
	cmp	[.bit_depth], 1
	jz	.palette2_1bit
	cmp	[.bit_depth], 2
	jz	.palette2_2bit
	cmp	[.bit_depth], 4
	jz	.palette2_4bit
.palette2_8bit:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
.palette2_8bit.extloop:
	init_block
	add	eax, edi
	push	eax
	mov	al, [esi]
	inc	esi
macro block_byte_innerloop extloop
{
local .l1
.l1:
	mov	ecx, ebx
	rep	stosb
	sub	edi, ebx
	add	edi, [.row_distance]
	dec	edx
	jnz	.l1
	pop	edi ebx
	mov	eax, [.col_increment]
	sub	[.i], eax
	ja	extloop
	add	edi, [.col_distance]
	mov	eax, [.row_increment]
	sub	[.j], eax
}
	block_byte_innerloop .palette2_8bit.extloop
	ja	.palette2_8bit
	jmp	.convert_done
.palette2_4bit:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
	mov	[.shift], 0
.palette2_4bit.extloop:
	init_block
	add	eax, edi
	push	eax
	xor	[.shift], 1
	jz	.palette2_4bit.shifted
	mov	al, [esi]
	inc	esi
	shr	al, 4
	jmp	@f
.palette2_4bit.shifted:
	mov	al, [esi-1]
	and	al, 0xF
@@:
	block_byte_innerloop .palette2_4bit.extloop
	ja	.palette2_4bit
	jmp	.convert_done
.palette2_2bit:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
	mov	[.shift], 0
.palette2_2bit.extloop:
	init_block
	add	eax, edi
	push	eax
	mov	cl, [.shift]
	sub	cl, 2
	jns	.palette2_2bit.shifted
	mov	cl, 6
	mov	al, [esi]
	inc	esi
	shr	al, cl
	jmp	@f
.palette2_2bit.shifted:
	mov	al, [esi-1]
	shr	al, cl
	and	al, 3
@@:
	mov	[.shift], cl
	block_byte_innerloop .palette2_2bit.extloop
	ja	.palette2_2bit
	jmp	.convert_done
.palette2_1bit:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
	mov	[.shift], 0
.palette2_1bit.extloop:
	init_block
	add	eax, edi
	push	eax
	mov	cl, [.shift]
	dec	cl
	jns	.palette2_1bit.shifted
	mov	cl, 7
	mov	al, [esi]
	inc	esi
	shr	al, cl
	jmp	@f
.palette2_1bit.shifted:
	mov	al, [esi-1]
	shr	al, cl
	and	al, 1
@@:
	mov	[.shift], cl
	block_byte_innerloop .palette2_1bit.extloop
	ja	.palette2_1bit
	jmp	.convert_done
.grayscale2_16bit:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
.grayscale2_16bit.extloop:
	init_block
	add	eax, edi
	push	eax
	mov	ax, [esi]
	add	esi, 2
	convert_16_to_8
	block_byte_innerloop .grayscale2_16bit.extloop
	ja	.grayscale2_16bit
	jmp	.convert_done
.rgb2:
	cmp	[.bit_depth], 16
	jz	.rgb2_16bit
.rgb2.next:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
.rgb2.extloop:
	init_block
	lea	eax, [eax*3]
	add	eax, edi
	push	eax
.rgb2.innloop1:
	push	edi
	mov	ecx, ebx
.rgb2.innloop2:
	mov	al, [esi+2]
	mov	[edi], al
	mov	al, [esi+1]
	mov	[edi+1], al
	mov	al, [esi]
	mov	[edi+2], al
	add	edi, 3
	dec	ecx
	jnz	.rgb2.innloop2
	pop	edi
	add	edi, [.row_distance]
	dec	edx
	jnz	.rgb2.innloop1
	pop	edi ebx
	add	esi, 3
	mov	eax, [.col_increment]
	sub	[.i], eax
	ja	.rgb2.extloop
	add	edi, [.col_distance]
	mov	eax, [.row_increment]
	sub	[.j], eax
	ja	.rgb2.next
	jmp	.convert_done
.rgb2_16bit:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
.rgb2_16bit.extloop:
	init_block
	lea	eax, [eax*3]
	add	eax, edi
	push	eax
.rgb2_16bit.innloop1:
	push	edi
	mov	ecx, ebx
.rgb2_16bit.innloop2:
	mov	ax, [esi+4]
	convert_16_to_8
	mov	[edi], al
	mov	ax, [esi+2]
	convert_16_to_8
	mov	[edi+1], al
	mov	ax, [esi]
	convert_16_to_8
	mov	[edi+2], al
	add	edi, 3
	dec	ecx
	jnz	.rgb2_16bit.innloop2
	pop	edi
	add	edi, [.row_distance]
	dec	edx
	jnz	.rgb2_16bit.innloop1
	pop	edi ebx
	add	esi, 6
	mov	eax, [.col_increment]
	sub	[.i], eax
	ja	.rgb2_16bit.extloop
	add	edi, [.col_distance]
	mov	eax, [.row_increment]
	sub	[.j], eax
	ja	.rgb2_16bit
	jmp	.convert_done
.grayscale_alpha2:
	call	.create_grayscale_palette
	cmp	[.bit_depth], 16
	jz	.grayscale_alpha2_16bit
.grayscale_alpha2.next:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
.grayscale_alpha2.extloop:
	init_block
	add	eax, edi
	push	eax
	mov	al, [esi]
	add	esi, 2
	block_byte_innerloop .grayscale_alpha2.extloop
	ja	.grayscale_alpha2.next
	jmp	.convert_done
.grayscale_alpha2_16bit:
	sub	ebx, 1
	jc	.convert_done
	add	esi, 1
	sub	ebx, [.scanline_len]
	jc	.convert_done
	mov	ecx, [.width]
	sub	ecx, [.starting_col]
	mov	[.i], ecx
.grayscale_alpha2_16bit.extloop:
	init_block
	add	eax, edi
	push	eax
	mov	ax, [esi]
	add	esi, 4
	convert_16_to_8
	block_byte_innerloop .grayscale_alpha2_16bit.extloop
	ja	.grayscale_alpha2_16bit
.convert_done:
; next interlace pass
.deinterlace_next:
	mov	eax, [.block_width]
	cmp	eax, [.block_height]
	jz	.deinterlace_dec_width
	mov	[.block_height], eax
	mov	[.col_increment], eax
	dec	[.col_increment_shift]
	mov	[.starting_row], eax
	and	[.starting_col], 0
	jmp	.deinterlace_loop
.deinterlace_dec_width:
	shr	eax, 1
	jz	.deinterlace_done
	mov	[.block_width], eax
	mov	[.starting_col], eax
	add	eax, eax
	and	[.starting_row], 0
	mov	[.row_increment], eax
	bsf	eax, eax
	mov	[.row_increment_shift], al
	jmp	.deinterlace_loop
.deinterlace_done:
	mcall	68, 13, [.allocated]
	mov	esi, [.cur_chunk_ptr]
	add	esi, [.cur_chunk_size]
	push	[.length]
	jmp	.next_chunk
 
.deflate_callback:
	mov	ebp, [esp+4]
	mov	ebx, [esp+8]
	xor	eax, eax
	mov	esi, [.cur_chunk_size]
	mov	[ebx], esi
	test	esi, esi
	jz	.deflate_callback.ret
	mov	eax, [.cur_chunk_ptr]
	mov	ecx, [.length]
	add	esi, eax
	mov	[.cur_chunk_ptr], esi
	and	[.cur_chunk_size], 0
@@:
	sub	ecx, 12
	jb	.deflate_callback.ret
	cmp	dword [esi+4+4], 'IDAT'
	jnz	.deflate_callback.ret
	mov	edx, [esi+4]
	bswap	edx
	sub	ecx, edx
	jb	.deflate_callback.ret
	add	esi, 4+8
	test	edx, edx
	jz	@b
	mov	[.cur_chunk_size], edx
	mov	[.cur_chunk_ptr], esi
	mov	[.length], ecx
.deflate_callback.ret:
	ret	8
 
.create_grayscale_palette:
	push	edi edx
	mov	edi, [eax + Image.Palette]
	mov	ecx, [.bit_depth]
	cmp	cl, 16
	jnz	@f
	mov	cl, 8
@@:
	push	1
	pop	eax
	shl	eax, cl
	xchg	eax, ecx
	mov	edx, 0x010101
	cmp	al, 8
	jz	.graypal_common
	mov	edx, 0x111111
	cmp	al, 4
	jz	.graypal_common
	mov	edx, 0x555555
	cmp	al, 2
	jz	.graypal_common
	mov	edx, 0xFFFFFF
.graypal_common:
	xor	eax, eax
@@:
	stosd
	add	eax, edx
	loop	@b
	pop	edx edi
	ret
;endp
 
 
 
;;================================================================================================;;
align 4
proc img.encode.png uses ebx edx, _img:dword, _common:dword, _specific:dword
;;------------------------------------------------------------------------------------------------;;
;? Encode image into raw data in png format                                                       ;;
;;------------------------------------------------------------------------------------------------;;
;> [_img]      = pointer to image                                                                 ;;
;> [_common]   = format independent options                                                       ;;
;> [_specific] = 0 / pointer to the structure of format specific options                          ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 / pointer to encoded data                                                              ;;
;< ecx = error code / the size of encoded data                                                    ;;
;;================================================================================================;;
locals
	encoded_file rd 1
	encoded_file_size rd 1
	simag png_image
endl
	mov ebx,[_img]
	mov	eax,[ebx+Image.Type]
	cmp	eax,Image.bpp24
	je @f
		mov	ecx,LIBIMG_ERROR_BIT_DEPTH
		jmp	.error
	@@:
 
	mov edx,ebp
	sub edx,sizeof.png_image
	mov dword[edx+png_image.version],PNG_IMAGE_VERSION
	mov ecx,[ebx+Image.Width]
	mov [edx+png_image.width],ecx ;Image width in pixels (columns)
	mov eax,[ebx+Image.Height]
	mov [edx+png_image.height],eax ;Image height in pixels (rows)
	mov dword[edx+png_image.format],PNG_COLOR_TYPE_RGB
	;mov dword[edx+png_image.flags],PNG_IMAGE_FLAG_???
 
	imul ecx,3
	mov edi,ecx
	imul edi,[ebx+Image.Height]
	cmp edi,4096
	jge @f
		mov edi,4096 ;minimum memory size
	@@:
	mov [encoded_file_size],edi
	stdcall [mem.alloc],edi
	test eax,eax
	jnz	@f
		mov	ecx,LIBIMG_ERROR_OUT_OF_MEMORY
		jmp	.error
    @@:
	mov [encoded_file],eax
	mov edi,edx
	sub edi,4
	stdcall png_image_write_to_memory, edx,eax,edi,0,[ebx+Image.Data],ecx,0
	mov	eax,[encoded_file]
	mov	ecx,[encoded_file_size]
	jmp	.quit
 
.error:
	xor	eax,eax
.quit:
	ret
endp

Rev 6733	Rev 7279
1	;;================================================================================================;;	1	;;================================================================================================;;
2	;;//// png.asm //// (c) diamond, 2009 ////////////////////////////////////////////////////////////;;	2	;;//// png.asm //// (c) diamond, 2009 ////////////////////////////////////////////////////////////;;
3	;;================================================================================================;;	3	;;================================================================================================;;
4	;; ;;	4	;; ;;
5	;; This file is part of Common development libraries (Libs-Dev). ;;	5	;; This file is part of Common development libraries (Libs-Dev). ;;
6	;; ;;	6	;; ;;
7	;; Libs-Dev is free software: you can redistribute it and/or modify it under the terms of the GNU ;;	7	;; Libs-Dev is free software: you can redistribute it and/or modify it under the terms of the GNU ;;
8	;; Lesser General Public License as published by the Free Software Foundation, either version 2.1 ;;	8	;; Lesser General Public License as published by the Free Software Foundation, either version 2.1 ;;
9	;; of the License, or (at your option) any later version. ;;	9	;; of the License, or (at your option) any later version. ;;
10	;; ;;	10	;; ;;
11	;; Libs-Dev is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without ;;	11	;; Libs-Dev is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without ;;
12	;; even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ;;	12	;; even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ;;
13	;; Lesser General Public License for more details. ;;	13	;; Lesser General Public License for more details. ;;
14	;; ;;	14	;; ;;
15	;; You should have received a copy of the GNU Lesser General Public License along with Libs-Dev. ;;	15	;; You should have received a copy of the GNU Lesser General Public License along with Libs-Dev. ;;
16	;; If not, see . ;;	16	;; If not, see . ;;
17	;; ;;	17	;; ;;
18	;;================================================================================================;;	18	;;================================================================================================;;
19		19
20	include 'libpng/png.asm'	20	include 'libpng/png.asm'
21		21
22	;;================================================================================================;;	22	;;================================================================================================;;
23	;;proc img.is.png _data, _length ;////////////////////////////////////////////////////////////////;;	23	;;proc img.is.png _data, _length ;////////////////////////////////////////////////////////////////;;
24	img.is.png:	24	img.is.png:
25	;;------------------------------------------------------------------------------------------------;;	25	;;------------------------------------------------------------------------------------------------;;
26	;? Determine if raw data could be decoded (is in PNG format) ;;	26	;? Determine if raw data could be decoded (is in PNG format) ;;
27	;;------------------------------------------------------------------------------------------------;;	27	;;------------------------------------------------------------------------------------------------;;
28	;> _data = raw data as read from file/stream ;;	28	;> _data = raw data as read from file/stream ;;
29	;> _length = data length ;;	29	;> _length = data length ;;
30	;;------------------------------------------------------------------------------------------------;;	30	;;------------------------------------------------------------------------------------------------;;
31	;< eax = false / true ;;	31	;< eax = false / true ;;
32	;;================================================================================================;;	32	;;================================================================================================;;
33	; test 1 (length of data)	33	; test 1 (length of data)
34	cmp dword [esp+8], 8	34	cmp dword [esp+8], 8
35	jb .nope	35	jb .nope
36	; test 2: signature	36	; test 2: signature
37	mov eax, [esp+4]	37	mov eax, [esp+4]
38	cmp dword [eax], 0x474E5089	38	cmp dword [eax], 0x474E5089
39	jne .nope	39	jne .nope
40	cmp dword [eax+4], 0x0A1A0A0D	40	cmp dword [eax+4], 0x0A1A0A0D
41	je .yep	41	je .yep
42		42
43	.nope:	43	.nope:
44	xor eax, eax	44	xor eax, eax
45	ret 8	45	ret 8
46		46
47	.yep:	47	.yep:
48	xor eax, eax	48	xor eax, eax
49	inc eax	49	inc eax
50	ret 8	50	ret 8
51	;endp	51	;endp
52		52
53	;;================================================================================================;;	53	;;================================================================================================;;
54	;;proc img.decode.png _data, _length, _options ;//////////////////////////////////////////////////;;	54	;;proc img.decode.png _data, _length, _options ;//////////////////////////////////////////////////;;
55	img.decode.png:	55	img.decode.png:
56	xor eax, eax ; .image = 0	56	xor eax, eax ; .image = 0
57	pushad	57	pushad
58	mov ebp, esp	58	mov ebp, esp
59	.localsize = 29*4	59	.localsize = 29*4
60	virtual at ebp - .localsize	60	virtual at ebp - .localsize
61	.width dd ?	61	.width dd ?
62	.height dd ?	62	.height dd ?
63	.bit_depth dd ?	63	.bit_depth dd ?
64	.color_type dd ?	64	.color_type dd ?
65	.bytes_per_pixel dd ?	65	.bytes_per_pixel dd ?
66	.scanline_len dd ?	66	.scanline_len dd ?
67	.bits_per_pixel dd ?	67	.bits_per_pixel dd ?
68	.size_rest dd ?	68	.size_rest dd ?
69	.cur_chunk_ptr dd ?	69	.cur_chunk_ptr dd ?
70	.cur_chunk_size dd ?	70	.cur_chunk_size dd ?
71	.allocated dd ?	71	.allocated dd ?
72	.paeth_a dd ?	72	.paeth_a dd ?
73	.paeth_b dd ?	73	.paeth_b dd ?
74	.paeth_c dd ?	74	.paeth_c dd ?
75	.paeth_pa dd ?	75	.paeth_pa dd ?
76	.paeth_pb dd ?	76	.paeth_pb dd ?
77	.paeth_pc dd ?	77	.paeth_pc dd ?
78	.i dd ?	78	.i dd ?
79	.j dd ?	79	.j dd ?
80	; variables to handle interlace	80	; variables to handle interlace
81	.row_distance dd ? ; diff between two consecutives rows in destination	81	.row_distance dd ? ; diff between two consecutives rows in destination
82	.col_distance dd ? ; summand for moving to next row in source	82	.col_distance dd ? ; summand for moving to next row in source
83	.row_increment dd ?	83	.row_increment dd ?
84	.col_increment dd ?	84	.col_increment dd ?
85	.block_height dd ?	85	.block_height dd ?
86	.block_width dd ?	86	.block_width dd ?
87	.interlace db ? ; 0 if not interlaced, 1 if interlaced	87	.interlace db ? ; 0 if not interlaced, 1 if interlaced
88	.row_increment_shift db ?	88	.row_increment_shift db ?
89	.col_increment_shift db ?	89	.col_increment_shift db ?
90	.shift db ? ; shift for current src byte	90	.shift db ? ; shift for current src byte
91	.starting_row dd ?	91	.starting_row dd ?
92	.starting_col dd ?	92	.starting_col dd ?
93	.idat_read dd ?	93	.idat_read dd ?
94	rb 1Ch	94	rb 1Ch
95	.image dd ?	95	.image dd ?
96	rd 1	96	rd 1
97	.data dd ?	97	.data dd ?
98	.length dd ?	98	.length dd ?
99	.options dd ?	99	.options dd ?
100	end virtual	100	end virtual
101	push eax ; .idat_read = 0	101	push eax ; .idat_read = 0
102	push eax ; .starting_col = 0	102	push eax ; .starting_col = 0
103	push eax ; .starting_row = 0	103	push eax ; .starting_row = 0
104	push eax ; .col_increment_shift, .row_increment_shift	104	push eax ; .col_increment_shift, .row_increment_shift
105	inc eax	105	inc eax
106	push eax ; .block_width	106	push eax ; .block_width
107	push eax ; .block_height	107	push eax ; .block_height
108	push eax ; .col_increment	108	push eax ; .col_increment
109	push eax ; .row_increment	109	push eax ; .row_increment
110	sub esp, .localsize-32	110	sub esp, .localsize-32
111	; load deflate unpacker, if not yet	111	; load deflate unpacker, if not yet
112	; acquire mutex	112	; acquire mutex
113	@@:	113	@@:
114	push 1	114	push 1
115	pop eax	115	pop eax
116	xchg [deflate_loader_mutex], eax ; 'xchg' has an implicit 'lock' prefix	116	xchg [deflate_loader_mutex], eax ; 'xchg' has an implicit 'lock' prefix
117	test eax, eax	117	test eax, eax
118	jz @f	118	jz @f
119	mcall 5, 1	119	mcall 5, 1
120	jmp @b	120	jmp @b
121	@@:	121	@@:
122	cmp [deflate_unpack2], __deflate_unpack2_import_name__	122	cmp [deflate_unpack2], __deflate_unpack2_import_name__
123	jnz .deflate_loaded	123	jnz .deflate_loaded
124	; do loading	124	; do loading
125	invoke dll.load, @IMPORT	125	invoke dll.load, @IMPORT
126	test eax, eax	126	test eax, eax
127	jz .deflate_loaded	127	jz .deflate_loaded
128	add esp, .localsize	128	add esp, .localsize
129	popad	129	popad
130	mov [deflate_loader_mutex], eax	130	mov [deflate_loader_mutex], eax
131	ret 12	131	ret 12
132	.deflate_loaded:	132	.deflate_loaded:
133	; release mutex	133	; release mutex
134	mov [deflate_loader_mutex], 0	134	mov [deflate_loader_mutex], 0
135	; ok, continue	135	; ok, continue
136	mov esi, [.data] ; esi -> data	136	mov esi, [.data] ; esi -> data
137	mov ecx, [.length] ; ecx = length	137	mov ecx, [.length] ; ecx = length
138	; the signature has been already checked in img.is.png	138	; the signature has been already checked in img.is.png
139	lodsd	139	lodsd
140	lodsd	140	lodsd
141	sub ecx, 8	141	sub ecx, 8
142	xor ebx, ebx ; no image allocated	142	xor ebx, ebx ; no image allocated
143	.chunks_loop:	143	.chunks_loop:
144	sub ecx, 12	144	sub ecx, 12
145	jc .eof	145	jc .eof
146	lodsd ; chunk length	146	lodsd ; chunk length
147	bswap eax	147	bswap eax
148	sub ecx, eax	148	sub ecx, eax
149	jc .eof	149	jc .eof
150	push ecx ; save length of data rest	150	push ecx ; save length of data rest
151	xchg eax, ecx ; ecx = size of data in the chunk	151	xchg eax, ecx ; ecx = size of data in the chunk
152	lodsd ; chunk type	152	lodsd ; chunk type
153	cmp eax, 'IHDR'	153	cmp eax, 'IHDR'
154	jz .ihdr	154	jz .ihdr
155	cmp eax, 'IDAT'	155	cmp eax, 'IDAT'
156	jz .idat	156	jz .idat
157	cmp eax, 'IEND'	157	cmp eax, 'IEND'
158	jz .iend	158	jz .iend
159	cmp eax, 'PLTE'	159	cmp eax, 'PLTE'
160	jz .palette	160	jz .palette
161	; unrecognized chunk, ignore	161	; unrecognized chunk, ignore
162	lea esi, [esi+ecx+4]	162	lea esi, [esi+ecx+4]
163	pop ecx	163	pop ecx
164	jmp .chunks_loop	164	jmp .chunks_loop
165	; IHDR chunk	165	; IHDR chunk
166	.ihdr:	166	.ihdr:
167	cmp ecx, 13	167	cmp ecx, 13
168	jnz .invalid_chunk	168	jnz .invalid_chunk
169	cmp [.image], 0	169	cmp [.image], 0
170	jnz .invalid_chunk	170	jnz .invalid_chunk
171	; read image characteristics	171	; read image characteristics
172	lodsd	172	lodsd
173	bswap eax	173	bswap eax
174	mov [.width], eax	174	mov [.width], eax
175	lodsd	175	lodsd
176	bswap eax	176	bswap eax
177	mov [.height], eax	177	mov [.height], eax
178	xor eax, eax	178	xor eax, eax
179	lea ebx, [eax+1]	179	lea ebx, [eax+1]
180	lodsb	180	lodsb
181	cmp al, 16	181	cmp al, 16
182	ja .invalid_chunk	182	ja .invalid_chunk
183	test al, al	183	test al, al
184	jz .invalid_chunk	184	jz .invalid_chunk
185	lea edx, [eax-1]	185	lea edx, [eax-1]
186	test al, dl	186	test al, dl
187	jnz .invalid_chunk	187	jnz .invalid_chunk
188	mov [.bit_depth], eax	188	mov [.bit_depth], eax
189	lodsb	189	lodsb
190	test al, not 7	190	test al, not 7
191	jnz .invalid_chunk	191	jnz .invalid_chunk
192	mov [.color_type], eax	192	mov [.color_type], eax
193	lodsb	193	lodsb
194	test al, al	194	test al, al
195	jnz .invalid_chunk ; only compression method 0 is defined	195	jnz .invalid_chunk ; only compression method 0 is defined
196	lodsb	196	lodsb
197	test al, al	197	test al, al
198	jnz .invalid_chunk ; only filtering method 0 is defined	198	jnz .invalid_chunk ; only filtering method 0 is defined
199	lodsb	199	lodsb
200	cmp al, 1	200	cmp al, 1
201	ja .invalid_chunk ; only interlacing methods 0 and 1 are defined	201	ja .invalid_chunk ; only interlacing methods 0 and 1 are defined
202	mov [.interlace], al	202	mov [.interlace], al
203	; check for correctness and calculate bytes_per_pixel and scanline_len	203	; check for correctness and calculate bytes_per_pixel and scanline_len
204	mov eax, [.bit_depth]	204	mov eax, [.bit_depth]
205	mov edx, [.color_type]	205	mov edx, [.color_type]
206	dec edx	206	dec edx
207	js .grayscale1	207	js .grayscale1
208	dec edx	208	dec edx
209	jz .rgb1	209	jz .rgb1
210	dec edx	210	dec edx
211	jz .palette1	211	jz .palette1
212	dec edx	212	dec edx
213	jz .grayscale_alpha1	213	jz .grayscale_alpha1
214	dec edx	214	dec edx
215	dec edx	215	dec edx
216	jnz .invalid_chunk	216	jnz .invalid_chunk
217	.rgb_alpha1:	217	.rgb_alpha1:
218	inc ebx	218	inc ebx
219	.rgb1:	219	.rgb1:
220	inc ebx	220	inc ebx
221	.grayscale_alpha1:	221	.grayscale_alpha1:
222	inc ebx	222	inc ebx
223	cmp al, 8	223	cmp al, 8
224	jb .invalid_chunk	224	jb .invalid_chunk
225	jmp @f	225	jmp @f
226	.palette1:	226	.palette1:
227	cmp al, 8	227	cmp al, 8
228	ja .invalid_chunk	228	ja .invalid_chunk
229	.grayscale1:	229	.grayscale1:
230	@@:	230	@@:
231	mul ebx	231	mul ebx
232	mov [.bits_per_pixel], eax	232	mov [.bits_per_pixel], eax
233	add eax, 7	233	add eax, 7
234	shr eax, 3	234	shr eax, 3
235	mov [.bytes_per_pixel], eax	235	mov [.bytes_per_pixel], eax
236	; allocate image	236	; allocate image
237	push Image.bpp24	237	push Image.bpp24
238	pop eax	238	pop eax
239	cmp [.color_type], 2	239	cmp [.color_type], 2
240	jz @f	240	jz @f
241	mov al, Image.bpp32	241	mov al, Image.bpp32
242	cmp [.color_type], 6	242	cmp [.color_type], 6
243	jz @f	243	jz @f
244	mov al, Image.bpp8i	244	mov al, Image.bpp8i
245	@@:	245	@@:
246	stdcall img.create, [.width], [.height], eax	246	stdcall img.create, [.width], [.height], eax
247	test eax, eax	247	test eax, eax
248	jz .invalid_chunk	248	jz .invalid_chunk
249	mov [.image], eax	249	mov [.image], eax
250	jmp .next_chunk	250	jmp .next_chunk
251	.invalid_chunk:	251	.invalid_chunk:
252	.iend:	252	.iend:
253	pop ecx	253	pop ecx
254	.eof:	254	.eof:
255	add esp, .localsize	255	add esp, .localsize
256	popad	256	popad
257	ret 12	257	ret 12
258	; PLTE chunk	258	; PLTE chunk
259	.palette:	259	.palette:
260	mov eax, [.image]	260	mov eax, [.image]
261	test eax, eax	261	test eax, eax
262	jz .invalid_chunk	262	jz .invalid_chunk
263	cmp [.color_type], 3	263	cmp [.color_type], 3
264	jz .copy_palette	264	jz .copy_palette
265	.ignore_chunk:	265	.ignore_chunk:
266	add esi, ecx	266	add esi, ecx
267	.next_chunk:	267	.next_chunk:
268	lodsd	268	lodsd
269	pop ecx	269	pop ecx
270	jmp .chunks_loop	270	jmp .chunks_loop
271	.copy_palette:	271	.copy_palette:
272	mov edi, [eax + Image.Palette]	272	mov edi, [eax + Image.Palette]
273	xor eax, eax	273	xor eax, eax
274	cmp ecx, 256*3	274	cmp ecx, 256*3
275	ja .next_chunk	275	ja .next_chunk
276	@@:	276	@@:
277	sub ecx, 3	277	sub ecx, 3
278	jz @f	278	jz @f
279	js .invalid_chunk	279	js .invalid_chunk
280	lodsd	280	lodsd
281	dec esi	281	dec esi
282	bswap eax	282	bswap eax
283	shr eax, 8	283	shr eax, 8
284	stosd	284	stosd
285	jmp @b	285	jmp @b
286	@@:	286	@@:
287	lodsd	287	lodsd
288	dec esi	288	dec esi
289	bswap eax	289	bswap eax
290	shr eax, 8	290	shr eax, 8
291	stosd	291	stosd
292	jmp .next_chunk	292	jmp .next_chunk
293	.idat:	293	.idat:
294	jecxz .next_chunk	294	jecxz .next_chunk
295	cmp [.idat_read], 0	295	cmp [.idat_read], 0
296	jnz @f	296	jnz @f
297	lodsb	297	lodsb
298	inc [.idat_read]	298	inc [.idat_read]
299	and al, 0xF	299	and al, 0xF
300	cmp al, 8	300	cmp al, 8
301	jnz .invalid_chunk	301	jnz .invalid_chunk
302	dec ecx	302	dec ecx
303	jz .next_chunk	303	jz .next_chunk
304	@@:	304	@@:
305	cmp [.idat_read], 1	305	cmp [.idat_read], 1
306	jnz @f	306	jnz @f
307	lodsb	307	lodsb
308	inc [.idat_read]	308	inc [.idat_read]
309	test al, 20h	309	test al, 20h
310	jnz .invalid_chunk	310	jnz .invalid_chunk
311	dec ecx	311	dec ecx
312	jz .next_chunk	312	jz .next_chunk
313	@@:	313	@@:
314	mov [.cur_chunk_ptr], esi	314	mov [.cur_chunk_ptr], esi
315	mov [.cur_chunk_size], ecx	315	mov [.cur_chunk_size], ecx
316	pop [.length]	316	pop [.length]
317	push eax	317	push eax
318	push esp	318	push esp
319	push ebp	319	push ebp
320	push .deflate_callback	320	push .deflate_callback
321	call [deflate_unpack2]	321	call [deflate_unpack2]
322	pop ecx	322	pop ecx
323	test eax, eax	323	test eax, eax
324	jz .invalid_chunk	324	jz .invalid_chunk
325	; convert PNG unpacked data to RAW data	325	; convert PNG unpacked data to RAW data
326	mov esi, eax	326	mov esi, eax
327	mov [.allocated], eax	327	mov [.allocated], eax
328	mov [.size_rest], ecx	328	mov [.size_rest], ecx
329	; unfilter and deinterlace	329	; unfilter and deinterlace
330	; .interlace_pass, .starting_row and .starting_col have been already set to 0	330	; .interlace_pass, .starting_row and .starting_col have been already set to 0
331	; .block_width, .block_height, .col_increment, .row_increment were set	331	; .block_width, .block_height, .col_increment, .row_increment were set
332	; to values for non-interlaced images; correct if necessary	332	; to values for non-interlaced images; correct if necessary
333	cmp [.interlace], 0	333	cmp [.interlace], 0
334	jz .deinterlace_loop	334	jz .deinterlace_loop
335	push 8	335	push 8
336	pop eax	336	pop eax
337	mov [.row_increment], eax	337	mov [.row_increment], eax
338	mov [.col_increment], eax	338	mov [.col_increment], eax
339	mov [.block_height], eax	339	mov [.block_height], eax
340	mov [.block_width], eax	340	mov [.block_width], eax
341	mov [.row_increment_shift], 3	341	mov [.row_increment_shift], 3
342	mov [.col_increment_shift], 3	342	mov [.col_increment_shift], 3
343	.deinterlace_loop:	343	.deinterlace_loop:
344	mov edx, [.height]	344	mov edx, [.height]
345	cmp edx, [.starting_row]	345	cmp edx, [.starting_row]
346	jbe .deinterlace_next	346	jbe .deinterlace_next
347	mov ebx, [.width]	347	mov ebx, [.width]
348	sub ebx, [.starting_col]	348	sub ebx, [.starting_col]
349	jbe .deinterlace_next	349	jbe .deinterlace_next
350	mov cl, [.col_increment_shift]	350	mov cl, [.col_increment_shift]
351	add ebx, [.col_increment]	351	add ebx, [.col_increment]
352	dec ebx	352	dec ebx
353	shr ebx, cl	353	shr ebx, cl
354	mov eax, [.bits_per_pixel]	354	mov eax, [.bits_per_pixel]
355	imul eax, ebx	355	imul eax, ebx
356	add eax, 7	356	add eax, 7
357	shr eax, 3	357	shr eax, 3
358	mov [.scanline_len], eax	358	mov [.scanline_len], eax
359	shl ebx, cl	359	shl ebx, cl
360	mov [.col_distance], ebx	360	mov [.col_distance], ebx
361	; Unfilter	361	; Unfilter
362	mov ecx, [.size_rest]	362	mov ecx, [.size_rest]
363	push esi	363	push esi
364	.unfilter_loop_e:	364	.unfilter_loop_e:
365	mov ebx, [.scanline_len]	365	mov ebx, [.scanline_len]
366	sub ecx, 1	366	sub ecx, 1
367	jc .unfilter_abort	367	jc .unfilter_abort
368	sub ecx, ebx	368	sub ecx, ebx
369	jc .unfilter_abort	369	jc .unfilter_abort
370	movzx eax, byte [esi]	370	movzx eax, byte [esi]
371	add esi, 1	371	add esi, 1
372	cmp eax, 4	372	cmp eax, 4
373	ja .next_scanline	373	ja .next_scanline
374	jmp dword [@f + eax*4]	374	jmp dword [@f + eax*4]
375	align 4	375	align 4
376	@@:	376	@@:
377	dd .unfilter_none	377	dd .unfilter_none
378	dd .unfilter_sub	378	dd .unfilter_sub
379	dd .unfilter_up	379	dd .unfilter_up
380	dd .unfilter_average	380	dd .unfilter_average
381	dd .unfilter_paeth	381	dd .unfilter_paeth
382	.unfilter_sub:	382	.unfilter_sub:
383	mov edi, [.bytes_per_pixel]	383	mov edi, [.bytes_per_pixel]
384	add esi, edi	384	add esi, edi
385	sub ebx, edi	385	sub ebx, edi
386	jbe .next_scanline	386	jbe .next_scanline
387	neg edi	387	neg edi
388	@@:	388	@@:
389	mov al, [esi+edi]	389	mov al, [esi+edi]
390	add [esi], al	390	add [esi], al
391	add esi, 1	391	add esi, 1
392	sub ebx, 1	392	sub ebx, 1
393	jnz @b	393	jnz @b
394	jmp .next_scanline	394	jmp .next_scanline
395	.unfilter_up:	395	.unfilter_up:
396	cmp edx, [.height]	396	cmp edx, [.height]
397	jz .unfilter_none	397	jz .unfilter_none
398	lea edi, [ebx+1]	398	lea edi, [ebx+1]
399	neg edi	399	neg edi
400	@@:	400	@@:
401	mov al, [esi+edi]	401	mov al, [esi+edi]
402	add [esi], al	402	add [esi], al
403	add esi, 1	403	add esi, 1
404	sub ebx, 1	404	sub ebx, 1
405	jnz @b	405	jnz @b
406	jmp .next_scanline	406	jmp .next_scanline
407	.unfilter_average:	407	.unfilter_average:
408	mov edi, [.bytes_per_pixel]	408	mov edi, [.bytes_per_pixel]
409	cmp edx, [.height]	409	cmp edx, [.height]
410	jz .unfilter_average_firstline	410	jz .unfilter_average_firstline
411	push edx	411	push edx
412	lea edx, [ebx+1]	412	lea edx, [ebx+1]
413	neg edx	413	neg edx
414	sub ebx, edi	414	sub ebx, edi
415	@@:	415	@@:
416	mov al, [esi+edx]	416	mov al, [esi+edx]
417	shr al, 1	417	shr al, 1
418	add [esi], al	418	add [esi], al
419	add esi, 1	419	add esi, 1
420	sub edi, 1	420	sub edi, 1
421	jnz @b	421	jnz @b
422	mov edi, [.bytes_per_pixel]	422	mov edi, [.bytes_per_pixel]
423	neg edi	423	neg edi
424	test ebx, ebx	424	test ebx, ebx
425	jz .unfilter_average_done	425	jz .unfilter_average_done
426	@@:	426	@@:
427	mov al, [esi+edx]	427	mov al, [esi+edx]
428	add al, [esi+edi]	428	add al, [esi+edi]
429	rcr al, 1	429	rcr al, 1
430	add [esi], al	430	add [esi], al
431	add esi, 1	431	add esi, 1
432	sub ebx, 1	432	sub ebx, 1
433	jnz @b	433	jnz @b
434	.unfilter_average_done:	434	.unfilter_average_done:
435	pop edx	435	pop edx
436	jmp .next_scanline	436	jmp .next_scanline
437	.unfilter_average_firstline:	437	.unfilter_average_firstline:
438	mov edi, [.bytes_per_pixel]	438	mov edi, [.bytes_per_pixel]
439	add esi, edi	439	add esi, edi
440	sub ebx, edi	440	sub ebx, edi
441	jbe .next_scanline	441	jbe .next_scanline
442	neg edi	442	neg edi
443	@@:	443	@@:
444	mov al, [esi+edi]	444	mov al, [esi+edi]
445	shr al, 1	445	shr al, 1
446	add [esi], al	446	add [esi], al
447	add esi, 1	447	add esi, 1
448	sub ebx, 1	448	sub ebx, 1
449	jnz @b	449	jnz @b
450	jmp .unfilter_none	450	jmp .unfilter_none
451	.unfilter_paeth:	451	.unfilter_paeth:
452	cmp edx, [.height]	452	cmp edx, [.height]
453	jz .unfilter_sub	453	jz .unfilter_sub
454	push edx	454	push edx
455	lea edx, [ebx+1]	455	lea edx, [ebx+1]
456	mov edi, [.bytes_per_pixel]	456	mov edi, [.bytes_per_pixel]
457	neg edx	457	neg edx
458	sub ebx, edi	458	sub ebx, edi
459	@@:	459	@@:
460	mov al, [esi+edx]	460	mov al, [esi+edx]
461	add [esi], al	461	add [esi], al
462	add esi, 1	462	add esi, 1
463	sub edi, 1	463	sub edi, 1
464	jnz @b	464	jnz @b
465	mov edi, [.bytes_per_pixel]	465	mov edi, [.bytes_per_pixel]
466	neg edi	466	neg edi
467	test ebx, ebx	467	test ebx, ebx
468	jz .unfilter_paeth_done	468	jz .unfilter_paeth_done
469	push ecx	469	push ecx
470	@@:	470	@@:
471	push ebx	471	push ebx
472	; PaethPredictor(Raw(x-bpp) = a, Prior(x) = b, Prior(x-bpp) = c)	472	; PaethPredictor(Raw(x-bpp) = a, Prior(x) = b, Prior(x-bpp) = c)
473	movzx eax, byte [esi+edi]	473	movzx eax, byte [esi+edi]
474	mov [.paeth_a], eax	474	mov [.paeth_a], eax
475	movzx ecx, byte [esi+edx]	475	movzx ecx, byte [esi+edx]
476	add edi, edx	476	add edi, edx
477	mov [.paeth_b], ecx	477	mov [.paeth_b], ecx
478	add ecx, eax	478	add ecx, eax
479	movzx eax, byte [esi+edi]	479	movzx eax, byte [esi+edi]
480	mov [.paeth_c], eax	480	mov [.paeth_c], eax
481	sub ecx, eax ; ecx = a + b - c = p	481	sub ecx, eax ; ecx = a + b - c = p
482	; calculate pa = abs(p-a), pb = abs(p-b), pc = abs(p-c)	482	; calculate pa = abs(p-a), pb = abs(p-b), pc = abs(p-c)
483	mov ebx, ecx	483	mov ebx, ecx
484	sub ebx, eax ; ebx = p - c	484	sub ebx, eax ; ebx = p - c
485	cmp ebx, 80000000h	485	cmp ebx, 80000000h
486	sbb eax, eax ; eax = (p < c) ? 0 : 0xFFFFFFF	486	sbb eax, eax ; eax = (p < c) ? 0 : 0xFFFFFFF
487	not eax ; eax = (p < c) ? 0xFFFFFFFF : 0	487	not eax ; eax = (p < c) ? 0xFFFFFFFF : 0
488	and eax, ebx ; eax = (p < c) ? p - c : 0	488	and eax, ebx ; eax = (p < c) ? p - c : 0
489	sub ebx, eax	489	sub ebx, eax
490	sub ebx, eax ; ebx = abs(p-c)	490	sub ebx, eax ; ebx = abs(p-c)
491	mov [.paeth_pc], ebx	491	mov [.paeth_pc], ebx
492	mov ebx, ecx	492	mov ebx, ecx
493	sub ebx, [.paeth_a]	493	sub ebx, [.paeth_a]
494	cmp ebx, 80000000h	494	cmp ebx, 80000000h
495	sbb eax, eax	495	sbb eax, eax
496	not eax	496	not eax
497	and eax, ebx	497	and eax, ebx
498	sub ebx, eax	498	sub ebx, eax
499	sub ebx, eax	499	sub ebx, eax
500	mov [.paeth_pa], ebx	500	mov [.paeth_pa], ebx

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/libs-dev/libimg/png/png.asm – Rev 6733 → 7279