kolibrios-fun/programs/games/phenix/trunk/gif_lite.inc

; GIF LITE v3.0 by Willow
; Written in pure assembler by Ivushkin Andrey aka Willow
; Modified by Diamond
;
; This include file will contain functions to handle GIF image format
;
; Created: August 15, 2004
; Last changed: June 24, 2007

; Requires kglobals.inc (iglobal/uglobal macro)
; (program must 'include "kglobals.inc"' and say 'IncludeUGlobal'
; somewhere in uninitialized data area).

; Configuration: [changed from program which includes this file]
; 1. The constant COLOR_ORDER: must be one of
;    PALETTE - for 8-bit image with palette (sysfunction 65)
;    MENUETOS - for MenuetOS and KolibriOS color order (sysfunction 7)
;    OTHER - for standard color order
; 2. Define constant GIF_SUPPORT_INTERLACED if you want to support interlaced
;    GIFs.
; 3. Single image mode vs multiple image mode:
;    if the program defines the variable 'gif_img_count' of type dword
;    somewhere, ReadGIF will enter multiple image mode: gif_img_count
;    will be initialized with image count, output format is GIF_list,
;    the function GetGIFinfo retrieves Nth image info. Otherwise, ReadGIF
;    uses single image mode: exit after end of first image, output is
;    <dd width,height, times width*height[*3] db image>

if ~ (COLOR_ORDER in <PALETTE,MENUETOS,OTHER>)
; This message may not appear under MenuetOS, so watch...
  display 'Please define COLOR_ORDER: PALETTE, MENUETOS or OTHER',13,10
end if

if defined gif_img_count
; virtual structure, used internally

struct GIF_list
    NextImg rd 1
    Left   rw 1
    Top    rw 1
    Width  rw 1
    Height rw 1
    Delay  rd 1
    Displacement rd 1 ; 0 = not specified
                       ; 1 = do not dispose
                       ; 2 = restore to background color
                       ; 3 = restore to previous
if COLOR_ORDER eq PALETTE
    Image rd 1
end if
ends

struct GIF_info
    Left   rw 1
    Top    rw 1
    Width  rw 1
    Height rw 1
    Delay  rd 1
    Displacement rd 1
if COLOR_ORDER eq PALETTE
    Palette rd 1
end if
ends

; ****************************************
;   FUNCTION GetGIFinfo - retrieve Nth image info
; ****************************************
; in:
;   esi - pointer to image list header
;   ecx - image_index (0...img_count-1)
;   edi - pointer to GIF_info structure to be filled

; out:
;   eax - pointer to RAW data, or 0, if error

GetGIFinfo:
    push  esi ecx edi
    xor   eax,eax
    jecxz .eloop
  .lp:
    mov   esi,[esi]
    test  esi,esi
    jz    .error
    loop  .lp
  .eloop:
    lodsd
    movsd
    movsd
    movsd
    movsd
if COLOR_ORDER eq PALETTE
    lodsd
    mov   [edi],esi
else
    mov   eax,esi
end if
  .error:
    pop   edi ecx esi
    ret

end if

_null fix 0x1000

; ****************************************
;   FUNCTION ReadGIF - unpacks GIF image
; ****************************************
; in:
;   esi - pointer to GIF file in memory
;   edi - pointer to output image list

; out:
;   eax - 0, all OK;
;   eax - 1, invalid signature;
;   eax >=8, unsupported image attributes
;

ReadGIF:
    push esi edi
    mov  [.cur_info],edi
    xor  eax,eax
    mov  [.globalColor],eax
if defined gif_img_count
    mov  [gif_img_count],eax
    mov  [.anim_delay],eax
    mov  [.anim_disp],eax
end if
    inc  eax
    cmp  dword[esi],'GIF8'
    jne  .ex            ; signature
    mov  ecx,[esi+0xa]
    add  esi,0xd
    mov  edi,esi
    test cl,cl
    jns  .nextblock
    mov  [.globalColor],esi
    call .Gif_skipmap
  .nextblock:
    cmp  byte[edi],0x21
    jne  .noextblock
    inc  edi
if defined gif_img_count
    cmp  byte[edi],0xf9 ; Graphic Control Ext
    jne  .no_gc
    movzx eax,word [edi+3]
    mov  [.anim_delay],eax
    mov  al,[edi+2]
    shr  al,2
    and  eax,7
    mov  [.anim_disp],eax
    add  edi,7
    jmp  .nextblock
  .no_gc:
end if
    inc  edi
  .block_skip:
    movzx eax,byte[edi]
    lea  edi,[edi+eax+1]
    test eax,eax
    jnz  .block_skip
    jmp  .nextblock
  .noextblock:
    mov  al,8
    cmp  byte[edi],0x2c    ; image beginning
    jne  .ex
if defined gif_img_count
    inc  [gif_img_count]
end if
    inc  edi
    mov  esi,[.cur_info]
if defined gif_img_count
    add  esi,4
end if
    xchg esi,edi
if defined GIF_SUPPORT_INTERLACED
    movzx ecx,word[esi+4]
    mov  [.width],ecx
    movzx eax,word[esi+6]
    imul eax,ecx
if ~(COLOR_ORDER eq PALETTE)
    lea  eax,[eax*3]
end if
    mov  [.img_end],eax
    inc  eax
    mov  [.row_end],eax
    and  [.pass],0
    test byte[esi+8],40h
    jz   @f
if ~(COLOR_ORDER eq PALETTE)
    lea  ecx,[ecx*3]
end if
    mov  [.row_end],ecx
@@:
end if
if defined gif_img_count
    movsd
    movsd
    mov  eax,[.anim_delay]
    stosd
    mov  eax,[.anim_disp]
    stosd
else
    movzx eax,word[esi+4]
    stosd
    movzx eax,word[esi+6]
    stosd
    add   esi,8
end if
    push edi
    mov  ecx,[esi]
    inc  esi
    test cl,cl
    js   .uselocal
    push [.globalColor]
    mov  edi,esi
    jmp  .setPal
  .uselocal:
    call .Gif_skipmap
    push esi
  .setPal:
    movzx ecx,byte[edi]
    inc  ecx
    mov  [.codesize],ecx
    dec  ecx
if ~(COLOR_ORDER eq PALETTE)
    pop  [.Palette]
end if
    lea  esi,[edi+1]
    mov  edi,.gif_workarea
    xor  eax,eax
    lodsb               ; eax - block_count
    add  eax,esi
    mov  [.block_ofs],eax
    mov  [.bit_count],8
    mov  eax,1
    shl  eax,cl
    mov  [.CC],eax
    mov  ecx,eax
    inc  eax
    mov  [.EOI],eax
    mov  eax, _null shl 16
  .filltable:
    stosd
    inc  eax
    loop .filltable
if COLOR_ORDER eq PALETTE
    pop  eax
    pop  edi
    push edi
    scasd
    push esi
    mov  esi,eax
    mov  ecx,[.CC]
@@:
    lodsd
    dec  esi
    bswap eax
    shr  eax,8
    stosd
    loop @b
    pop  esi
    pop  eax
    mov  [eax],edi
else
    pop  edi
end if
if defined GIF_SUPPORT_INTERLACED
    mov  [.img_start],edi
    add  [.img_end],edi
    add  [.row_end],edi
end if
  .reinit:
    mov  edx,[.EOI]
    inc  edx
    push [.codesize]
    pop  [.compsize]
    call .Gif_get_sym
    cmp  eax,[.CC]
    je   .reinit
    call .Gif_output
  .cycle:
    movzx ebx,ax
    call .Gif_get_sym
    cmp  eax,edx
    jae  .notintable
    cmp  eax,[.CC]
    je   .reinit
    cmp  eax,[.EOI]
    je   .end
    call .Gif_output
  .add:
    mov  dword [.gif_workarea+edx*4],ebx
    cmp  edx,0xFFF
    jae  .cycle
    inc  edx
    bsr  ebx,edx
    cmp  ebx,[.compsize]
    jne  .noinc
    inc  [.compsize]
  .noinc:
    jmp  .cycle
  .notintable:
    push eax
    mov  eax,ebx
    call .Gif_output
    push ebx
    movzx eax,bx
    call .Gif_output
    pop  ebx eax
    jmp  .add
  .end:
if defined GIF_SUPPORT_INTERLACED
    mov  edi,[.img_end]
end if
if defined gif_img_count
    mov  eax,[.cur_info]
    mov  [eax],edi
    mov  [.cur_info],edi
    add  esi,2
    xchg esi,edi
  .nxt:
    cmp  byte[edi],0
    jnz  .continue
    inc  edi
    jmp  .nxt
  .continue:
    cmp  byte[edi],0x3b
    jne  .nextblock
    xchg esi,edi
    and  dword [eax],0
end if
    xor  eax,eax
  .ex:
    pop  edi esi
    ret

.Gif_skipmap:
; in: ecx - image descriptor, esi - pointer to colormap
; out: edi - pointer to area after colormap

    and  ecx,111b
    inc  ecx            ; color map size
    mov  ebx,1
    shl  ebx,cl
    lea  ebx,[ebx*2+ebx]
    lea  edi,[esi+ebx]
    ret

.Gif_get_sym:
    mov  ecx,[.compsize]
    push ecx
    xor  eax,eax
  .shift:
    ror  byte[esi],1
    rcr  eax,1
    dec  [.bit_count]
    jnz  .loop1
    inc  esi
    cmp  esi,[.block_ofs]
    jb   .noblock
    push eax
    xor  eax,eax
    lodsb
    test eax,eax
    jnz  .nextbl
    mov  eax,[.EOI]
    sub  esi,2
    add  esp,8
    jmp  .exx
  .nextbl:
    add  eax,esi
    mov  [.block_ofs],eax
    pop  eax
  .noblock:
    mov  [.bit_count],8
  .loop1:
    loop .shift
    pop  ecx
    rol  eax,cl
  .exx:
    xor  ecx,ecx
    ret

.Gif_output:
    push esi eax edx
    mov  edx,.gif_workarea
  .next:
    push word[edx+eax*4]
    mov  ax,word[edx+eax*4+2]
    inc  ecx
    cmp  ax,_null
    jnz  .next
    shl  ebx,16
    mov  bx,[esp]
  .loop2:
    pop  ax

    if COLOR_ORDER eq PALETTE
        stosb
    else
        lea  esi,[eax+eax*2]
        add  esi,[.Palette]

    if COLOR_ORDER eq MENUETOS
        mov  esi,[esi]
        bswap esi
        shr  esi,8
        mov  [edi],esi
        add  edi,3
    else
        movsb
        movsb
        movsb
    end if
    end if

if defined GIF_SUPPORT_INTERLACED
    cmp  edi,[.row_end]
    jb   .norowend
    mov  eax,[.width]
if ~(COLOR_ORDER eq PALETTE)
    lea  eax,[eax*3]
end if
    push eax
    sub  edi,eax
    add  eax,eax
    cmp  [.pass],3
    jz   @f
    add  eax,eax
    cmp  [.pass],2
    jz   @f
    add  eax,eax
@@:
    add  edi,eax
    pop  eax
    cmp  edi,[.img_end]
    jb   .nextrow
    mov  edi,[.img_start]
    inc  [.pass]
    add  edi,eax
    cmp  [.pass],3
    jz   @f
    add  edi,eax
    cmp  [.pass],2
    jz   @f
    add  edi,eax
    add  edi,eax
@@:
.nextrow:
    add  eax,edi
    mov  [.row_end],eax
    xor  eax,eax
.norowend:
end if

    loop .loop2
    pop  edx eax esi
    ret

uglobal
align 4
    ReadGIF.globalColor rd 1
    ReadGIF.cur_info rd 1        ; image table pointer
    ReadGIF.codesize rd 1
    ReadGIF.compsize rd 1
    ReadGIF.bit_count rd 1
    ReadGIF.CC rd 1
    ReadGIF.EOI rd 1
if ~(COLOR_ORDER eq PALETTE)
    ReadGIF.Palette rd 1
end if
    ReadGIF.block_ofs rd 1
if defined GIF_SUPPORT_INTERLACED
    ReadGIF.row_end rd 1
    ReadGIF.img_end rd 1
    ReadGIF.img_start rd 1
    ReadGIF.pass rd 1
    ReadGIF.width rd 1
end if
if defined gif_img_count
    ReadGIF.anim_delay rd 1
    ReadGIF.anim_disp rd 1
end if
    ReadGIF.gif_workarea rb 16*1024
endg