forked from KolibriOS/kolibrios
762 lines
14 KiB
PHP
762 lines
14 KiB
PHP
lang equ ru
|
|
|
|
;
|
|
; Assembler
|
|
; SMALL
|
|
; CODE
|
|
; Graphics
|
|
; Libary
|
|
;
|
|
; Ver 0.18
|
|
;
|
|
|
|
; draw image into image with alpha color mask
|
|
; image_draw_acimage dest, source, x, y, alpha_color
|
|
;
|
|
macro image_draw_acimage dest, source, x, y, alpha_color
|
|
{
|
|
local next_pix,next_line,skip_pix,no_skip
|
|
push dest
|
|
push source
|
|
push x
|
|
push y
|
|
push alpha_color
|
|
pop ebp ; alpha color
|
|
pop eax ; y
|
|
pop ebx ; x
|
|
pop esi ; src
|
|
pop edi ; dest
|
|
call image_draw_acimage_proc
|
|
|
|
if ~ defined image_draw_acimage_used
|
|
image_draw_acimage_used equ 1
|
|
|
|
jmp end_image_draw_acimage_proc
|
|
image_draw_acimage_proc:
|
|
mov ecx,dword [edi] ; ecx = canvas width
|
|
mul ecx ; edx:eax = ypos * canvas width
|
|
add eax,ebx ; eax = (ypos * canvas width) + xpos
|
|
lea eax,[eax+eax*2+8] ; eax=(y*xsize+x)*3+8 (8=skip xy size dwords)
|
|
|
|
mov edx,[esi] ; edx = img width
|
|
sub ecx,edx ; ecx = canvas width - img width
|
|
lea ebx,[ecx*2+ecx] ; ebx = how many pixels skip for new line
|
|
mov ecx,[esi+4] ; ecx = img height
|
|
add esi,8 ; esi + 8 for skip xy size dwords
|
|
add edi,eax ; edi = dest position
|
|
shl ebp,8 ; for fast compare with alpha color
|
|
cld ; set movs direction flag
|
|
next_line:
|
|
push edx
|
|
next_pix:
|
|
mov eax,[esi]
|
|
shl eax,8
|
|
cmp eax,ebp
|
|
je skip_pix
|
|
movsw
|
|
movsb
|
|
jmp no_skip
|
|
skip_pix:
|
|
add esi,3
|
|
add edi,3
|
|
no_skip:
|
|
dec edx
|
|
jnz next_pix
|
|
pop edx
|
|
add edi,ebx
|
|
dec ecx
|
|
jnz next_line
|
|
ret
|
|
end_image_draw_acimage_proc :
|
|
end if
|
|
|
|
}
|
|
|
|
macro image_set_size image,width,height
|
|
{
|
|
mov dword [image],width
|
|
mov dword [image+4],height
|
|
}
|
|
|
|
; label - draw label on window
|
|
; example:
|
|
; label 10,12,'Hello World!',cl_Green+font_size_x4+utf16
|
|
|
|
macro image_draw_label image,x,y,text,color
|
|
{
|
|
local label_text
|
|
draw_to_buffer equ 00001000b shl 24
|
|
jmp @f
|
|
label_text db text
|
|
@@:
|
|
words2reg ebx,x,y ; ebx - position
|
|
dword2reg ecx,color+draw_to_buffer ; ecx - color
|
|
mov edi,image
|
|
mov edx,label_text ; edx - address of label text
|
|
mov esi,@b-label_text ; esi - size of libel in bytes
|
|
mov eax,4
|
|
mcall
|
|
}
|
|
|
|
; draw_frect - draw filled rect
|
|
macro draw_frect x,y,xs,ys,color
|
|
{
|
|
wordstoreg ebx,x,xs ;x*65536+xs
|
|
wordstoreg ecx,y,ys ;y*65536+ys
|
|
mov edx,color
|
|
mov eax,13
|
|
mcall
|
|
}
|
|
|
|
; draw_label - Draw label in window
|
|
; example:
|
|
; draw_label 10,12,'Hello World!',cl_Green+font_size_x4+utf16
|
|
|
|
macro draw_label x,y,text,color
|
|
{
|
|
local label_text
|
|
words2reg ebx,x,y ; ebx - position
|
|
if text eqtype 123 | text eqtype eax
|
|
movt edx,text
|
|
mov ecx,color+(1 shl 31) ; ecx - color
|
|
else
|
|
mov edx,label_text ; edx - address of label text
|
|
jmp @f
|
|
label_text db text
|
|
@@:
|
|
mov esi,@b-label_text ; esi - size of libel in bytes
|
|
movt ecx,color ; ecx - color
|
|
end if
|
|
mov eax,4
|
|
mcall
|
|
}
|
|
|
|
hide_zeros equ (1 shl 31)
|
|
use_bg_color equ (1 shl 30)
|
|
use_big_font equ (1 shl 28)
|
|
|
|
macro draw_number data, x, y, color, numtype, bg_color
|
|
{
|
|
movt ecx,data
|
|
movt ebx,numtype
|
|
mov bl,0 ; if bl = 0, ecx is contain number
|
|
words2reg edx,x,y
|
|
if bg_color eq
|
|
movt esi,color
|
|
else
|
|
movt esi,color+use_bg_color
|
|
movt edi,bg_color
|
|
end if
|
|
mov eax,47
|
|
mcall
|
|
}
|
|
|
|
; draw_image - macro for draw image on window area
|
|
macro draw_image x, y, image
|
|
{
|
|
mov ecx,[image-2] ; -2 for except shl ecx,16
|
|
mov cx,[image+4] ; ecx = xsize*65536+ysize
|
|
wordstoreg edx, x, y ; edx = x*65536+y
|
|
lea ebx,[image+8] ; ebx = image data address
|
|
mov eax,7 ; eax = 7 is draw image function
|
|
mcall
|
|
}
|
|
|
|
aframetoimg_use_count=0
|
|
macro aframetoimg img, x, y, canvas,acol
|
|
{
|
|
local loo,loo2,acolor
|
|
aframetoimg_use_count=aframetoimg_use_count+1
|
|
if aframetoimg_use_count = 1
|
|
|
|
jmp end_aframetoimg_proc
|
|
|
|
acolor dd 0
|
|
aframetoimg_proc:
|
|
;getout coord
|
|
mov [acolor],ebp
|
|
|
|
mov edx,ebx ;img ;xsize
|
|
movzx eax,word [edx]
|
|
add eax,esi ;y cor
|
|
|
|
; mov eax,esi ;y cor
|
|
mul dword [ecx] ;canvas xsize
|
|
add eax,edi ;x cor
|
|
|
|
mov ebp,ebx ;img ;xsize
|
|
movzx edx,word [ebp]
|
|
add eax,edx
|
|
|
|
mov ebp,eax
|
|
shl eax,1
|
|
add ebp,eax
|
|
add ebp,ecx ;canvas+8;start
|
|
add ebp,8
|
|
;get img size
|
|
add ebx,4
|
|
mov eax,ebx ;img ;xsize
|
|
movzx esi,word [eax]
|
|
movzx edi,word [eax+2]
|
|
add ebx,4
|
|
mov edx,ebx ;img+8
|
|
loo2:
|
|
push esi
|
|
loo:
|
|
;test on alpha color
|
|
mov eax,[edx]
|
|
shl eax,8
|
|
shr eax,8
|
|
cmp eax,[acolor]
|
|
jne yx
|
|
add edx,3
|
|
add ebp,3
|
|
jmp nx
|
|
yx:
|
|
mov al,byte [edx]
|
|
mov byte [ebp],al
|
|
inc ebp
|
|
inc edx
|
|
mov al,byte [edx]
|
|
mov byte [ebp],al
|
|
inc ebp
|
|
inc edx
|
|
mov al,byte [edx]
|
|
mov byte [ebp],al
|
|
inc ebp
|
|
inc edx
|
|
nx:
|
|
dec esi
|
|
jnz loo
|
|
pop esi
|
|
sub ebp,3
|
|
mov eax,[ecx] ;offset = offset+((canxsize-imgxsize)*3)
|
|
sub eax,esi
|
|
add ebp,eax
|
|
shl eax,1
|
|
add ebp,eax
|
|
|
|
add ebp,3
|
|
|
|
dec edi
|
|
jnz loo2
|
|
ret
|
|
end_aframetoimg_proc:
|
|
end if
|
|
push img
|
|
push canvas
|
|
push x
|
|
push y
|
|
push acol
|
|
pop ebp
|
|
pop esi
|
|
pop edi
|
|
pop ecx
|
|
pop ebx
|
|
call aframetoimg_proc
|
|
}
|
|
|
|
frametoimg_use_count=0
|
|
macro frametoimg img, x, y, canvas
|
|
{
|
|
local loo,loo2
|
|
frametoimg_use_count=frametoimg_use_count+1
|
|
if frametoimg_use_count = 1
|
|
|
|
jmp end_frametoimg_proc
|
|
|
|
frametoimg_proc:
|
|
;getout coord
|
|
mov edx,ebx ;img ;xsize
|
|
movzx eax,word [edx]
|
|
add eax,esi ;y cor
|
|
|
|
; mov eax,esi ;y cor
|
|
mul dword [ecx] ;canvas xsize
|
|
add eax,edi ;x cor
|
|
|
|
mov ebp,ebx ;img ;xsize
|
|
movzx edx,word [ebp]
|
|
add eax,edx
|
|
|
|
mov ebp,eax
|
|
shl eax,1
|
|
add ebp,eax
|
|
add ebp,ecx ;canvas+8;start
|
|
add ebp,8
|
|
;get img size
|
|
add ebx,4
|
|
mov eax,ebx ;img ;xsize
|
|
movzx esi,word [eax]
|
|
movzx edi,word [eax+2]
|
|
add ebx,4
|
|
mov edx,ebx ;img+8
|
|
loo2:
|
|
push esi
|
|
loo:
|
|
mov al,byte [edx]
|
|
mov byte [ebp],al
|
|
inc ebp
|
|
inc edx
|
|
mov al,byte [edx]
|
|
mov byte [ebp],al
|
|
inc ebp
|
|
inc edx
|
|
mov al,byte [edx]
|
|
mov byte [ebp],al
|
|
inc ebp
|
|
inc edx
|
|
|
|
dec esi
|
|
jnz loo
|
|
pop esi
|
|
sub ebp,3
|
|
mov eax,[ecx] ;offset = offset+((canxsize-imgxsize)*3)
|
|
sub eax,esi
|
|
add ebp,eax
|
|
shl eax,1
|
|
add ebp,eax
|
|
|
|
add ebp,3
|
|
|
|
dec edi
|
|
jnz loo2
|
|
ret
|
|
end_frametoimg_proc:
|
|
end if
|
|
push img
|
|
push canvas
|
|
push x
|
|
push y
|
|
pop esi
|
|
pop edi
|
|
pop ecx
|
|
pop ebx
|
|
call frametoimg_proc
|
|
}
|
|
|
|
|
|
imgtoimg_use_count=0
|
|
macro imgtoimg img, x, y, canvas
|
|
{
|
|
local loo,loo2
|
|
imgtoimg_use_count=imgtoimg_use_count+1
|
|
if imgtoimg_use_count = 1
|
|
|
|
jmp end_imgtoimg_proc
|
|
imgtoimg_proc:
|
|
;getout coord
|
|
mov eax,esi ;y cor
|
|
mul dword [ecx] ;canvas xsize
|
|
add eax,edi ;x cor
|
|
mov ebp,eax
|
|
shl eax,1
|
|
add ebp,eax
|
|
add ebp,ecx ;canvas+8;start
|
|
add ebp,8
|
|
;get img size
|
|
mov eax,ebx ;img ;xsize
|
|
mov esi,[eax]
|
|
add ebx,4
|
|
mov eax,ebx ; img+4 ;ysize
|
|
mov edi,[eax]
|
|
add ebx,4
|
|
mov edx,ebx ;img+8
|
|
loo2:
|
|
push esi
|
|
loo:
|
|
mov al,byte [edx]
|
|
mov byte [ebp],al
|
|
inc ebp
|
|
inc edx
|
|
mov al,byte [edx]
|
|
mov byte [ebp],al
|
|
inc ebp
|
|
inc edx
|
|
mov al,byte [edx]
|
|
mov byte [ebp],al
|
|
inc ebp
|
|
inc edx
|
|
dec esi
|
|
jnz loo
|
|
pop esi
|
|
sub ebp,3
|
|
mov eax,[ecx] ;offset = offset+((canxsize-imgxsize)*3)
|
|
sub eax,esi
|
|
add ebp,eax
|
|
shl eax,1
|
|
add ebp,eax
|
|
add ebp,3
|
|
dec edi
|
|
jnz loo2
|
|
ret
|
|
end_imgtoimg_proc:
|
|
end if
|
|
push img
|
|
push canvas
|
|
push x
|
|
push y
|
|
pop esi
|
|
pop edi
|
|
pop ecx
|
|
pop ebx
|
|
call imgtoimg_proc
|
|
}
|
|
|
|
; FPS - Set Frame Per Second Display
|
|
fps_show_frequency=40
|
|
macro fps x,y,color,delcolor
|
|
{
|
|
local spdat,savetime,new_time,fps,fps_cntr,out_fps,new_time,ttt
|
|
local no_out_fps
|
|
jmp spdat
|
|
savetime dd 0
|
|
fps_cntr dd 0
|
|
fps dd 0
|
|
ttt dd 0
|
|
spdat:
|
|
get_time:
|
|
mov eax,3
|
|
mcall
|
|
cmp eax,[savetime]
|
|
jne new_time
|
|
inc [fps_cntr]
|
|
cmp dword [ttt],0
|
|
je out_fps
|
|
dec dword [ttt]
|
|
jmp no_out_fps
|
|
new_time:
|
|
mov [savetime],eax
|
|
mov ebx,[fps_cntr]
|
|
mov [fps],ebx
|
|
mov [fps_cntr],0
|
|
out_fps:
|
|
if ~(delcolor eq )
|
|
mov ebx,x*65536+30
|
|
mov ecx,y*65536+7
|
|
mov edx,delcolor
|
|
mov eax,13
|
|
mcall
|
|
end if
|
|
mov dword [ttt],fps_show_frequency
|
|
mov eax,47
|
|
mov ebx,5*65536
|
|
; mov bl,0
|
|
mov edx,x*65536+y
|
|
mov esi,color
|
|
mov ecx,[fps]
|
|
mcall
|
|
no_out_fps:
|
|
}
|
|
|
|
macro rgbtobgr image
|
|
{
|
|
mov eax,[image]
|
|
mul dword [image+4]
|
|
mov ecx,eax
|
|
mov esi,image+8
|
|
@@:
|
|
mov al,[esi]
|
|
mov bl,[esi+2]
|
|
mov [esi],bl
|
|
mov [esi+2],al
|
|
add esi,3
|
|
dec ecx
|
|
jnz @b
|
|
}
|
|
|
|
macro setframe x , y ,arg3
|
|
{
|
|
mov eax,7
|
|
mov ebx,arg3
|
|
add ebx,8
|
|
wordstoreg edx, x , y ;arg1*65536+arg2
|
|
add edx,dword [arg3]
|
|
mov ecx,dword [arg3+4]
|
|
mcall
|
|
}
|
|
|
|
|
|
macro getimg imgsrc,x,y,xs,ys,imgdest
|
|
{
|
|
local next_pixel,next_line
|
|
; store image size
|
|
if xs eqtype 0 | xs eqtype eax
|
|
mov dword [imgdest],xs
|
|
else
|
|
mov eax,xs
|
|
mov dword [imgdest],eax
|
|
end if
|
|
if ys eqtype 0 | ys eqtype eax
|
|
mov dword [imgdest+4],ys
|
|
else
|
|
;push ys
|
|
;pop dword [imgdest+4]
|
|
mov eax,ys
|
|
mov dword [imgdest+4],eax
|
|
end if
|
|
|
|
lea edi,[8+imgdest] ; edi = destinaton address
|
|
mov eax,dword [imgsrc] ; eax = xsize of source image in pixels
|
|
push eax ; store eax before mul operation
|
|
mov edx,y
|
|
mul edx ; edx:eax = eax*edx
|
|
add eax,x
|
|
lea esi,[imgsrc+8+eax+2*eax] ; esi = start offset on img src
|
|
pop eax ; restore eax
|
|
sub eax,xs ; eax = src image xsize - crop fragment xsize
|
|
lea eax,[eax+eax*2] ; eax = eax * 3 (bytes per pixel)
|
|
|
|
; this loop used esi,edi,ecx,edx,eax registers
|
|
mov edx,ys ; edx = ysize in pixels
|
|
cld ; set direction
|
|
next_line:
|
|
mov ecx,xs ; ecx = xsize in pixels
|
|
next_pixel:
|
|
movsw
|
|
movsb ; write 3 bytes pixel
|
|
dec ecx
|
|
jnz next_pixel
|
|
add esi,eax
|
|
dec edx
|
|
jnz next_line
|
|
}
|
|
|
|
macro copyimg img2_off,img1_off
|
|
{
|
|
mov eax,dword [img1_off]
|
|
mov ebx,dword [img1_off+4]
|
|
mul ebx
|
|
lea ecx,[eax+2*eax]
|
|
lea esi,[img1_off+8]
|
|
lea edi,[img2_off+8]
|
|
cld
|
|
rep movsb
|
|
}
|
|
|
|
macro fullimg img_off,xs,ys,color
|
|
{
|
|
local cop
|
|
mov eax,xs
|
|
mov ebx,ys
|
|
mov dword [img_off],eax
|
|
mov dword [img_off+4],ebx
|
|
mul ebx
|
|
lea ebp,[eax+2*eax]
|
|
mov esi,color
|
|
if color eqtype 0
|
|
mov ecx,color/65536
|
|
else
|
|
mov ecx,esi
|
|
shr ecx,16
|
|
end if
|
|
xor edi,edi
|
|
cop:
|
|
mov word [img_off+8+edi],si
|
|
add edi,2
|
|
mov byte [img_off+8+edi],cl
|
|
inc edi
|
|
cmp edi,ebp
|
|
jne cop
|
|
}
|
|
|
|
; number of frame in ecx
|
|
; callculatin offset of raw data
|
|
|
|
macro getframeoff num_of_frame,offset_of_animation,offset_of_frame
|
|
{
|
|
local loo,setpic
|
|
mov ebp,num_of_frame ;ecx
|
|
mov esi,offset_of_animation;Image
|
|
loo:
|
|
cmp ebp,0
|
|
je setpic
|
|
movzx eax,word [esi+4]
|
|
movzx ebx,word [esi+6]
|
|
mul ebx ;dword [esi+4]
|
|
mov ebx,3
|
|
mul ebx
|
|
add eax,8
|
|
add esi,eax
|
|
dec ebp
|
|
jmp loo
|
|
setpic:
|
|
mov dword offset_of_frame,esi
|
|
}
|
|
|
|
; BMPTOIMG -Convert BMP format TO IMG format
|
|
; (SYNTAX) BMPTOIMG BMP_source_offset,IMG_dest_ofset
|
|
; (SAMPLE) View BMPLS.ASM sample.
|
|
; ( NOTE ) This is macro is not brake bmp structure! Tested in 32,8,4 bits
|
|
|
|
bmptoimg_data_area_count=0
|
|
macro bmptoimg bmp_load_area,img_dest_area
|
|
{
|
|
local fileinfo,string,end_bmp,nodix
|
|
local converttable,noaddelem,nextbit,convert1bpp,convert4bpp,convert2
|
|
local nextelem,convertno32,nomorestring,convert1,nextstring,yespicsize
|
|
;local qwe,bmpfn
|
|
|
|
; convert:
|
|
movzx eax,word [bmp_load_area+28]
|
|
mul dword [bmp_load_area+18]
|
|
add eax,31
|
|
shr eax,5
|
|
mov dword [bmptoimg_data_area_dwps],eax ;dwps-doublewords per string
|
|
shl eax,2
|
|
mov dword [bmptoimg_data_area_bps],eax ;bps-bytes per string
|
|
|
|
cmp dword [bmp_load_area+34],0
|
|
jne yespicsize ;if picture size is defined
|
|
mul dword [bmp_load_area+22]
|
|
mov dword [bmp_load_area+34],eax
|
|
|
|
yespicsize:
|
|
mov ebp,img_dest_area+8
|
|
|
|
mov eax,bmp_load_area
|
|
mov ebx,eax
|
|
add ebx, [bmp_load_area+2];file size
|
|
inc ebx
|
|
mov dword [bmptoimg_soi],ebx ;soi-start of image area for drawing
|
|
|
|
add eax, [bmp_load_area+10]
|
|
mov dword [bmptoimg_data_area_sop],eax ;sop-start of picture in file
|
|
add eax, [bmp_load_area+34]
|
|
mov dword [bmptoimg_data_area_eop],eax ;eop-end of picture in file
|
|
mov eax, [bmp_load_area+18]
|
|
lea eax,[eax+2*eax] ;3x pixels in eax
|
|
|
|
mov edi,dword [bmptoimg_soi] ;initializing
|
|
mov esi,dword [bmptoimg_data_area_eop]
|
|
sub esi,dword [bmptoimg_data_area_bps]
|
|
|
|
|
|
nextstring:
|
|
push edi
|
|
push ebp
|
|
cmp word [bmp_load_area+28],24
|
|
jne convertno32
|
|
|
|
mov edi,ebp
|
|
mov ecx,[bmptoimg_data_area_dwps]
|
|
cld
|
|
rep movsd
|
|
|
|
convert1:
|
|
pop ebp
|
|
pop edi
|
|
sub esi,dword [bmptoimg_data_area_bps]
|
|
sub esi,dword [bmptoimg_data_area_bps]
|
|
cmp esi,dword [bmptoimg_data_area_sop]
|
|
jb end_bmp
|
|
add edi,eax
|
|
add ebp,eax
|
|
jmp nextstring
|
|
|
|
convertno32:
|
|
mov ebx,bmp_load_area
|
|
add ebx, [bmp_load_area+14]
|
|
add ebx,14 ;start of color table
|
|
push esi
|
|
add esi,dword [bmptoimg_data_area_bps]
|
|
mov dword [bmptoimg_data_area_eos],esi
|
|
pop esi
|
|
nextelem:
|
|
push eax
|
|
movzx eax,byte [esi]
|
|
cmp word [bmp_load_area+28],4
|
|
je convert4bpp
|
|
cmp word [bmp_load_area+28],1
|
|
je convert1bpp
|
|
call converttable
|
|
|
|
convert2:
|
|
pop eax
|
|
inc esi
|
|
cmp esi,dword [bmptoimg_data_area_eos]
|
|
jae convert1
|
|
add edi,3
|
|
add ebp,3
|
|
jmp nextelem
|
|
|
|
convert4bpp:
|
|
shl ax,4
|
|
shr al,4
|
|
push ax
|
|
movzx eax,ah
|
|
call converttable
|
|
add edi,3
|
|
add ebp,3
|
|
pop ax
|
|
movzx eax,al
|
|
call converttable
|
|
jmp convert2
|
|
|
|
convert1bpp:
|
|
mov ecx,eax
|
|
mov edx,7
|
|
nextbit:
|
|
xor eax,eax
|
|
bt ecx,edx
|
|
jnc noaddelem
|
|
inc eax
|
|
noaddelem:
|
|
push edx
|
|
call converttable
|
|
pop edx
|
|
dec edx
|
|
js convert2
|
|
add edi,3
|
|
add ebp,3
|
|
jmp nextbit
|
|
converttable:
|
|
shl eax,2
|
|
add eax,ebx
|
|
mov edx, dword [eax]
|
|
; mov dword [edi],edx
|
|
mov [ebp],edx
|
|
ret
|
|
|
|
bmptoimg_data_area_count=bmptoimg_data_area_count+1
|
|
if bmptoimg_data_area_count = 1
|
|
; DATA AREA
|
|
bmptoimg_soi dd 0
|
|
bmptoimg_data_area_bps dd 0
|
|
bmptoimg_data_area_dwps dd 0
|
|
bmptoimg_data_area_sop dd 0
|
|
bmptoimg_data_area_eop dd 0
|
|
bmptoimg_data_area_eos dd 0
|
|
end if
|
|
|
|
end_bmp:
|
|
mov eax,dword [bmp_load_area+18]
|
|
mov ebx,dword [bmp_load_area+22]
|
|
mov dword [img_dest_area],eax
|
|
mov dword [img_dest_area+4],ebx
|
|
}
|
|
|
|
if used ReadGIF
|
|
; For convert RGB to BGR
|
|
COLOR_ORDER equ MENUETOS
|
|
include 'gif_lite.inc'
|
|
end if
|
|
|
|
macro giftoani gifsrc,imgsrc,num_of_frames
|
|
{
|
|
gif_img_count = num_of_frames
|
|
mov esi, gifsrc
|
|
mov edi, imgsrc
|
|
call ReadGIF
|
|
}
|
|
|
|
macro giftoimg gifsrc,imgsrc
|
|
{
|
|
if defined gif_img_count
|
|
error 'giftoimg cannot be used in GIF multiple images mode. Use giftoani instead.'
|
|
end if
|
|
mov esi, gifsrc
|
|
mov edi, imgsrc
|
|
call ReadGIF
|
|
}
|