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


;;================================================================================================;;
;;//// 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 '../../../../develop/libraries/libs-dev/libio/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'
 
;;================================================================================================;;
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
DEBUGF 2, 'img.from_file: %s\n', [_filename]
	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, 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
    pop ebx
    ret
    @@: mov eax, [ebx + FormatsTableEntry.Decode]
    pop ebx
    leave
    jmp eax
endp
 
;;================================================================================================;;
proc img.encode _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]
    shr ecx, 3
    @@: mov eax, [esi]
    xchg    eax, [edi]
    mov [esi], eax
    add esi, 4
    add edi, -4
    sub ecx, 1
    jnz @b
 
    pop edi esi ecx
    add esi, [scanline_len]
    add edi, [scanline_len]
    dec ecx
    jnz .next_line_horz
    jmp .exit
 
.bpp1x_horz:
    sub edi, 2
  .next_line_horz1x:
    push    ecx esi edi
 
    mov ecx, [ebx + Image.Width]
    @@: mov ax, [esi]
    mov dx, [edi]
    mov [edi], ax
    mov [esi], dx
    add esi, 2
    sub edi, 2
    sub ecx, 2
    ja  @b
 
    pop edi esi ecx
    add esi, [scanline_len]
    add edi, [scanline_len]
    dec ecx
    jnz .next_line_horz1x
    jmp .exit
 
.bpp8ig_horz:
    dec edi
  .next_line_horz8ig:
    push    ecx esi edi
 
    mov ecx, [scanline_len]
    shr ecx, 1
    @@: mov al, [esi]
    mov dl, [edi]
    mov [edi], al
    mov [esi], dl
    add esi, 1
    sub edi, 1
    sub ecx, 1
    jnz @b
 
    pop edi esi ecx
    add esi, [scanline_len]
    add edi, [scanline_len]
    dec ecx
    jnz .next_line_horz8ig
    jmp .exit
 
.bpp24_horz:
    sub edi, 3
  .next_line_horz24:
    push    ecx esi edi
 
    mov ecx, [ebx + Image.Width]
    @@:
    mov al, [esi]
    mov dl, [edi]
    mov [edi], al
    mov [esi], dl
    mov al, [esi+1]
    mov dl, [edi+1]
    mov [edi+1], al
    mov [esi+1], dl
    mov al, [esi+2]
    mov dl, [edi+2]
    mov [edi+2], al
    mov [esi+2], dl
    add esi, 3
    sub edi, 3
    sub ecx, 2
    ja  @b
 
    pop edi esi ecx
    add esi, [scanline_len]
    add edi, [scanline_len]
    dec ecx
    jnz .next_line_horz24
    jmp .exit
 
.bpp1_horz:
    mov edi, [scanline_len]
    mov edx, [ebx + Image.Width]
    and edx, 7
    neg edx
    add edx, 8
    and edx, 7
.bpp1_horz.begin:
    push ebx edx esi
    mov eax, 7
    add edi, esi
    sub edi, 1
    mov ebx, [ebx + Image.Width]
    shr ebx, 1
.bpp1_horz.bit:
    bt  [edi], edx
    jc  @f
    btr [esi], eax
    jmp .bpp1_horz.right
  @@:
    bts [esi], eax
  .bpp1_horz.right:
    jnc @f
    bts [edi], edx
    jmp .bpp1_horz.bit_done
  @@:
    btr [edi], edx
  .bpp1_horz.bit_done:
    inc edx
    and edx, 7
    jnz @f
    dec edi
  @@:
    dec eax
    jns @f
    mov eax, 7
    inc esi
  @@:
    dec ebx
    jnz .bpp1_horz.bit
 
    pop esi edx ebx
    add esi, [scanline_len]
    mov edi, [scanline_len]
    dec ecx
    jnz .bpp1_horz.begin
    jmp .exit
 
 
.bpp2i_horz:
    mov edi, [scanline_len]
    mov edx, [ebx + Image.Width]
    and edx, 3
    neg edx
    add edx, 4
    and edx, 3
.bpp2i_horz.begin:
    push ebx edx esi
    mov eax, 3
    add edi, esi
    sub edi, 1
    mov ebx, [ebx + Image.Width]
    shr ebx, 1
.bpp2i_horz.pixel:
    push ebx ecx
    mov ebx, 3
    mov ecx, edx
    shl ebx, cl
    shl ebx, cl
    and bl, [edi]
    shr ebx, cl
    shr ebx, cl
    mov bh,  3
    mov ecx, eax
    shl ebx, cl
    shl ebx, cl
    not bh
    and bh, [esi]
    or  bl, bh
    mov bh, [esi]
    mov [esi], bl
    shr ebx, 8
    shr ebx, cl
    shr ebx, cl
    and ebx, 3
    mov bh,  3
    mov ecx, edx
    shl ebx, cl
    shl ebx, cl
    not bh
    and bh, [edi]
    or  bl, bh
    mov [edi], bl
    pop ecx ebx
  .bpp2i_horz.pixel_done:
    inc edx
    and edx, 3
    jnz @f
    dec edi
  @@:
    dec eax
    jns @f
    mov eax, 3
    inc esi
  @@:
    dec ebx
    jnz .bpp2i_horz.pixel
 
    pop esi edx ebx
    add esi, [scanline_len]
    mov edi, [scanline_len]
    dec ecx
    jnz .bpp2i_horz.begin
    jmp .exit
 
 
.bpp4i_horz:
    mov edi, [scanline_len]
    mov edx, [ebx + Image.Width]
    and edx, 1
    neg edx
    add edx, 2
    and edx, 1
.bpp4i_horz.begin:
    push ebx edx esi
    mov eax, 1
    add edi, esi
    sub edi, 1
    mov ebx, [ebx + Image.Width]
    shr ebx, 1
.bpp4i_horz.pixel:
    push ebx ecx
    mov ebx, 15
    mov ecx, edx
    shl ecx, 2
    shl ebx, cl
    and bl, [edi]
    shr ebx, cl
    mov bh,  15
    mov ecx, eax
    shl ecx, 2
    shl ebx, cl
    not bh
    and bh, [esi]
    or  bl, bh
    mov bh, [esi]
    mov [esi], bl
    shr ebx, 8
    shr ebx, cl
    and ebx, 15
    mov bh,  15
    mov ecx, edx
    shl ecx, 2
    shl ebx, cl
    not bh
    and bh, [edi]
    or  bl, bh
    mov [edi], bl
    pop ecx ebx
  .bpp4i_horz.pixel_done:
    inc edx
    and edx, 1
    jnz @f
    dec edi
  @@:
    dec eax
    jns @f
    mov eax, 1
    inc esi
  @@:
    dec ebx
    jnz .bpp4i_horz.pixel
 
    pop esi edx ebx
    add esi, [scanline_len]
    mov edi, [scanline_len]
    dec ecx
    jnz .bpp4i_horz.begin
    jmp .exit
 
 
  .exit:
    xor eax, eax
    inc eax
    pop edi esi ebx
    ret
 
  .error:
    xor eax, eax
    pop edi esi ebx
    ret
endp
 
;;================================================================================================;;
proc img.flip _img, _flip_kind ;//////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Flip all layers of image                                                                       ;;
;;------------------------------------------------------------------------------------------------;;
;> _img = pointer to image                                                                        ;;
;> _flip_kind = one of FLIP_* constants                                                           ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = false / true                                                                             ;;
;;================================================================================================;;
    push    1
    mov ebx, [_img]
@@:
    mov eax, [ebx + Image.Previous]
    test    eax, eax
    jz  .loop
    mov ebx, eax
    jmp @b
.loop:
    stdcall img.flip.layer, ebx, [_flip_kind]
    test    eax, eax
    jnz @f
    mov byte [esp], 0
@@:
    mov ebx, [ebx + Image.Next]
    test    ebx, ebx
    jnz .loop
    pop eax
    ret
endp
 
;;================================================================================================;;
proc img.rotate.layer _img, _rotate_kind ;////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Rotate image layer                                                                             ;;
;;------------------------------------------------------------------------------------------------;;
;> _img = pointer to image                                                                        ;;
;> _rotate_kind = one of ROTATE_* constants                                                       ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = false / true                                                                             ;;
;;================================================================================================;;
locals
  scanline_len_old    dd ?
  scanline_len_new    dd ?
  scanline_pixels_new dd ?
  line_buffer         dd ?
  pixels_ptr          dd ?
endl
 
    mov [line_buffer], 0
 
    push    ebx esi edi
    mov ebx, [_img]
    stdcall img._.validate, ebx
    or  eax, eax
    jnz .error
 
    cmp [_rotate_kind], ROTATE_90_CCW
    je  .rotate_ccw_low
    cmp [_rotate_kind], ROTATE_90_CW
    je  .rotate_cw_low
    cmp [_rotate_kind], ROTATE_180
    je  .flip
    jmp .exit
 
  .rotate_ccw_low:
    mov eax, [ebx + Image.Height]
    mov [scanline_pixels_new], eax
    call    img._.get_scanline_len
    mov [scanline_len_new], eax
 
    invoke  mem.alloc, eax
    or  eax, eax
    jz  .error
    mov [line_buffer], eax
 
    mov eax, [ebx + Image.Width]
    mov ecx, eax
    call    img._.get_scanline_len
    mov [scanline_len_old], eax
 
    mov eax, [scanline_len_new]
    imul    eax, ecx
    add eax, [ebx + Image.Data]
    mov [pixels_ptr], eax
 
    cmp [ebx + Image.Type], Image.bpp1
    jz  .rotate_ccw1
    cmp [ebx + Image.Type], Image.bpp2i
    jz  .rotate_ccw2i
    cmp [ebx + Image.Type], Image.bpp4i
    jz  .rotate_ccw4i
    cmp [ebx + Image.Type], Image.bpp8i
    jz  .rotate_ccw8ig
    cmp [ebx + Image.Type], Image.bpp8g
    jz  .rotate_ccw8ig
    cmp [ebx + Image.Type], Image.bpp24
    jz  .rotate_ccw24
    cmp [ebx + Image.Type], Image.bpp32
    jz  .rotate_ccw32
 
  .next_column_ccw_low1x:
    dec ecx
    js  .exchange_dims
    push    ecx
 
    mov edx, [scanline_len_old]
    add [scanline_len_old], -2
 
    mov ecx, [scanline_pixels_new]
    mov esi, [ebx + Image.Data]
    mov edi, [line_buffer]
    @@: mov ax, [esi]
    mov [edi], ax
    add esi, edx
    add edi, 2
    sub ecx, 1
    jnz @b
 
    mov eax, [scanline_pixels_new]
    mov edi, [ebx + Image.Data]
    lea esi, [edi + 2]
    mov edx, [scanline_len_old]
    @@: mov ecx, edx
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
    add esi, 1
    sub eax, 1
    jnz @b
 
    mov eax, [scanline_len_new]
    sub [pixels_ptr], eax
    mov ecx, [scanline_pixels_new]
    mov esi, [line_buffer]
    mov edi, [pixels_ptr]
    mov edx, ecx
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
 
    pop ecx
    jmp .next_column_ccw_low1x
 
.rotate_ccw32:
  .next_column_ccw_low:
    dec ecx
    js  .exchange_dims
    push    ecx
 
    mov edx, [scanline_len_old]
    add [scanline_len_old], -4
 
    mov ecx, [scanline_pixels_new]
    mov esi, [ebx + Image.Data]
    mov edi, [line_buffer]
    @@: mov eax, [esi]
    stosd
    add esi, edx
    dec ecx
    jnz @b
 
    mov eax, [scanline_pixels_new]
    mov edi, [ebx + Image.Data]
    lea esi, [edi + 4]
    mov edx, [scanline_len_old]
    shr edx, 2
    @@: mov ecx, edx
    rep movsd
    add esi, 4
    dec eax
    jnz @b
 
    mov eax, [scanline_len_new]
    sub [pixels_ptr], eax
    mov ecx, [scanline_pixels_new]
    mov esi, [line_buffer]
    mov edi, [pixels_ptr]
    rep movsd
 
    pop ecx
    jmp .next_column_ccw_low
 
.rotate_ccw8ig:
  .next_column_ccw_low8ig:
    dec ecx
    js  .exchange_dims
    push    ecx
 
    mov edx, [scanline_len_old]
    add [scanline_len_old], -1
 
    mov ecx, [scanline_pixels_new]
    mov esi, [ebx + Image.Data]
    mov edi, [line_buffer]
    @@: mov al, [esi]
    mov [edi], al
    add esi, edx
    add edi, 1
    sub ecx, 1
    jnz @b
 
    mov eax, [scanline_pixels_new]
    mov edi, [ebx + Image.Data]
    lea esi, [edi + 1]
    mov edx, [scanline_len_old]
    @@: mov ecx, edx
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
    add esi, 1
    sub eax, 1
    jnz @b
 
    mov eax, [scanline_len_new]
    sub [pixels_ptr], eax
    mov ecx, [scanline_pixels_new]
    mov esi, [line_buffer]
    mov edi, [pixels_ptr]
    mov edx, ecx
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
 
    pop ecx
    jmp .next_column_ccw_low8ig
 
.rotate_ccw24:
  .next_column_ccw_low24:
    dec ecx
    js  .exchange_dims
    push    ecx
 
    mov edx, [scanline_len_old]
    add [scanline_len_old], -3
 
    mov ecx, [scanline_pixels_new]
    mov esi, [ebx + Image.Data]
    mov edi, [line_buffer]
    @@: mov al, [esi]
    mov [edi], al
    mov al, [esi+1]
    mov [edi+1], al
    mov al, [esi+2]
    mov [edi+2], al
    add esi, edx
    add edi, 3
    sub ecx, 1
    jnz @b
 
    mov eax, [scanline_pixels_new]
    mov edi, [ebx + Image.Data]
    lea esi, [edi + 3]
    mov edx, [scanline_len_old]
    @@: mov ecx, edx
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
    add esi, 3
    sub eax, 1
    jnz @b
 
    mov eax, [scanline_len_new]
    sub [pixels_ptr], eax
    mov ecx, eax
    mov esi, [line_buffer]
    mov edi, [pixels_ptr]
    shr ecx, 2
    rep movsd
    mov ecx, eax
    and ecx, 3
    rep movsb
 
    pop ecx
    jmp .next_column_ccw_low24
 
.rotate_ccw1:
    push ecx edx
 
    mov eax, [ebx + Image.Height]
    add eax, 7
    shr eax, 3
    imul eax, [ebx + Image.Width]
    push eax                                            ; save new data size
 
    invoke  mem.alloc, eax
    or  eax, eax
    jz  .error
    push eax                                            ; save pointer to new data
 
    mov ecx, [ebx + Image.Width]
    and ecx, 7
    neg ecx
    add ecx, 8
    and ecx, 7
 
    mov edi, eax
    mov esi, [ebx + Image.Data]
    mov eax, 7
    mov edx, [scanline_len_old]
    dec edx
    add esi, edx
 
  .rotate_ccw1.begin:
    bt  [esi], ecx
    jc .rotate_ccw1.one
  .rotate_ccw1.zero:
    btr [edi], eax
    jmp @f
  .rotate_ccw1.one:
    bts [edi], eax
  @@:
    add esi, [scanline_len_old]
    dec [scanline_pixels_new]
    jz .rotate_ccw1.end_of_line
    sub eax, 1
    adc edi, 0
    and eax, 7
    jmp .rotate_ccw1.begin
  .rotate_ccw1.end_of_line:
    inc edi
    mov eax, [ebx + Image.Height]
    mov [scanline_pixels_new], eax
    mov eax, 7
    inc ecx
    and ecx, 7
    jz @f
    mov esi, [ebx + Image.Data]
    add esi, edx
    jmp .rotate_ccw1.begin 
  @@:
    dec edx
    js .rotate_ccw1.quit
    mov esi, [ebx + Image.Data]
    add esi, edx
    jmp .rotate_ccw1.begin
  .rotate_ccw1.quit:
    pop esi                                             ; get pointer to new data
    mov edi, [ebx + Image.Data]
    pop ecx                                             ; get new data size
    rep movsb
    invoke  mem.free, esi
    pop edx ecx
     jmp .exchange_dims
 
 
.rotate_ccw2i:
    push ecx edx
 
    mov eax, [ebx + Image.Height]
    add eax, 3
    shr eax, 2
    imul eax, [ebx + Image.Width]
    push eax                                            ; save new data size
 
    invoke  mem.alloc, eax
    or  eax, eax
    jz  .error
    push eax                                            ; save pointer to new data
 
    mov ecx, [ebx + Image.Width]
    and ecx, 3
    neg ecx
    add ecx, 4
    and ecx, 3
 
    mov edi, eax
    mov esi, [ebx + Image.Data]
    mov eax, 3
    mov edx, [scanline_len_old]
    dec edx
    add esi, edx
 
  .rotate_ccw2i.begin:
    push ebx ecx
    mov ebx, 3
    shl ebx, cl
    shl ebx, cl
    and bl, [esi]
    shr ebx, cl
    shr ebx, cl
    mov bh, 3
    mov ecx, eax
    shl ebx, cl
    shl ebx, cl
    not bh
    and bh, [edi]
    or  bl, bh
    mov [edi], bl
    pop ecx ebx
 
    add esi, [scanline_len_old]
    dec [scanline_pixels_new]
    jz .rotate_ccw2i.end_of_line
    sub eax, 1
    adc edi, 0
    and eax, 3
    jmp .rotate_ccw2i.begin
  .rotate_ccw2i.end_of_line:
    inc edi
    mov eax, 3
    mov esi, [ebx + Image.Height]
    mov [scanline_pixels_new], esi
    inc ecx
    and ecx, 3
    jz @f
    mov esi, [ebx + Image.Data]
    add esi, edx
    jmp .rotate_ccw2i.begin 
  @@:
    dec edx
    js .rotate_ccw2i.quit
    mov esi, [ebx + Image.Data]
    add esi, edx
    jmp .rotate_ccw2i.begin
  .rotate_ccw2i.quit:
    pop esi                                             ; get pointer to new data
    mov edi, [ebx + Image.Data]
    pop ecx                                             ; get new data size
    rep movsb
    invoke  mem.free, esi
    pop edx ecx
     jmp .exchange_dims
 
 
.rotate_ccw4i:
    push ecx edx
 
    mov eax, [ebx + Image.Height]
    add eax, 1
    shr eax, 1
    imul eax, [ebx + Image.Width]
    push eax                                            ; save new data size
 
    invoke  mem.alloc, eax
    or  eax, eax
    jz  .error
    push eax                                            ; save pointer to new data
 
    mov ecx, [ebx + Image.Width]
    and ecx, 1
    neg ecx
    add ecx, 2
    and ecx, 1
 
    mov edi, eax
    mov esi, [ebx + Image.Data]
    mov eax, 1
    mov edx, [scanline_len_old]
    dec edx
    add esi, edx
 
  .rotate_ccw4i.begin:
    push ebx ecx
    mov ebx, 15
    shl ecx, 2
    shl ebx, cl
    and bl, [esi]
    shr ebx, cl
    mov bh, 15
    mov ecx, eax
    shl ecx, 2
    shl ebx, cl
    not bh
    and bh, [edi]
    or  bl, bh
    mov [edi], bl
    pop ecx ebx
 
    add esi, [scanline_len_old]
    dec [scanline_pixels_new]
    jz .rotate_ccw4i.end_of_line
    sub eax, 1
    adc edi, 0
    and eax, 1
    jmp .rotate_ccw4i.begin
  .rotate_ccw4i.end_of_line:
    inc edi
    mov eax, 1
    mov esi, [ebx + Image.Height]
    mov [scanline_pixels_new], esi
    inc ecx
    and ecx, 1
    jz @f
    mov esi, [ebx + Image.Data]
    add esi, edx
    jmp .rotate_ccw4i.begin 
  @@:
    dec edx
    js .rotate_ccw4i.quit
    mov esi, [ebx + Image.Data]
    add esi, edx
    jmp .rotate_ccw4i.begin
  .rotate_ccw4i.quit:
    pop esi                                             ; get pointer to new data
    mov edi, [ebx + Image.Data]
    pop ecx                                             ; get new data size
    rep movsb
    invoke  mem.free, esi
    pop edx ecx
     jmp .exchange_dims
 
 
 
  .rotate_cw_low:
    mov eax, [ebx + Image.Height]
    mov [scanline_pixels_new], eax
    call    img._.get_scanline_len
    mov [scanline_len_new], eax
 
    invoke  mem.alloc, eax
    or  eax, eax
    jz  .error
    mov [line_buffer], eax
 
    mov eax, [ebx + Image.Width]
    mov ecx, eax
    call    img._.get_scanline_len
    mov [scanline_len_old], eax
 
    mov eax, [scanline_len_new]
    imul    eax, ecx
    add eax, [ebx + Image.Data]
    mov [pixels_ptr], eax
 
    cmp [ebx + Image.Type], Image.bpp1
    jz  .rotate_cw1
    cmp [ebx + Image.Type], Image.bpp2i
    jz  .rotate_cw2i
    cmp [ebx + Image.Type], Image.bpp4i
    jz  .rotate_cw4i
    cmp [ebx + Image.Type], Image.bpp8i
    jz  .rotate_cw8ig
    cmp [ebx + Image.Type], Image.bpp8g
    jz  .rotate_cw8ig
    cmp [ebx + Image.Type], Image.bpp24
    jz  .rotate_cw24
    cmp [ebx + Image.Type], Image.bpp32
    jz  .rotate_cw32
 
  .next_column_cw_low1x:
    dec ecx
    js  .exchange_dims
    push    ecx
 
    mov edx, [scanline_len_old]
    add [scanline_len_old], -2
 
    mov ecx, [scanline_pixels_new]
    mov esi, [pixels_ptr]
    add esi, -2
    mov edi, [line_buffer]
    @@: mov ax, [esi]
    mov [edi], ax
    sub esi, edx
    add edi, 2
    sub ecx, 1
    jnz @b
 
    mov eax, [scanline_pixels_new]
    dec eax
    mov edi, [ebx + Image.Data]
    add edi, [scanline_len_old]
    lea esi, [edi + 2]
    mov edx, [scanline_len_old]
    @@: mov ecx, edx
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
    add esi, 3
    sub eax, 1
    jnz @b
 
    mov eax, [scanline_len_new]
    sub [pixels_ptr], eax
    mov ecx, eax
    mov esi, [line_buffer]
    mov edi, [pixels_ptr]
    shr ecx, 2
    rep movsd
    mov ecx, eax
    and ecx, 3
    rep movsb
 
    pop ecx
    jmp .next_column_cw_low1x
 
.rotate_cw32:
  .next_column_cw_low:
    dec ecx
    js  .exchange_dims
    push    ecx
 
    mov edx, [scanline_len_old]
    add [scanline_len_old], -4
 
    mov ecx, [scanline_pixels_new]
    mov esi, [pixels_ptr]
    add esi, -4
    mov edi, [line_buffer]
    @@: mov eax, [esi]
    stosd
    sub esi, edx
    dec ecx
    jnz @b
 
    mov eax, [scanline_pixels_new]
    dec eax
    mov edi, [ebx + Image.Data]
    add edi, [scanline_len_old]
    lea esi, [edi + 4]
    mov edx, [scanline_len_old]
    shr edx, 2
    @@: mov ecx, edx
    rep movsd
    add esi, 4
    dec eax
    jnz @b
 
    mov eax, [scanline_len_new]
    sub [pixels_ptr], eax
    mov ecx, [scanline_pixels_new]
    mov esi, [line_buffer]
    mov edi, [pixels_ptr]
    rep movsd
 
    pop ecx
    jmp .next_column_cw_low
 
.rotate_cw8ig:
  .next_column_cw_low8ig:
    dec ecx
    js  .exchange_dims
    push    ecx
 
    mov edx, [scanline_len_old]
    add [scanline_len_old], -1
 
    mov ecx, [scanline_pixels_new]
    mov esi, [pixels_ptr]
    add esi, -1
    mov edi, [line_buffer]
    @@: mov al, [esi]
    mov [edi], al
    sub esi, edx
    add edi, 1
    sub ecx, 1
    jnz @b
 
    mov eax, [scanline_pixels_new]
    dec eax
    mov edi, [ebx + Image.Data]
    add edi, [scanline_len_old]
    lea esi, [edi + 1]
    mov edx, [scanline_len_old]
    @@: mov ecx, edx
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
    add esi, 1
    sub eax, 1
    jnz @b
 
    mov eax, [scanline_len_new]
    sub [pixels_ptr], eax
    mov ecx, eax
    mov esi, [line_buffer]
    mov edi, [pixels_ptr]
    shr ecx, 2
    rep movsd
    mov ecx, eax
    and ecx, 3
    rep movsb
 
    pop ecx
    jmp .next_column_cw_low8ig
 
.rotate_cw24:
  .next_column_cw_low24:
    dec ecx
    js  .exchange_dims
    push    ecx
 
    mov edx, [scanline_len_old]
    add [scanline_len_old], -3
 
    mov ecx, [scanline_pixels_new]
    mov esi, [pixels_ptr]
    add esi, -3
    mov edi, [line_buffer]
    @@: mov al, [esi]
    mov [edi], al
    mov al, [esi+1]
    mov [edi+1], al
    mov al, [esi+2]
    mov [edi+2], al
    sub esi, edx
    add edi, 3
    sub ecx, 1
    jnz @b
 
    mov eax, [scanline_pixels_new]
    dec eax
    mov edi, [ebx + Image.Data]
    add edi, [scanline_len_old]
    lea esi, [edi + 3]
    mov edx, [scanline_len_old]
    @@: mov ecx, edx
    shr ecx, 2
    rep movsd
    mov ecx, edx
    and ecx, 3
    rep movsb
    add esi, 3
    sub eax, 1
    jnz @b
 
    mov eax, [scanline_len_new]
    sub [pixels_ptr], eax
    mov ecx, eax
    mov esi, [line_buffer]
    mov edi, [pixels_ptr]
    shr ecx, 2
    rep movsd
    mov ecx, eax
    and ecx, 3
    rep movsb
 
    pop ecx
    jmp .next_column_cw_low24
 
 
.rotate_cw1:
    push ecx edx
 
    mov eax, [ebx + Image.Height]
    add eax, 7
    shr eax, 3
    imul [ebx + Image.Width]
    push eax                                            ; save new data size
 
    invoke  mem.alloc, eax
    or  eax, eax
    jz  .error
    push eax                                            ; save pointer to new data
 
    mov edi, eax
    mov esi, [ebx + Image.Data]
    mov eax, [ebx + Image.Height]
    dec eax
    imul eax, [scanline_len_old]
    add esi, eax
    mov eax, 7
    mov ecx, 7
    mov edx, 0
 
  .rotate_cw1.begin:
    bt  [esi], ecx
    jc .rotate_cw1.one
  .rotate_cw1.zero:
    btr [edi], eax
    jmp @f
  .rotate_cw1.one:
    bts [edi], eax
  @@:
    sub esi, [scanline_len_old]
    dec [scanline_pixels_new]
    jz  .rotate_cw1.end_of_line
    sub eax, 1
    adc edi, 0
    and eax, 7
    jmp .rotate_cw1.begin
  .rotate_cw1.end_of_line:
    inc edi
    mov eax, [ebx + Image.Height]
    mov [scanline_pixels_new],   eax
    mov eax, 7
    dec ecx
    jns @f
    mov ecx, 7
    inc edx
    cmp edx, [scanline_len_old]
    je .rotate_cw1.quit
  @@:
    mov esi, [ebx + Image.Height]
    dec esi
    imul esi, [scanline_len_old]
    add esi, [ebx + Image.Data]
    add esi, edx
    jmp .rotate_cw1.begin
  .rotate_cw1.quit:
    pop eax                                             ; get pointer to new data
    mov esi, eax
    mov edi, [ebx + Image.Data]
    pop ecx                                             ; get new data size
    rep movsb
    invoke  mem.free, eax
    pop edx ecx
    jmp .exchange_dims
 
 
.rotate_cw2i:
    push ecx edx
 
    mov eax, [ebx + Image.Height]
    add eax, 3
    shr eax, 2
    imul [ebx + Image.Width]
    push eax                                            ; save new data size
 
    invoke  mem.alloc, eax
    or  eax, eax
    jz  .error
    push eax                                            ; save pointer to new data
 
    mov edi, eax
    mov esi, [ebx + Image.Data]
    mov eax, [ebx + Image.Height]
    dec eax
    imul eax, [scanline_len_old]
    add esi, eax
    mov eax, 3
    mov ecx, 3
    mov edx, 0
 
  .rotate_cw2i.begin:
    push ebx ecx
    mov ebx, 3
    shl ebx, cl
    shl ebx, cl
    and bl, [esi]
    shr ebx, cl
    shr ebx, cl
    mov bh, 3
    mov ecx, eax
    shl ebx, cl
    shl ebx, cl
    not bh
    and bh, [edi]
    or  bl, bh
    mov [edi], bl
    pop ecx ebx
 
    sub esi, [scanline_len_old]
    dec [scanline_pixels_new]
    jz  .rotate_cw2i.end_of_line
    sub eax, 1
    adc edi, 0
    and eax, 3
    jmp .rotate_cw2i.begin
  .rotate_cw2i.end_of_line:
    inc edi
    mov eax, [ebx + Image.Height]
    mov [scanline_pixels_new],   eax
    mov eax, 3
    dec ecx
    jns @f
    mov ecx, 3
    inc edx
    cmp edx, [scanline_len_old]
    je .rotate_cw2i.quit
  @@:
    mov esi, [ebx + Image.Height]
    dec esi
    imul esi, [scanline_len_old]
    add esi, [ebx + Image.Data]
    add esi, edx
    jmp .rotate_cw2i.begin
  .rotate_cw2i.quit:
    pop eax                                             ; get pointer to new data
    mov esi, eax
    mov edi, [ebx + Image.Data]
    pop ecx                                             ; get new data size
    rep movsb
    invoke  mem.free, eax
    pop edx ecx
    jmp .exchange_dims
 
 
.rotate_cw4i:
    push ecx edx
 
    mov eax, [ebx + Image.Height]
    add eax, 1
    shr eax, 1
    imul [ebx + Image.Width]
    push eax                                            ; save new data size
 
    invoke  mem.alloc, eax
    or  eax, eax
    jz  .error
    push eax                                            ; save pointer to new data
 
    mov edi, eax
    mov esi, [ebx + Image.Data]
    mov eax, [ebx + Image.Height]
    dec eax
    imul eax, [scanline_len_old]
    add esi, eax
    mov eax, 1
    mov ecx, 1
    mov edx, 0
 
  .rotate_cw4i.begin:
    push ebx ecx
    mov ebx, 15
    shl ecx, 2
    shl ebx, cl
    and bl, [esi]
    shr ebx, cl
    mov bh, 15
    mov ecx, eax
    shl ecx, 2
    shl ebx, cl
    not bh
    and bh, [edi]
    or  bl, bh
    mov [edi], bl
    pop ecx ebx
 
    sub esi, [scanline_len_old]
    dec [scanline_pixels_new]
    jz  .rotate_cw4i.end_of_line
    sub eax, 1
    adc edi, 0
    and eax, 1
    jmp .rotate_cw4i.begin
  .rotate_cw4i.end_of_line:
    inc edi
    mov eax, [ebx + Image.Height]
    mov [scanline_pixels_new],   eax
    mov eax, 1
    dec ecx
    jns @f
    mov ecx, 1
    inc edx
    cmp edx, [scanline_len_old]
    je .rotate_cw4i.quit
  @@:
    mov esi, [ebx + Image.Height]
    dec esi
    imul esi, [scanline_len_old]
    add esi, [ebx + Image.Data]
    add esi, edx
    jmp .rotate_cw4i.begin
  .rotate_cw4i.quit:
    pop eax                                             ; get pointer to new data
    mov esi, eax
    mov edi, [ebx + Image.Data]
    pop ecx                                             ; get new data size
    rep movsb
    invoke  mem.free, eax
    pop edx ecx
    jmp .exchange_dims
 
 
  .flip:
    stdcall img.flip.layer, [_img], FLIP_VERTICAL
    test eax, eax
    jz  .error
    jmp .exit
 
  .exchange_dims:
    push    [ebx + Image.Width] [ebx + Image.Height]
    pop [ebx + Image.Width] [ebx + Image.Height]
 
  .exit:
    invoke  mem.free, [line_buffer]
    xor eax, eax
    inc eax
    pop edi esi ebx
    ret
 
  .error:
    invoke  mem.free, [line_buffer]
    xor eax, eax
    pop edi esi ebx
    ret
endp
 
;;================================================================================================;;
proc img.rotate _img, _rotate_kind ;//////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Rotate all layers of image                                                                     ;;
;;------------------------------------------------------------------------------------------------;;
;> _img = pointer to image                                                                        ;;
;> _rotate_kind = one of ROTATE_* constants                                                       ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = false / true                                                                             ;;
;;================================================================================================;;
    push    1
    mov ebx, [_img]
@@:
    mov eax, [ebx + Image.Previous]
    test    eax, eax
    jz  .loop
    mov ebx, eax
    jmp @b
.loop:
    stdcall img.rotate.layer, ebx, [_rotate_kind]
    test    eax, eax
    jnz @f
    mov byte [esp], 0
@@:
    mov ebx, [ebx + Image.Next]
    test    ebx, ebx
    jnz .loop
    pop eax
    ret
endp
 
;;================================================================================================;;
proc img.draw _img, _x, _y, _width, _height, _xpos, _ypos ;///////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Draw image in the window                                                                       ;;
;;------------------------------------------------------------------------------------------------;;
;> _img = pointer to image                                                                        ;;
;>_x = x-coordinate in the window                                                                 ;;
;>_y = y-coordinate in the window                                                                 ;;
;>_width = maximum width to draw                                                                  ;;
;>_height = maximum height to draw                                                                ;;
;>_xpos = offset in image by x-axis                                                               ;;
;>_ypos = offset in image by y-axis                                                               ;;
;;------------------------------------------------------------------------------------------------;;
;< no return value                                                                                ;;
;;================================================================================================;;
    push    ebx esi edi
    mov ebx, [_img]
    stdcall img._.validate, ebx
    test    eax, eax
    jnz .done
    mov ecx, [ebx + Image.Width]
    sub ecx, [_xpos]
    jbe .done
    cmp ecx, [_width]
    jb  @f
    mov ecx, [_width]
@@:
    mov edx, [ebx + Image.Height]
    sub edx, [_ypos]
    jbe .done
    cmp edx, [_height]
    jb  @f
    mov edx, [_height]
@@:
    mov eax, [ebx + Image.Width]
    sub eax, ecx
    call    img._.get_scanline_len
    shl ecx, 16
    add ecx, edx
    push    eax
    mov eax, [ebx + Image.Width]
    imul    eax, [_ypos]
    add eax, [_xpos]
    call    img._.get_scanline_len
    add eax, [ebx + Image.Data]
    mov edx, [_x - 2]
    mov dx, word [_y]
    mov esi, [ebx + Image.Type]
    mov esi, [type2bpp + (esi-1)*4]
    mov edi, [ebx + Image.Palette]
    xchg    eax, ebx
    pop eax
    push    ebp
    push    65
    pop ebp
    xchg    eax, ebp
    int 40h
    pop ebp
.done:
    pop edi esi ebx
    ret
endp
 
 
align 4
img.formats_table:
  .bmp  dd LIBIMG_FORMAT_BMP,  img.is.bmp,  img.decode.bmp,     img.encode.bmp, 1 + (1 SHL Image.bpp24) + (1 SHL Image.bpp32)
  .ico  dd LIBIMG_FORMAT_ICO,  img.is.ico,  img.decode.ico_cur, img.encode.ico, 0
  .cur  dd LIBIMG_FORMAT_CUR,  img.is.cur,  img.decode.ico_cur, img.encode.cur, 0
  .gif  dd LIBIMG_FORMAT_GIF,  img.is.gif,  img.decode.gif,     img.encode.gif, 0
  .png  dd LIBIMG_FORMAT_PNG,  img.is.png,  img.decode.png,     img.encode.png, 1 + (1 SHL Image.bpp24)
  .jpg  dd LIBIMG_FORMAT_JPEG, img.is.jpg,  img.decode.jpg,     img.encode.jpg, 0
  .tga  dd LIBIMG_FORMAT_TGA,  img.is.tga,  img.decode.tga,     img.encode.tga, 0
  .pcx  dd LIBIMG_FORMAT_PCX,  img.is.pcx,  img.decode.pcx,     img.encode.pcx, 0
  .xcf  dd LIBIMG_FORMAT_XCF,  img.is.xcf,  img.decode.xcf,     img.encode.xcf, 0
  .tiff dd LIBIMG_FORMAT_TIFF, img.is.tiff, img.decode.tiff,    img.encode.tiff,0
  .pnm  dd LIBIMG_FORMAT_PNM,  img.is.pnm,  img.decode.pnm,     img.encode.pnm, 1 + (1 SHL Image.bpp1) + (1 SHL Image.bpp8g) + (1 SHL Image.bpp24)
  .wbmp dd LIBIMG_FORMAT_WBMP, img.is.wbmp, img.decode.wbmp,    img.encode.wbmp,0
  .xbm  dd LIBIMG_FORMAT_XBM,  img.is.xbm,  img.decode.xbm,     img.encode.xbm, 0
  .z80  dd LIBIMG_FORMAT_Z80,  img.is.z80,  img.decode.z80,     img.encode.z80, 0 ;this must be the last entry as there are no signatures in z80 screens at all
        dd 0
 
 
 
 
 
 
 
 
 
 
 
 
 
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
;! Below are private procs you should never call directly from your code                          ;;
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
 
 
;;================================================================================================;;
proc img._.validate, _img ;///////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? --- TBD ---                                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;> --- TBD ---                                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;< --- TBD ---                                                                                    ;;
;;================================================================================================;;
    xor eax, eax
    ret
endp
 
;;================================================================================================;;
proc img._.new ;//////////////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? --- TBD ---                                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;> --- TBD ---                                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = 0 / pointer to image                                                                     ;;
;;================================================================================================;;
    invoke  mem.alloc, sizeof.Image
    test    eax, eax
    jz  @f
    push    ecx
    xor ecx, ecx
    mov [eax + Image.Data], ecx
    mov [eax + Image.Type], ecx
    mov [eax + Image.Flags], ecx
    mov [eax + Image.Extended], ecx
    mov [eax + Image.Previous], ecx
    mov [eax + Image.Next], ecx
    pop ecx
@@:
    ret
endp
 
;;================================================================================================;;
proc img._.delete _img ;//////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? --- TBD ---                                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;> --- TBD ---                                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = false / true                                                                             ;;
;;================================================================================================;;
    push    edx
    mov edx, [_img]
    cmp [edx + Image.Data], 0
    je  @f
    invoke  mem.free, [edx + Image.Data]
    @@: cmp [edx + Image.Extended], 0
    je  @f
    invoke  mem.free, [edx + Image.Extended]
    @@: invoke  mem.free, edx
    pop edx
    ret
endp
 
;;================================================================================================;;
proc img._.resize_data _img, _width, _height ;////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? --- TBD ---                                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;> --- TBD ---                                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;< --- TBD ---                                                                                    ;;
;;================================================================================================;;
    push    ebx esi
    mov ebx, [_img]
    mov eax, [_height]
; our memory is limited, [_width]*[_height] must not overflow
; image with width or height greater than 65535 is most likely bogus
    cmp word [_width+2], 0
    jnz .error
    cmp word [_height+2], 0
    jnz .error
    imul    eax, [_width]
    test    eax, eax
    jz  .error
    cmp [ebx + Image.Type], Image.bpp1
    jz  .bpp1
    cmp [ebx + Image.Type], Image.bpp2i
    jz  .bpp2i
    cmp [ebx + Image.Type], Image.bpp4i
    jz  .bpp4i
    cmp [ebx + Image.Type], Image.bpp8i
    jz  .bpp8i
    cmp [ebx + Image.Type], Image.bpp8g
    jz  .bpp8g
    cmp [ebx + Image.Type], Image.bpp8a
    jz  .bpp8a
    cmp [ebx + Image.Type], Image.bpp24
    jz  .bpp24
.bpp32:
    shl eax, 2
    jmp @f
.bpp24:
    lea eax, [eax*3]
    jmp @f
.bpp8i:
    add eax, 256*4  ; for palette
.bpp8g:
    jmp @f
.bpp8a:
    shl eax, 1
    jmp @f
.bpp4i:
    mov eax, [_width]
    add eax, 1
    shr eax, 1
    imul eax, [_height]
    mov ecx, eax
    mov eax, [_height]
    add eax, 1
    shr eax, 1
    imul eax, [_width]
    cmp eax, ecx
    jge .bpp4i.skip
    mov eax, ecx
 .bpp4i.skip:
    add eax, 16*4    ; for palette
    jmp @f
.bpp2i:
    mov eax, [_width]
    add eax, 3
    shr eax, 2
    imul eax, [_height]
    mov ecx, eax
    mov eax, [_height]
    add eax, 3
    shr eax, 2
    imul eax, [_width]
    cmp eax, ecx
    jge .bpp2i.skip
    mov eax, ecx
 .bpp2i.skip:
    add eax, 4*4    ; for palette
    jmp @f
.bpp1:
    mov eax, [_width]
    add eax, 7
    shr eax, 3
    imul eax, [_height]
    mov ecx, eax
    mov eax, [_height]
    add eax, 7
    shr eax, 3
    imul eax, [_width]
    cmp eax, ecx
    jge .bpp1.skip
    mov eax, ecx
 .bpp1.skip:
 
    add eax, 2*4    ; for palette
@@:
    mov esi, eax
    invoke  mem.realloc, [ebx + Image.Data], eax
    or  eax, eax
    jz  .error
 
    mov [ebx + Image.Data], eax
    push    [_width]
    pop [ebx + Image.Width]
    push    [_height]
    pop [ebx + Image.Height]
    cmp [ebx + Image.Type], Image.bpp8i
    jnz @f
    lea esi, [eax + esi - 256*4]
    mov [ebx + Image.Palette], esi
    jmp .ret
@@:
    cmp [ebx + Image.Type], Image.bpp1
    jnz @f
    lea esi, [eax + esi - 2*4]
    mov [ebx + Image.Palette], esi
    jmp .ret
@@:
    cmp [ebx + Image.Type], Image.bpp2i
    jnz @f
    lea esi, [eax + esi - 4*4]
    mov [ebx + Image.Palette], esi
    jmp .ret
@@:
    cmp [ebx + Image.Type], Image.bpp4i
    jnz .ret
    lea esi, [eax + esi - 16*4]
    mov [ebx + Image.Palette], esi
    jmp .ret
 
  .error:
    xor eax, eax
  .ret:
    pop esi ebx
    ret
endp
 
;;================================================================================================;;
img._.get_scanline_len: ;/////////////////////////////////////////////////////////////////////////;;
;;------------------------------------------------------------------------------------------------;;
;? Get scanline length of image in bytes                                                          ;;
;;------------------------------------------------------------------------------------------------;;
;> eax = width of image in pixels                                                                 ;;
;> ebx = image                                                                                    ;;
;;------------------------------------------------------------------------------------------------;;
;< eax = scanline length in bytes                                                                 ;;
;;================================================================================================;;
    cmp [ebx + Image.Type], Image.bpp1
    jz  .bpp1.1
    cmp [ebx + Image.Type], Image.bpp2i
    jz  .bpp2i.1
    cmp [ebx + Image.Type], Image.bpp4i
    jz  .bpp4i.1
    cmp [ebx + Image.Type], Image.bpp8i
    jz  .bpp8.1
    cmp [ebx + Image.Type], Image.bpp8g
    jz  .bpp8.1
    cmp [ebx + Image.Type], Image.bpp8a
    jz  .bpp8a.1
    cmp [ebx + Image.Type], Image.bpp24
    jz  .bpp24.1
    add eax, eax
    cmp [ebx + Image.Type], Image.bpp32
    jnz .quit
    add eax, eax
    jmp .quit
.bpp24.1:
    lea eax, [eax*3]
    jmp .quit
.bpp1.1:
    add eax, 7
    shr eax, 3
    jmp .quit
.bpp2i.1:
    add eax, 3
    shr eax, 2
    jmp .quit
.bpp4i.1:
    add eax, 1
    shr eax, 1
    jmp .quit
.bpp8a.1:
    shl eax, 1
.bpp8.1:
.quit:
    ret
 
 
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
;! Below is private data you should never use directly from your code                             ;;
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
 
include_debug_strings
 
align 4
type2bpp    dd  8, 24, 32, 15, 16, 1, 9, 2, 4
img._.do_rgb.handlers:
    dd  img._.do_rgb.bpp8i
    dd  img._.do_rgb.bpp24
    dd  img._.do_rgb.bpp32
    dd  img._.do_rgb.bpp15.amd  ; can be overwritten in lib_init
    dd  img._.do_rgb.bpp16.amd  ; can be overwritten in lib_init
    dd  img._.do_rgb.bpp1
    dd  img._.do_rgb.bpp8g
    dd  img._.do_rgb.bpp2i
    dd  img._.do_rgb.bpp4i
 
img.flip.layer.handlers_horz:
    dd  img.flip.layer.bpp8ig_horz
    dd  img.flip.layer.bpp24_horz
    dd  img.flip.layer.bpp32_horz
    dd  img.flip.layer.bpp1x_horz
    dd  img.flip.layer.bpp1x_horz
    dd  img.flip.layer.bpp1_horz
    dd  img.flip.layer.bpp8ig_horz
    dd  img.flip.layer.bpp2i_horz
    dd  img.flip.layer.bpp4i_horz
 
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
;! Exported functions section                                                                     ;;
;;================================================================================================;;
;;////////////////////////////////////////////////////////////////////////////////////////////////;;
;;================================================================================================;;
 
 
align 4
@EXPORT:
 
export                                      \
    lib_init           , 'lib_init'           , \
    0x00050007         , 'version'            , \
    img.is_img         , 'img_is_img'         , \
    img.info           , 'img_info'           , \
    img.from_file      , 'img_from_file'      , \
    img.to_file        , 'img_to_file'        , \
    img.from_rgb       , 'img_from_rgb'       , \
    img.to_rgb         , 'img_to_rgb'         , \
    img.to_rgb2        , 'img_to_rgb2'        , \
    img.decode         , 'img_decode'         , \
    img.encode         , 'img_encode'         , \
    img.create         , 'img_create'         , \
    img.destroy        , 'img_destroy'        , \
    img.destroy.layer  , 'img_destroy_layer'  , \
    img.count          , 'img_count'          , \
    img.lock_bits      , 'img_lock_bits'      , \
    img.unlock_bits    , 'img_unlock_bits'    , \
    img.flip           , 'img_flip'           , \
    img.flip.layer     , 'img_flip_layer'     , \
    img.rotate         , 'img_rotate'         , \
    img.rotate.layer   , 'img_rotate_layer'   , \
    img.draw           , 'img_draw'           , \
    img.scale          , 'img_scale'          , \
    img.get_scaled_size, 'img_get_scaled_size', \
    img.convert        , 'img_convert'        , \
    img.formats_table  , 'img_formats_table'
 
; import from deflate unpacker
; is initialized only when PNG loading is requested
align 16
@IMPORT:
 
library                           \
        archiver, 'archiver.obj', \
        libio   , 'libio.obj'
 
import  archiver, \
        deflate_unpack2, 'deflate_unpack2',\
        deflateInit2,    'deflateInit2',\
        deflateReset,    'deflateReset',\
        deflate,         'deflate',\
        deflateEnd,      'deflateEnd',\
        calc_crc32,      'calc_crc32'
 
import libio                    , \
        file.size , 'file_size' , \
        file.open , 'file_open' , \
        file.read , 'file_read' , \
        file.close, 'file_close'
 
align 4
; mutex for unpacker loading
deflate_loader_mutex    dd  0
 
; default palette for GIF - b&w
gif_default_palette:
    db  0, 0, 0
    db  0xFF, 0xFF, 0xFF
 
section '.data' data readable writable align 16
; uninitialized data - global constant tables
mem.alloc   dd ?
mem.free    dd ?
mem.realloc dd ?
dll.load    dd ?
 
; data for YCbCr -> RGB translation
color_table_1       rd  256
color_table_2       rd  256
color_table_3       rd  256
color_table_4       rd  256

Rev 6807	Rev 7105
1	;;================================================================================================;;	1	;;================================================================================================;;
2	;;//// libimg.asm //// (c) mike.dld, 2007-2008, (c) diamond, 2009, (c) dunkaist, 2011-2013 ///////;;	2	;;//// libimg.asm //// (c) mike.dld, 2007-2008, (c) diamond, 2009, (c) dunkaist, 2011-2013 ///////;;
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		20
21	format MS COFF	21	format MS COFF
22		22
23	public @EXPORT as 'EXPORTS'	23	public @EXPORT as 'EXPORTS'
24		24
25	include '../../../../struct.inc'	25	include '../../../../struct.inc'
26	include '../../../../proc32.inc'	26	include '../../../../proc32.inc'
27	include '../../../../macros.inc'	27	include '../../../../macros.inc'
28	include '../../../../config.inc'	28	include '../../../../config.inc'
29	;include '../../../../debug.inc'	29	include '../../../../debug-fdo.inc'
-		30	__DEBUG__ = 0
-		31	__DEBUG_LEVEL__ = 1
-		32	include '../../../../develop/libraries/libs-dev/libio/libio.inc'
30	purge section,mov,add,sub	33	purge section,mov,add,sub
31		34
32	include 'libimg.inc'	35	include 'libimg.inc'
33		36
34	section '.flat' code readable align 16	37	section '.flat' code readable align 16
35		38
36	include 'bmp/bmp.asm'	39	include 'bmp/bmp.asm'
37	include 'gif/gif.asm'	40	include 'gif/gif.asm'
38	include 'jpeg/jpeg.asm'	41	include 'jpeg/jpeg.asm'
39	include 'png/png.asm'	42	include 'png/png.asm'
40	include 'tga/tga.asm'	43	include 'tga/tga.asm'
41	include 'z80/z80.asm'	44	include 'z80/z80.asm'
42	include 'ico_cur/ico_cur.asm'	45	include 'ico_cur/ico_cur.asm'
43	include 'pcx/pcx.asm'	46	include 'pcx/pcx.asm'
44	include 'xcf/xcf.asm'	47	include 'xcf/xcf.asm'
45	include 'tiff/tiff.asm'	48	include 'tiff/tiff.asm'
46	include 'pnm/pnm.asm'	49	include 'pnm/pnm.asm'
47	include 'wbmp/wbmp.asm'	50	include 'wbmp/wbmp.asm'
48	include 'xbm/xbm.asm'	51	include 'xbm/xbm.asm'
49		52
50	include 'scale.asm'	53	include 'scale.asm'
51	include 'convert.asm'	54	include 'convert.asm'
52		55
53	;;================================================================================================;;	56	;;================================================================================================;;
54	proc lib_init ;///////////////////////////////////////////////////////////////////////////////////;;	57	proc lib_init ;///////////////////////////////////////////////////////////////////////////////////;;
55	;;------------------------------------------------------------------------------------------------;;	58	;;------------------------------------------------------------------------------------------------;;
56	;? Library entry point (called after library load) ;;	59	;? Library entry point (called after library load) ;;
57	;;------------------------------------------------------------------------------------------------;;	60	;;------------------------------------------------------------------------------------------------;;
58	;> eax = pointer to memory allocation routine ;;	61	;> eax = pointer to memory allocation routine ;;
59	;> ebx = pointer to memory freeing routine ;;	62	;> ebx = pointer to memory freeing routine ;;
60	;> ecx = pointer to memory reallocation routine ;;	63	;> ecx = pointer to memory reallocation routine ;;
61	;> edx = pointer to library loading routine ;;	64	;> edx = pointer to library loading routine ;;
62	;;------------------------------------------------------------------------------------------------;;	65	;;------------------------------------------------------------------------------------------------;;
63	;< eax = 1 (fail) / 0 (ok) (library initialization result) ;;	66	;< eax = 1 (fail) / 0 (ok) (library initialization result) ;;
64	;;================================================================================================;;	67	;;================================================================================================;;
65	mov [mem.alloc], eax	68	mov [mem.alloc], eax
66	mov [mem.free], ebx	69	mov [mem.free], ebx
67	mov [mem.realloc], ecx	70	mov [mem.realloc], ecx
68	mov [dll.load], edx	71	mov [dll.load], edx
69		72
70	or edx,edx	73	or edx,edx
71	jz @f	74	jz @f
72	invoke dll.load, @IMPORT	75	invoke dll.load, @IMPORT
73	@@:	76	@@:
74		77
75	call img.initialize.jpeg	78	call img.initialize.jpeg
76		79
77	xor eax, eax	80	xor eax, eax
78	cpuid	81	cpuid
79	cmp ecx, 'ntel'	82	cmp ecx, 'ntel'
80	jnz @f	83	jnz @f
81	mov dword [img._.do_rgb.handlers + (Image.bpp15-1)*4], img._.do_rgb.bpp15.intel	84	mov dword [img._.do_rgb.handlers + (Image.bpp15-1)*4], img._.do_rgb.bpp15.intel
82	mov dword [img._.do_rgb.handlers + (Image.bpp16-1)*4], img._.do_rgb.bpp16.intel	85	mov dword [img._.do_rgb.handlers + (Image.bpp16-1)*4], img._.do_rgb.bpp16.intel
83	@@:	86	@@:
84		87
85	.ok: xor eax,eax	88	.ok: xor eax,eax
86	ret	89	ret
87	endp	90	endp
88		91
89	;;================================================================================================;;	92	;;================================================================================================;;
90	proc img.is_img _data, _length ;//////////////////////////////////////////////////////////////////;;	93	proc img.is_img _data, _length ;//////////////////////////////////////////////////////////////////;;
91	;;------------------------------------------------------------------------------------------------;;	94	;;------------------------------------------------------------------------------------------------;;
92	;? --- TBD --- ;;	95	;? --- TBD --- ;;
93	;;------------------------------------------------------------------------------------------------;;	96	;;------------------------------------------------------------------------------------------------;;
94	;> --- TBD --- ;;	97	;> --- TBD --- ;;
95	;;------------------------------------------------------------------------------------------------;;	98	;;------------------------------------------------------------------------------------------------;;
96	;< --- TBD --- ;;	99	;< --- TBD --- ;;
97	;;================================================================================================;;	100	;;================================================================================================;;
98	push ebx	101	push ebx
99	mov ebx, img.formats_table	102	mov ebx, img.formats_table
100	@@: stdcall [ebx + FormatsTableEntry.Is], [_data], [_length]	103	@@: stdcall [ebx + FormatsTableEntry.Is], [_data], [_length]
101	or eax, eax	104	or eax, eax
102	jnz @f	105	jnz @f
103	add ebx, sizeof.FormatsTableEntry	106	add ebx, sizeof.FormatsTableEntry
104	cmp dword[ebx], 0	107	cmp dword[ebx], 0
105	jnz @b	108	jnz @b
106	xor eax, eax	109	xor eax, eax
107	@@: pop ebx	110	@@: pop ebx
108	ret	111	ret
109	endp	112	endp
110		113
111	;;================================================================================================;;	114	;;================================================================================================;;
112	proc img.info _data, _length ;////////////////////////////////////////////////////////////////////;;	115	proc img.info _data, _length ;////////////////////////////////////////////////////////////////////;;
113	;;------------------------------------------------------------------------------------------------;;	116	;;------------------------------------------------------------------------------------------------;;
114	;? --- TBD --- ;;	117	;? --- TBD --- ;;
115	;;------------------------------------------------------------------------------------------------;;	118	;;------------------------------------------------------------------------------------------------;;
116	;> --- TBD --- ;;	119	;> --- TBD --- ;;
117	;;------------------------------------------------------------------------------------------------;;	120	;;------------------------------------------------------------------------------------------------;;
118	;< --- TBD --- ;;	121	;< --- TBD --- ;;
119	;;================================================================================================;;	122	;;================================================================================================;;
120	xor eax, eax	123	xor eax, eax
121	ret	124	ret
122	endp	125	endp
123		126
124	;;================================================================================================;;	127	;;================================================================================================;;
125	proc img.from_file _filename ;////////////////////////////////////////////////////////////////////;;	128	proc img.from_file _filename ;////////////////////////////////////////////////////////////////////;;
126	;;------------------------------------------------------------------------------------------------;;	129	;;------------------------------------------------------------------------------------------------;;
127	;? --- TBD --- ;;	130	;? load file from disk and decode it ;;
128	;;------------------------------------------------------------------------------------------------;;	131	;;------------------------------------------------------------------------------------------------;;
129	;> --- TBD --- ;;	132	;> [_filename] = file name as passed to libio ;;
130	;;------------------------------------------------------------------------------------------------;;	133	;;------------------------------------------------------------------------------------------------;;
131	;< eax = 0 / pointer to image ;;	134	;< eax = 0 / pointer to image ;;
132	;;================================================================================================;;	135	;;================================================================================================;;
-		136	locals
-		137	fd dd ?
-		138	img_data_len dd ?
-		139	img_data dd ? ; raw bytes
-		140	img dd ? ; Image pointer
-		141	endl
-		142	DEBUGF 2, 'img.from_file: %s\n', [_filename]
-		143	push ebx
-		144	mov [img], 0
-		145	invoke file.open, [_filename], O_READ
-		146	mov [fd], eax
-		147	test eax, eax
-		148	jz .exit
-		149	invoke file.size, [_filename]
133	xor eax, eax	150	test eax, eax
-		151	jnz .exit_close
-		152	mov [img_data_len], ebx
-		153	invoke mem.alloc, ebx
-		154	test eax, eax
-		155	jz .exit_close
-		156	mov [img_data], eax
-		157	invoke file.read, [fd], eax, [img_data_len]
-		158	cmp eax, -1
-		159	jz .exit_free_close
-		160	cmp eax, [img_data_len]
-		161	jnz .exit_free_close
-		162	stdcall img.decode, [img_data], [img_data_len], 0
-		163	test eax, eax
-		164	jz .exit_free_close
-		165	mov [img], eax
-		166	.exit_free_close:
-		167	invoke mem.free, [img_data]
-		168	.exit_close:
-		169	invoke file.close, [fd]
-		170	mov eax, [img]
-		171	.exit:
-		172	pop ebx
134	ret	173	ret
135	endp	174	endp
136		175
137	;;================================================================================================;;	176	;;================================================================================================;;
138	proc img.to_file _img, _filename ;////////////////////////////////////////////////////////////////;;	177	proc img.to_file _img, _filename ;////////////////////////////////////////////////////////////////;;
139	;;------------------------------------------------------------------------------------------------;;	178	;;------------------------------------------------------------------------------------------------;;
140	;? --- TBD --- ;;	179	;? --- TBD --- ;;
141	;;------------------------------------------------------------------------------------------------;;	180	;;------------------------------------------------------------------------------------------------;;
142	;> --- TBD --- ;;	181	;> --- TBD --- ;;
143	;;------------------------------------------------------------------------------------------------;;	182	;;------------------------------------------------------------------------------------------------;;
144	;< eax = false / true ;;	183	;< eax = false / true ;;
145	;;================================================================================================;;	184	;;================================================================================================;;
146	xor eax, eax	185	xor eax, eax
147	ret	186	ret
148	endp	187	endp
149		188
150	;;================================================================================================;;	189	;;================================================================================================;;
151	proc img.from_rgb _rgb_data ;/////////////////////////////////////////////////////////////////////;;	190	proc img.from_rgb _rgb_data ;/////////////////////////////////////////////////////////////////////;;
152	;;------------------------------------------------------------------------------------------------;;	191	;;------------------------------------------------------------------------------------------------;;
153	;? --- TBD --- ;;	192	;? --- TBD --- ;;
154	;;------------------------------------------------------------------------------------------------;;	193	;;------------------------------------------------------------------------------------------------;;
155	;> --- TBD --- ;;	194	;> --- TBD --- ;;
156	;;------------------------------------------------------------------------------------------------;;	195	;;------------------------------------------------------------------------------------------------;;
157	;< eax = 0 / pointer to image ;;	196	;< eax = 0 / pointer to image ;;
158	;;================================================================================================;;	197	;;================================================================================================;;
159	xor eax, eax	198	xor eax, eax
160	ret	199	ret
161	endp	200	endp
162		201
163	;;================================================================================================;;	202	;;================================================================================================;;
164	proc img.to_rgb2 _img, _out ;/////////////////////////////////////////////////////////////////////;;	203	proc img.to_rgb2 _img, _out ;/////////////////////////////////////////////////////////////////////;;
165	;;------------------------------------------------------------------------------------------------;;	204	;;------------------------------------------------------------------------------------------------;;
166	;? decodes image data into RGB triplets and stores them where [_out] points to ;;	205	;? decodes image data into RGB triplets and stores them where [_out] points to ;;
167	;;------------------------------------------------------------------------------------------------;;	206	;;------------------------------------------------------------------------------------------------;;
168	;> [_img] = pointer to source image ;;	207	;> [_img] = pointer to source image ;;
169	;> [_out] = where to store RGB triplets ;;	208	;> [_out] = where to store RGB triplets ;;
170	;;------------------------------------------------------------------------------------------------;;	209	;;------------------------------------------------------------------------------------------------;;
171	;< none ;;	210	;< none ;;
172	;;================================================================================================;;	211	;;================================================================================================;;
173	push esi edi	212	push esi edi
174	mov esi, [_img]	213	mov esi, [_img]
175	stdcall img._.validate, esi	214	stdcall img._.validate, esi
176	or eax, eax	215	or eax, eax
177	jnz .ret	216	jnz .ret
178	mov edi, [_out]	217	mov edi, [_out]
179	call img._.do_rgb	218	call img._.do_rgb
180	.ret:	219	.ret:
181	pop edi esi	220	pop edi esi
182	ret	221	ret
183	endp	222	endp
184		223
185	;;================================================================================================;;	224	;;================================================================================================;;
186	proc img.to_rgb _img ;////////////////////////////////////////////////////////////////////////////;;	225	proc img.to_rgb _img ;////////////////////////////////////////////////////////////////////////////;;
187	;;------------------------------------------------------------------------------------------------;;	226	;;------------------------------------------------------------------------------------------------;;
188	;? decodes image data into RGB triplets and returns pointer to memory area of following structure:;;	227	;? decodes image data into RGB triplets and returns pointer to memory area of following structure:;;
189	;? width dd ? ;;	228	;? width dd ? ;;
190	;? height dd ? ;;	229	;? height dd ? ;;
191	;? rgb triplets ;;	230	;? rgb triplets ;;
192	;;------------------------------------------------------------------------------------------------;;	231	;;------------------------------------------------------------------------------------------------;;
193	;> [_img] = pointer to source image ;;	232	;> [_img] = pointer to source image ;;
194	;;------------------------------------------------------------------------------------------------;;	233	;;------------------------------------------------------------------------------------------------;;
195	;< eax = 0 / pointer to rgb_data (array of [rgb] triplets) ;;	234	;< eax = 0 / pointer to rgb_data (array of [rgb] triplets) ;;
196	;;================================================================================================;;	235	;;================================================================================================;;
197	push esi edi	236	push esi edi
198	mov esi, [_img]	237	mov esi, [_img]
199	stdcall img._.validate, esi	238	stdcall img._.validate, esi
200	or eax, eax	239	or eax, eax
201	jnz .error	240	jnz .error
202		241
203	mov esi, [_img]	242	mov esi, [_img]
204	mov ecx, [esi + Image.Width]	243	mov ecx, [esi + Image.Width]
205	imul ecx, [esi + Image.Height]	244	imul ecx, [esi + Image.Height]
206	lea eax, [ecx * 3 + 4 * 3]	245	lea eax, [ecx * 3 + 4 * 3]
207	invoke mem.alloc, eax	246	invoke mem.alloc, eax
208	or eax, eax	247	or eax, eax
209	jz .error	248	jz .error
210		249
211	mov edi, eax	250	mov edi, eax
212	push eax	251	push eax
213	mov eax, [esi + Image.Width]	252	mov eax, [esi + Image.Width]
214	stosd	253	stosd
215	mov eax, [esi + Image.Height]	254	mov eax, [esi + Image.Height]
216	stosd	255	stosd
217	call img._.do_rgb	256	call img._.do_rgb
218	pop eax	257	pop eax
219	pop edi esi	258	pop edi esi
220	ret	259	ret
221		260
222	.error:	261	.error:
223	xor eax, eax	262	xor eax, eax
224	pop edi esi	263	pop edi esi
225	ret	264	ret
226	endp	265	endp
227		266
228	;;================================================================================================;;	267	;;================================================================================================;;
229	proc img._.do_rgb ;///////////////////////////////////////////////////////////////////////////////;;	268	proc img._.do_rgb ;///////////////////////////////////////////////////////////////////////////////;;
230	;;------------------------------------------------------------------------------------------------;;	269	;;------------------------------------------------------------------------------------------------;;
231	;? decodes [esi + Image.Data] data into RGB triplets and stores them at [edi] ;;	270	;? decodes [esi + Image.Data] data into RGB triplets and stores them at [edi] ;;
232	;;------------------------------------------------------------------------------------------------;;	271	;;------------------------------------------------------------------------------------------------;;
233	;> esi = pointer to source image ;;	272	;> esi = pointer to source image ;;
234	;> edi = pointer to memory to store RGB triplets ;;	273	;> edi = pointer to memory to store RGB triplets ;;
235	;;------------------------------------------------------------------------------------------------;;	274	;;------------------------------------------------------------------------------------------------;;
236	;< none ;;	275	;< none ;;
237	;;================================================================================================;;	276	;;================================================================================================;;
238	mov ecx, [esi + Image.Width]	277	mov ecx, [esi + Image.Width]
239	imul ecx, [esi + Image.Height]	278	imul ecx, [esi + Image.Height]
240	mov eax, [esi + Image.Type]	279	mov eax, [esi + Image.Type]
241	jmp dword [.handlers + (eax-1)*4]	280	jmp dword [.handlers + (eax-1)*4]
242		281
243	align 16	282	align 16
244	.bpp8i:	283	.bpp8i:
245	; 8 BPP WITH PALETTE -> 24 BPP	284	; 8 BPP WITH PALETTE -> 24 BPP
246	push ebx	285	push ebx
247	mov ebx, [esi + Image.Palette]	286	mov ebx, [esi + Image.Palette]
248	mov esi, [esi + Image.Data]	287	mov esi, [esi + Image.Data]
249	sub ecx, 1	288	sub ecx, 1
250	jz .bpp8i.last	289	jz .bpp8i.last
251	@@:	290	@@:
252	movzx eax, byte [esi]	291	movzx eax, byte [esi]
253	add esi, 1	292	add esi, 1
254	mov eax, [ebx + eax*4]	293	mov eax, [ebx + eax*4]
255	mov [edi], eax	294	mov [edi], eax
256	add edi, 3	295	add edi, 3
257	sub ecx, 1	296	sub ecx, 1
258	jnz @b	297	jnz @b
259	.bpp8i.last:	298	.bpp8i.last:
260	movzx eax, byte [esi]	299	movzx eax, byte [esi]
261	mov eax, [ebx + eax*4]	300	mov eax, [ebx + eax*4]
262	mov [edi], ax	301	mov [edi], ax
263	shr eax, 16	302	shr eax, 16
264	mov [edi+2], al	303	mov [edi+2], al
265	pop ebx	304	pop ebx
266	ret	305	ret
267		306
268	align 16	307	align 16
269	.bpp8g:	308	.bpp8g:
270	; 8 BPP GRAYSCALE -> 24 BPP	309	; 8 BPP GRAYSCALE -> 24 BPP
271	mov esi, [esi + Image.Data]	310	mov esi, [esi + Image.Data]
272	@@:	311	@@:
273	lodsb	312	lodsb
274	mov ah, al	313	mov ah, al
275	stosb	314	stosb
276	stosw	315	stosw
277	dec ecx	316	dec ecx
278	jnz @b	317	jnz @b
279	ret	318	ret
280	;	319	;
281	;align 16	320	;align 16
282	;.bpp8a: ; considered application layer, may be changed in the future	321	;.bpp8a: ; considered application layer, may be changed in the future
283	;; 8a BPP -> 24 BPP	322	;; 8a BPP -> 24 BPP
284	; mov esi, [esi + Image.Data]	323	; mov esi, [esi + Image.Data]
285	;@@:	324	;@@:
286	; lodsw	325	; lodsw
287	; mov ah, al	326	; mov ah, al
288	; stosb	327	; stosb
289	; stosw	328	; stosw
290	; dec ecx	329	; dec ecx
291	; jnz @b	330	; jnz @b
292	; ret	331	; ret
293		332
294	; 15 BPP -> 24 BPP	333	; 15 BPP -> 24 BPP
295	.bpp15.intel:	334	.bpp15.intel:
296	push ebx ebp	335	push ebx ebp
297	sub ecx, 4	336	sub ecx, 4
298	jb .bpp15.tail	337	jb .bpp15.tail
299	align 16	338	align 16
300	.bpp15.intel.loop:	339	.bpp15.intel.loop:
301	repeat 2	340	repeat 2
302	mov ebx, [esi]	341	mov ebx, [esi]
303	mov al, [esi]	342	mov al, [esi]
304	mov ah, [esi+1]	343	mov ah, [esi+1]
305	add esi, 4	344	add esi, 4
306	and al, 0x1F	345	and al, 0x1F
307	and ah, 0x1F shl 2	346	and ah, 0x1F shl 2
308	mov ebp, ebx	347	mov ebp, ebx
309	mov dl, al	348	mov dl, al
310	mov dh, ah	349	mov dh, ah
311	shr al, 2	350	shr al, 2
312	shr ah, 4	351	shr ah, 4
313	shl dl, 3	352	shl dl, 3
314	shl dh, 1	353	shl dh, 1
315	and ebp, 0x1F shl 5	354	and ebp, 0x1F shl 5
316	add al, dl	355	add al, dl
317	add ah, dh	356	add ah, dh
318	shr ebp, 2	357	shr ebp, 2
319	mov [edi], al	358	mov [edi], al
320	mov [edi+2], ah	359	mov [edi+2], ah
321	mov eax, ebx	360	mov eax, ebx
322	mov ebx, ebp	361	mov ebx, ebp
323	shr eax, 16	362	shr eax, 16
324	shr ebx, 5	363	shr ebx, 5
325	add ebx, ebp	364	add ebx, ebp
326	mov ebp, eax	365	mov ebp, eax
327	mov [edi+1], bl	366	mov [edi+1], bl
328	and eax, (0x1F) or (0x1F shl 10)	367	and eax, (0x1F) or (0x1F shl 10)
329	and ebp, 0x1F shl 5	368	and ebp, 0x1F shl 5
330	lea edx, [eax+eax]	369	lea edx, [eax+eax]
331	shr al, 2	370	shr al, 2
332	mov ebx, ebp	371	mov ebx, ebp
333	shr ah, 4	372	shr ah, 4
334	shl dl, 2	373	shl dl, 2
335	shr ebx, 2	374	shr ebx, 2
336	shr ebp, 7	375	shr ebp, 7
337	add al, dl	376	add al, dl
338	add ah, dh	377	add ah, dh
339	mov [edi+3], al	378	mov [edi+3], al
340	add ebx, ebp	379	add ebx, ebp
341	mov [edi+5], ah	380	mov [edi+5], ah
342	mov [edi+4], bl	381	mov [edi+4], bl
343	add edi, 6	382	add edi, 6
344	end repeat	383	end repeat
345	sub ecx, 4	384	sub ecx, 4
346	jnb .bpp15.intel.loop	385	jnb .bpp15.intel.loop
347	.bpp15.tail:	386	.bpp15.tail:
348	add ecx, 4	387	add ecx, 4
349	jz .bpp15.done	388	jz .bpp15.done
350	@@:	389	@@:
351	movzx eax, word [esi]	390	movzx eax, word [esi]
352	mov ebx, eax	391	mov ebx, eax
353	add esi, 2	392	add esi, 2
354	and eax, (0x1F) or (0x1F shl 10)	393	and eax, (0x1F) or (0x1F shl 10)
355	and ebx, 0x1F shl 5	394	and ebx, 0x1F shl 5
356	lea edx, [eax+eax]	395	lea edx, [eax+eax]
357	shr al, 2	396	shr al, 2
358	mov ebp, ebx	397	mov ebp, ebx
359	shr ebx, 2	398	shr ebx, 2
360	shr ah, 4	399	shr ah, 4
361	shl dl, 2	400	shl dl, 2
362	shr ebp, 7	401	shr ebp, 7
363	add eax, edx	402	add eax, edx
364	add ebx, ebp	403	add ebx, ebp
365	mov [edi], al	404	mov [edi], al
366	mov [edi+1], bl	405	mov [edi+1], bl
367	mov [edi+2], ah	406	mov [edi+2], ah
368	add edi, 3	407	add edi, 3
369	sub ecx, 1	408	sub ecx, 1
370	jnz @b	409	jnz @b
371	.bpp15.done:	410	.bpp15.done:
372	pop ebp ebx	411	pop ebp ebx
373	ret	412	ret
374		413
375	.bpp15.amd:	414	.bpp15.amd:
376	push ebx ebp	415	push ebx ebp
377	sub ecx, 4	416	sub ecx, 4
378	jb .bpp15.tail	417	jb .bpp15.tail
379	align 16	418	align 16
380	.bpp15.amd.loop:	419	.bpp15.amd.loop:
381	repeat 4	420	repeat 4
382	if (% mod 2) = 1	421	if (% mod 2) = 1
383	mov eax, dword [esi]	422	mov eax, dword [esi]
384	mov ebx, dword [esi]	423	mov ebx, dword [esi]
385	else	424	else
386	movzx eax, word [esi]	425	movzx eax, word [esi]
387	mov ebx, eax	426	mov ebx, eax
388	end if	427	end if
389	add esi, 2	428	add esi, 2
390	and eax, (0x1F) or (0x1F shl 10)	429	and eax, (0x1F) or (0x1F shl 10)
391	and ebx, 0x1F shl 5	430	and ebx, 0x1F shl 5
392	lea edx, [eax+eax]	431	lea edx, [eax+eax]
393	shr al, 2	432	shr al, 2
394	mov ebp, ebx	433	mov ebp, ebx
395	shr ebx, 2	434	shr ebx, 2
396	shr ah, 4	435	shr ah, 4
397	shl dl, 2	436	shl dl, 2
398	shr ebp, 7	437	shr ebp, 7
399	add eax, edx	438	add eax, edx
400	add ebx, ebp	439	add ebx, ebp
401	mov [edi], al	440	mov [edi], al
402	mov [edi+1], bl	441	mov [edi+1], bl
403	mov [edi+2], ah	442	mov [edi+2], ah
404	add edi, 3	443	add edi, 3
405	end repeat	444	end repeat
406	sub ecx, 4	445	sub ecx, 4
407	jnb .bpp15.amd.loop	446	jnb .bpp15.amd.loop
408	jmp .bpp15.tail	447	jmp .bpp15.tail
409		448
410	; 16 BPP -> 24 BPP	449	; 16 BPP -> 24 BPP
411	.bpp16.intel:	450	.bpp16.intel:
412	push ebx ebp	451	push ebx ebp
413	sub ecx, 4	452	sub ecx, 4
414	jb .bpp16.tail	453	jb .bpp16.tail
415	align 16	454	align 16
416	.bpp16.intel.loop:	455	.bpp16.intel.loop:
417	repeat 2	456	repeat 2
418	mov ebx, [esi]	457	mov ebx, [esi]
419	mov al, [esi]	458	mov al, [esi]
420	mov ah, [esi+1]	459	mov ah, [esi+1]
421	add esi, 4	460	add esi, 4
422	and al, 0x1F	461	and al, 0x1F
423	and ah, 0x1F shl 3	462	and ah, 0x1F shl 3
424	mov ebp, ebx	463	mov ebp, ebx
425	mov dl, al	464	mov dl, al
426	mov dh, ah	465	mov dh, ah
427	shr al, 2	466	shr al, 2
428	shr ah, 5	467	shr ah, 5
429	shl dl, 3	468	shl dl, 3
430	and ebp, 0x3F shl 5	469	and ebp, 0x3F shl 5
431	add al, dl	470	add al, dl
432	add ah, dh	471	add ah, dh
433	shr ebp, 3	472	shr ebp, 3
434	mov [edi], al	473	mov [edi], al
435	mov [edi+2], ah	474	mov [edi+2], ah
436	mov eax, ebx	475	mov eax, ebx
437	mov ebx, ebp	476	mov ebx, ebp
438	shr eax, 16	477	shr eax, 16
439	shr ebx, 6	478	shr ebx, 6
440	add ebx, ebp	479	add ebx, ebp
441	mov ebp, eax	480	mov ebp, eax
442	mov [edi+1], bl	481	mov [edi+1], bl
443	and eax, (0x1F) or (0x1F shl 11)	482	and eax, (0x1F) or (0x1F shl 11)
444	and ebp, 0x3F shl 5	483	and ebp, 0x3F shl 5
445	mov edx, eax	484	mov edx, eax
446	shr al, 2	485	shr al, 2
447	mov ebx, ebp	486	mov ebx, ebp
448	shr ah, 5	487	shr ah, 5
449	shl dl, 3	488	shl dl, 3
450	shr ebx, 3	489	shr ebx, 3
451	shr ebp, 9	490	shr ebp, 9
452	add al, dl	491	add al, dl
453	add ah, dh	492	add ah, dh
454	mov [edi+3], al	493	mov [edi+3], al
455	add ebx, ebp	494	add ebx, ebp
456	mov [edi+5], ah	495	mov [edi+5], ah
457	mov [edi+4], bl	496	mov [edi+4], bl
458	add edi, 6	497	add edi, 6
459	end repeat	498	end repeat
460	sub ecx, 4	499	sub ecx, 4
461	jnb .bpp16.intel.loop	500	jnb .bpp16.intel.loop

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/libs-dev/libimg/libimg.asm – Rev 6807 → 7105