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

Rev	Author	Line No.	Line
431	serge	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		2	;; ;;
694	serge	3	;; Copyright (C) KolibriOS team 2006-2008. All rights reserved. ;;
431	serge	4	;; Distributed under terms of the GNU General Public License ;;
		5	;; ;;
		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		7
694	serge	8	; Serge 2006-2008
		9	; email: infinity_sound@mail.ru
168	serge	10
		11	format MS COFF
		12
1916	Asper	13	DEBUG equ 1
465	serge	14
802	serge	15
		16	include 'proc32.inc'
		17	include 'main.inc'
		18	include 'imports.inc'
		19
		20
1916	Asper	21	CURRENT_API equ 0x0101 ;1.01
		22	COMPATIBLE_API equ 0x0100 ;1.00
465	serge	23
1916	Asper	24	API_VERSION equ (COMPATIBLE_API shl 16) or CURRENT_API
		25	SOUND_VERSION equ CURRENT_API
574	serge	26
		27
1916	Asper	28	FORCE_MMX equ 0 ;set to 1 to force use mmx or
		29	FORCE_MMX_128 equ 0 ;integer sse2 extensions
		30	;and reduce driver size
694	serge	31
378	serge	32	;USE_SSE equ 0
168	serge	33
1916	Asper	34	USE_SSE2_MIXER equ 0 ;floating point mixer. Disabled by default
694	serge	35
1916	Asper	36	OS_BASE equ 0x80000000
168	serge	37
1916	Asper	38	CAPS_SSE2 equ 26
		39	PG_SW equ 0x003
293	serge	40
188	serge	41	public START
168	serge	42	public service_proc
227	serge	43	public version
168	serge	44
1916	Asper	45	RT_INP_EMPTY equ 0xFF000001
		46	RT_OUT_EMPTY equ 0xFF000002
		47	RT_INP_FULL equ 0xFF000003
		48	RT_OUT_FULL equ 0xFF000004
168	serge	49
1916	Asper	50	EVENT_WATCHED equ 0x10000000
		51	EVENT_SIGNALED equ 0x20000000
		52	MANUAL_RESET equ 0x40000000
		53	MANUAL_DESTROY equ 0x80000000
168	serge	54
1916	Asper	55	DEV_PLAY equ 1
		56	DEV_STOP equ 2
		57	DEV_CALLBACK equ 3
		58	DEV_GET_POS equ 9
378	serge	59
168	serge	60	struc IOCTL
1916	Asper	61	{ .handle dd ?
		62	.io_code dd ?
		63	.input dd ?
		64	.inp_size dd ?
		65	.output dd ?
		66	.out_size dd ?
168	serge	67	}
		68
		69	virtual at 0
		70	IOCTL IOCTL
		71	end virtual
		72
188	serge	73	section '.flat' code readable align 16
168	serge	74
214	serge	75	proc START stdcall, state:dword
		76
1916	Asper	77	cmp [state], 1
		78	jne .exit
227	serge	79
1916	Asper	80	stdcall GetService, szSound
		81	test eax, eax
		82	jz .fail
		83	mov [hSound], eax
168	serge	84
1916	Asper	85	stdcall KernelAlloc, 16*512
		86	test eax, eax
		87	jz .out_of_mem
		88	mov [mix_buff], eax
168	serge	89
1916	Asper	90	mov eax, str.fd-FD_OFFSET
		91	mov [str.fd], eax
		92	mov [str.bk], eax
168	serge	93
293	serge	94	if FORCE_MMX
		95	if FORCE_MMX_128
		96	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
		97	stop
		98	end if
1916	Asper	99	mov [mix_2_core], mmx_mix_2
		100	mov [mix_3_core], mmx_mix_3
		101	mov [mix_4_core], mmx_mix_4
293	serge	102	end if
		103
		104	if FORCE_MMX_128
		105	if FORCE_MMX
		106	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
		107	stop
		108	end if
1916	Asper	109	mov [mix_2_core], mmx128_mix_2
		110	mov [mix_3_core], mmx128_mix_3
		111	mov [mix_4_core], mmx128_mix_4
293	serge	112	end if
		113
378	serge	114	if 0
		115
293	serge	116	if ~(FORCE_MMX or FORCE_MMX_128) ;autodetect
1916	Asper	117	mov eax, 1
		118	cpuid
		119	bt edx, CAPS_SSE2
		120	jc .mmx128
		121	;old 64-bit mmx
		122	mov [mix_2_core], mmx_mix_2
		123	mov [mix_3_core], mmx_mix_3
		124	mov [mix_4_core], mmx_mix_4
		125	jmp @F
		126	.mmx128: ;128-bit integer sse2 extensions
		127	mov [mix_2_core], mmx128_mix_2
		128	mov [mix_3_core], mmx128_mix_3
		129	mov [mix_4_core], mmx128_mix_4
293	serge	130	@@:
		131	end if
378	serge	132
		133	end if
1916	Asper	134	stdcall set_handler, [hSound], new_mix
		135	mov [eng_state], SND_STOP
		136	stdcall RegService, szInfinity, service_proc
		137	ret
168	serge	138	.fail:
		139	if DEBUG
1916	Asper	140	mov esi, msgFail
		141	call SysMsgBoardStr
168	serge	142	end if
214	serge	143	.exit:
1916	Asper	144	xor eax, eax
		145	ret
168	serge	146
		147	.out_of_mem:
		148	if DEBUG
1916	Asper	149	mov esi, msgMem
		150	call SysMsgBoardStr
168	serge	151	end if
1916	Asper	152	xor eax, eax
		153	ret
214	serge	154	endp
168	serge	155
1916	Asper	156	handle equ IOCTL.handle
		157	io_code equ IOCTL.io_code
		158	input equ IOCTL.input
		159	inp_size equ IOCTL.inp_size
		160	output equ IOCTL.output
		161	out_size equ IOCTL.out_size
168	serge	162
1679	serge	163
		164
168	serge	165	align 4
1679	serge	166
1916	Asper	167	srv_calls dd service_proc.srv_getversion ; 0
		168	dd service_proc.snd_create_buff ; 1
		169	dd service_proc.snd_destroy_buff ; 2
		170	dd service_proc.snd_setformat ; 3
		171	dd service_proc.snd_getformat ; 4
		172	dd service_proc.snd_reset ; 5
		173	dd service_proc.snd_setpos ; 6
		174	dd service_proc.snd_getpos ; 7
		175	dd service_proc.snd_setbuff ; 8
		176	dd service_proc.snd_out ; 9
		177	dd service_proc.snd_play ; 10
		178	dd service_proc.snd_stop ; 11
		179	dd service_proc.snd_setvolume ; 12
		180	dd service_proc.snd_getvolume ; 13
		181	dd service_proc.snd_setpan ; 14
		182	dd service_proc.snd_getpan ; 15
		183	dd service_proc.snd_getbuffsize ; 16
		184	dd service_proc.snd_getfreespace ; 17
		185	dd service_proc.snd_settimebase ; 18
		186	dd service_proc.snd_gettimestamp ; 19
1679	serge	187	srv_calls_end:
		188
168	serge	189	proc service_proc stdcall, ioctl:dword
		190
1916	Asper	191	mov edi, [ioctl]
		192	mov eax, [edi+io_code]
168	serge	193
1916	Asper	194	cmp eax, (srv_calls_end-srv_calls)/4
		195	ja .fail
1679	serge	196
1916	Asper	197	cmp eax, SND_DESTROY_BUFF
		198	jb @F
1679	serge	199
1690	serge	200	; cmp [edi+inp_size], 4
		201	; jb .fali
		202
1916	Asper	203	mov ebx, [edi+input]
		204	mov edx, [ebx]
1679	serge	205
1916	Asper	206	cmp [edx+STREAM.magic], 'WAVE'
		207	jne .fail
1679	serge	208
1916	Asper	209	cmp [edx+STREAM.size], STREAM.sizeof
		210	jne .fail
1679	serge	211
1690	serge	212	@@:
1916	Asper	213	jmp [srv_calls+eax*4]
1690	serge	214
		215
1679	serge	216	.fail:
1916	Asper	217	mov eax, -1
		218	ret
1679	serge	219
		220	align 4
		221	.srv_getversion:
1916	Asper	222	mov eax, [edi+output]
		223	cmp [edi+out_size], 4
		224	jne .fail
		225	mov eax, [eax]
		226	mov [eax], dword API_VERSION
		227	xor eax, eax
		228	ret
1679	serge	229
		230	align 4
		231	.snd_create_buff:
1916	Asper	232	mov ebx, [edi+input]
		233	stdcall CreateBuffer,[ebx],[ebx+4]
		234	mov edi, [ioctl]
		235	mov ecx, [edi+output]
		236	mov ecx, [ecx]
		237	mov [ecx], ebx
		238	ret
378	serge	239
1679	serge	240	align 4
		241	.snd_destroy_buff:
1916	Asper	242	mov eax, edx
		243	call DestroyBuffer
		244	ret
1679	serge	245
		246	align 4
		247	.snd_setformat:
1916	Asper	248	stdcall SetFormat, edx,[ebx+4]
		249	ret
168	serge	250
1679	serge	251	align 4
		252	.snd_getformat:
1916	Asper	253	movzx eax, word [edx+STREAM.format]
		254	mov ecx, [edi+output]
		255	mov ecx, [ecx]
		256	mov [ecx], eax
		257	xor eax, eax
		258	ret
1679	serge	259
		260	align 4
		261	.snd_reset:
1916	Asper	262	stdcall ResetBuffer,edx,[ebx+4]
		263	ret
1679	serge	264
		265	align 4
		266	.snd_setpos:
1916	Asper	267	stdcall SetBufferPos,edx,[ebx+4]
		268	ret
1679	serge	269
		270	align 4
		271	.snd_getpos:
1916	Asper	272	stdcall GetBufferPos, edx
		273	mov edi, [ioctl]
		274	mov ecx, [edi+output]
		275	mov ecx, [ecx]
		276	mov [ecx], ebx
		277	ret
1679	serge	278
		279	align 4
		280	.snd_setbuff:
1916	Asper	281	mov eax, [ebx+4]
		282	stdcall set_buffer, edx,eax,[ebx+8],[ebx+12]
		283	ret
1679	serge	284
		285	align 4
		286	.snd_out:
1916	Asper	287	mov eax, [ebx+4]
		288	stdcall wave_out, edx,eax,[ebx+8]
		289	ret
1679	serge	290
		291	align 4
		292	.snd_play:
1916	Asper	293	stdcall play_buffer, edx,[ebx+4]
		294	ret
1679	serge	295
		296	align 4
		297	.snd_stop:
1916	Asper	298	stdcall stop_buffer, edx
		299	ret
1679	serge	300
		301	align 4
		302	.snd_setvolume:
1916	Asper	303	stdcall SetBufferVol,edx,[ebx+4],[ebx+8]
		304	ret
168	serge	305
1679	serge	306	align 4
		307	.snd_getvolume:
1916	Asper	308	mov eax, [edi+output]
		309	mov ecx, [eax]
		310	mov eax, [eax+4]
		311	stdcall GetBufferVol,edx,ecx,eax
		312	ret
1679	serge	313	align 4
		314	.snd_setpan:
1916	Asper	315	stdcall SetBufferPan,edx,[ebx+4]
		316	ret
1679	serge	317
		318	align 4
		319	.snd_getpan:
1916	Asper	320	mov eax, [edx+STREAM.pan]
		321	mov ebx, [edi+output]
		322	mov ebx, [ebx]
		323	mov [ebx], eax
		324	xor eax, eax
		325	ret
378	serge	326
1679	serge	327	align 4
		328	.snd_getbuffsize:
1916	Asper	329	mov eax, [edx+STREAM.in_size]
		330	mov ecx, [edi+output]
		331	mov ecx, [ecx]
		332	mov [ecx], eax
		333	xor eax, eax
		334	ret
572	serge	335
1679	serge	336	align 4
		337	.snd_getfreespace:
1916	Asper	338	test [edx+STREAM.format], PCM_OUT
		339	jz .fail
572	serge	340
1916	Asper	341	mov ebx, [edx+STREAM.in_free]
		342	mov ecx, [edi+output]
		343	mov [ecx], ebx
		344	xor eax, eax
		345	ret
1679	serge	346	align 4
		347	.snd_settimebase:
1916	Asper	348	cmp [edi+inp_size], 12
		349	jne .fail
1679	serge	350
1916	Asper	351	mov eax, [ebx]
		352	mov ebx, [ebx+4]
		353	mov dword [edx+STREAM.time_base], eax
		354	mov dword [edx+STREAM.time_base+4], ebx
		355	xor eax, eax
		356	ret
1679	serge	357
		358	.snd_gettimestamp:
1916	Asper	359	cmp [edi+out_size], 8
		360	jne .fail
1679	serge	361
1916	Asper	362	pushfd
		363	cli
1697	serge	364
1916	Asper	365	xor ebx, ebx
		366	push 48
		367	push ebx ; local storage
1690	serge	368
1916	Asper	369	cmp [edx+STREAM.flags], SND_STOP
		370	je @F
1690	serge	371
1916	Asper	372	mov eax, esp
1690	serge	373
1916	Asper	374	push edx
		375	push edi
1690	serge	376
1916	Asper	377	push 4 ;.out_size
		378	push eax ;.output
		379	push ebx ;.inp_size
		380	push ebx ;.input
		381	push DEV_GET_POS ;.code
		382	push dword [hSound] ;.handle
		383	mov eax, esp
1690	serge	384
1916	Asper	385	stdcall ServiceHandler, eax
		386	add esp, 6*4
1690	serge	387
1916	Asper	388	pop edi
		389	pop edx
1690	serge	390
1916	Asper	391	test eax, eax
		392	jz @F
1690	serge	393
1916	Asper	394	mov dword [esp], 0 ; clear offset
1690	serge	395	@@:
1916	Asper	396	mov edi, [edi+output]
1679	serge	397
1916	Asper	398	emms
		399	fild qword [edx+STREAM.time_stamp]
		400	fiadd dword [esp] ; primary buffer offset
		401	fidiv dword [esp+4] ; total_samples / frequency
		402	fadd qword [edx+STREAM.time_base]
		403	fstp qword [edi]
		404	add esp, 8
1679	serge	405
1916	Asper	406	popfd
1697	serge	407
1916	Asper	408	xor eax, eax
		409	ret
168	serge	410	endp
		411
1679	serge	412
168	serge	413	restore handle
		414	restore io_code
		415	restore input
		416	restore inp_size
		417	restore output
		418	restore out_size
		419
328	serge	420	align 4
378	serge	421	proc CreateBuffer stdcall, format:dword, size:dword
1916	Asper	422	locals
		423	str dd ?
		424	ring_size dd ?
		425	ring_pages dd ?
		426	endl
168	serge	427
1916	Asper	428	mov eax, [format]
		429	cmp ax, PCM_1_8_8
		430	ja .fail
378	serge	431
1916	Asper	432	test eax, PCM_OUT
		433	jnz .test_out
		434	test eax, PCM_RING
		435	jnz .test_ring
378	serge	436	;staic
1916	Asper	437	test eax, PCM_STATIC
		438	jz .test_out ;use PCM_OUT as default format
		439	jmp .test_ok
378	serge	440	.test_out:
1916	Asper	441	test eax, PCM_RING+PCM_STATIC
		442	jnz .fail
		443	or [format], PCM_OUT ;force set
		444	jmp .test_ok
378	serge	445	.test_ring:
1916	Asper	446	test eax, PCM_OUT+PCM_STATIC
		447	jnz .fail
378	serge	448	.test_ok:
520	serge	449
1916	Asper	450	call GetPid
		451	mov ebx, eax
		452	mov eax, STREAM.sizeof
291	serge	453
1916	Asper	454	call CreateObject
		455	test eax, eax
		456	jz .fail
		457	mov [str], eax
168	serge	458
1916	Asper	459	mov ebx, [format]
		460	mov [eax+STREAM.format], ebx
168	serge	461
1916	Asper	462	xor ecx, ecx
		463	movzx ebx, bx
		464	cmp ebx, 19
		465	jb @f
		466	mov ecx, 0x80808080
378	serge	467	@@:
1916	Asper	468	mov [eax+STREAM.r_silence], ecx
168	serge	469
1916	Asper	470	shl ebx, 2
		471	lea ebx, [ebx+ebx2] ;ebx=12
168	serge	472
1916	Asper	473	mov ecx, [resampler_params+ebx]
		474	mov edx, [resampler_params+ebx+4]
		475	mov esi, [resampler_params+ebx+8]
378	serge	476
1916	Asper	477	mov [eax+STREAM.r_size],ecx
		478	mov [eax+STREAM.r_dt], edx
		479	mov [eax+STREAM.resample], esi
		480	xor ecx, ecx
		481	mov [eax+STREAM.l_vol], ecx
		482	mov [eax+STREAM.r_vol], ecx
		483	mov dword [eax+STREAM.l_amp], 0x7FFF7FFF
		484	mov [eax+STREAM.pan], ecx
378	serge	485
1916	Asper	486	test [format], PCM_STATIC
		487	jnz .static
378	serge	488
		489	; ring and waveout
		490
1916	Asper	491	mov ebx, 0x10000
		492	test [format], PCM_RING
		493	jz .waveout
378	serge	494
1916	Asper	495	mov ebx, [eax+STREAM.r_size]
		496	add ebx, 4095
		497	and ebx, -4096
		498	add ebx, ebx
378	serge	499	.waveout:
1916	Asper	500	mov [ring_size], ebx
		501	mov eax, ebx
		502	shr ebx, 12
		503	mov [ring_pages], ebx
378	serge	504
1916	Asper	505	stdcall CreateRingBuffer, eax, PG_SW
520	serge	506
1916	Asper	507	mov edi, [str]
		508	mov ecx, [ring_size]
		509	mov [edi+STREAM.in_base], eax
		510	mov [edi+STREAM.in_size], ecx
		511	add eax, 128
		512	mov [edi+STREAM.in_wp], eax
		513	mov [edi+STREAM.in_rp], eax
		514	mov [edi+STREAM.in_count], 0
168	serge	515
1916	Asper	516	mov [edi+STREAM.in_free], ecx
		517	add eax, ecx
		518	mov [edi+STREAM.in_top], eax
328	serge	519
1916	Asper	520	jmp .out_buff
378	serge	521	.static:
1916	Asper	522	mov ecx, [size]
		523	add ecx, 128 ;resampler required
		524	mov [eax+STREAM.in_size], ecx
		525	stdcall KernelAlloc, ecx
378	serge	526
1916	Asper	527	mov edi, [str]
		528	mov [edi+STREAM.in_base], eax
		529	add eax, 128
		530	mov [edi+STREAM.in_wp], eax
		531	mov [edi+STREAM.in_rp], eax
		532	mov ebx, [size]
		533	mov [edi+STREAM.in_count], ebx
		534	mov [edi+STREAM.in_free], ebx
		535	add eax, ebx
		536	mov [edi+STREAM.in_top], eax
378	serge	537
		538	.out_buff:
1916	Asper	539	stdcall AllocKernelSpace, dword 128*1024
328	serge	540
1916	Asper	541	mov edi, [str]
		542	xor ebx, ebx
1679	serge	543
1916	Asper	544	mov [edi+STREAM.out_base], eax
		545	mov [edi+STREAM.out_wp], eax
		546	mov [edi+STREAM.out_rp], eax
		547	mov [edi+STREAM.out_count], ebx
		548	add eax, 64*1024
		549	mov [edi+STREAM.out_top], eax
168	serge	550
1916	Asper	551	mov dword [edi+STREAM.time_base], ebx
		552	mov dword [edi+STREAM.time_base+4], ebx
1679	serge	553
1916	Asper	554	mov dword [edi+STREAM.time_stamp], ebx
		555	mov dword [edi+STREAM.time_stamp+4], ebx
		556	mov dword [edi+STREAM.last_ts], ebx
1679	serge	557
1916	Asper	558	stdcall AllocPages, dword 64/4
		559	mov edi, [str]
		560	mov ebx, [edi+STREAM.out_base]
		561	mov ecx, 16
		562	or eax, PG_SW
		563	push eax
		564	push ebx
		565	call CommitPages ;eax, ebx, ecx
		566	mov ecx, 16
		567	pop ebx
		568	pop eax
		569	add ebx, 64*1024
		570	call CommitPages ;double mapped
328	serge	571
1916	Asper	572	mov edi, [str]
		573	mov ecx, [edi+STREAM.in_top]
		574	mov edi, [edi+STREAM.in_base]
		575	sub ecx, edi
		576	xor eax, eax
		577	shr ecx, 2
		578	cld
		579	rep stosd
168	serge	580
1916	Asper	581	mov edi, [str]
		582	mov edi, [edi+STREAM.out_base]
		583	mov ecx, (64*1024)/4
		584	rep stosd
328	serge	585
1916	Asper	586	xor esi, esi
		587	mov ecx, MANUAL_DESTROY
		588	call CreateEvent
378	serge	589
1916	Asper	590	mov ebx, [str]
		591	mov [ebx+STREAM.notify_event], eax
		592	mov [ebx+STREAM.notify_id], edx
378	serge	593
1916	Asper	594	mov [ebx+STREAM.magic], 'WAVE'
		595	mov [ebx+STREAM.destroy], DestroyBuffer.destroy
		596	mov [ebx+STREAM.size], STREAM.sizeof
		597	mov [ebx+STREAM.flags], SND_STOP
378	serge	598
1916	Asper	599	pushf
		600	cli
		601	mov eax, str.fd-FD_OFFSET
		602	mov edx, [eax+STREAM.str_fd]
		603	mov [ebx+STREAM.str_fd], edx
		604	mov [ebx+STREAM.str_bk], eax
		605	mov [eax+STREAM.str_fd], ebx
		606	mov [edx+STREAM.str_bk], ebx
		607	popf
378	serge	608
1916	Asper	609	xor eax, eax
		610	ret
168	serge	611	.fail:
1916	Asper	612	xor ebx, ebx
		613	or eax, -1
		614	ret
168	serge	615	endp
		616
291	serge	617	;param
		618	; eax= buffer handle
		619
168	serge	620	align 4
291	serge	621	DestroyBuffer:
1916	Asper	622	.handle equ esp ;local
168	serge	623
1916	Asper	624	mov [eax+STREAM.flags], SND_STOP
291	serge	625	.destroy:
1916	Asper	626	push eax
328	serge	627
1916	Asper	628	pushfd
		629	cli
		630	mov ebx, [eax+STREAM.str_fd]
		631	mov ecx, [eax+STREAM.str_bk]
		632	mov [ebx+STREAM.str_bk], ecx
		633	mov [ecx+STREAM.str_fd], ebx
		634	popf
168	serge	635
1916	Asper	636	stdcall KernelFree, [eax+STREAM.in_base]
		637	mov eax, [.handle]
		638	stdcall KernelFree, [eax+STREAM.out_base]
328	serge	639
1916	Asper	640	pop eax ;restore stack
		641	call DestroyObject ;eax= stream
		642	xor eax, eax
		643	ret
168	serge	644	.fail:
1916	Asper	645	or eax, -1
		646	ret
378	serge	647	restore .handle
168	serge	648
		649	align 4
378	serge	650	proc SetFormat stdcall, str:dword, format:dword
168	serge	651
1916	Asper	652	cmp word [format], PCM_1_8_8
		653	ja .fail
168	serge	654
1916	Asper	655	mov edx, [str]
		656	mov [edx+STREAM.flags], SND_STOP
168	serge	657
1916	Asper	658	test [edx+STREAM.format], PCM_RING
		659	jnz .fail
168	serge	660
378	serge	661	; mov eax,[edx+STREAM.out_base]
		662	; mov [edx+STREAM.out_wp], eax
		663	; mov [edx+STREAM.out_rp], eax
		664	; mov [edx+STREAM.out_count], 0
168	serge	665
1916	Asper	666	movzx eax, word [format]
		667	mov word [edx+STREAM.format], ax
378	serge	668
1916	Asper	669	xor ebx, ebx
		670	cmp eax, 19
		671	jb @f
		672	mov ebx, 0x80808080
168	serge	673	@@:
1916	Asper	674	mov [edx+STREAM.r_silence], ebx
168	serge	675
1916	Asper	676	shl eax, 2
		677	lea eax, [eax+eax2] ;eax=12
168	serge	678
1916	Asper	679	mov edi, [resampler_params+eax]
		680	mov ecx, [resampler_params+eax+4]
		681	mov ebx, [resampler_params+eax+8]
168	serge	682
1916	Asper	683	mov [edx+STREAM.r_size],edi
		684	mov [edx+STREAM.r_dt], ecx
		685	mov [edx+STREAM.resample], ebx
168	serge	686
1916	Asper	687	mov edi, [edx+STREAM.in_base]
		688	mov ecx, 128/4
		689	mov eax, [edx+STREAM.r_silence]
		690	cld
		691	rep stosd
		692	xor eax, eax
		693	ret
168	serge	694	.fail:
1916	Asper	695	or eax, -1
		696	ret
168	serge	697	endp
		698
378	serge	699	; for static buffers only
		700	; use waveout for streams
		701
168	serge	702	align 4
378	serge	703	proc set_buffer stdcall, str:dword,src:dword,offs:dword,size:dword
168	serge	704
1916	Asper	705	mov edx, [str]
		706	test [edx+STREAM.format], PCM_OUT
		707	jnz .fail
168	serge	708
1916	Asper	709	mov esi, [src]
		710	mov edi, [offs]
		711	add edi, [edx+STREAM.in_base]
		712	add edi, 128
168	serge	713
1916	Asper	714	cmp edi, [edx+STREAM.in_top]
		715	jae .fail
168	serge	716
1916	Asper	717	mov ecx, [size]
		718	lea ebx, [ecx+edi]
		719	sub ebx, [edx+STREAM.in_top]
		720	jb @F
		721	sub ecx, ebx
378	serge	722	@@:
1916	Asper	723	shr ecx, 2
		724	cld
		725	rep movsd
		726	xor eax,eax
		727	ret
168	serge	728	.fail:
1916	Asper	729	or eax, -1
		730	ret
168	serge	731	endp
		732
378	serge	733	; for stream buffers only
		734
168	serge	735	align 4
378	serge	736	proc wave_out stdcall, str:dword,src:dword,size:dword
1916	Asper	737	locals
		738	state_saved dd ?
		739	fpu_state rb 528
		740	endl
168	serge	741
1916	Asper	742	mov edx, [str]
		743	mov eax, [edx+STREAM.format]
		744	test eax, PCM_OUT
		745	jz .fail
168	serge	746
1916	Asper	747	cmp ax, PCM_ALL
		748	je .fail
168	serge	749
1916	Asper	750	mov esi,[src]
		751	test esi, esi
		752	jz .fail
168	serge	753
1916	Asper	754	cmp esi, OS_BASE
		755	jae .fail
168	serge	756
1916	Asper	757	mov [state_saved], 0
168	serge	758
378	serge	759	.main_loop:
1916	Asper	760	mov edx, [str]
168	serge	761
1916	Asper	762	mov ebx, [size]
		763	test ebx, ebx
		764	jz .done
378	serge	765
1916	Asper	766	cmp [edx+STREAM.flags], SND_STOP
		767	jne .fill
378	serge	768
1916	Asper	769	mov edi, [edx+STREAM.in_base]
		770	mov ecx, 128/4
		771	mov eax, [edx+STREAM.r_silence]
		772	cld
		773	rep stosd
378	serge	774
1916	Asper	775	mov ecx, [edx+STREAM.in_size]
		776	sub ecx, 128
		777	mov [edx+STREAM.in_wp], edi
		778	mov [edx+STREAM.in_rp], edi
		779	mov [edx+STREAM.in_count], 0
		780	mov [edx+STREAM.in_free], ecx
378	serge	781
1916	Asper	782	mov eax,[edx+STREAM.out_base]
		783	mov [edx+STREAM.out_wp], eax
		784	mov [edx+STREAM.out_rp], eax
		785	mov [edx+STREAM.out_count], 0
378	serge	786	.fill:
1916	Asper	787	cli
1024	serge	788
1916	Asper	789	mov ecx, [edx+STREAM.in_free]
		790	test ecx, ecx
		791	jz .wait
378	serge	792
1916	Asper	793	cmp ecx, ebx
		794	jbe @F
378	serge	795
1916	Asper	796	mov ecx, ebx
378	serge	797	@@:
1916	Asper	798	sub [size], ecx
		799	add [edx+STREAM.in_count], ecx
		800	sub [edx+STREAM.in_free], ecx
168	serge	801
1916	Asper	802	shr ecx, 2
		803	mov edi, [edx+STREAM.in_wp]
		804	mov esi, [src]
		805	cld
		806	rep movsd
378	serge	807
1916	Asper	808	mov [src], esi
		809	cmp edi, [edx+STREAM.in_top]
		810	jb @F
		811	sub edi, [edx+STREAM.in_size]
285	serge	812	@@:
1916	Asper	813	mov [edx+STREAM.in_wp], edi
168	serge	814
1916	Asper	815	cmp [edx+STREAM.out_count], 32768
		816	jae .skip
378	serge	817
1916	Asper	818	cmp [state_saved], 0
		819	jne @F
		820	lea eax, [fpu_state+15]
		821	and eax, -16
		822	call FpuSave
		823	mov [state_saved], 1
378	serge	824	@@:
1916	Asper	825	stdcall refill, edx
1024	serge	826
378	serge	827	.skip:
1916	Asper	828	sti
		829	mov edx, [str]
		830	mov [edx+STREAM.flags], SND_PLAY
		831	cmp [eng_state], SND_PLAY
		832	je .main_loop
378	serge	833
1916	Asper	834	stdcall dev_play, [hSound]
		835	mov [eng_state], SND_PLAY
		836	jmp .main_loop
378	serge	837	.wait:
1916	Asper	838	sti
		839	mov edx, [str]
		840	mov eax, [edx+STREAM.notify_event]
		841	mov ebx, [edx+STREAM.notify_id]
		842	call WaitEvent ;eax ebx
		843	jmp .main_loop
285	serge	844	.done:
1916	Asper	845	cmp [state_saved], 1
		846	jne @F
378	serge	847
1916	Asper	848	lea eax, [fpu_state+15]
		849	and eax, -16
		850	call FpuRestore
378	serge	851	@@:
1916	Asper	852	xor eax, eax
		853	ret
378	serge	854	.fail:
1916	Asper	855	or eax, -1
		856	ret
378	serge	857	endp
		858
		859	; both static and stream
		860	; reset all but not clear buffers
		861
		862
		863	; flags reserved
		864	; RESET_INPUT equ 1 ;reserved reset and clear input buffer
		865	; RESET_OUTPUT equ 2 ;reserved reset and clear output buffer
		866	; RESET_ALL equ 3
		867
		868
		869	align 4
		870	proc ResetBuffer stdcall, str:dword, flags:dword
		871
1916	Asper	872	mov edx, [str]
		873	mov [edx+STREAM.flags], SND_STOP
378	serge	874
1916	Asper	875	mov edi, [edx+STREAM.in_base]
		876	mov ecx, 128/4
		877	mov eax, [edx+STREAM.r_silence]
		878	cld
		879	rep stosd
378	serge	880
1916	Asper	881	mov [edx+STREAM.in_wp], edi
		882	mov [edx+STREAM.in_rp], edi
378	serge	883
1916	Asper	884	test [edx+STREAM.flags], PCM_STATIC
		885	jnz .static
		886	mov [edx+STREAM.in_count], 0
		887	jmp @F
567	serge	888	.static:
1916	Asper	889	mov eax, [edx+STREAM.in_size]
		890	mov [edx+STREAM.in_count], eax
567	serge	891	@@:
		892
1916	Asper	893	mov eax, [edx+STREAM.in_size]
		894	sub eax, 128
		895	mov [edx+STREAM.in_free], eax
378	serge	896
1916	Asper	897	xor eax, eax
		898	mov ebx,[edx+STREAM.out_base]
		899	mov [edx+STREAM.out_wp], ebx
		900	mov [edx+STREAM.out_rp], ebx
		901	mov [edx+STREAM.out_count], eax
		902	ret
378	serge	903	.fail:
1916	Asper	904	or eax, -1
		905	ret
378	serge	906	endp
		907
		908	; for static buffers only
		909
		910	align 4
		911	proc SetBufferPos stdcall, str:dword, pos:dword
		912
1916	Asper	913	mov edx, [str]
		914	test [edx+STREAM.format], PCM_STATIC
		915	jz .fail
378	serge	916
1916	Asper	917	mov [edx+STREAM.flags], SND_STOP
378	serge	918
1916	Asper	919	mov eax, [pos]
		920	add eax, [edx+STREAM.in_base]
		921	mov ebx, [edx+STREAM.in_top]
		922	add eax, 128
378	serge	923
1916	Asper	924	cmp eax, ebx
		925	jae .fail
378	serge	926
1916	Asper	927	mov [edx+STREAM.in_rp], eax
		928	sub ebx, eax
		929	mov [edx+STREAM.in_count], ebx
		930	xor eax, eax
		931	ret
378	serge	932	.fail:
1916	Asper	933	or eax, -1
		934	ret
378	serge	935	endp
		936
		937	align 4
		938	proc GetBufferPos stdcall, str:dword
		939
1916	Asper	940	mov edx, [str]
		941	test [edx+STREAM.format], PCM_STATIC
		942	jz .fail
378	serge	943
1916	Asper	944	mov ebx, [edx+STREAM.in_rp]
		945	sub ebx, [edx+STREAM.in_base]
		946	sub ebx, 128
		947	xor eax, eax
		948	ret
378	serge	949	.fail:
1916	Asper	950	xor ebx,ebx
		951	or eax, -1
		952	ret
378	serge	953	endp
		954
		955	; both
		956
		957	align 4
		958	proc SetBufferVol stdcall, str:dword,l_vol:dword,r_vol:dword
		959
1916	Asper	960	mov edx, [str]
		961	stdcall set_vol_param,[l_vol],[r_vol],[edx+STREAM.pan]
		962	ret
378	serge	963	endp
		964
1916	Asper	965
		966	proc minw stdcall, arg1:dword, arg2:dword
		967	mov ax, word [arg1]
		968	cmp ax, word [arg2]
		969	jle @f
		970	mov eax, [arg2]
		971	@@:
		972	ret
		973	endp
		974
		975	proc maxw stdcall, arg1:dword, arg2:dword
		976	mov ax, word [arg1]
		977	cmp ax, word [arg2]
		978	jge @f
		979	mov eax, [arg2]
		980	@@:
		981	ret
		982	endp
		983
		984
378	serge	985	proc set_vol_param stdcall, l_vol:dword,r_vol:dword,pan:dword
1916	Asper	986	locals
		987	_600 dd ?
		988	_32767 dd ?
		989	state rb 108
		990	endl
378	serge	991
1916	Asper	992	mov [_600], 0x44160000 ;600.0
		993	mov [_32767], 32767
378	serge	994
1916	Asper	995	lea ebx, [state]
		996	fnsave [ebx]
378	serge	997
1916	Asper	998	stdcall minw, [l_vol], [vol_max]
		999	stdcall maxw, eax, [vol_min]
		1000	mov [l_vol], eax
		1001	mov [edx+STREAM.l_vol], eax
		1002	stdcall minw, [r_vol], [vol_max+4]
		1003	stdcall maxw, eax, [vol_min+4]
		1004	mov [r_vol], eax
		1005	mov [edx+STREAM.r_vol], eax
378	serge	1006
1916	Asper	1007	stdcall minw, [pan], [pan_max]
		1008	stdcall maxw, eax, [vol_min]
		1009	mov [edx+STREAM.pan], eax
378	serge	1010
1916	Asper	1011	cmp word [edx+STREAM.pan], 0
		1012	jl .@f
378	serge	1013
1916	Asper	1014	mov ebx, [l_vol]
		1015	sub ebx, eax
		1016	stdcall minw, ebx, [vol_max]
		1017	stdcall maxw, eax, [vol_min]
		1018	mov [l_vol], eax
		1019	jmp .calc_amp
378	serge	1020	@@:
1916	Asper	1021	mov ebx, [r_vol]
		1022	add ebx, [pan]
		1023	stdcall minw, ebx, [vol_max+4]
		1024	stdcall maxw, eax, [vol_min+4]
		1025	mov [r_vol], eax
378	serge	1026	.calc_amp:
1916	Asper	1027	emms
		1028	fild word [l_vol]
378	serge	1029
1916	Asper	1030	call .calc
378	serge	1031
1916	Asper	1032	fistp word [edx+STREAM.l_amp]
		1033	fstp dword [edx+STREAM.l_amp_f]
		1034	fstp st0
378	serge	1035
1916	Asper	1036	fild word [r_vol]
378	serge	1037
1916	Asper	1038	call .calc
378	serge	1039
1916	Asper	1040	fistp word [edx+STREAM.r_amp]
		1041	fstp dword [edx+STREAM.r_amp_f]
		1042	fstp st0
378	serge	1043
1916	Asper	1044	fnclex
		1045	lea ebx, [state]
		1046	frstor [ebx]
378	serge	1047
1916	Asper	1048	xor eax, eax
		1049	inc eax
		1050	ret
378	serge	1051	.calc:
1916	Asper	1052	fdiv dword [_600]
		1053	fld st0
		1054	frndint
		1055	fxch st1
		1056	fsub st, st1
		1057	f2xm1
		1058	fld1
		1059	faddp st1, st0
		1060	fscale
		1061	fld st0
		1062	fimul dword [_32767]
		1063	ret 0
378	serge	1064	endp
		1065
1916	Asper	1066
378	serge	1067	align 4
		1068	proc GetBufferVol stdcall, str:dword,p_lvol:dword,p_rvol:dword
		1069
1916	Asper	1070	mov edx, [str]
		1071	mov eax, [p_lvol]
		1072	movsx ecx, word [edx+STREAM.l_vol]
		1073	mov [eax], ecx
378	serge	1074
1916	Asper	1075	mov eax, [p_rvol]
		1076	movsx ecx, word [edx+STREAM.r_vol]
		1077	mov [eax], ecx
		1078	xor eax, eax
		1079	ret
378	serge	1080	endp
		1081
		1082	align 4
		1083	proc SetBufferPan stdcall, str:dword,pan:dword
		1084
1916	Asper	1085	mov edx, [str]
		1086	stdcall set_vol_param,[edx+STREAM.l_vol],\
		1087	[edx+STREAM.r_vol],[pan]
		1088	ret
378	serge	1089	endp
		1090
		1091	; for static and ring buffers only
		1092
		1093	align 4
		1094	proc play_buffer stdcall, str:dword, flags:dword
		1095
1916	Asper	1096	mov ebx, [str]
		1097	mov eax, [ebx+STREAM.format]
		1098	test eax, PCM_OUT
		1099	jnz .fail
378	serge	1100
1916	Asper	1101	cmp ax, PCM_ALL
		1102	je .fail
378	serge	1103
1916	Asper	1104	mov [ebx+STREAM.flags], SND_PLAY
		1105	cmp [eng_state], SND_PLAY
		1106	je .done
378	serge	1107
1916	Asper	1108	stdcall dev_play, [hSound]
		1109	mov [eng_state], SND_PLAY
378	serge	1110	.done:
1916	Asper	1111	test [flags], PLAY_SYNC
		1112	jz @F
378	serge	1113
1916	Asper	1114	mov edx, [str]
378	serge	1115	.wait:
1916	Asper	1116	mov eax, [edx+STREAM.notify_event]
		1117	mov ebx, [edx+STREAM.notify_id]
		1118	call WaitEvent ;eax ebx
378	serge	1119
1916	Asper	1120	mov edx, [str]
		1121	cmp [edx+STREAM.flags], SND_STOP
		1122	jne .wait
378	serge	1123	@@:
1916	Asper	1124	xor eax, eax
		1125	ret
168	serge	1126	.fail:
1916	Asper	1127	or eax, -1
		1128	ret
378	serge	1129	endp
		1130
567	serge	1131	; for static and ring buffers only
378	serge	1132
		1133	align 4
		1134	proc stop_buffer stdcall, str:dword
		1135
1916	Asper	1136	mov edx, [str]
		1137	test [edx+STREAM.format], PCM_STATIC+PCM_RING
		1138	jz .fail
378	serge	1139
1916	Asper	1140	mov [edx+STREAM.flags], SND_STOP
378	serge	1141
		1142	; stdcall [ServiceHandler], [hSound], dword DEV_STOP, 0
		1143
1916	Asper	1144	mov eax, [edx+STREAM.notify_event]
		1145	mov ebx, [edx+STREAM.notify_id]
		1146	call ClearEvent ;eax ebx
378	serge	1147
1916	Asper	1148	xor eax, eax
		1149	ret
378	serge	1150	.fail:
1916	Asper	1151	or eax, -1
		1152	ret
168	serge	1153	endp
		1154
695	serge	1155	; param
378	serge	1156	; eax= mix_list
		1157
168	serge	1158	align 4
378	serge	1159	do_mix_list:
		1160
1916	Asper	1161	xor edx, edx
		1162	mov esi, str.fd-FD_OFFSET
		1163	mov ebx, [esi+STREAM.str_fd]
378	serge	1164	@@:
1916	Asper	1165	cmp ebx, esi
		1166	je .done
378	serge	1167
1916	Asper	1168	cmp [ebx+STREAM.magic], 'WAVE'
		1169	jne .next
378	serge	1170
1916	Asper	1171	cmp [ebx+STREAM.size], STREAM.sizeof
		1172	jne .next
378	serge	1173
1916	Asper	1174	cmp [ebx+STREAM.flags], SND_PLAY;
		1175	jne .next
378	serge	1176
1916	Asper	1177	mov ecx, [ebx+STREAM.out_count]
		1178	test ecx, ecx
		1179	jnz .l1
378	serge	1180
1916	Asper	1181	test [ebx+STREAM.format], PCM_RING
		1182	jnz .next
		1183	mov [ebx+STREAM.flags], SND_STOP
		1184	jmp .next
378	serge	1185	.l1:
1916	Asper	1186	cmp ecx, 512
		1187	jae .add_buff
378	serge	1188
1916	Asper	1189	mov edi, [ebx+STREAM.out_rp]
		1190	add edi, ecx
		1191	sub ecx, 512
		1192	neg ecx
		1193	push eax
		1194	xor eax, eax
		1195	cld
		1196	rep stosb
		1197	pop eax
378	serge	1198
1916	Asper	1199	mov [ebx+STREAM.out_count], 512
378	serge	1200
		1201	.add_buff:
1916	Asper	1202	mov ecx, [ebx+STREAM.out_rp]
		1203	mov [eax],ecx
694	serge	1204
		1205	if USE_SSE2_MIXER
1916	Asper	1206	mov edi, dword [ebx+STREAM.l_amp_f]
		1207	mov [eax+4], edi
		1208	mov edi, dword [ebx+STREAM.r_amp_f]
		1209	mov [eax+8], edi
694	serge	1210	else
1916	Asper	1211	mov edi, dword [ebx+STREAM.l_amp]
		1212	mov [eax+4], edi
694	serge	1213	end if
1916	Asper	1214	add [ebx+STREAM.out_rp], 512
		1215	sub [ebx+STREAM.out_count], 512
378	serge	1216
1916	Asper	1217	add eax, 12
		1218	inc edx
378	serge	1219	.next:
1916	Asper	1220	mov ebx, [ebx+STREAM.str_fd]
		1221	jmp @B
378	serge	1222	.done:
1916	Asper	1223	mov eax, edx
		1224	ret
378	serge	1225
		1226	align 4
291	serge	1227	prepare_playlist:
168	serge	1228
1916	Asper	1229	xor edx, edx
		1230	mov [play_count], edx
		1231	mov esi, str.fd-FD_OFFSET
		1232	mov edi, [esi+STREAM.str_fd]
291	serge	1233	@@:
1916	Asper	1234	cmp edi, esi
		1235	je .done
168	serge	1236
1916	Asper	1237	cmp [edi+STREAM.magic], 'WAVE'
		1238	jne .next
168	serge	1239
1916	Asper	1240	cmp [edi+STREAM.size], STREAM.sizeof
		1241	jne .next
168	serge	1242
1916	Asper	1243	cmp [edi+STREAM.flags], SND_PLAY;
		1244	jne .next
168	serge	1245
1916	Asper	1246	mov [play_list+edx], edi
		1247	inc [play_count]
		1248	add edx, 4
168	serge	1249	.next:
1916	Asper	1250	mov edi, [edi+STREAM.str_fd]
		1251	jmp @B
291	serge	1252	.done:
1916	Asper	1253	ret
168	serge	1254
		1255	align 4
		1256	proc set_handler stdcall, hsrv:dword, handler_proc:dword
1916	Asper	1257	locals
		1258	handler dd ?
		1259	io_code dd ?
		1260	input dd ?
		1261	inp_size dd ?
		1262	output dd ?
		1263	out_size dd ?
		1264	val dd ?
		1265	endl
168	serge	1266
1916	Asper	1267	mov eax, [hsrv]
		1268	lea ecx, [handler_proc]
		1269	xor ebx, ebx
168	serge	1270
1916	Asper	1271	mov [handler], eax
		1272	mov [io_code], DEV_CALLBACK
		1273	mov [input], ecx
		1274	mov [inp_size], 4
		1275	mov [output], ebx
		1276	mov [out_size], 0
168	serge	1277
1916	Asper	1278	lea eax, [handler]
		1279	stdcall ServiceHandler, eax
		1280	ret
168	serge	1281	endp
		1282
		1283	align 4
		1284	proc dev_play stdcall, hsrv:dword
1916	Asper	1285	locals
		1286	handle dd ?
		1287	io_code dd ?
		1288	input dd ?
		1289	inp_size dd ?
		1290	output dd ?
		1291	out_size dd ?
		1292	val dd ?
		1293	endl
168	serge	1294
1916	Asper	1295	mov eax, [hsrv]
		1296	xor ebx, ebx
168	serge	1297
1916	Asper	1298	mov [handle], eax
		1299	mov [io_code], DEV_PLAY
		1300	mov [input], ebx
		1301	mov [inp_size], ebx
		1302	mov [output], ebx
		1303	mov [out_size], ebx
168	serge	1304
1916	Asper	1305	lea eax, [handle]
		1306	stdcall ServiceHandler, eax
		1307	ret
168	serge	1308	endp
		1309
378	serge	1310	if 0
		1311	align 4
		1312	dword2str:
		1313	mov esi, hex_buff
		1314	mov ecx, -8
		1315	@@:
		1316	rol eax, 4
		1317	mov ebx, eax
		1318	and ebx, 0x0F
		1319	mov bl, [ebx+hexletters]
		1320	mov [8+esi+ecx], bl
		1321	inc ecx
		1322	jnz @B
		1323	ret
		1324
		1325	hexletters db '0123456789ABCDEF'
		1326	hex_buff db 8 dup(0),13,10,0
		1327
		1328	end if
		1329
168	serge	1330	include 'mixer.asm'
293	serge	1331	include 'mix_mmx.inc'
		1332	include 'mix_sse2.inc'
168	serge	1333
291	serge	1334	;if USE_SSE
		1335	; include 'mix_sse.inc'
		1336	;end if
		1337
168	serge	1338	align 16
		1339	resampler_params:
378	serge	1340	;r_size r_dt resampler_func
1916	Asper	1341	dd 0,0,0 ; 0 PCM_ALL
		1342	dd 16384, 0, copy_stream ; 1 PCM_2_16_48
		1343	dd 8192, 0, m16_stereo ; 2 PCM_1_16_48
168	serge	1344
1916	Asper	1345	dd 16384, 30109, resample_2 ; 3 PCM_2_16_44
		1346	dd 8192, 30109, resample_1 ; 4 PCM_1_16_44
168	serge	1347
1916	Asper	1348	dd 16384, 21846, resample_2 ; 5 PCM_2_16_32
		1349	dd 8192, 21846, resample_1 ; 6 PCM_1_16_32
168	serge	1350
1916	Asper	1351	dd 16384, 16384, resample_2 ; 7 PCM_2_16_24
		1352	dd 8192, 16384, resample_1 ; 8 PCM_1_16_24
168	serge	1353
1916	Asper	1354	dd 8192, 15052, resample_2 ; 9 PCM_2_16_22
		1355	dd 4096, 15052, resample_1 ;10 PCM_1_16_22
168	serge	1356
1916	Asper	1357	dd 8192, 10923, resample_2 ;11 PCM_2_16_16
		1358	dd 4096, 10923, resample_1 ;12 PCM_1_16_16
168	serge	1359
1916	Asper	1360	dd 8192, 8192, resample_2 ;13 PCM_2_16_12
		1361	dd 4096, 8192, resample_1 ;14 PCM_1_16_12
168	serge	1362
1916	Asper	1363	dd 4096, 7527, resample_2 ;15 PCM_2_16_11
		1364	dd 2048, 7527, resample_1 ;16 PCM_1_16_11
168	serge	1365
1916	Asper	1366	dd 4096, 5462, resample_2 ;17 PCM_2_16_8
		1367	dd 2048, 5462, resample_1 ;18 PCM_1_16_8
168	serge	1368
1916	Asper	1369	dd 16384, 0, s8_stereo ;19 PCM_2_8_48
		1370	dd 8192, 0, m8_stereo ;20 PCM_1_8_48
168	serge	1371
1916	Asper	1372	dd 8192, 30109, resample_28 ;21 PCM_2_8_44
		1373	dd 4096, 30109, resample_18 ;22 PCM_1_8_44
168	serge	1374
1916	Asper	1375	dd 8192, 21846, resample_28 ;23 PCM_2_8_32
		1376	dd 4096, 21846, resample_18 ;24 PCM_1_8_32
168	serge	1377
1916	Asper	1378	dd 8192, 16384, resample_28 ;25 PCM_2_8_24
		1379	dd 4096, 16384, resample_18 ;26 PCM_1_8_24
168	serge	1380
1916	Asper	1381	dd 4096, 15052, resample_28 ;27 PCM_2_8_22
		1382	dd 2048, 15052, resample_18 ;28 PCM_1_8_22
168	serge	1383
1916	Asper	1384	dd 4096, 10923, resample_28 ;29 PCM_2_8_16
		1385	dd 2048, 10923, resample_18 ;30 PCM_1_8_16
168	serge	1386
1916	Asper	1387	dd 4096, 8192, resample_28 ;31 PCM_2_8_12
		1388	dd 2048, 8192, resample_18 ;32 PCM_1_8_12
168	serge	1389
1916	Asper	1390	dd 2048, 7527, resample_28 ;33 PCM_2_8_11
		1391	dd 1024, 7527, resample_18 ;34 PCM_1_8_11
168	serge	1392
1916	Asper	1393	dd 2048, 5462, resample_28 ;35 PCM_2_8_8
		1394	dd 1024, 5462, resample_18 ;36 PCM_1_8_8
168	serge	1395
1916	Asper	1396	m7 dw 0x8000,0x8000,0x8000,0x8000
		1397	mm80 dq 0x8080808080808080
281	serge	1398	mm_mask dq 0xFF00FF00FF00FF00
168	serge	1399
378	serge	1400	vol_max dd 0x00000000,0x00000000
		1401	vol_min dd 0x0000D8F0,0x0000D8F0
		1402	pan_max dd 0x00002710,0x00002710
		1403
291	serge	1404	;stream_map dd 0xFFFF ; 16
574	serge	1405	version dd (5 shl 16) or SOUND_VERSION
168	serge	1406
281	serge	1407	szInfinity db 'INFINITY',0
		1408	szSound db 'SOUND',0
168	serge	1409
		1410	if DEBUG
281	serge	1411	msgFail db 'Sound service not loaded',13,10,0
		1412	msgPlay db 'Play buffer',13,10,0
		1413	msgStop db 'Stop',13,10,0
		1414	msgUser db 'User callback',13,10,0
1916	Asper	1415	msgMem db 'Not enough memory',13,10,0
291	serge	1416	msgDestroy db 'Destroy sound buffer', 13,10,0
378	serge	1417	msgWaveout db 'Play waveout', 13,10,0
		1418	msgSetVolume db 'Set volume',13,10,0
168	serge	1419	end if
188	serge	1420
		1421	section '.data' data readable writable align 16
		1422
281	serge	1423	play_list rd 16
		1424	mix_input rd 16
		1425	play_count rd 1
1916	Asper	1426	hSound rd 1
378	serge	1427	eng_state rd 1
281	serge	1428	mix_buff rd 1
		1429	mix_buff_map rd 1
1916	Asper	1430	str.fd rd 1
		1431	str.bk rd 1
188	serge	1432
293	serge	1433	mix_2_core rd 1
		1434	mix_3_core rd 1
		1435	mix_4_core rd 1

Subversion Repositories Kolibri OS

(root)/kernel/trunk/drivers/infinity.asm – Rev 1916