Subversion Repositories Kolibri OS

;;================================================================================================;;

;;//// libimg.asm //// (c) mike.dld, 2007-2008, (c) diamond, 2009, (c) dunkaist, 2011-2013 ///////;;

;;================================================================================================;;

;;												  ;;

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

;;												  ;;

;;================================================================================================;;

format MS COFF

public @EXPORT as 'EXPORTS'

include 'struct.inc'

include 'proc32.inc'

include 'macros.inc'

include 'config.inc'

include 'debug-fdo.inc'

__DEBUG__ = 0

__DEBUG_LEVEL__ = 1

include 'libio.inc'

purge section,mov,add,sub

include 'libimg.inc'

section '.flat' code readable align 16

include 'bmp/bmp.asm'

include 'gif/gif.asm'

include 'jpeg/jpeg.asm'

include 'png/png.asm'

include 'tga/tga.asm'

include 'z80/z80.asm'

include 'ico_cur/ico_cur.asm'

include 'pcx/pcx.asm'

include 'xcf/xcf.asm'

include 'tiff/tiff.asm'

include 'pnm/pnm.asm'

include 'wbmp/wbmp.asm'

include 'xbm/xbm.asm'

include 'scale.asm'

include 'convert.asm'

COMPOSITE_MODE equ MMX

; MMX | pretty fast and compatible

; SSE | a bit faster, but may be unsupported by some CPUs

include 'blend.asm'

;;================================================================================================;;

proc lib_init ;///////////////////////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? Library entry point (called after library load)						  ;;

;;------------------------------------------------------------------------------------------------;;

;> eax = pointer to memory allocation routine							  ;;

;> ebx = pointer to memory freeing routine							  ;;

;> ecx = pointer to memory reallocation routine 						  ;;

;> edx = pointer to library loading routine							  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = 1 (fail) / 0 (ok) (library initialization result)					  ;;

;;================================================================================================;;

    mov [mem.alloc], eax

    mov [mem.free], ebx

    mov [mem.realloc], ecx

    mov [dll.load], edx

    or edx,edx

    jz @f

      invoke dll.load, @IMPORT

    @@:

    call    img.initialize.jpeg

    xor eax, eax

    cpuid

    cmp ecx, 'ntel'

    jnz @f

    mov dword [img._.do_rgb.handlers + (Image.bpp15-1)*4], img._.do_rgb.bpp15.intel

    mov dword [img._.do_rgb.handlers + (Image.bpp16-1)*4], img._.do_rgb.bpp16.intel

  @@:

  .ok:	xor eax,eax

    ret

endp

;;================================================================================================;;

proc img.is_img _data, _length ;//////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;> --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;< --- TBD ---											  ;;

;;================================================================================================;;

    push    ebx

    mov ebx, img.formats_table

    @@: stdcall [ebx + FormatsTableEntry.Is], [_data], [_length]

    or	eax, eax

    jnz @f

    add ebx, sizeof.FormatsTableEntry

    cmp dword[ebx], 0

    jnz @b

    xor eax, eax

    @@: pop ebx

    ret

endp

;;================================================================================================;;

proc img.info _data, _length ;////////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;> --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;< --- TBD ---											  ;;

;;================================================================================================;;

    xor eax, eax

    ret

endp

;;================================================================================================;;

proc img.from_file _filename ;////////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? load file from disk and decode it								  ;;

;;------------------------------------------------------------------------------------------------;;

;> [_filename] = file name as passed to libio							  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = 0 / pointer to image									  ;;

;;================================================================================================;;

locals

	fd		dd ?

	img_data_len	dd ?

	img_data	dd ?	; raw bytes

	img		dd ?	; Image pointer

endl

	push	ebx

	mov	[img], 0

	invoke	file.open, [_filename], O_READ

	mov	[fd], eax

	test	eax, eax

	jz	.exit

	invoke	file.size, [_filename]

	test	eax, eax

	jnz	.exit_close

	mov	[img_data_len], ebx

	invoke	mem.alloc, ebx

	test	eax, eax

	jz	.exit_close

	mov	[img_data], eax

	invoke	file.read, [fd], eax, [img_data_len]

	cmp	eax, -1

	jz	.exit_free_close

	cmp	eax, [img_data_len]

	jnz	.exit_free_close

	stdcall img.decode, [img_data], [img_data_len], 0

	test	eax, eax

	jz	.exit_free_close

	mov	[img], eax

  .exit_free_close:

	invoke	mem.free, [img_data]

  .exit_close:

	invoke	file.close, [fd]

	mov	eax, [img]

  .exit:

	pop	ebx

	ret

endp

;;================================================================================================;;

proc img.to_file _img, _filename ;////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;> --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = false / true										  ;;

;;================================================================================================;;

    xor eax, eax

    ret

endp

;;================================================================================================;;

proc img.from_rgb _rgb_data ;/////////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;> --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = 0 / pointer to image									  ;;

;;================================================================================================;;

    xor eax, eax

    ret

endp

;;================================================================================================;;

proc img.to_rgb2 _img, _out ;/////////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? decodes image data into RGB triplets and stores them where [_out] points to			  ;;

;;------------------------------------------------------------------------------------------------;;

;> [_img] = pointer to source image								  ;;

;> [_out] = where to store RGB triplets 							  ;;

;;------------------------------------------------------------------------------------------------;;

;< none 											  ;;

;;================================================================================================;;

    push    esi edi

    mov esi, [_img]

    stdcall img._.validate, esi

    or	eax, eax

    jnz .ret

    mov edi, [_out]

    call    img._.do_rgb

.ret:

    pop edi esi

    ret

endp

;;================================================================================================;;

proc img.to_rgb _img ;////////////////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? decodes image data into RGB triplets and returns pointer to memory area of following structure:;;

;? width  dd ?											  ;;

;? height dd ?											  ;;

;? rgb triplets 										  ;;

;;------------------------------------------------------------------------------------------------;;

;> [_img] = pointer to source image								  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = 0 / pointer to rgb_data (array of [rgb] triplets)					  ;;

;;================================================================================================;;

    push    esi edi

    mov esi, [_img]

    stdcall img._.validate, esi

    or	eax, eax

    jnz .error

    mov esi, [_img]

    mov ecx, [esi + Image.Width]

    imul    ecx, [esi + Image.Height]

    lea eax, [ecx * 3 + 4 * 3]

    invoke  mem.alloc, eax

    or	eax, eax

    jz	.error

    mov edi, eax

    push    eax

    mov eax, [esi + Image.Width]

    stosd

    mov eax, [esi + Image.Height]

    stosd

    call    img._.do_rgb

    pop eax

    pop edi esi

    ret

  .error:

    xor eax, eax

    pop edi esi

    ret

endp

;;================================================================================================;;

proc img._.do_rgb ;///////////////////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? decodes [esi + Image.Data] data into RGB triplets and stores them at [edi]			  ;;

;;------------------------------------------------------------------------------------------------;;

;> esi = pointer to source image								  ;;

;> edi = pointer to memory to store RGB triplets						  ;;

;;------------------------------------------------------------------------------------------------;;

;< none 											  ;;

;;================================================================================================;;

    mov ecx, [esi + Image.Width]

    imul    ecx, [esi + Image.Height]

    mov eax, [esi + Image.Type]

    jmp dword [.handlers + (eax-1)*4]

align 16

.bpp8i:

; 8 BPP WITH PALETTE -> 24 BPP

    push    ebx

    mov ebx, [esi + Image.Palette]

    mov esi, [esi + Image.Data]

    sub ecx, 1

    jz	.bpp8i.last

@@:

    movzx   eax, byte [esi]

    add esi, 1

    mov eax, [ebx + eax*4]

    mov [edi], eax

    add edi, 3

    sub ecx, 1

    jnz @b

.bpp8i.last:

    movzx   eax, byte [esi]

    mov eax, [ebx + eax*4]

    mov [edi], ax

    shr eax, 16

    mov [edi+2], al

    pop ebx

    ret

align 16

.bpp8g:

; 8 BPP GRAYSCALE -> 24 BPP

    mov esi, [esi + Image.Data]

@@:

    lodsb

    mov ah, al

    stosb

    stosw

    dec ecx

    jnz @b

    ret

;

;align 16

;.bpp8a: ; considered application layer, may be changed in the future

;; 8a BPP -> 24 BPP

;    mov esi, [esi + Image.Data]

;@@:

;    lodsw

;    mov ah, al

;    stosb

;    stosw

;    dec ecx

;    jnz @b

;    ret

; 15 BPP -> 24 BPP

.bpp15.intel:

    push    ebx ebp

    sub ecx, 4

    jb	.bpp15.tail

align 16

.bpp15.intel.loop:

repeat 2

    mov ebx, [esi]

    mov al, [esi]

    mov ah, [esi+1]

    add esi, 4

    and al, 0x1F

    and ah, 0x1F shl 2

    mov ebp, ebx

    mov dl, al

    mov dh, ah

    shr al, 2

    shr ah, 4

    shl dl, 3

    shl dh, 1

    and ebp, 0x1F shl 5

    add al, dl

    add ah, dh

    shr ebp, 2

    mov [edi], al

    mov [edi+2], ah

    mov eax, ebx

    mov ebx, ebp

    shr eax, 16

    shr ebx, 5

    add ebx, ebp

    mov ebp, eax

    mov [edi+1], bl

    and eax, (0x1F) or (0x1F shl 10)

    and ebp, 0x1F shl 5

    lea edx, [eax+eax]

    shr al, 2

    mov ebx, ebp

    shr ah, 4

    shl dl, 2

    shr ebx, 2

    shr ebp, 7

    add al, dl

    add ah, dh

    mov [edi+3], al

    add ebx, ebp

    mov [edi+5], ah

    mov [edi+4], bl

    add edi, 6

end repeat

    sub ecx, 4

    jnb .bpp15.intel.loop

.bpp15.tail:

    add ecx, 4

    jz	.bpp15.done

@@:

    movzx   eax, word [esi]

    mov ebx, eax

    add esi, 2

    and eax, (0x1F) or (0x1F shl 10)

    and ebx, 0x1F shl 5

    lea edx, [eax+eax]

    shr al, 2

    mov ebp, ebx

    shr ebx, 2

    shr ah, 4

    shl dl, 2

    shr ebp, 7

    add eax, edx

    add ebx, ebp

    mov [edi], al

    mov [edi+1], bl

    mov [edi+2], ah

    add edi, 3

    sub ecx, 1

    jnz @b

.bpp15.done:

    pop ebp ebx

    ret

.bpp15.amd:

    push    ebx ebp

    sub ecx, 4

    jb	.bpp15.tail

align 16

.bpp15.amd.loop:

repeat 4

if (% mod 2) = 1

    mov eax, dword [esi]

    mov ebx, dword [esi]

else

    movzx   eax, word [esi]

    mov ebx, eax

end if

    add esi, 2

    and eax, (0x1F) or (0x1F shl 10)

    and ebx, 0x1F shl 5

    lea edx, [eax+eax]

    shr al, 2

    mov ebp, ebx

    shr ebx, 2

    shr ah, 4

    shl dl, 2

    shr ebp, 7

    add eax, edx

    add ebx, ebp

    mov [edi], al

    mov [edi+1], bl

    mov [edi+2], ah

    add edi, 3

end repeat

    sub ecx, 4

    jnb .bpp15.amd.loop

    jmp .bpp15.tail

; 16 BPP -> 24 BPP

.bpp16.intel:

    push    ebx ebp

    sub ecx, 4

    jb	.bpp16.tail

align 16

.bpp16.intel.loop:

repeat 2

    mov ebx, [esi]

    mov al, [esi]

    mov ah, [esi+1]

    add esi, 4

    and al, 0x1F

    and ah, 0x1F shl 3

    mov ebp, ebx

    mov dl, al

    mov dh, ah

    shr al, 2

    shr ah, 5

    shl dl, 3

    and ebp, 0x3F shl 5

    add al, dl

    add ah, dh

    shr ebp, 3

    mov [edi], al

    mov [edi+2], ah

    mov eax, ebx

    mov ebx, ebp

    shr eax, 16

    shr ebx, 6

    add ebx, ebp

    mov ebp, eax

    mov [edi+1], bl

    and eax, (0x1F) or (0x1F shl 11)

    and ebp, 0x3F shl 5

    mov edx, eax

    shr al, 2

    mov ebx, ebp

    shr ah, 5

    shl dl, 3

    shr ebx, 3

    shr ebp, 9

    add al, dl

    add ah, dh

    mov [edi+3], al

    add ebx, ebp

    mov [edi+5], ah

    mov [edi+4], bl

    add edi, 6

end repeat

    sub ecx, 4

    jnb .bpp16.intel.loop

.bpp16.tail:

    add ecx, 4

    jz	.bpp16.done

@@:

    movzx   eax, word [esi]

    mov ebx, eax

    add esi, 2

    and eax, (0x1F) or (0x1F shl 11)

    and ebx, 0x3F shl 5

    mov edx, eax

    shr al, 2

    mov ebp, ebx

    shr ebx, 3

    shr ah, 5

    shl dl, 3

    shr ebp, 9

    add eax, edx

    add ebx, ebp

    mov [edi], al

    mov [edi+1], bl

    mov [edi+2], ah

    add edi, 3

    sub ecx, 1

    jnz @b

.bpp16.done:

    pop ebp ebx

    ret

.bpp16.amd:

    push    ebx ebp

    sub ecx, 4

    jb	.bpp16.tail

align 16

.bpp16.amd.loop:

repeat 4

if (% mod 2) = 1

    mov eax, dword [esi]

    mov ebx, dword [esi]

else

    movzx   eax, word [esi]

    mov ebx, eax

end if

    add esi, 2

    and eax, (0x1F) or (0x1F shl 11)

    and ebx, 0x3F shl 5

    mov edx, eax

    shr al, 2

    mov ebp, ebx

    shr ebx, 3

    shr ah, 5

    shl dl, 3

    shr ebp, 9

    add eax, edx

    add ebx, ebp

    mov [edi], al

    mov [edi+1], bl

    mov [edi+2], ah

    add edi, 3

end repeat

    sub ecx, 4

    jnb .bpp16.amd.loop

    jmp .bpp16.tail

align 16

.bpp24:

; 24 BPP -> 24 BPP

    lea ecx, [ecx*3 + 3]

    mov esi, [esi + Image.Data]

    shr ecx, 2

    rep movsd

    ret

align 16

.bpp32:

; 32 BPP -> 24 BPP

    mov esi, [esi + Image.Data]

    @@:

    mov eax, [esi]

    mov [edi], ax

    shr eax, 16

    mov [edi+2], al

    add esi, 4

    add edi, 3

    sub ecx, 1

    jnz @b

    @@:

    ret

align 16

.bpp1:

    push ebx ebp

    mov ebp, [esi + Image.Width]

    mov edx, [esi + Image.Height]

    shl edx, 16

    mov ebx, [esi + Image.Palette]

    mov esi, [esi + Image.Data]

  .bpp1.pre:

    mov dx, bp

    mov ecx, 7

  .bpp1.begin:

    xor eax, eax

    bt	[esi], ecx

    adc eax, 0

    mov eax, [ebx + eax*4]

    mov [edi], ax

    shr eax, 16

    mov [edi + 2], al

    add edi, 3

    dec dx

    jz .bpp1.end_line

    dec ecx

    jns .bpp1.begin

    mov ecx, 7

    inc esi

    jmp .bpp1.begin

  .bpp1.end_line:

    sub edx, 0x10000

    jz .bpp1.quit

    inc esi

    jmp .bpp1.pre

  .bpp1.quit:

    pop ebp ebx

    ret

align 16

.bpp2i:

    push ebx ebp

    mov ebp, [esi + Image.Width]

    mov edx, [esi + Image.Height]

    shl edx, 16

    mov ebx, [esi + Image.Palette]

    mov esi, [esi + Image.Data]

  .bpp2i.pre:

    mov dx, bp

    mov ecx, 3

  .bpp2i.begin:

    mov eax, 3

    shl ecx, 1

    shl eax, cl

    and al, [esi]

    shr eax, cl

    shr ecx, 1

    mov eax, [ebx + eax*4]

    mov [edi], ax

    shr eax, 16

    mov [edi + 2], al

    add edi, 3

    dec dx

    jz .bpp2i.end_line

    dec ecx

    jns .bpp2i.begin

    mov ecx, 3

    inc esi

    jmp .bpp2i.begin

  .bpp2i.end_line:

    sub edx, 0x10000

    jz .bpp2i.quit

    inc esi

    jmp .bpp2i.pre

  .bpp2i.quit:

    pop ebp ebx

    ret

align 16

.bpp4i:

    push ebx ebp

    mov ebp, [esi + Image.Width]

    mov edx, [esi + Image.Height]

    shl edx, 16

    mov ebx, [esi + Image.Palette]

    mov esi, [esi + Image.Data]

  .bpp4i.pre:

    mov dx, bp

    mov ecx, 1

  .bpp4i.begin:

    mov eax, 15

    shl ecx, 2

    shl eax, cl

    and al, [esi]

    shr eax, cl

    shr ecx, 2

    mov eax, [ebx + eax*4]

    mov [edi], ax

    shr eax, 16

    mov [edi + 2], al

    add edi, 3

    dec dx

    jz .bpp4i.end_line

    dec ecx

    jns .bpp4i.begin

    mov ecx, 1

    inc esi

    jmp .bpp4i.begin

  .bpp4i.end_line:

    sub edx, 0x10000

    jz .bpp4i.quit

    inc esi

    jmp .bpp4i.pre

  .bpp4i.quit:

    pop ebp ebx

    ret

endp

;;================================================================================================;;

proc img.decode _data, _length, _options ;////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? decodes loaded into memory graphic file							  ;;

;;------------------------------------------------------------------------------------------------;;

;> [_data]    = pointer to file in memory							  ;;

;> [_length]  = size in bytes of memory area pointed to by [_data]				  ;;

;> [_options] = 0 / pointer to the structure of additional options				  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = 0 / pointer to image									  ;;

;;================================================================================================;;

    push    ebx

    mov ebx, [_length]

    or  ebx,ebx

    jz  .fail

    mov ebx, img.formats_table

    @@: stdcall [ebx + FormatsTableEntry.Is], [_data], [_length]

    or	eax, eax

    jnz @f

    add ebx, sizeof.FormatsTableEntry

    cmp dword[ebx], eax ;0

    jnz @b

  .fail:

    xor eax, eax

    pop ebx

    ret

    @@: mov eax, [ebx + FormatsTableEntry.Decode]

    pop ebx

    leave

    jmp eax

endp

;;================================================================================================;;

proc img.encode uses ebx, _img, _common, _specific ;////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? encode image to some format									  ;;

;;------------------------------------------------------------------------------------------------;;

;> [_img]      = pointer to input image 							  ;;

;> [_common]   = some most important/common options						  ;;

;     0x00 :  byte : format id (defined in libimg.inc)						  ;;

;     0x01 :  byte : fast encoding (0) / best compression ratio (255)				  ;;

;		     0 : store uncompressed data (if supported both by the format and libimg)	  ;;

;		     1 - 255 : use compression, if supported					  ;;

;		     this option may be ignored if any format specific options are defined	  ;;

;		     i.e. 0 here will be ignored if particular compression algorithm is specified ;;

;     0x02 :  byte : flags (bitfield)								  ;;

;		    0x01 : return an error if format specific conditions cannot be met		  ;;

;		    0x02 : preserve current bit depth. means 8bpp/16bpp/24bpp and so on 	  ;;

;		    0x04 : delete alpha channel, if any 					  ;;

;		    0x08 : flush alpha channel with 0xff, if any; add it if none		  ;;

;     0x03 :  byte : reserved, must be 0							  ;;

;> [_specific] = 0 / pointer to the structure of format specific options			  ;;

;		    see .inc for description					  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = 0 / pointer to encoded data								  ;;

;< ecx = error code / the size of encoded data							  ;;

;     1 : out of memory 									  ;;

;     2 : format is not supported								  ;;

;     3 : specific conditions cannot be satisfied						  ;;

;     4 : bit depth cannot be preserved 							  ;;

;;================================================================================================;;

	mov	ebx, [_img]

	movzx	eax, byte[_common]

	dec	eax

	imul	eax, sizeof.FormatsTableEntry

	add	eax, FormatsTableEntry.Capabilities

	add	eax, img.formats_table

	mov	eax, [eax]

	test	eax, 1				; is encoding to this format supported at all?

	jnz	@f

	mov	ecx, LIBIMG_ERROR_FORMAT

	jmp	.error

    @@:

	mov	ecx, [ebx + Image.Type]

	mov	edx, 1

	shl	edx, cl

	test	eax, edx

	jnz	.bit_depth_ok

	test	byte[_common+2], LIBIMG_ENCODE_STRICT_BIT_DEPTH

	jz	@f

	mov	ecx, LIBIMG_ERROR_BIT_DEPTH

	jmp	.error

    @@:

	mov	edx, 1 SHL Image.bpp24

	test	eax, edx

	jnz	@f

	mov	ecx, LIBIMG_ERROR_BIT_DEPTH

	jmp	.error

    @@:

	stdcall img.create, [ebx + Image.Width], [ebx + Image.Height], Image.bpp24

	test	eax, eax

	jnz	@f

	mov	ecx, LIBIMG_ERROR_OUT_OF_MEMORY

	jmp	.error

    @@:

	push	eax

	stdcall img.to_rgb2, ebx, [eax + Image.Data]

	pop	ebx

  .bit_depth_ok:

	movzx	eax, byte[_common]

	dec	eax

	imul	eax, sizeof.FormatsTableEntry

	add	eax, FormatsTableEntry.Encode

	add	eax, img.formats_table

	mov	eax, [eax]

	stdcall eax, [_img], [_common], [_specific]

	push	eax ecx

	cmp	ebx, [_img]

	je	@f

	stdcall img.destroy, ebx

    @@:

	pop	ecx eax

	jmp	.quit

  .error:

	xor	eax, eax

  .quit:

	ret

endp

;;================================================================================================;;

proc img.create _width, _height, _type ;//////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? creates an Image structure and initializes some its fields					  ;;

;;------------------------------------------------------------------------------------------------;;

;> [_width]  = width of an image in pixels							  ;;

;> [_height] = height of an image in pixels							  ;;

;> [_type]   = one of the Image.bppN constants from libimg.inc					  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = 0 / pointer to image									  ;;

;;================================================================================================;;

    push    ecx

    stdcall img._.new

    or	eax, eax

    jz	.error

    mov ecx, [_type]

    mov [eax + Image.Type], ecx

    push    eax

    stdcall img.resize_data, eax, [_width], [_height]

    or	eax, eax

    jz	.error.2

    pop eax

    jmp .ret

  .error.2:

;	pop	eax

    stdcall img._.delete; eax

    xor eax, eax

  .error:

  .ret:

    pop ecx

    ret

endp

;;================================================================================================;;

proc img.destroy.layer _img ;/////////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? frees memory occupied by an image and all the memory regions its fields point to		  ;;

;? for image sequences deletes only one frame and fixes Previous/Next pointers			  ;;

;;------------------------------------------------------------------------------------------------;;

;> [_img] = pointer to image									  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = 0 (fail) / 1 (success) 								  ;;

;;================================================================================================;;

    mov eax, [_img]

    mov edx, [eax + Image.Previous]

    test    edx, edx

    jz	@f

    push    [eax + Image.Next]

    pop [edx + Image.Next]

@@:

    mov edx, [eax + Image.Next]

    test    edx, edx

    jz	@f

    push    [eax + Image.Previous]

    pop [edx + Image.Previous]

@@:

    stdcall img._.delete, eax

    ret

endp

;;================================================================================================;;

proc img.destroy _img ;///////////////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? frees memory occupied by an image and all the memory regions its fields point to		  ;;

;? follows Previous/Next pointers and deletes all the images in sequence			  ;;

;;------------------------------------------------------------------------------------------------;;

;> [_img] = pointer to image									  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = 0 (fail) / 1 (success) 								  ;;

;;================================================================================================;;

    push    1

    mov eax, [_img]

    mov eax, [eax + Image.Previous]

.destroy_prev_loop:

    test    eax, eax

    jz	.destroy_prev_done

    pushd   [eax + Image.Previous]

    stdcall img._.delete, eax

    test    eax, eax

    jnz @f

    mov byte [esp+4], 0

@@:

    pop eax

    jmp .destroy_prev_loop

.destroy_prev_done:

    mov eax, [_img]

.destroy_next_loop:

    pushd   [eax + Image.Next]

    stdcall img._.delete, eax

    test    eax, eax

    jnz @f

    mov byte [esp+4], 0

@@:

    pop eax

    test    eax, eax

    jnz .destroy_next_loop

    pop eax

    ret

endp

;;================================================================================================;;

proc img.count _img ;/////////////////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? Get number of images in the list (e.g. in animated GIF file) 				  ;;

;;------------------------------------------------------------------------------------------------;;

;> _img = pointer to image									  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = -1 (fail) / >0 (ok)									  ;;

;;================================================================================================;;

    push    ecx edx

    mov edx, [_img]

    stdcall img._.validate, edx

    or	eax, eax

    jnz .error

    @@: mov eax, [edx + Image.Previous]

    or	eax, eax

    jz	@f

    mov edx, eax

    jmp @b

    @@: xor ecx, ecx

    @@: inc ecx

    mov eax, [edx + Image.Next]

    or	eax, eax

    jz	.exit

    mov edx, eax

    jmp @b

  .exit:

    mov eax, ecx

    pop edx ecx

    ret

  .error:

    or	eax, -1

    pop edx ecx

    ret

endp

;;//// image processing //////////////////////////////////////////////////////////////////////////;;

;;================================================================================================;;

proc img.lock_bits _img, _start_line, _end_line ;/////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;> --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = 0 / pointer to bits									  ;;

;;================================================================================================;;

    xor eax, eax

    ret

endp

;;================================================================================================;;

proc img.unlock_bits _img, _lock ;////////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;> --- TBD ---											  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = false / true										  ;;

;;================================================================================================;;

    xor eax, eax

    ret

endp

;;================================================================================================;;

proc img.flip.layer _img, _flip_kind ;////////////////////////////////////////////////////////////;;

;;------------------------------------------------------------------------------------------------;;

;? Flip image layer										  ;;

;;------------------------------------------------------------------------------------------------;;

;> _img = pointer to image									  ;;

;> _flip_kind = one of FLIP_* constants 							  ;;

;;------------------------------------------------------------------------------------------------;;

;< eax = false / true										  ;;

;;================================================================================================;;

locals

  scanline_len dd ?

endl

    push    ebx esi edi

    mov ebx, [_img]

    stdcall img._.validate, ebx

    or	eax, eax

    jnz .error

    mov ecx, [ebx + Image.Height]

    mov eax, [ebx + Image.Width]

    call    img._.get_scanline_len

    mov [scanline_len], eax

    test    [_flip_kind], FLIP_VERTICAL

    jz	.dont_flip_vert

    imul    eax, ecx

    sub eax, [scanline_len]

    shr ecx, 1

    mov esi, [ebx + Image.Data]

    lea edi, [esi + eax]

  .next_line_vert:

    push    ecx

    mov ecx, [scanline_len]

    push    ecx

    shr ecx, 2

    @@:

    dec ecx

    js	@f

    mov eax, [esi]

    xchg    eax, [edi]

    mov [esi], eax

    add esi, 4

    add edi, 4

    jmp @b

    @@:

    pop ecx

    and ecx, 3

    jz	.cont_line_vert

    @@:

    mov al, [esi]

    xchg    al, [edi]

    mov [esi], al

    add esi, 1

    add edi, 1

    dec ecx

    jnz @b

    .cont_line_vert:

    pop ecx

    mov eax, [scanline_len]

    shl eax, 1

    sub edi, eax

    dec ecx

    jnz .next_line_vert

  .dont_flip_vert:

    test    [_flip_kind], FLIP_HORIZONTAL

    jz	.exit

    mov ecx, [ebx + Image.Height]

    mov eax, [ebx + Image.Type]

    mov esi, [ebx + Image.Data]

    mov edi, [scanline_len]

    add edi, esi

    jmp dword [.handlers_horz + (eax-1)*4]

.bpp32_horz:

    sub edi, 4

  .next_line_horz:

    push    ecx esi edi

    mov ecx, [scanline_len]