WebSVN – Kolibri OS – Diff – /programs/media/ac97snd/ac97snd/k_lib.asm


format MS COFF
 
include "proc32.inc"
 
section '.text' align 16 code readable executable
 
public _InitHeap@4
public _UserAlloc@4
public _UserFree@4
 
public _GetNotify@4
public _CreateThread@8
public _GetMousePos@4
 
public _get_fileinfo@8
public _create_file@4
public _read_file@20
public _write_file@20
 
public _get_key@4
public _remap_key@4
public _get_button_id
 
public _GetScreenSize@8
 
public _DrawWindow@36
public _make_button@24
public _draw_bar@20
 
public _write_text@20
public _debug_out@4
public _debug_out_hex@4
public _create_thread@12
 
 
public _memset
 
struc FILEIO
{   .cmd            dd ?
    .offset         dd ?
                    dd ?
    .count          dd ?
    .buff           dd ?
                    db ?
    .name           dd ?
};
 
struc CTRL_INFO
{   .pci_cmd        dd  ?
    .irq            dd  ?
    .glob_cntrl     dd  ?
    .glob_sta       dd  ?
    .codec_io_base  dd  ?
    .ctrl_io_base   dd  ?
    .codec_mem_base dd  ?
    .ctrl_mem_base  dd  ?
    .codec_id       dd  ?
}
CTRL_INFO_SIZE      equ 9*4
 
align 4
_GetScreenSize@8:
           .x equ esp+12
           .y equ esp+16 
 
           push ebx
           push ecx
           mov eax, 14
           int 0x40
           mov ebx, [.y]
           movzx ecx, ax
           inc ecx
           mov [ebx], ecx
           mov ebx, [.x]
           shr eax, 16
           inc eax
           mov [ebx], eax
           pop ecx
           pop ebx
           ret 8
 
align 4
_create_thread@12:
.thr_proc    equ esp+8
.param       equ esp+12
.stack_size  equ esp+16
 
           push ebx
           
           mov eax, 68
           mov ebx, 12
           mov ecx, [.stack_size]
           add ecx, 4095
           and ecx, -4096
           int 0x40
           test eax, eax
           jz .fail
 
           lea edx, [eax+ecx-12]
           mov [edx], dword .exit_point
           mov ebx, [.param]
           mov [edx+4], ebx
           mov [edx+8], ecx
 
           mov eax, 51
           mov ebx, 1
           mov ecx, [.thr_proc]
           int 0x40
           pop ebx
           ret 12
.fail:
           not eax
           pop ebx
           ret 12
align 4
.exit_point:
           pop ecx
           mov eax, 68
           mov ebx, 13
           int 0x40
           mov eax, -1
           int 0x40
 
restore .thr_proc
restore .param
restore .stack_size
 
align 4
proc _get_button_id
           mov   eax,17
           int   0x40
           test  al,al
           jnz   @F
           shr   eax,8
           ret
@@:
           xor   eax,eax
           dec   eax
           ret
endp
 
align 4
proc _get_fileinfo@8 stdcall, name:dword, info:dword
           push ebx
           push ecx
           push esi
           push edi
           xor eax, eax
           mov ebx, [name]
           mov ecx, [info]
 
           mov [fileio.cmd], 5
           mov [fileio.offset], eax
           mov [fileio.offset+4], eax
           mov [fileio.count], eax
           mov [fileio.buff], ecx
           mov byte [fileio.buff+4], al
           mov [fileio.name], ebx
 
           mov eax, 70
           lea ebx, [fileio]
           int 0x40
           pop edi
           pop esi
           pop ecx
           pop ebx
           ret
endp
 
align 4
proc _create_file@4 stdcall, name:dword
           push ebx
           xor eax, eax
           mov ebx, [name]
 
           mov [fileio.cmd], 2
           mov [fileio.offset], eax
           mov [fileio.offset+4], eax
           mov [fileio.count], eax
           mov [fileio.buff], eax
           mov byte [fileio.buff+4], al
           mov [fileio.name], ebx
 
           mov eax, 70
           lea ebx, [fileio]
           int 0x40
           pop ebx
           ret
endp
 
align 4
proc _read_file@20 stdcall,name:dword, buff:dword, offset:dword,\
                                     count:dword,reads:dword
           push ebx
           push esi
           push edi
           push edx
           xor eax, eax
           mov ebx, [name]
           mov edx, [offset]
           mov esi, [buff]
           mov edi, [count]
 
           mov [fileio.cmd], eax
           mov [fileio.offset], edx
           mov [fileio.offset+4], eax
           mov [fileio.count], edi
           mov [fileio.buff], esi
           mov byte [fileio.buff+4], al
           mov [fileio.name], ebx
 
           mov eax, 70
           lea ebx, [fileio]
           int 0x40
           mov esi, [reads]
           test esi, esi
           jz @f
           mov [esi], ebx
@@:
           pop edx
           pop edi
           pop esi
           pop ebx
           ret
endp
 
 
align 4
proc _write_file@20 stdcall,name:dword, buff:dword, offset:dword,\
                                     count:dword,writes:dword
           push ebx
           push esi
           push edi
           push edx
           xor eax, eax
           mov ebx, [name]
           mov edx, [offset]
           mov esi, [buff]
           mov edi, [count]
 
           mov [fileio.cmd], 3
           mov [fileio.offset], edx
           mov [fileio.offset+4], eax
           mov [fileio.count], edi
           mov [fileio.buff], esi
           mov byte [fileio.buff+4], al
           mov [fileio.name], ebx
 
           mov eax, 70
           lea ebx, [fileio]
           int 0x40
           mov esi, [writes]
           test esi, esi
           jz @f
           mov [esi], ebx
@@:
           pop edx
           pop edi
           pop esi
           pop ebx
           ret
endp
 
align 4
proc _get_key@4 stdcall, key:dword
           push ebx
           push ecx
           mov eax, 2
           int 0x40
           mov ebx, [key]
           mov ecx, eax
           shr ecx, 8
           mov [ebx], ecx
           movzx eax, al
           pop ecx
           pop ebx
           ret
endp
 
align 4
proc _InitHeap@4 stdcall, heap_size:dword
           push ebx
           push ecx
           mov eax, 68
           mov ebx, 11
           mov ecx, [heap_size]
           int 0x40
           pop ecx
           pop ebx
           ret
endp
 
align 4
proc _UserAlloc@4 stdcall, alloc_size:dword
           push ebx
           push ecx
           mov eax, 68
           mov ebx, 12
           mov ecx, [alloc_size]
           int 0x40
           pop ecx
           pop ebx
           ret
endp
 
align 4
proc _UserFree@4 stdcall, pmem:dword
           push ebx
           push ecx
           mov eax, 68
           mov ebx, 13
           mov ecx, [pmem]
           int 0x40
           pop ecx
           pop ebx
           ret
endp           
 
align 4
proc _GetNotify@4 stdcall, p_ev:dword
           push ebx
           push ecx
           mov eax, 68
           mov ebx, 14
           mov ecx, [p_ev]
           int 0x40
           pop ecx
           pop ebx
           ret
endp
 
align 4
proc _CreateThread@8 stdcall, fn:dword, p_stack:dword
              push ebx
              push ecx
              push edx
              mov eax, 51
              mov ebx, 1
              mov ecx, [fn]
              mov edx,[p_stack]
              int 0x40
              pop edx
              pop ecx
              pop ebx
              ret
endp
 
align 4
proc _GetMousePos@4 stdcall,rel_type:dword
           push ebx
           mov eax, 37
           mov ebx, [rel_type]
           int 0x40
           pop ebx
           ret
endp
 
align 4
proc _DrawWindow@36 stdcall, x:dword, y:dword, sx:dword, sy:dword,\
                               workcolor:dword, style:dword, captioncolor:dword,\
                               windowtype:dword, bordercolor:dword
           push ebx
           push ecx
           push edx
           push edi
           push esi
           
           mov ebx, [x]
           mov ecx, [y]
           shl ebx, 16
           shl ecx, 16
           mov bx, word [sx]
           mov cx,  word [sy]
           mov  edx,[style]
           shl  edx,24
           add  edx,[workcolor]
           mov  esi,[windowtype]
           shl  esi,24
           add  esi,[captioncolor]
           mov  edi,[bordercolor]
           xor  eax,eax
           int  0x40
           pop esi
           pop edi
           pop edx
           pop ecx
           pop ebx
           ret
endp
 
align 4
proc _make_button@24 stdcall,x:dword, y:dword, \
 
 
                     xsize:dword, ysize:dword, \
 
 
                     id:dword, color:dword   
 
 
           push  ebx
           push  esi
           
           mov   ebx,[x]
           mov   ecx,[y]
 
 
           shl   ebx,16
           shl   ecx,16
           mov   bx, word [xsize]
           mov   cx, word [ysize]
 
           mov   edx,[id]
           mov   esi,[color]
 
           mov   eax,8
           int   0x40
           pop   esi
           pop   ebx
           ret
endp           
 
align 4
_draw_bar@20:
;arg1 - x
;arg2 - y
;arg3 - xsize
;arg4 - ysize
;arg5 - color
  push  ebx ecx
  mov   eax,13
  mov   ebx,[esp+12]
  shl   ebx,16
  mov   bx,[esp+20]
  mov   ecx,[esp+16]
  shl   ecx,16
  mov   cx,[esp+24]
  mov   edx,[esp+28]
  int   0x40
  pop   ecx ebx
  ret   20
 
_write_text@20:
;arg1 - x
;arg2 - y
;arg3 - color
;arg4 - text
;arg5 - len
  push  ebx ecx esi
  mov   eax,4
  mov   ebx,[esp+16]
  shl   ebx,16
  mov   bx,[esp+20]
  mov   ecx,[esp+24]
  mov   edx,[esp+28]
  mov   esi,[esp+32]
  int   0x40
  pop   esi ecx ebx
  ret   20
 
align 4
proc _debug_out@4 stdcall, val:dword
           push ebx
           push ecx
           mov  ecx,[val]
           mov  ebx,1
           mov  eax,63
           int  0x40
           pop ecx
           pop ebx
           ret
endp
 
align 4
proc _debug_out_hex@4 stdcall val:dword
           locals
             count dd ?
           endl
 
           mov [count], 8
.new_char:
           rol [val], 4
           mov ecx, [val]
           and ecx, 0x0f
           mov cl,byte [__hexdigits+ecx]
           mov eax, 63
           mov ebx, 1
           int 0x40
           dec [count]
           jnz .new_char
           ret
endp
 
align 4
proc _remap_key@4 stdcall, key:dword
 
           mov eax, [key]
           and eax, 0x7F
           movzx eax, byte [keymap+eax]
           ret
endp
 
align 4
_memset:
           mov     edx,[esp + 0ch]
           mov     ecx,[esp + 4]
 
           test    edx,edx
           jz      short toend
 
           xor     eax,eax
           mov     al,[esp + 8]
 
           push    edi
           mov     edi,ecx
 
           cmp     edx,4
           jb      tail
 
           neg     ecx
           and     ecx,3
           jz      short dwords
 
           sub     edx,ecx
adjust_loop:
           mov     [edi],al
           add     edi,1
           sub     ecx,1
           jnz     adjust_loop
 
dwords:
        mov     ecx,eax
        shl     eax,8
        add     eax,ecx
        mov     ecx,eax
        shl     eax,10h
        add     eax,ecx
 
        mov     ecx,edx
        and     edx,3
        shr     ecx,2
        jz      tail
 
                cld
        rep     stosd
main_loop_tail:
        test    edx,edx
        jz      finish
 
 
tail:
        mov     [edi],al
        add     edi,1
 
        sub     edx,1
        jnz     tail
 
finish:
        mov     eax,[esp + 8]
        pop     edi
 
        ret
 
toend:
        mov     eax,[esp + 4]
 
        ret
 
;public __allmul
 
__allmul:
        mov eax, [esp+8]
        mov ecx, [esp+16]
        or ecx,eax
        mov ecx, [esp+12]
        jnz .hard
        mov eax, [esp+4]
        mul ecx
        ret 16
.hard:
        push ebx
        mul ecx
        mov ebx,eax
        mov eax, [esp+8]
        mul dword [esp+20]
        add ebx,eax
        mov eax,[esp+8]
        mul ecx
        add edx,ebx
        pop ebx
        ret 16
 
;public __allshr
 
align 4
__allshr:
        cmp cl,64
        jae .sign
 
        cmp cl, 32
        jae .MORE32
        shrd eax,edx,cl
        sar edx,cl
        ret
.MORE32:
        mov     eax,edx
        sar     edx,31
        and     cl,31
        sar     eax,cl
        ret
.sign:
        sar     edx,31
        mov     eax,edx
        ret
 
 
;public _scalbn
 
align 4
proc _scalbn
	          fild	dword [esp+12]
	          fld	qword [esp+4]
	          fscale
	          fstp	st1
	          ret
endp
 
 
;public  __alloca_probe_8
;public  __alloca_probe_16
 
__alloca_probe_16:                       ; 16 byte aligned alloca
 
        push    ecx
        lea     ecx, [esp + 8]          ; TOS before entering this function
        sub     ecx, eax                ; New TOS
        and     ecx, (16 - 1)           ; Distance from 16 bit align (align down)
        add     eax, ecx                ; Increase allocation size
        sbb     ecx, ecx                ; ecx = 0xFFFFFFFF if size wrapped around
        or      eax, ecx                ; cap allocation size on wraparound
        pop     ecx                     ; Restore ecx
        jmp     __chkstk
 
alloca_8:                               ; 8 byte aligned alloca
__alloca_probe_8:
 
        push    ecx
        lea     ecx, [esp+8]          ; TOS before entering this function
        sub     ecx, eax                ; New TOS
        and     ecx, (8 - 1)            ; Distance from 8 bit align (align down)
        add     eax, ecx                ; Increase allocation Size
        sbb     ecx, ecx                ; ecx = 0xFFFFFFFF if size wrapped around
        or      eax, ecx                ; cap allocation size on wraparound
        pop     ecx                     ; Restore ecx
        jmp     __chkstk
 
;public __chkstk
;public _alloca_probe
 
align 4
;_alloca_probe:
__chkstk:
        push    ecx
        lea     ecx, [esp+8-4]          ; TOS before entering function + size for ret value
        sub     ecx, eax                ; new TOS
 
; Handle allocation size that results in wraparound.
; Wraparound will result in StackOverflow exception.
 
        sbb     eax, eax                ; 0 if CF==0, ~0 if CF==1
        not     eax                     ; ~0 if TOS did not wrapped around, 0 otherwise
        and     ecx, eax                ; set to 0 if wraparound
 
        mov     eax, esp                ; current TOS
        and     eax, -4096              ; Round down to current page boundary
 
cs10:
        cmp     ecx, eax                ; Is new TOS
        jb      short cs20              ; in probed page?
        mov     eax, ecx                ; yes.
        pop     ecx
        xchg    esp, eax                ; update esp
        mov     eax, [eax]              ; get return address
        mov     [esp], eax              ; and put it at new TOS
        ret
 
; Find next lower page and probe
cs20:
        sub     eax, 4096               ; decrease by PAGESIZE
        test    [eax],eax     ; probe page.
        jmp     short cs10
 
public __ftol2_sse
 
align 4
__ftol2_sse:
           push ebp
           mov ebp, esp
           sub esp, 20
           and esp, 0xFFFFFFF0
           fld st0
           fst dword [esp+18]
           fistp qword [esp+10]
           fild qword [esp+10]
           mov edx, [esp+18]
           mov eax, [esp+10]
           test eax, eax
           jz .QnaNZ
 
.not_QnaNZ:
           fsubp st1, st0
           test edx, edx
           jns .pos
           fstp dword [esp]
           mov ecx, [esp]
           xor ecx, 0x80000000
           add ecx, 0x7FFFFFFF
           adc eax, 0
           mov edx, [esp+14]
           adc edx, 0
           jmp .exit
.pos:
           fstp dword [esp]
           mov ecx, [esp]
           add ecx, 0x7FFFFFFF
           sbb eax, 0
           jmp .exit
.QnaNZ:
           mov edx, [esp+14]
           test edx, 0x7FFFFFFF
           jne .not_QnaNZ
           fstp dword [esp+18]
           fstp dword [esp+18]
.exit:
           leave
           ret
 
section '.data' align 16 data readable writable
 
align 16
__hexdigits db '0123456789ABCDEF'
 
         ;  0    1    2    3    4    5    6    7
         ;  8    9    a    b    c    d    e    f
 
keymap:
     db      0,  27, '1', '2', '3', '4', '5', '6'   ;00
     db    '7', '8', '9', '0', '-', '=',0x7F, 0x9   ;08
     db    'q', 'w', 'e', 'r', 't', 'y', 'u', 'i'   ;10
     db    'o', 'p', '[', ']',  13,0x9D, 'a', 's'   ;18
     db    'd', 'f', 'g', 'h', 'j', 'k', 'l', ';'   ;20
     db      0, '~',0xB6, '|',0x7A,0x87, 'c', 'v'   ;28
     db    'b', 'n', 'm', ',', '.', '/',0xB6, '*'   ;30
     db   0xB8, ' ',   0,0xBB,0xBC,0xBD,0xBE,0xBF   ;38
     db   0xC0,0xC1,0xC2,0xC3,0xC4,   0,   0,   0   ;40
     db   0xAD,   0,   0,0xAC,   0,0xAE,   0,   0   ;48
     db   0xAF,   0,   0,   0,   0,   0,   0,   0   ;50
     db      0,   0,   0,   0,   0,   0,   0,   0   ;58
     db      0,   0,   0,   0,   0,   0,   0,   0   ;60
     db      0,   0,   0,   0,   0,   0,   0,   0   ;68
     db      0,   0,   0,   0,   0,   0,   0,   0   ;70
     db      0,   0,   0,   0,   0,   0,   0,   0   ;78
 
public ___sse2_available
___sse2_available dd 0
 
public __fltused
__fltused    dd 0
 
align 4
fileio FILEIO

Rev 799	Rev 801
1	format MS COFF	1	format MS COFF
2		2
3	include "proc32.inc"	3	include "proc32.inc"
4		4
5	section '.text' align 16 code readable executable	5	section '.text' align 16 code readable executable
6		6
7	public _InitHeap@4	7	public _InitHeap@4
8	public _UserAlloc@4	8	public _UserAlloc@4
9	public _UserFree@4	9	public _UserFree@4
10		10
11	public _GetNotify@4	11	public _GetNotify@4
12	public _CreateThread@8	12	public _CreateThread@8
13	public _GetMousePos@4	13	public _GetMousePos@4
14		14
15	public _get_fileinfo@8	15	public _get_fileinfo@8
16	public _create_file@4	16	public _create_file@4
17	public _read_file@20	17	public _read_file@20
18	public _write_file@20	18	public _write_file@20
19		19
20	public _get_key@4	20	public _get_key@4
21	public _remap_key@4	21	public _remap_key@4
22	public _get_button_id	22	public _get_button_id
23		23
24	public _GetScreenSize@8	24	public _GetScreenSize@8
25		25
26	public _DrawWindow@36	26	public _DrawWindow@36
27	public _make_button@24	27	public _make_button@24
28	public _draw_bar@20	28	public _draw_bar@20
29		29
30	public _write_text@20	30	public _write_text@20
31	public _debug_out@4	31	public _debug_out@4
32	public _debug_out_hex@4	32	public _debug_out_hex@4
33	public _create_thread@12	33	public _create_thread@12
34		34
35		35
36	public _memset	36	public _memset
37		37
38	struc FILEIO	38	struc FILEIO
39	{ .cmd dd ?	39	{ .cmd dd ?
40	.offset dd ?	40	.offset dd ?
41	dd ?	41	dd ?
42	.count dd ?	42	.count dd ?
43	.buff dd ?	43	.buff dd ?
44	db ?	44	db ?
45	.name dd ?	45	.name dd ?
46	};	46	};
47		47
48	struc CTRL_INFO	48	struc CTRL_INFO
49	{ .pci_cmd dd ?	49	{ .pci_cmd dd ?
50	.irq dd ?	50	.irq dd ?
51	.glob_cntrl dd ?	51	.glob_cntrl dd ?
52	.glob_sta dd ?	52	.glob_sta dd ?
53	.codec_io_base dd ?	53	.codec_io_base dd ?
54	.ctrl_io_base dd ?	54	.ctrl_io_base dd ?
55	.codec_mem_base dd ?	55	.codec_mem_base dd ?
56	.ctrl_mem_base dd ?	56	.ctrl_mem_base dd ?
57	.codec_id dd ?	57	.codec_id dd ?
58	}	58	}
59	CTRL_INFO_SIZE equ 9*4	59	CTRL_INFO_SIZE equ 9*4
60		60
61	align 4	61	align 4
62	_GetScreenSize@8:	62	_GetScreenSize@8:
63	.x equ esp+12	63	.x equ esp+12
64	.y equ esp+16	64	.y equ esp+16
65		65
66	push ebx	66	push ebx
67	push ecx	67	push ecx
68	mov eax, 14	68	mov eax, 14
69	int 0x40	69	int 0x40
70	mov ebx, [.y]	70	mov ebx, [.y]
71	movzx ecx, ax	71	movzx ecx, ax
72	inc ecx	72	inc ecx
73	mov [ebx], ecx	73	mov [ebx], ecx
74	mov ebx, [.x]	74	mov ebx, [.x]
75	shr eax, 16	75	shr eax, 16
76	inc eax	76	inc eax
77	mov [ebx], eax	77	mov [ebx], eax
78	pop ecx	78	pop ecx
79	pop ebx	79	pop ebx
80	ret 8	80	ret 8
81		81
82	align 4	82	align 4
83	_create_thread@12:	83	_create_thread@12:
84	.thr_proc equ esp+8	84	.thr_proc equ esp+8
85	.param equ esp+12	85	.param equ esp+12
86	.stack_size equ esp+16	86	.stack_size equ esp+16
87		87
88	push ebx	88	push ebx
89		89
90	mov eax, 68	90	mov eax, 68
91	mov ebx, 12	91	mov ebx, 12
92	mov ecx, [.stack_size]	92	mov ecx, [.stack_size]
93	add ecx, 4095	93	add ecx, 4095
94	and ecx, -4096	94	and ecx, -4096
95	int 0x40	95	int 0x40
96	test eax, eax	96	test eax, eax
97	jz .fail	97	jz .fail
98		98
99	lea edx, [eax+ecx-12]	99	lea edx, [eax+ecx-12]
100	mov [edx], dword .exit_point	100	mov [edx], dword .exit_point
101	mov ebx, [.param]	101	mov ebx, [.param]
102	mov [edx+4], ebx	102	mov [edx+4], ebx
103	mov [edx+8], ecx	103	mov [edx+8], ecx
104		104
105	mov eax, 51	105	mov eax, 51
106	mov ebx, 1	106	mov ebx, 1
107	mov ecx, [.thr_proc]	107	mov ecx, [.thr_proc]
108	int 0x40	108	int 0x40
109	pop ebx	109	pop ebx
110	ret 12	110	ret 12
111	.fail:	111	.fail:
112	not eax	112	not eax
113	pop ebx	113	pop ebx
114	ret 12	114	ret 12
115	align 4	115	align 4
116	.exit_point:	116	.exit_point:
117	pop ecx	117	pop ecx
118	mov eax, 68	118	mov eax, 68
119	mov ebx, 13	119	mov ebx, 13
120	int 0x40	120	int 0x40
121	mov eax, -1	121	mov eax, -1
122	int 0x40	122	int 0x40
123		123
124	restore .thr_proc	124	restore .thr_proc
125	restore .param	125	restore .param
126	restore .stack_size	126	restore .stack_size
127		127
128	align 4	128	align 4
129	proc _get_button_id	129	proc _get_button_id
130	mov eax,17	130	mov eax,17
131	int 0x40	131	int 0x40
132	test al,al	132	test al,al
133	jnz @F	133	jnz @F
134	shr eax,8	134	shr eax,8
135	ret	135	ret
136	@@:	136	@@:
137	xor eax,eax	137	xor eax,eax
138	dec eax	138	dec eax
139	ret	139	ret
140	endp	140	endp
141		141
142	align 4	142	align 4
143	proc _get_fileinfo@8 stdcall, name:dword, info:dword	143	proc _get_fileinfo@8 stdcall, name:dword, info:dword
144	push ebx	144	push ebx
145	push ecx	145	push ecx
146	push esi	146	push esi
147	push edi	147	push edi
148	xor eax, eax	148	xor eax, eax
149	mov ebx, [name]	149	mov ebx, [name]
150	mov ecx, [info]	150	mov ecx, [info]
151		151
152	mov [fileio.cmd], 5	152	mov [fileio.cmd], 5
153	mov [fileio.offset], eax	153	mov [fileio.offset], eax
154	mov [fileio.offset+4], eax	154	mov [fileio.offset+4], eax
155	mov [fileio.count], eax	155	mov [fileio.count], eax
156	mov [fileio.buff], ecx	156	mov [fileio.buff], ecx
157	mov byte [fileio.buff+4], al	157	mov byte [fileio.buff+4], al
158	mov [fileio.name], ebx	158	mov [fileio.name], ebx
159		159
160	mov eax, 70	160	mov eax, 70
161	lea ebx, [fileio]	161	lea ebx, [fileio]
162	int 0x40	162	int 0x40
163	pop edi	163	pop edi
164	pop esi	164	pop esi
165	pop ecx	165	pop ecx
166	pop ebx	166	pop ebx
167	ret	167	ret
168	endp	168	endp
169		169
170	align 4	170	align 4
171	proc _create_file@4 stdcall, name:dword	171	proc _create_file@4 stdcall, name:dword
172	push ebx	172	push ebx
173	xor eax, eax	173	xor eax, eax
174	mov ebx, [name]	174	mov ebx, [name]
175		175
176	mov [fileio.cmd], 2	176	mov [fileio.cmd], 2
177	mov [fileio.offset], eax	177	mov [fileio.offset], eax
178	mov [fileio.offset+4], eax	178	mov [fileio.offset+4], eax
179	mov [fileio.count], eax	179	mov [fileio.count], eax
180	mov [fileio.buff], eax	180	mov [fileio.buff], eax
181	mov byte [fileio.buff+4], al	181	mov byte [fileio.buff+4], al
182	mov [fileio.name], ebx	182	mov [fileio.name], ebx
183		183
184	mov eax, 70	184	mov eax, 70
185	lea ebx, [fileio]	185	lea ebx, [fileio]
186	int 0x40	186	int 0x40
187	pop ebx	187	pop ebx
188	ret	188	ret
189	endp	189	endp
190		190
191	align 4	191	align 4
192	proc _read_file@20 stdcall,name:dword, buff:dword, offset:dword,\	192	proc _read_file@20 stdcall,name:dword, buff:dword, offset:dword,\
193	count:dword,reads:dword	193	count:dword,reads:dword
194	push ebx	194	push ebx
195	push esi	195	push esi
196	push edi	196	push edi
197	push edx	197	push edx
198	xor eax, eax	198	xor eax, eax
199	mov ebx, [name]	199	mov ebx, [name]
200	mov edx, [offset]	200	mov edx, [offset]
201	mov esi, [buff]	201	mov esi, [buff]
202	mov edi, [count]	202	mov edi, [count]
203		203
204	mov [fileio.cmd], eax	204	mov [fileio.cmd], eax
205	mov [fileio.offset], edx	205	mov [fileio.offset], edx
206	mov [fileio.offset+4], eax	206	mov [fileio.offset+4], eax
207	mov [fileio.count], edi	207	mov [fileio.count], edi
208	mov [fileio.buff], esi	208	mov [fileio.buff], esi
209	mov byte [fileio.buff+4], al	209	mov byte [fileio.buff+4], al
210	mov [fileio.name], ebx	210	mov [fileio.name], ebx
211		211
212	mov eax, 70	212	mov eax, 70
213	lea ebx, [fileio]	213	lea ebx, [fileio]
214	int 0x40	214	int 0x40
215	mov esi, [reads]	215	mov esi, [reads]
216	test esi, esi	216	test esi, esi
217	jz @f	217	jz @f
218	mov [esi], ebx	218	mov [esi], ebx
219	@@:	219	@@:
220	pop edx	220	pop edx
221	pop edi	221	pop edi
222	pop esi	222	pop esi
223	pop ebx	223	pop ebx
224	ret	224	ret
225	endp	225	endp
226		226
227		227
228	align 4	228	align 4
229	proc _write_file@20 stdcall,name:dword, buff:dword, offset:dword,\	229	proc _write_file@20 stdcall,name:dword, buff:dword, offset:dword,\
230	count:dword,writes:dword	230	count:dword,writes:dword
231	push ebx	231	push ebx
232	push esi	232	push esi
233	push edi	233	push edi
234	push edx	234	push edx
235	xor eax, eax	235	xor eax, eax
236	mov ebx, [name]	236	mov ebx, [name]
237	mov edx, [offset]	237	mov edx, [offset]
238	mov esi, [buff]	238	mov esi, [buff]
239	mov edi, [count]	239	mov edi, [count]
240		240
241	mov [fileio.cmd], 3	241	mov [fileio.cmd], 3
242	mov [fileio.offset], edx	242	mov [fileio.offset], edx
243	mov [fileio.offset+4], eax	243	mov [fileio.offset+4], eax
244	mov [fileio.count], edi	244	mov [fileio.count], edi
245	mov [fileio.buff], esi	245	mov [fileio.buff], esi
246	mov byte [fileio.buff+4], al	246	mov byte [fileio.buff+4], al
247	mov [fileio.name], ebx	247	mov [fileio.name], ebx
248		248
249	mov eax, 70	249	mov eax, 70
250	lea ebx, [fileio]	250	lea ebx, [fileio]
251	int 0x40	251	int 0x40
252	mov esi, [writes]	252	mov esi, [writes]
253	test esi, esi	253	test esi, esi
254	jz @f	254	jz @f
255	mov [esi], ebx	255	mov [esi], ebx
256	@@:	256	@@:
257	pop edx	257	pop edx
258	pop edi	258	pop edi
259	pop esi	259	pop esi
260	pop ebx	260	pop ebx
261	ret	261	ret
262	endp	262	endp
263		263
264	align 4	264	align 4
265	proc _get_key@4 stdcall, key:dword	265	proc _get_key@4 stdcall, key:dword
266	push ebx	266	push ebx
267	push ecx	267	push ecx
268	mov eax, 2	268	mov eax, 2
269	int 0x40	269	int 0x40
270	mov ebx, [key]	270	mov ebx, [key]
271	mov ecx, eax	271	mov ecx, eax
272	shr ecx, 8	272	shr ecx, 8
273	mov [ebx], ecx	273	mov [ebx], ecx
274	movzx eax, al	274	movzx eax, al
275	pop ecx	275	pop ecx
276	pop ebx	276	pop ebx
277	ret	277	ret
278	endp	278	endp
279		279
280	align 4	280	align 4
281	proc _InitHeap@4 stdcall, heap_size:dword	281	proc _InitHeap@4 stdcall, heap_size:dword
282	push ebx	282	push ebx
283	push ecx	283	push ecx
284	mov eax, 68	284	mov eax, 68
285	mov ebx, 11	285	mov ebx, 11
286	mov ecx, [heap_size]	286	mov ecx, [heap_size]
287	int 0x40	287	int 0x40
288	pop ecx	288	pop ecx
289	pop ebx	289	pop ebx
290	ret	290	ret
291	endp	291	endp
292		292
293	align 4	293	align 4
294	proc _UserAlloc@4 stdcall, alloc_size:dword	294	proc _UserAlloc@4 stdcall, alloc_size:dword
295	push ebx	295	push ebx
296	push ecx	296	push ecx
297	mov eax, 68	297	mov eax, 68
298	mov ebx, 12	298	mov ebx, 12
299	mov ecx, [alloc_size]	299	mov ecx, [alloc_size]
300	int 0x40	300	int 0x40
301	pop ecx	301	pop ecx
302	pop ebx	302	pop ebx
303	ret	303	ret
304	endp	304	endp
305		305
306	align 4	306	align 4
307	proc _UserFree@4 stdcall, pmem:dword	307	proc _UserFree@4 stdcall, pmem:dword
308	push ebx	308	push ebx
309	push ecx	309	push ecx
310	mov eax, 68	310	mov eax, 68
311	mov ebx, 13	311	mov ebx, 13
312	mov ecx, [pmem]	312	mov ecx, [pmem]
313	int 0x40	313	int 0x40
314	pop ecx	314	pop ecx
315	pop ebx	315	pop ebx
316	ret	316	ret
317	endp	317	endp
318		318
319	align 4	319	align 4
320	proc _GetNotify@4 stdcall, p_ev:dword	320	proc _GetNotify@4 stdcall, p_ev:dword
321	push ebx	321	push ebx
322	push ecx	322	push ecx
323	mov eax, 68	323	mov eax, 68
324	mov ebx, 14	324	mov ebx, 14
325	mov ecx, [p_ev]	325	mov ecx, [p_ev]
326	int 0x40	326	int 0x40
327	pop ecx	327	pop ecx
328	pop ebx	328	pop ebx
329	ret	329	ret
330	endp	330	endp
331		331
332	align 4	332	align 4
333	proc _CreateThread@8 stdcall, fn:dword, p_stack:dword	333	proc _CreateThread@8 stdcall, fn:dword, p_stack:dword
334	push ebx	334	push ebx
335	push ecx	335	push ecx
336	push edx	336	push edx
337	mov eax, 51	337	mov eax, 51
338	mov ebx, 1	338	mov ebx, 1
339	mov ecx, [fn]	339	mov ecx, [fn]
340	mov edx,[p_stack]	340	mov edx,[p_stack]
341	int 0x40	341	int 0x40
342	pop edx	342	pop edx
343	pop ecx	343	pop ecx
344	pop ebx	344	pop ebx
345	ret	345	ret
346	endp	346	endp
347		347
348	align 4	348	align 4
349	proc _GetMousePos@4 stdcall,rel_type:dword	349	proc _GetMousePos@4 stdcall,rel_type:dword
350	push ebx	350	push ebx
351	mov eax, 37	351	mov eax, 37
352	mov ebx, [rel_type]	352	mov ebx, [rel_type]
353	int 0x40	353	int 0x40
354	pop ebx	354	pop ebx
355	ret	355	ret
356	endp	356	endp
357		357
358	align 4	358	align 4
359	proc _DrawWindow@36 stdcall, x:dword, y:dword, sx:dword, sy:dword,\	359	proc _DrawWindow@36 stdcall, x:dword, y:dword, sx:dword, sy:dword,\
360	workcolor:dword, style:dword, captioncolor:dword,\	360	workcolor:dword, style:dword, captioncolor:dword,\
361	windowtype:dword, bordercolor:dword	361	windowtype:dword, bordercolor:dword
362	push ebx	362	push ebx
363	push ecx	363	push ecx
364	push edx	364	push edx
365	push edi	365	push edi
366	push esi	366	push esi
367		367
368	mov ebx, [x]	368	mov ebx, [x]
369	mov ecx, [y]	369	mov ecx, [y]
370	shl ebx, 16	370	shl ebx, 16
371	shl ecx, 16	371	shl ecx, 16
372	mov bx, word [sx]	372	mov bx, word [sx]
373	mov cx, word [sy]	373	mov cx, word [sy]
374	mov edx,[style]	374	mov edx,[style]
375	shl edx,24	375	shl edx,24
376	add edx,[workcolor]	376	add edx,[workcolor]
377	mov esi,[windowtype]	377	mov esi,[windowtype]
378	shl esi,24	378	shl esi,24
379	add esi,[captioncolor]	379	add esi,[captioncolor]
380	mov edi,[bordercolor]	380	mov edi,[bordercolor]
381	xor eax,eax	381	xor eax,eax
382	int 0x40	382	int 0x40
383	pop esi	383	pop esi
384	pop edi	384	pop edi
385	pop edx	385	pop edx
386	pop ecx	386	pop ecx
387	pop ebx	387	pop ebx
388	ret	388	ret
389	endp	389	endp
390		390
391	align 4	391	align 4
392	_make_button@24:	392	proc _make_button@24 stdcall,x:dword, y:dword, \
393	;arg1 - x	-
394	;arg2 - y	-
395	;arg3 - xsize	393	xsize:dword, ysize:dword, \
396	;arg4 - ysize	-
397	;arg5 - id	-
398	;arg6 - color	394	id:dword, color:dword
399		395
400	push ebx	-
401	push ecx	396	push ebx
-		397	push esi
402	push esi	398
-		399	mov ebx,[x]
403	mov ebx,[esp+12]	400	mov ecx,[y]
404	shl ebx,16	-
405	mov bx,[esp+20]	-
406	mov ecx,[esp+16]	401	shl ebx,16
-		402	shl ecx,16
407	shl ecx,16	403	mov bx, word [xsize]
-		404	mov cx, word [ysize]
408	mov cx,[esp+24]	405
409	mov edx,[esp+28]	406	mov edx,[id]
-		407	mov esi,[color]
410	mov esi,[esp+32]	408
411	mov eax,8	409	mov eax,8
-		410	int 0x40
412	int 0x40	411	pop esi
413	pop esi ecx ebx	412	pop ebx
-		413	ret
414	ret 24	414	endp
415		415
416	align 4	416	align 4
417	_draw_bar@20:	417	_draw_bar@20:
418	;arg1 - x	418	;arg1 - x
419	;arg2 - y	419	;arg2 - y
420	;arg3 - xsize	420	;arg3 - xsize
421	;arg4 - ysize	421	;arg4 - ysize
422	;arg5 - color	422	;arg5 - color
423	push ebx ecx	423	push ebx ecx
424	mov eax,13	424	mov eax,13
425	mov ebx,[esp+12]	425	mov ebx,[esp+12]
426	shl ebx,16	426	shl ebx,16
427	mov bx,[esp+20]	427	mov bx,[esp+20]
428	mov ecx,[esp+16]	428	mov ecx,[esp+16]
429	shl ecx,16	429	shl ecx,16
430	mov cx,[esp+24]	430	mov cx,[esp+24]
431	mov edx,[esp+28]	431	mov edx,[esp+28]
432	int 0x40	432	int 0x40
433	pop ecx ebx	433	pop ecx ebx
434	ret 20	434	ret 20
435		435
436	_write_text@20:	436	_write_text@20:
437	;arg1 - x	437	;arg1 - x
438	;arg2 - y	438	;arg2 - y
439	;arg3 - color	439	;arg3 - color
440	;arg4 - text	440	;arg4 - text
441	;arg5 - len	441	;arg5 - len
442	push ebx ecx esi	442	push ebx ecx esi
443	mov eax,4	443	mov eax,4
444	mov ebx,[esp+16]	444	mov ebx,[esp+16]
445	shl ebx,16	445	shl ebx,16
446	mov bx,[esp+20]	446	mov bx,[esp+20]
447	mov ecx,[esp+24]	447	mov ecx,[esp+24]
448	mov edx,[esp+28]	448	mov edx,[esp+28]
449	mov esi,[esp+32]	449	mov esi,[esp+32]
450	int 0x40	450	int 0x40
451	pop esi ecx ebx	451	pop esi ecx ebx
452	ret 20	452	ret 20
453		453
454	align 4	454	align 4
455	proc _debug_out@4 stdcall, val:dword	455	proc _debug_out@4 stdcall, val:dword
456	push ebx	456	push ebx
457	push ecx	457	push ecx
458	mov ecx,[val]	458	mov ecx,[val]
459	mov ebx,1	459	mov ebx,1
460	mov eax,63	460	mov eax,63
461	int 0x40	461	int 0x40
462	pop ecx	462	pop ecx
463	pop ebx	463	pop ebx
464	ret	464	ret
465	endp	465	endp
466		466
467	align 4	467	align 4
468	proc _debug_out_hex@4 stdcall val:dword	468	proc _debug_out_hex@4 stdcall val:dword
469	locals	469	locals
470	count dd ?	470	count dd ?
471	endl	471	endl
472		472
473	mov [count], 8	473	mov [count], 8
474	.new_char:	474	.new_char:
475	rol [val], 4	475	rol [val], 4
476	mov ecx, [val]	476	mov ecx, [val]
477	and ecx, 0x0f	477	and ecx, 0x0f
478	mov cl,byte [__hexdigits+ecx]	478	mov cl,byte [__hexdigits+ecx]
479	mov eax, 63	479	mov eax, 63
480	mov ebx, 1	480	mov ebx, 1
481	int 0x40	481	int 0x40
482	dec [count]	482	dec [count]
483	jnz .new_char	483	jnz .new_char
484	ret	484	ret
485	endp	485	endp
486		486
487	align 4	487	align 4
488	proc _remap_key@4 stdcall, key:dword	488	proc _remap_key@4 stdcall, key:dword
489		489
490	mov eax, [key]	490	mov eax, [key]
491	and eax, 0x7F	491	and eax, 0x7F
492	movzx eax, byte [keymap+eax]	492	movzx eax, byte [keymap+eax]
493	ret	493	ret

Subversion Repositories Kolibri OS

(root)/programs/media/ac97snd/ac97snd/k_lib.asm – Rev 799 → 801