WebSVN – Kolibri OS – Diff – /kernel/trunk/drivers/infinity.asm


;
;   This file is part of the Infinity sound library.
;   (C) copyright Serge 2006
;   email: infinity_sound@mail.ru
;
;   This program is free software; you can redistribute it and/or modify
;   it under the terms of the GNU General Public License as published by
;   the Free Software Foundation; either version 2 of the License, or
;   (at your option) any later version.
;
;   This program 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 General Public License for more details.
 
format MS COFF
 
include 'proc32.inc'
include 'main.inc'
include 'imports.inc'
 
FORCE_MMX        equ 0  ;set to 1 to force use mmx or
FORCE_MMX_128    equ 0  ;integer sse2 extensions
                        ;and reduce driver size
;USE_SSE         equ 0
 
DEBUG            equ 1
 
EVENT_NOTIFY     equ 0x00000200
 
OS_BASE          equ 0
new_app_base     equ 0x60400000
PROC_BASE        equ OS_BASE+0x0080000
 
CAPS_SSE2        equ 26
PG_SW            equ 0x003
 
 
public START
public service_proc
public version
 
SND_CREATE_BUFF     equ 2
SND_PLAY            equ 3
SND_STOP            equ 4
SND_SETBUFF         equ 5
SND_DESTROY_BUFF    equ 6
 
DEV_PLAY            equ 1
DEV_STOP            equ 2
DEV_CALLBACK        equ 3
 
struc IOCTL
{  .handle           dd ?
   .io_code          dd ?
   .input            dd ?
   .inp_size         dd ?
   .output           dd ?
   .out_size         dd ?
}
 
virtual at 0
  IOCTL IOCTL
end virtual
 
section '.flat' code readable align 16
 
proc START stdcall, state:dword
 
           cmp [state], 1
           jne .exit
 
           stdcall GetService, szSound
           test eax, eax
           jz .fail
           mov [hSound], eax
 
           stdcall KernelAlloc, 16*512
           test eax, eax
           jz .out_of_mem
           mov [mix_buff], eax
 
           mov eax, str.fd-FD_OFFSET
           mov [str.fd], eax
           mov [str.bk], eax
 
if FORCE_MMX
 if FORCE_MMX_128
  display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
  stop
 end if
           mov [mix_2_core], mmx_mix_2
           mov [mix_3_core], mmx_mix_3
           mov [mix_4_core], mmx_mix_4
end if
 
if FORCE_MMX_128
 if FORCE_MMX
  display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
  stop
 end if
           mov [mix_2_core], mmx128_mix_2
           mov [mix_3_core], mmx128_mix_3
           mov [mix_4_core], mmx128_mix_4
end if
 
if ~(FORCE_MMX or FORCE_MMX_128)  ;autodetect
           mov eax, 1
           cpuid
           bt edx, CAPS_SSE2
           jc .mmx128
                                           ;old 64-bit mmx
           mov [mix_2_core], mmx_mix_2
           mov [mix_3_core], mmx_mix_3
           mov [mix_4_core], mmx_mix_4
           jmp @F
.mmx128:                                   ;128-bit integer sse2 extensions
           mov [mix_2_core], mmx128_mix_2
           mov [mix_3_core], mmx128_mix_3
           mov [mix_4_core], mmx128_mix_4
@@:
end if
           stdcall set_handler, [hSound], new_mix
           stdcall RegService, szInfinity, service_proc
           ret
.fail:
     if DEBUG
           mov esi, msgFail
           call SysMsgBoardStr
     end if
.exit:
           xor eax, eax
           ret
 
.out_of_mem:
     if DEBUG
           mov esi, msgMem
           call SysMsgBoardStr
     end if
           xor eax, eax
           ret
endp
 
handle     equ  IOCTL.handle
io_code    equ  IOCTL.io_code
input      equ  IOCTL.input
inp_size   equ  IOCTL.inp_size
output     equ  IOCTL.output
out_size   equ  IOCTL.out_size
 
align 4
proc service_proc stdcall, ioctl:dword
 
           mov edi, [ioctl]
           mov eax, [edi+io_code]
 
           cmp eax, SND_CREATE_BUFF
           jne @F
           mov ebx, [edi+input]
           stdcall CreateBuffer,[ebx]
           ret
@@:
           cmp eax, SND_PLAY
           jne @F
 
           mov ebx, [edi+input]
           stdcall play_buffer, [ebx]
           ret
@@:
           cmp eax, SND_STOP
           jne @F
 
;       if DEBUG
;          mov esi, msgStop
;          call   [SysMsgBoardStr]
;       end if
 
           mov ebx, [edi+input]
           stdcall stop_buffer, [ebx]
           ret
@@:
           cmp eax, SND_SETBUFF
           jne @F
 
           mov ebx, [edi+input]
           mov eax, [ebx+4]
           add eax, new_app_base
           stdcall set_buffer, [ebx],eax,[ebx+8],[ebx+12]
           ret
@@:
           cmp eax, SND_DESTROY_BUFF
           jne @F
 
           mov eax, [edi+input]
           mov eax, [eax]
           call DestroyBuffer    ;eax
           ret
@@:
           xor eax, eax
           ret
endp
 
restore   handle
restore   io_code
restore   input
restore   inp_size
restore   output
restore   out_size
 
TASK_COUNT    equ 0x0003004
CURRENT_TASK  equ 0x0003000
 
align 4
proc CreateBuffer stdcall, format:dword
           locals
             str dd ?
           endl
 
           mov ebx, [CURRENT_TASK]      ;hack: direct accsess
           shl ebx, 5                   ;to kernel data
           mov ebx, [0x3000+ebx+4]
           mov eax, STREAM_SIZE
 
           call CreateObject
           test eax, eax
           jz .fail
           mov [str], eax
 
           mov [eax+STREAM.magic], 'WAVE'
           mov [eax+STREAM.destroy], DestroyBuffer.destroy
           mov [eax+STREAM.size], STREAM_SIZE
 
           pushf
           cli
           mov ebx, str.fd-FD_OFFSET
           mov edx, [ebx+STREAM.str_fd]
           mov [eax+STREAM.str_fd], edx
           mov [eax+STREAM.str_bk], ebx
           mov [ebx+STREAM.str_fd], eax
           mov [edx+STREAM.str_bk], eax
           popf
 
           stdcall KernelAlloc, dword 72*1024
 
           mov edi, [str]
           mov [edi+STREAM.base], eax
           add eax, 0x1000
           mov [edi+STREAM.seg_0], eax
           mov [edi+STREAM.curr_seg], eax
           mov [edi+STREAM.notify_off1], eax
           add eax, 0x8000
           mov [edi+STREAM.lim_0], eax
           add eax, 0x1000
           mov [edi+STREAM.seg_1], eax
           mov [edi+STREAM.notify_off2], eax
           add eax, 0x8000
           mov [edi+STREAM.limit], eax
           mov [edi+STREAM.lim_1], eax
 
; create ring buffer
 
           stdcall AllocKernelSpace, dword 128*1024
 
           mov edi, [str]
           mov [edi+STREAM.work_buff], eax
           mov [edi+STREAM.work_read], eax
           mov [edi+STREAM.work_write], eax
           mov [edi+STREAM.work_count], 0
           add eax, 64*1024
           mov [edi+STREAM.work_top], eax
 
           stdcall AllocPages, dword 64/4
           mov edi, [str]
           mov ebx, [edi+STREAM.work_buff]
           mov ecx, 16
           or eax, PG_SW
           push eax
           push ebx
           call CommitPages ;eax, ebx, ecx
           mov ecx, 16
           pop ebx
           pop eax
           add ebx, 64*1024
           call CommitPages    ;double mapped
 
           mov edi, [str]
           mov eax, [format]
           mov [edi+STREAM.format], eax
           mov [edi+STREAM.flags], SND_STOP
 
           xor ebx, ebx
           cmp eax, 19
           jb @f
           mov ebx, 0x80808080
@@:
           mov [edi+STREAM.r_silence], ebx
 
           shl eax, 4
           mov ebx, [resampler_params+eax]
           mov ecx, [resampler_params+eax+4]
           mov edx, [resampler_params+eax+8]
 
           mov [edi+STREAM.r_size],ebx
           mov [edi+STREAM.r_end], ecx
           mov [edi+STREAM.r_dt],  edx
 
           mov ebx, [resampler_params+eax+12]
           mov [edi+STREAM.resample], ebx
 
           mov edx, [edi+STREAM.base]
           lea eax, [edx+0x9000]
           call GetPgAddr  ;eax
           call FreePage   ;eax
 
           mov eax, edx
           lea ebx, [edx+0x9000]
           call GetPgAddr  ;eax
           stdcall MapPage, ebx, eax, dword 3
 
           mov edi, [edi+STREAM.base]
           mov ecx, (72*1024)/4
           xor eax, eax
           cld
           rep stosd
 
           mov edi, [str]
           mov edi, [edi+STREAM.work_buff]
           mov ecx, (64*1024)/4
           rep stosd
 
           mov eax, [str]
           ret
.fail:
           xor eax, eax
           ret
endp
 
if 0
align 4
pid_to_slot:
 
           push   ebx
           push   ecx
           mov    ebx,[TASK_COUNT]
           shl    ebx,5
           mov    ecx,2*32
.loop:
           cmp    byte [CURRENT_TASK+ecx+0xa],9
           jz     .endloop              ;skip empty slots
           cmp    [CURRENT_TASK+ecx+0x4],eax ;check PID
           jz     .pid_found
.endloop:
           add    ecx,32
           cmp    ecx,ebx
           jle    .loop
           pop    ecx
           pop    ebx
           xor    eax,eax
           ret
 
.pid_found:
           shr    ecx,5
           mov    eax,ecx
           pop    ecx
           pop    ebx
           ret
 
end if
 
;param
; eax= buffer handle
 
align 4
DestroyBuffer:
           .handle  equ esp       ;local
 
           cmp [eax+STREAM.magic], 'WAVE'
           jne .fail
 
           cmp [eax+STREAM.size], STREAM_SIZE
           jne .fail
.destroy:
           push eax
 
           pushf
           cli
           mov ebx, [eax+STREAM.str_fd]
           mov ecx, [eax+STREAM.str_bk]
           mov [ebx+STREAM.str_bk], ecx
           mov [ecx+STREAM.str_fd], ebx
           popf
 
           stdcall KernelFree, [eax+STREAM.base]
           mov eax, [.handle]
           stdcall KernelFree, [eax+STREAM.work_buff]
 
           pop eax               ;restore stack
           call DestroyObject    ;eax
.fail:
           ret
 
align 4
proc play_buffer stdcall, str:dword
 
           mov ebx, [str]
           cmp [ebx+STREAM.magic], 'WAVE'
           jne .fail
 
           cmp [ebx+STREAM.size], STREAM_SIZE
           jne .fail
 
           mov edi,[ebx+STREAM.work_buff]
           mov [ebx+STREAM.work_read], edi
           mov [ebx+STREAM.work_write], edi
           mov [ebx+STREAM.work_count], 0
 
           mov edx, [ebx+STREAM.base]
           add edx, 0x1000
           mov [ebx+STREAM.seg_0], edx
           mov [ebx+STREAM.curr_seg], edx
           add edx, 0x8000
           mov [ebx+STREAM.lim_0], edx
           add edx, 0x1000
           mov [ebx+STREAM.seg_1], edx
           add edx, 0x8000
           mov [ebx+STREAM.lim_1], edx
 
           mov edx, [ebx+STREAM.seg_0]
           mov ecx, -128
           mov eax, [ebx+STREAM.r_silence]
@@:
           mov [edx+ecx], eax
           add ecx, 4
           jnz @B
 
           stdcall [ebx+STREAM.resample], edi, edx,\
           [ebx+STREAM.r_dt],[ebx+STREAM.r_size],[ebx+STREAM.r_end]
 
           mov ebx, [str]
 
           add [ebx+STREAM.work_count], eax
           add [ebx+STREAM.work_write], eax
 
           mov edx, [ebx+STREAM.r_size]
           add [ebx+STREAM.curr_seg], edx
 
           mov [ebx+STREAM.flags], SND_PLAY
 
           mov eax, [ebx+STREAM.r_silence]
           mov edi, [ebx+STREAM.work_write]
           mov ecx, [ebx+STREAM.work_top]
           sub ecx, edi
           shr ecx, 2
           cld
           rep stosd
 
           stdcall  dev_play, [hSound]
           xor eax, eax
           inc eax
           ret
.fail:
           xor eax, eax
           ret
endp
 
align 4
proc stop_buffer stdcall, str:dword
 
           mov edi, [str]
 
           cmp [edi+STREAM.magic], 'WAVE'
           jne .fail
 
           cmp [edi+STREAM.size], STREAM_SIZE
           jne .fail
 
           mov [edi+STREAM.flags], SND_STOP
 
;           stdcall [ServiceHandler], [hSound], dword DEV_STOP, 0
 
           xor eax, eax
           inc eax
           ret
.fail:
           xor eax, eax
           ret
endp
 
align 4
proc set_buffer stdcall, str:dword,src:dword,offs:dword,size:dword
 
           mov edx, [str]
           test edx, edx
           jz .fail
 
           cmp [edx+STREAM.magic], 'WAVE'
           jne .fail
 
           cmp [edx+STREAM.size], STREAM_SIZE
           jne .fail
 
           mov esi,[src]
           test esi, esi
           jz .fail
 
           cmp esi, new_app_base
           jb .fail
 
           mov edi, [offs]
           mov ecx, 0x8000
 
           sub ecx, edi
           jbe .seg_1
 
           sub [size], ecx
           jb .fail
 
           add edi, [edx+STREAM.base]
           add edi, 0x1000
           shr ecx, 2
           cld
           rep movsd
           jmp @F
.seg_1:
           add edi, [edx+STREAM.base]
           add edi, 0x1000
@@:
           add edi, 0x1000
           mov ecx, [size]
           test ecx, ecx
           jz .done
           cmp ecx, 0x8000
           ja .fail
 
           shr ecx, 2
           rep movsd
.done:
           xor eax, eax
           inc eax
           ret
.fail:
           xor eax, eax
           ret
endp
 
align 4
prepare_playlist:
 
           xor edx, edx
           mov [play_count], edx
           mov esi, str.fd-FD_OFFSET
           mov edi, [esi+STREAM.str_fd]
@@:
           cmp edi, esi
           je .done
 
           cmp [edi+STREAM.magic], 'WAVE'
           jne .next
 
           cmp [edi+STREAM.size], STREAM_SIZE
           jne .next
 
           cmp [edi+STREAM.flags], SND_PLAY;
           jne .next
           cmp [edi+STREAM.work_count], 16384
           jb .next
 
           mov [play_list+edx], edi
           inc [play_count]
           add edx, 4
.next:
           mov edi, [edi+STREAM.str_fd]
           jmp @B
.done:
           ret
 
align 4
proc set_handler stdcall, hsrv:dword, handler_proc:dword
           locals
             handler    dd ?
             io_code    dd ?
             input      dd ?
             inp_size   dd ?
             output     dd ?
             out_size   dd ?
             val        dd ?
           endl
 
           mov eax, [hsrv]
           lea ecx, [handler_proc]
           xor ebx, ebx
 
           mov [handler], eax
           mov [io_code], DEV_CALLBACK
           mov [input], ecx
           mov [inp_size], 4
           mov [output], ebx
           mov [out_size], 0
 
           lea eax, [handler]
           stdcall ServiceHandler, eax
           ret
endp
 
align 4
proc dev_play stdcall, hsrv:dword
           locals
             handle     dd ?
             io_code    dd ?
             input      dd ?
             inp_size   dd ?
             output     dd ?
             out_size   dd ?
             val        dd ?
           endl
 
           mov eax, [hsrv]
           xor ebx, ebx
 
           mov [handle], eax
           mov [io_code], DEV_PLAY
           mov [input], ebx
           mov [inp_size], ebx
           mov [output], ebx
           mov [out_size], ebx
 
           lea eax, [handle]
           stdcall ServiceHandler, eax
           ret
endp
 
include 'mixer.asm'
include 'mix_mmx.inc'
include 'mix_sse2.inc'
 
;if USE_SSE
; include 'mix_sse.inc'
;end if
 
align 16
resampler_params:
     ;r_size    r_end   r_dt   resampler_func
     dd 0,0,0,0                                  ; 0  PCM_ALL
     dd 16384,          0,     0, copy_stream    ; 1  PCM_2_16_48
     dd 16384,          0,     0, m16_stereo     ; 2  PCM_1_16_48
 
     dd 16384, 0x08000000, 30109, resample_2     ; 3  PCM_2_16_44
     dd  8192, 0x08000000, 30109, resample_1     ; 4  PCM_1_16_44
 
     dd 16384, 0x08000000, 21846, resample_2     ; 5  PCM_2_16_32
     dd  8192, 0x08000000, 21846, resample_1     ; 6  PCM_1_16_32
 
     dd 16384, 0x08000000, 16384, resample_2     ; 7  PCM_2_16_24
     dd  8192, 0x08000000, 16384, resample_1     ; 8  PCM_1_16_24
 
     dd  8192, 0x04000000, 15052, resample_2     ; 9  PCM_2_16_22
     dd  4096, 0x04000000, 15052, resample_1     ;10  PCM_1_16_22
 
     dd  8192, 0x04000000, 10923, resample_2     ;11  PCM_2_16_16
     dd  4096, 0x04000000, 10923, resample_1     ;12  PCM_1_16_16
 
     dd  8192, 0x04000000,  8192, resample_2     ;13  PCM_2_16_12
     dd  4096, 0x04000000,  8192, resample_1     ;14  PCM_1_16_12
 
     dd  4096, 0x02000000,  7527, resample_2     ;15  PCM_2_16_11
     dd  2048, 0x02000000,  7527, resample_1     ;16  PCM_1_16_11
 
     dd  4096, 0x02000000,  5462, resample_2     ;17  PCM_2_16_8
     dd  2048, 0x02000000,  5462, resample_1     ;18  PCM_1_16_8
 
     dd 16384,          0,     0, s8_stereo      ;19  PCM_2_8_48
     dd  8192,          0,     0, m8_stereo      ;20  PCM_1_8_48
 
     dd  8192, 0x08000000, 30109, resample_28    ;21  PCM_2_8_44
     dd  4096, 0x08000000, 30109, resample_18    ;22  PCM_1_8_44
 
     dd  8192, 0x08000000, 21846, resample_28    ;23  PCM_2_8_32
     dd  4096, 0x08000000, 21846, resample_18    ;24  PCM_1_8_32
 
     dd  8192, 0x08000000, 16384, resample_28    ;25  PCM_2_8_24
     dd  4096, 0x08000000, 16384, resample_18    ;26  PCM_1_8_24
 
     dd  4096, 0x04000000, 15052, resample_28    ;27  PCM_2_8_22
     dd  2048, 0x04000000, 15052, resample_18    ;28  PCM_1_8_22
 
     dd  4096, 0x04000000, 10923, resample_28    ;29  PCM_2_8_16
     dd  2048, 0x04000000, 10923, resample_18    ;30  PCM_1_8_16
 
     dd  4096, 0x04000000,  8192, resample_28    ;31  PCM_2_8_12
     dd  2048, 0x04000000,  8192, resample_18    ;32  PCM_1_8_12
 
     dd  2048, 0x02000000,  7527, resample_28    ;33  PCM_2_8_11
     dd  1024, 0x02000000,  7527, resample_18    ;34  PCM_1_8_11
 
     dd  2048, 0x02000000,  5462, resample_28    ;35  PCM_2_8_8
     dd  1024, 0x02000000,  5462, resample_18    ;36  PCM_1_8_8
 
m7            dw 0x8000,0x8000,0x8000,0x8000
mm80          dq 0x8080808080808080
mm_mask       dq 0xFF00FF00FF00FF00
 
;stream_map    dd 0xFFFF       ; 16
version       dd 0x00030003
 
szInfinity    db 'INFINITY',0
szSound       db 'SOUND',0
 
if DEBUG
msgFail       db 'Sound service not loaded',13,10,0
msgPlay       db 'Play buffer',13,10,0
msgStop       db 'Stop',13,10,0
msgUser       db 'User callback',13,10,0
msgMem        db 'Not enough memory',13,10,0
msgDestroy    db 'Destroy sound buffer', 13,10,0
end if
 
section '.data' data readable writable align 16
 
play_list     rd 16
mix_input     rd 16
play_count    rd 1
hSound        rd 1
mix_buff      rd 1
mix_buff_map  rd 1
str.fd        rd 1
str.bk        rd 1
 
mix_2_core    rd 1
mix_3_core    rd 1
mix_4_core    rd 1

Rev 328	Rev 346
1	;	1	;
2	; This file is part of the Infinity sound library.	2	; This file is part of the Infinity sound library.
3	; (C) copyright Serge 2006	3	; (C) copyright Serge 2006
4	; email: infinity_sound@mail.ru	4	; email: infinity_sound@mail.ru
5	;	5	;
6	; This program is free software; you can redistribute it and/or modify	6	; This program is free software; you can redistribute it and/or modify
7	; it under the terms of the GNU General Public License as published by	7	; it under the terms of the GNU General Public License as published by
8	; the Free Software Foundation; either version 2 of the License, or	8	; the Free Software Foundation; either version 2 of the License, or
9	; (at your option) any later version.	9	; (at your option) any later version.
10	;	10	;
11	; This program is distributed in the hope that it will be useful,	11	; This program is distributed in the hope that it will be useful,
12	; but WITHOUT ANY WARRANTY; without even the implied warranty of	12	; but WITHOUT ANY WARRANTY; without even the implied warranty of
13	; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	; GNU General Public License for more details.	14	; GNU General Public License for more details.
15		15
16	format MS COFF	16	format MS COFF
17		17
18	include 'proc32.inc'	18	include 'proc32.inc'
19	include 'main.inc'	19	include 'main.inc'
20	include 'imports.inc'	20	include 'imports.inc'
21		21
22	FORCE_MMX equ 0 ;set to 1 to force use mmx or	22	FORCE_MMX equ 0 ;set to 1 to force use mmx or
23	FORCE_MMX_128 equ 0 ;integer sse2 extensions	23	FORCE_MMX_128 equ 0 ;integer sse2 extensions
24	;and reduce driver size	24	;and reduce driver size
25	;USE_SSE equ 0	25	;USE_SSE equ 0
26		26
27	DEBUG equ 1	27	DEBUG equ 1
28		28
29	EVENT_NOTIFY equ 0x00000200	29	EVENT_NOTIFY equ 0x00000200
30		30
31	OS_BASE equ 0	31	OS_BASE equ 0
32	new_app_base equ 0x60400000	32	new_app_base equ 0x60400000
33	PROC_BASE equ OS_BASE+0x0080000	33	PROC_BASE equ OS_BASE+0x0080000
34		34
35	CAPS_SSE2 equ 26	35	CAPS_SSE2 equ 26
36	PG_SW equ 0x003	36	PG_SW equ 0x003
37		37
38		38
39	public START	39	public START
40	public service_proc	40	public service_proc
41	public version	41	public version
42		42
43	SND_CREATE_BUFF equ 2	43	SND_CREATE_BUFF equ 2
44	SND_PLAY equ 3	44	SND_PLAY equ 3
45	SND_STOP equ 4	45	SND_STOP equ 4
46	SND_SETBUFF equ 5	46	SND_SETBUFF equ 5
47	SND_DESTROY_BUFF equ 6	47	SND_DESTROY_BUFF equ 6
48		48
49	DEV_PLAY equ 1	49	DEV_PLAY equ 1
50	DEV_STOP equ 2	50	DEV_STOP equ 2
51	DEV_CALLBACK equ 3	51	DEV_CALLBACK equ 3
52		52
53	struc IOCTL	53	struc IOCTL
54	{ .handle dd ?	54	{ .handle dd ?
55	.io_code dd ?	55	.io_code dd ?
56	.input dd ?	56	.input dd ?
57	.inp_size dd ?	57	.inp_size dd ?
58	.output dd ?	58	.output dd ?
59	.out_size dd ?	59	.out_size dd ?
60	}	60	}
61		61
62	virtual at 0	62	virtual at 0
63	IOCTL IOCTL	63	IOCTL IOCTL
64	end virtual	64	end virtual
65		65
66	section '.flat' code readable align 16	66	section '.flat' code readable align 16
67		67
68	proc START stdcall, state:dword	68	proc START stdcall, state:dword
69		69
70	cmp [state], 1	70	cmp [state], 1
71	jne .exit	71	jne .exit
72		72
73	stdcall GetService, szSound	73	stdcall GetService, szSound
74	test eax, eax	74	test eax, eax
75	jz .fail	75	jz .fail
76	mov [hSound], eax	76	mov [hSound], eax
77		77
78	stdcall KernelAlloc, 16*512	78	stdcall KernelAlloc, 16*512
79	test eax, eax	79	test eax, eax
80	jz .out_of_mem	80	jz .out_of_mem
81	mov [mix_buff], eax	81	mov [mix_buff], eax
82		82
83	mov eax, str.fd-FD_OFFSET	83	mov eax, str.fd-FD_OFFSET
84	mov [str.fd], eax	84	mov [str.fd], eax
85	mov [str.bk], eax	85	mov [str.bk], eax
86		86
87	if FORCE_MMX	87	if FORCE_MMX
88	if FORCE_MMX_128	88	if FORCE_MMX_128
89	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10	89	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
90	stop	90	stop
91	end if	91	end if
92	mov [mix_2_core], mmx_mix_2	92	mov [mix_2_core], mmx_mix_2
93	mov [mix_3_core], mmx_mix_3	93	mov [mix_3_core], mmx_mix_3
94	mov [mix_4_core], mmx_mix_4	94	mov [mix_4_core], mmx_mix_4
95	end if	95	end if
96		96
97	if FORCE_MMX_128	97	if FORCE_MMX_128
98	if FORCE_MMX	98	if FORCE_MMX
99	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10	99	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
100	stop	100	stop
101	end if	101	end if
102	mov [mix_2_core], mmx128_mix_2	102	mov [mix_2_core], mmx128_mix_2
103	mov [mix_3_core], mmx128_mix_3	103	mov [mix_3_core], mmx128_mix_3
104	mov [mix_4_core], mmx128_mix_4	104	mov [mix_4_core], mmx128_mix_4
105	end if	105	end if
106		106
107	if ~(FORCE_MMX or FORCE_MMX_128) ;autodetect	107	if ~(FORCE_MMX or FORCE_MMX_128) ;autodetect
108	mov eax, 1	108	mov eax, 1
109	cpuid	109	cpuid
110	bt edx, CAPS_SSE2	110	bt edx, CAPS_SSE2
111	jc .mmx128	111	jc .mmx128
112	;old 64-bit mmx	112	;old 64-bit mmx
113	mov [mix_2_core], mmx_mix_2	113	mov [mix_2_core], mmx_mix_2
114	mov [mix_3_core], mmx_mix_3	114	mov [mix_3_core], mmx_mix_3
115	mov [mix_4_core], mmx_mix_4	115	mov [mix_4_core], mmx_mix_4
116	jmp @F	116	jmp @F
117	.mmx128: ;128-bit integer sse2 extensions	117	.mmx128: ;128-bit integer sse2 extensions
118	mov [mix_2_core], mmx128_mix_2	118	mov [mix_2_core], mmx128_mix_2
119	mov [mix_3_core], mmx128_mix_3	119	mov [mix_3_core], mmx128_mix_3
120	mov [mix_4_core], mmx128_mix_4	120	mov [mix_4_core], mmx128_mix_4
121	@@:	121	@@:
122	end if	122	end if
123	stdcall set_handler, [hSound], new_mix	123	stdcall set_handler, [hSound], new_mix
124	stdcall RegService, szInfinity, service_proc	124	stdcall RegService, szInfinity, service_proc
125	ret	125	ret
126	.fail:	126	.fail:
127	if DEBUG	127	if DEBUG
128	mov esi, msgFail	128	mov esi, msgFail
129	call SysMsgBoardStr	129	call SysMsgBoardStr
130	end if	130	end if
131	.exit:	131	.exit:
132	xor eax, eax	132	xor eax, eax
133	ret	133	ret
134		134
135	.out_of_mem:	135	.out_of_mem:
136	if DEBUG	136	if DEBUG
137	mov esi, msgMem	137	mov esi, msgMem
138	call SysMsgBoardStr	138	call SysMsgBoardStr
139	end if	139	end if
140	xor eax, eax	140	xor eax, eax
141	ret	141	ret
142	endp	142	endp
143		143
144	handle equ IOCTL.handle	144	handle equ IOCTL.handle
145	io_code equ IOCTL.io_code	145	io_code equ IOCTL.io_code
146	input equ IOCTL.input	146	input equ IOCTL.input
147	inp_size equ IOCTL.inp_size	147	inp_size equ IOCTL.inp_size
148	output equ IOCTL.output	148	output equ IOCTL.output
149	out_size equ IOCTL.out_size	149	out_size equ IOCTL.out_size
150		150
151	align 4	151	align 4
152	proc service_proc stdcall, ioctl:dword	152	proc service_proc stdcall, ioctl:dword
153		153
154	mov edi, [ioctl]	154	mov edi, [ioctl]
155	mov eax, [edi+io_code]	155	mov eax, [edi+io_code]
156		156
157	cmp eax, SND_CREATE_BUFF	157	cmp eax, SND_CREATE_BUFF
158	jne @F	158	jne @F
159	mov ebx, [edi+input]	159	mov ebx, [edi+input]
160	stdcall CreateBuffer,[ebx]	160	stdcall CreateBuffer,[ebx]
161	ret	161	ret
162	@@:	162	@@:
163	cmp eax, SND_PLAY	163	cmp eax, SND_PLAY
164	jne @F	164	jne @F
165		165
166	mov ebx, [edi+input]	166	mov ebx, [edi+input]
167	stdcall play_buffer, [ebx]	167	stdcall play_buffer, [ebx]
168	ret	168	ret
169	@@:	169	@@:
170	cmp eax, SND_STOP	170	cmp eax, SND_STOP
171	jne @F	171	jne @F
172		172
173	; if DEBUG	173	; if DEBUG
174	; mov esi, msgStop	174	; mov esi, msgStop
175	; call [SysMsgBoardStr]	175	; call [SysMsgBoardStr]
176	; end if	176	; end if
177		177
178	mov ebx, [edi+input]	178	mov ebx, [edi+input]
179	stdcall stop_buffer, [ebx]	179	stdcall stop_buffer, [ebx]
180	ret	180	ret
181	@@:	181	@@:
182	cmp eax, SND_SETBUFF	182	cmp eax, SND_SETBUFF
183	jne @F	183	jne @F
184		184
185	mov ebx, [edi+input]	185	mov ebx, [edi+input]
186	mov eax, [ebx+4]	186	mov eax, [ebx+4]
187	add eax, new_app_base	187	add eax, new_app_base
188	stdcall set_buffer, [ebx],eax,[ebx+8],[ebx+12]	188	stdcall set_buffer, [ebx],eax,[ebx+8],[ebx+12]
189	ret	189	ret
190	@@:	190	@@:
191	cmp eax, SND_DESTROY_BUFF	191	cmp eax, SND_DESTROY_BUFF
192	jne @F	192	jne @F
193		193
194	mov eax, [edi+input]	194	mov eax, [edi+input]
195	mov eax, [eax]	195	mov eax, [eax]
196	call DestroyBuffer ;eax	196	call DestroyBuffer ;eax
197	ret	197	ret
198	@@:	198	@@:
199	xor eax, eax	199	xor eax, eax
200	ret	200	ret
201	endp	201	endp
202		202
203	restore handle	203	restore handle
204	restore io_code	204	restore io_code
205	restore input	205	restore input
206	restore inp_size	206	restore inp_size
207	restore output	207	restore output
208	restore out_size	208	restore out_size
209		209
210	TASK_COUNT equ 0x0003004	210	TASK_COUNT equ 0x0003004
211	CURRENT_TASK equ 0x0003000	211	CURRENT_TASK equ 0x0003000
212		212
213	align 4	213	align 4
214	proc CreateBuffer stdcall, format:dword	214	proc CreateBuffer stdcall, format:dword
215	locals	215	locals
216	str dd ?	216	str dd ?
217	endl	217	endl
218		218
219	mov ebx, [CURRENT_TASK] ;hack: direct accsess	219	mov ebx, [CURRENT_TASK] ;hack: direct accsess
220	shl ebx, 5 ;to kernel data	220	shl ebx, 5 ;to kernel data
221	mov ebx, [0x3000+ebx+4]	221	mov ebx, [0x3000+ebx+4]
222	mov eax, STREAM_SIZE	222	mov eax, STREAM_SIZE
223		223
224	call CreateObject	224	call CreateObject
225	test eax, eax	225	test eax, eax
226	jz .fail	226	jz .fail
227	mov [str], eax	227	mov [str], eax
228		228
229	mov [eax+STREAM.magic], 'WAVE'	229	mov [eax+STREAM.magic], 'WAVE'
230	mov [eax+STREAM.destroy], DestroyBuffer.destroy	230	mov [eax+STREAM.destroy], DestroyBuffer.destroy
231	mov [eax+STREAM.size], STREAM_SIZE	231	mov [eax+STREAM.size], STREAM_SIZE
232		232
233	pushf	233	pushf
234	cli	234	cli
235	mov ebx, str.fd-FD_OFFSET	235	mov ebx, str.fd-FD_OFFSET
236	mov edx, [ebx+STREAM.str_fd]	236	mov edx, [ebx+STREAM.str_fd]
237	mov [eax+STREAM.str_fd], edx	237	mov [eax+STREAM.str_fd], edx
238	mov [eax+STREAM.str_bk], ebx	238	mov [eax+STREAM.str_bk], ebx
239	mov [ebx+STREAM.str_fd], eax	239	mov [ebx+STREAM.str_fd], eax
240	mov [edx+STREAM.str_bk], eax	240	mov [edx+STREAM.str_bk], eax
241	popf	241	popf
242		242
243	stdcall KernelAlloc, dword 72*1024	243	stdcall KernelAlloc, dword 72*1024
244		244
245	mov edi, [str]	245	mov edi, [str]
246	mov [edi+STREAM.base], eax	246	mov [edi+STREAM.base], eax
247	add eax, 0x1000	247	add eax, 0x1000
248	mov [edi+STREAM.seg_0], eax	248	mov [edi+STREAM.seg_0], eax
249	mov [edi+STREAM.curr_seg], eax	249	mov [edi+STREAM.curr_seg], eax
250	mov [edi+STREAM.notify_off1], eax	250	mov [edi+STREAM.notify_off1], eax
251	add eax, 0x8000	251	add eax, 0x8000
252	mov [edi+STREAM.lim_0], eax	252	mov [edi+STREAM.lim_0], eax
253	add eax, 0x1000	253	add eax, 0x1000
254	mov [edi+STREAM.seg_1], eax	254	mov [edi+STREAM.seg_1], eax
255	mov [edi+STREAM.notify_off2], eax	255	mov [edi+STREAM.notify_off2], eax
256	add eax, 0x8000	256	add eax, 0x8000
257	mov [edi+STREAM.limit], eax	257	mov [edi+STREAM.limit], eax
258	mov [edi+STREAM.lim_1], eax	258	mov [edi+STREAM.lim_1], eax
259		259
260	; create ring buffer	260	; create ring buffer
261		261
262	stdcall AllocKernelSpace, dword 128*1024	262	stdcall AllocKernelSpace, dword 128*1024
263		263
264	mov edi, [str]	264	mov edi, [str]
265	mov [edi+STREAM.work_buff], eax	265	mov [edi+STREAM.work_buff], eax
266	mov [edi+STREAM.work_read], eax	266	mov [edi+STREAM.work_read], eax
267	mov [edi+STREAM.work_write], eax	267	mov [edi+STREAM.work_write], eax
268	mov [edi+STREAM.work_count], 0	268	mov [edi+STREAM.work_count], 0
269	add eax, 64*1024	269	add eax, 64*1024
270	mov [edi+STREAM.work_top], eax	270	mov [edi+STREAM.work_top], eax
271		271
272	stdcall AllocPages, dword 64/4	272	stdcall AllocPages, dword 64/4
273	mov edi, [str]	273	mov edi, [str]
274	mov ebx, [edi+STREAM.work_buff]	274	mov ebx, [edi+STREAM.work_buff]
275	mov ecx, 16	275	mov ecx, 16
276	or eax, PG_SW	276	or eax, PG_SW
277	push eax	277	push eax
278	push ebx	278	push ebx
279	call CommitPages ;eax, ebx, ecx	279	call CommitPages ;eax, ebx, ecx
280	mov ecx, 16	280	mov ecx, 16
281	pop ebx	281	pop ebx
282	pop eax	282	pop eax
283	add ebx, 64*1024	283	add ebx, 64*1024
284	call CommitPages ;double mapped	284	call CommitPages ;double mapped
285		285
286	mov edi, [str]	286	mov edi, [str]
287	mov eax, [format]	287	mov eax, [format]
288	mov [edi+STREAM.format], eax	288	mov [edi+STREAM.format], eax
289	mov [edi+STREAM.flags], SND_STOP	289	mov [edi+STREAM.flags], SND_STOP
290		290
291	xor ebx, ebx	291	xor ebx, ebx
292	cmp eax, 19	292	cmp eax, 19
293	jb @f	293	jb @f
294	mov ebx, 0x80808080	294	mov ebx, 0x80808080
295	@@:	295	@@:
296	mov [edi+STREAM.r_silence], ebx	296	mov [edi+STREAM.r_silence], ebx
297		297
298	shl eax, 4	298	shl eax, 4
299	mov ebx, [resampler_params+eax]	299	mov ebx, [resampler_params+eax]
300	mov ecx, [resampler_params+eax+4]	300	mov ecx, [resampler_params+eax+4]
301	mov edx, [resampler_params+eax+8]	301	mov edx, [resampler_params+eax+8]
302		302
303	mov [edi+STREAM.r_size],ebx	303	mov [edi+STREAM.r_size],ebx
304	mov [edi+STREAM.r_end], ecx	304	mov [edi+STREAM.r_end], ecx
305	mov [edi+STREAM.r_dt], edx	305	mov [edi+STREAM.r_dt], edx
306		306
307	mov ebx, [resampler_params+eax+12]	307	mov ebx, [resampler_params+eax+12]
308	mov [edi+STREAM.resample], ebx	308	mov [edi+STREAM.resample], ebx
309		309
310	mov edx, [edi+STREAM.base]	310	mov edx, [edi+STREAM.base]
311	lea eax, [edx+0x9000]	311	lea eax, [edx+0x9000]
312	call GetPgAddr ;eax	312	call GetPgAddr ;eax
313	call FreePage ;eax	313	call FreePage ;eax
314		314
315	mov eax, edx	315	mov eax, edx
316	lea ebx, [edx+0x9000]	316	lea ebx, [edx+0x9000]
317	call GetPgAddr ;eax	317	call GetPgAddr ;eax
318	stdcall MapPage, ebx, eax, dword 3	318	stdcall MapPage, ebx, eax, dword 3
319		319
320	mov edi, [edi+STREAM.base]	320	mov edi, [edi+STREAM.base]
321	mov ecx, (72*1024)/4	321	mov ecx, (72*1024)/4
322	xor eax, eax	322	xor eax, eax
323	cld	323	cld
324	rep stosd	324	rep stosd
325		325
326	mov edi, [str]	326	mov edi, [str]
327	mov edi, [edi+STREAM.work_buff]	327	mov edi, [edi+STREAM.work_buff]
328	mov ecx, (64*1024)/4	328	mov ecx, (64*1024)/4
329	rep stosd	329	rep stosd
330		330
331	mov eax, [str]	331	mov eax, [str]
332	ret	332	ret
333	.fail:	333	.fail:
334	xor eax, eax	334	xor eax, eax
335	ret	335	ret
336	endp	336	endp
337		337
338	if 0	338	if 0
339	align 4	339	align 4
340	pid_to_slot:	340	pid_to_slot:
341		341
342	push ebx	342	push ebx
343	push ecx	343	push ecx
344	mov ebx,[TASK_COUNT]	344	mov ebx,[TASK_COUNT]
345	shl ebx,5	345	shl ebx,5
346	mov ecx,2*32	346	mov ecx,2*32
347	.loop:	347	.loop:
348	cmp byte [CURRENT_TASK+ecx+0xa],9	348	cmp byte [CURRENT_TASK+ecx+0xa],9
349	jz .endloop ;skip empty slots	349	jz .endloop ;skip empty slots
350	cmp [CURRENT_TASK+ecx+0x4],eax ;check PID	350	cmp [CURRENT_TASK+ecx+0x4],eax ;check PID
351	jz .pid_found	351	jz .pid_found
352	.endloop:	352	.endloop:
353	add ecx,32	353	add ecx,32
354	cmp ecx,ebx	354	cmp ecx,ebx
355	jle .loop	355	jle .loop
356	pop ecx	356	pop ecx
357	pop ebx	357	pop ebx
358	xor eax,eax	358	xor eax,eax
359	ret	359	ret
360		360
361	.pid_found:	361	.pid_found:
362	shr ecx,5	362	shr ecx,5
363	mov eax,ecx	363	mov eax,ecx
364	pop ecx	364	pop ecx
365	pop ebx	365	pop ebx
366	ret	366	ret
367		367
368	end if	368	end if
369		369
370	;param	370	;param
371	; eax= buffer handle	371	; eax= buffer handle
372		372
373	align 4	373	align 4
374	DestroyBuffer:	374	DestroyBuffer:
375	.handle equ esp ;local	375	.handle equ esp ;local
376		376
377	cmp [eax+STREAM.magic], 'WAVE'	377	cmp [eax+STREAM.magic], 'WAVE'
378	jne .fail	378	jne .fail
379		379
380	cmp [eax+STREAM.size], STREAM_SIZE	380	cmp [eax+STREAM.size], STREAM_SIZE
381	jne .fail	381	jne .fail
382	.destroy:	382	.destroy:
383	push eax	383	push eax
384		384
385	pushf	385	pushf
386	cli	386	cli
387	mov ebx, [eax+STREAM.str_fd]	387	mov ebx, [eax+STREAM.str_fd]
388	mov ecx, [eax+STREAM.str_bk]	388	mov ecx, [eax+STREAM.str_bk]
389	mov [ebx+STREAM.str_bk], ecx	389	mov [ebx+STREAM.str_bk], ecx
390	mov [ecx+STREAM.str_fd], ebx	390	mov [ecx+STREAM.str_fd], ebx
391	popf	391	popf
392		392
393	stdcall KernelFree, [eax+STREAM.base]	393	stdcall KernelFree, [eax+STREAM.base]
394	mov eax, [.handle]	394	mov eax, [.handle]
395	stdcall KernelFree, [eax+STREAM.work_buff]	395	stdcall KernelFree, [eax+STREAM.work_buff]
396		396
397	pop eax ;restore stack	397	pop eax ;restore stack
398	call DestroyObject ;eax	398	call DestroyObject ;eax
399	.fail:	399	.fail:
400	ret	400	ret
401		401
402	align 4	402	align 4
403	proc play_buffer stdcall, str:dword	403	proc play_buffer stdcall, str:dword
404		404
405	mov ebx, [str]	405	mov ebx, [str]
406	cmp [ebx+STREAM.magic], 'WAVE'	406	cmp [ebx+STREAM.magic], 'WAVE'
407	jne .fail	407	jne .fail
408		408
409	cmp [ebx+STREAM.size], STREAM_SIZE	409	cmp [ebx+STREAM.size], STREAM_SIZE
410	jne .fail	410	jne .fail
411		411
412	mov edi,[ebx+STREAM.work_buff]	412	mov edi,[ebx+STREAM.work_buff]
413	mov [ebx+STREAM.work_read], edi	413	mov [ebx+STREAM.work_read], edi
414	mov [ebx+STREAM.work_write], edi	414	mov [ebx+STREAM.work_write], edi
415	mov [ebx+STREAM.work_count], 0	415	mov [ebx+STREAM.work_count], 0
416		416
417	mov edx, [ebx+STREAM.base]	417	mov edx, [ebx+STREAM.base]
418	add edx, 0x1000	418	add edx, 0x1000
419	mov [ebx+STREAM.seg_0], edx	419	mov [ebx+STREAM.seg_0], edx
420	mov [ebx+STREAM.curr_seg], edx	420	mov [ebx+STREAM.curr_seg], edx
421	add edx, 0x8000	421	add edx, 0x8000
422	mov [ebx+STREAM.lim_0], edx	422	mov [ebx+STREAM.lim_0], edx
423	add edx, 0x1000	423	add edx, 0x1000
424	mov [ebx+STREAM.seg_1], edx	424	mov [ebx+STREAM.seg_1], edx
425	add edx, 0x8000	425	add edx, 0x8000
426	mov [ebx+STREAM.lim_1], edx	426	mov [ebx+STREAM.lim_1], edx
427		427
428	mov edx, [ebx+STREAM.seg_0]	428	mov edx, [ebx+STREAM.seg_0]
429	mov ecx, -128	429	mov ecx, -128
430	mov eax, [ebx+STREAM.r_silence]	430	mov eax, [ebx+STREAM.r_silence]
431	@@:	431	@@:
432	mov [edx+ecx], eax	432	mov [edx+ecx], eax
433	add ecx, 4	433	add ecx, 4
434	jnz @B	434	jnz @B
435		435
436	stdcall [ebx+STREAM.resample], edi, edx,\	436	stdcall [ebx+STREAM.resample], edi, edx,\
437	[ebx+STREAM.r_dt],[ebx+STREAM.r_size],[ebx+STREAM.r_end]	437	[ebx+STREAM.r_dt],[ebx+STREAM.r_size],[ebx+STREAM.r_end]
438		438
439	mov ebx, [str]	439	mov ebx, [str]
440		440
441	add [ebx+STREAM.work_count], eax	441	add [ebx+STREAM.work_count], eax
442	add [ebx+STREAM.work_write], eax	442	add [ebx+STREAM.work_write], eax
443		443
444	mov edx, [ebx+STREAM.r_size]	444	mov edx, [ebx+STREAM.r_size]
445	add [ebx+STREAM.curr_seg], edx	445	add [ebx+STREAM.curr_seg], edx
446		446
447	mov [ebx+STREAM.flags], SND_PLAY	447	mov [ebx+STREAM.flags], SND_PLAY
448		448
449	mov eax, [ebx+STREAM.r_silence]	449	mov eax, [ebx+STREAM.r_silence]
450	mov edi, [ebx+STREAM.work_write]	450	mov edi, [ebx+STREAM.work_write]
451	mov ecx, [ebx+STREAM.work_top]	451	mov ecx, [ebx+STREAM.work_top]
452	sub ecx, edi	452	sub ecx, edi
453	shr ecx, 2	453	shr ecx, 2
454	cld	454	cld
455	rep stosd	455	rep stosd
456		456
457	stdcall dev_play, [hSound]	457	stdcall dev_play, [hSound]
458	xor eax, eax	458	xor eax, eax
459	inc eax	459	inc eax
460	ret	460	ret
461	.fail:	461	.fail:
462	xor eax, eax	462	xor eax, eax
463	ret	463	ret
464	endp	464	endp
465		465
466	align 4	466	align 4
467	proc stop_buffer stdcall, str:dword	467	proc stop_buffer stdcall, str:dword
468		468
469	mov edi, [str]	469	mov edi, [str]
470		470
471	cmp [edi+STREAM.magic], 'WAVE'	471	cmp [edi+STREAM.magic], 'WAVE'
472	jne .fail	472	jne .fail
473		473
474	cmp [edi+STREAM.size], STREAM_SIZE	474	cmp [edi+STREAM.size], STREAM_SIZE
475	jne .fail	475	jne .fail
476		476
477	mov [edi+STREAM.flags], SND_STOP	477	mov [edi+STREAM.flags], SND_STOP
478		478
479	; stdcall [ServiceHandler], [hSound], dword DEV_STOP, 0	479	; stdcall [ServiceHandler], [hSound], dword DEV_STOP, 0
480		480
481	xor eax, eax	481	xor eax, eax
482	inc eax	482	inc eax
483	ret	483	ret
484	.fail:	484	.fail:
485	xor eax, eax	485	xor eax, eax
486	ret	486	ret
487	endp	487	endp
488		488
489	align 4	489	align 4
490	proc set_buffer stdcall, str:dword,src:dword,offs:dword,size:dword	490	proc set_buffer stdcall, str:dword,src:dword,offs:dword,size:dword
491		491
492	mov edx, [str]	492	mov edx, [str]
493	test edx, edx	493	test edx, edx
494	jz .fail	494	jz .fail
495		495
496	cmp [edx+STREAM.magic], 'WAVE'	496	cmp [edx+STREAM.magic], 'WAVE'
497	jne .fail	497	jne .fail
498		498
499	cmp [edx+STREAM.size], STREAM_SIZE	499	cmp [edx+STREAM.size], STREAM_SIZE
500	jne .fail	500	jne .fail

Subversion Repositories Kolibri OS

(root)/kernel/trunk/drivers/infinity.asm – Rev 328 → 346