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

Rev	Author	Line No.	Line
168	serge	1	;
		2	; This file is part of the Infinity sound library.
		3	; (C) copyright Serge 2006
		4	; email: infinity_sound@mail.ru
		5	;
		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
		8	; the Free Software Foundation; either version 2 of the License, or
		9	; (at your option) any later version.
		10	;
		11	; This program is distributed in the hope that it will be useful,
		12	; but WITHOUT ANY WARRANTY; without even the implied warranty of
		13	; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		14	; GNU General Public License for more details.
		15
		16	format MS COFF
		17
		18	include 'proc32.inc'
		19	include 'main.inc'
281	serge	20	include 'imports.inc'
168	serge	21
		22	DEBUG equ 1
		23
		24	EVENT_NOTIFY equ 0x00000200
		25
		26	OS_BASE equ 0; 0x80400000
		27	new_app_base equ 0x60400000; 0x01000000
		28	PROC_BASE equ OS_BASE+0x0080000
		29
188	serge	30	public START
168	serge	31	public service_proc
227	serge	32	public version
168	serge	33
		34	SND_CREATE_BUFF equ 2
		35	SND_PLAY equ 3
		36	SND_STOP equ 4
		37	SND_SETBUFF equ 5
		38	SND_DESTROY_BUFF equ 6
		39
		40	DEV_PLAY equ 1
		41	DEV_STOP equ 2
		42	DEV_CALLBACK equ 3
		43
		44	struc IOCTL
		45	{ .handle dd ?
		46	.io_code dd ?
		47	.input dd ?
		48	.inp_size dd ?
		49	.output dd ?
		50	.out_size dd ?
		51	}
		52
		53	virtual at 0
		54	IOCTL IOCTL
		55	end virtual
		56
188	serge	57	section '.flat' code readable align 16
168	serge	58
214	serge	59	proc START stdcall, state:dword
		60
227	serge	61	cmp [state], 1
		62	jne .exit
		63
188	serge	64	stdcall GetService, szSound
168	serge	65	test eax, eax
		66	jz .fail
		67	mov [hSound], eax
		68
188	serge	69	stdcall KernelAlloc, 16*512
168	serge	70	test eax, eax
		71	jz .out_of_mem
		72	mov [mix_buff], eax
		73
		74	mov edi, stream_list
		75	mov ecx, 17
		76	xor eax, eax
		77	cld
		78	rep stosd
		79
		80	mov edi, stream
		81	mov ecx, 4*STREAM_SIZE
		82	rep stosd
188	serge	83	mov [stream_count],0
168	serge	84
		85	stdcall set_handler, [hSound], new_mix
188	serge	86	stdcall RegService, szInfinity, service_proc
227	serge	87	ret
168	serge	88	.fail:
		89	if DEBUG
227	serge	90	mov esi, msgFail
188	serge	91	call SysMsgBoardStr
168	serge	92	end if
214	serge	93	.exit:
227	serge	94	xor eax, eax
		95	ret
168	serge	96
		97	.out_of_mem:
		98	if DEBUG
		99	mov esi, msgMem
188	serge	100	call SysMsgBoardStr
168	serge	101	end if
227	serge	102	xor eax, eax
188	serge	103	ret
214	serge	104	endp
168	serge	105
		106	handle equ IOCTL.handle
		107	io_code equ IOCTL.io_code
		108	input equ IOCTL.input
		109	inp_size equ IOCTL.inp_size
		110	output equ IOCTL.output
		111	out_size equ IOCTL.out_size
		112
		113	align 4
		114	proc service_proc stdcall, ioctl:dword
		115
		116	mov edi, [ioctl]
		117	mov eax, [edi+io_code]
		118
227	serge	119	cmp eax, SND_CREATE_BUFF
		120	jne @F
168	serge	121	mov ebx, [edi+input]
		122	stdcall CreateBuffer,[ebx]
227	serge	123	ret
168	serge	124	@@:
227	serge	125	cmp eax, SND_PLAY
		126	jne @F
168	serge	127
		128	mov ebx, [edi+input]
227	serge	129	stdcall play_buffer, [ebx]
		130	ret
168	serge	131	@@:
227	serge	132	cmp eax, SND_STOP
		133	jne @F
168	serge	134
		135	; if DEBUG
		136	; mov esi, msgStop
		137	; call [SysMsgBoardStr]
		138	; end if
		139
		140	mov ebx, [edi+input]
227	serge	141	stdcall stop_buffer, [ebx]
		142	ret
168	serge	143	@@:
227	serge	144	cmp eax, SND_SETBUFF
		145	jne @F
168	serge	146
		147	mov ebx, [edi+input]
227	serge	148	mov eax, [ebx+4]
		149	add eax, new_app_base
		150	stdcall set_buffer, [ebx],eax,[ebx+8],[ebx+12]
		151	ret
168	serge	152	@@:
		153	cmp eax, SND_DESTROY_BUFF
227	serge	154	jne @F
168	serge	155
		156	mov ebx, [edi+input]
		157	stdcall DestroyBuffer, [ebx]
227	serge	158	ret
168	serge	159	@@:
227	serge	160	xor eax, eax
		161	ret
168	serge	162	endp
		163
		164	restore handle
		165	restore io_code
		166	restore input
		167	restore inp_size
		168	restore output
		169	restore out_size
		170
		171	TASK_COUNT equ 0x0003004
		172	CURRENT_TASK equ 0x0003000
		173
		174	align 8
		175	proc CreateBuffer stdcall, format:dword
227	serge	176	locals
		177	str dd ?
		178	endl
168	serge	179
227	serge	180	call alloc_stream
		181	and eax, eax
		182	jz .fail
		183	mov [str], eax
168	serge	184	mov edi, eax
		185
227	serge	186	mov edx, [stream_count]
		187	mov [stream_list+edx*4], eax
		188	inc [stream_count]
168	serge	189
227	serge	190	mov [edi+STREAM.magic], 'WAVE'
		191	mov [edi+STREAM.size], STREAM_SIZE
168	serge	192
285	serge	193	stdcall KernelAlloc, 172*1024
168	serge	194
227	serge	195	mov edi, [str]
		196	mov [edi+STREAM.base], eax
285	serge	197	add eax, 0x1000
281	serge	198	mov [edi+STREAM.seg_0], eax
227	serge	199	mov [edi+STREAM.curr_seg], eax
		200	mov [edi+STREAM.notify_off1], eax
285	serge	201	add eax, 0x8000
281	serge	202	mov [edi+STREAM.lim_0], eax
285	serge	203	add eax, 0x1000
281	serge	204	mov [edi+STREAM.seg_1], eax
227	serge	205	mov [edi+STREAM.notify_off2], eax
285	serge	206	add eax, 0x8000
227	serge	207	mov [edi+STREAM.limit], eax
281	serge	208	mov [edi+STREAM.lim_1], eax
168	serge	209
227	serge	210	mov [edi+STREAM.work_buff], eax
		211	mov [edi+STREAM.work_read], eax
		212	mov [edi+STREAM.work_write], eax
		213	mov [edi+STREAM.work_count], 0
		214	add eax, 0x10000
		215	mov [edi+STREAM.work_top], eax
168	serge	216
227	serge	217	mov ebx, [CURRENT_TASK]
168	serge	218	shl ebx, 5
		219	mov eax, [0x3000+ebx+4]
		220
227	serge	221	mov [edi+STREAM.notify_task], eax
168	serge	222
227	serge	223	mov eax, [format]
		224	mov [edi+STREAM.format], eax
		225	mov [edi+STREAM.flags], SND_STOP
168	serge	226
		227	xor ebx, ebx
		228	cmp eax, 19
		229	jb @f
		230	mov ebx, 0x80808080
		231	@@:
		232	mov [edi+STREAM.r_silence], ebx
		233
227	serge	234	shl eax, 4
168	serge	235	mov ebx, [resampler_params+eax]
		236	mov ecx, [resampler_params+eax+4]
		237	mov edx, [resampler_params+eax+8]
		238
		239	mov [edi+STREAM.r_size],ebx
		240	mov [edi+STREAM.r_end], ecx
		241	mov [edi+STREAM.r_dt], edx
		242
227	serge	243	mov ebx, [resampler_params+eax+12]
		244	mov [edi+STREAM.resample], ebx
168	serge	245
285	serge	246	mov edx, [edi+STREAM.base]
		247	lea eax, [edx+0x9000]
		248	call GetPgAddr ;eax
		249	call FreePage ;eax
		250
		251	mov eax, edx
		252	lea ebx, [edx+0x9000]
		253	call GetPgAddr ;eax
		254	stdcall MapPage, ebx, eax, dword 3
		255
227	serge	256	mov edi, [edi+STREAM.base]
285	serge	257	mov ecx, (168*1024)/4
227	serge	258	xor eax, eax
		259	rep stosd
168	serge	260
227	serge	261	mov eax, [str]
		262	ret
168	serge	263	.fail:
227	serge	264	xor eax, eax
		265	ret
168	serge	266	endp
		267
		268	align 4
		269	pid_to_slot:
		270
227	serge	271	push ebx
		272	push ecx
		273	mov ebx,[TASK_COUNT]
		274	shl ebx,5
		275	mov ecx,2*32
168	serge	276	.loop:
227	serge	277	cmp byte [CURRENT_TASK+ecx+0xa],9
		278	jz .endloop ;skip empty slots
		279	cmp [CURRENT_TASK+ecx+0x4],eax ;check PID
		280	jz .pid_found
168	serge	281	.endloop:
227	serge	282	add ecx,32
		283	cmp ecx,ebx
		284	jle .loop
		285	pop ecx
		286	pop ebx
		287	xor eax,eax
		288	ret
168	serge	289
		290	.pid_found:
227	serge	291	shr ecx,5
		292	mov eax,ecx
		293	pop ecx
		294	pop ebx
		295	ret
168	serge	296
		297	align 4
		298	proc DestroyBuffer stdcall, str:dword
		299
		300	mov esi, [str]
		301
		302	cmp [esi+STREAM.magic], 'WAVE'
227	serge	303	jne .fail
168	serge	304
		305	cmp [esi+STREAM.size], STREAM_SIZE
227	serge	306	jne .fail
168	serge	307
188	serge	308	stdcall KernelFree, [esi+STREAM.base]
168	serge	309
		310	mov eax, [str]
227	serge	311	call free_stream
168	serge	312
		313	mov edi, [str]
		314	mov ecx, STREAM_SIZE/4
		315	xor eax, eax
		316	cld
		317	rep stosd
		318
		319	mov eax, [str]
		320	mov esi, stream_list
		321	mov ecx, 16
		322	@@:
		323	cmp [esi], eax
		324	je .remove
		325	add esi, 4
		326	dec ecx
		327	jnz @B
		328	xor eax, eax
227	serge	329	inc eax
		330	ret
168	serge	331	.remove:
		332	mov edi, esi
		333	add esi, 4
		334	cld
		335	rep movsd
		336	dec [stream_count]
		337	xor eax, eax
227	serge	338	inc eax
		339	ret
168	serge	340	.fail:
227	serge	341	xor eax, eax
		342	ret
168	serge	343	endp
		344
		345	align 4
		346	proc play_buffer stdcall, str:dword
		347
227	serge	348	mov ebx, [str]
		349	cmp [ebx+STREAM.magic], 'WAVE'
		350	jne .fail
168	serge	351
227	serge	352	cmp [ebx+STREAM.size], STREAM_SIZE
		353	jne .fail
168	serge	354
285	serge	355	mov edi,[ebx+STREAM.work_buff]
		356	mov [ebx+STREAM.work_read], edi
		357	mov [ebx+STREAM.work_write], edi
227	serge	358	mov [ebx+STREAM.work_count], 0
168	serge	359
285	serge	360	mov edx, [ebx+STREAM.base]
		361	add edx, 0x1000
		362	mov [ebx+STREAM.seg_0], edx
		363	mov [ebx+STREAM.curr_seg], edx
		364	add edx, 0x8000
		365	mov [ebx+STREAM.lim_0], edx
		366	add edx, 0x1000
		367	mov [ebx+STREAM.seg_1], edx
		368	add edx, 0x8000
		369	mov [ebx+STREAM.lim_1], edx
168	serge	370
285	serge	371	mov edx, [ebx+STREAM.seg_0]
		372	mov ecx, -128
168	serge	373	mov eax, [ebx+STREAM.r_silence]
		374	@@:
285	serge	375	mov [edx+ecx], eax
		376	add ecx, 4
227	serge	377	jnz @B
168	serge	378
285	serge	379	stdcall [ebx+STREAM.resample], edi, edx,\
227	serge	380	[ebx+STREAM.r_dt],[ebx+STREAM.r_size],[ebx+STREAM.r_end]
168	serge	381
227	serge	382	mov ebx, [str]
168	serge	383
285	serge	384	add [ebx+STREAM.work_count], eax
		385	add [ebx+STREAM.work_write], eax
168	serge	386
285	serge	387	mov edx, [ebx+STREAM.r_size]
		388	add [ebx+STREAM.curr_seg], edx
168	serge	389
285	serge	390	mov [ebx+STREAM.flags], SND_PLAY
168	serge	391
285	serge	392	mov eax, [ebx+STREAM.r_silence]
		393	mov edi, [ebx+STREAM.work_write]
		394	mov ecx, [ebx+STREAM.work_top]
		395	sub ecx, edi
		396	shr ecx, 2
		397	cld
		398	rep stosd
		399
227	serge	400	stdcall dev_play, [hSound]
		401	xor eax, eax
		402	inc eax
		403	ret
168	serge	404	.fail:
227	serge	405	xor eax, eax
		406	ret
168	serge	407	endp
		408
		409	align 4
		410	proc stop_buffer stdcall, str:dword
		411
227	serge	412	mov edi, [str]
168	serge	413
227	serge	414	cmp [edi+STREAM.magic], 'WAVE'
		415	jne .fail
168	serge	416
227	serge	417	cmp [edi+STREAM.size], STREAM_SIZE
		418	jne .fail
168	serge	419
227	serge	420	mov [edi+STREAM.flags], SND_STOP
168	serge	421
		422	; stdcall [ServiceHandler], [hSound], dword DEV_STOP, 0
		423
227	serge	424	xor eax, eax
		425	inc eax
		426	ret
168	serge	427	.fail:
227	serge	428	xor eax, eax
		429	ret
168	serge	430	endp
		431
		432	align 4
		433	proc set_buffer stdcall, str:dword,src:dword,offs:dword,size:dword
		434
227	serge	435	mov edx, [str]
		436	test edx, edx
		437	jz .fail
168	serge	438
227	serge	439	cmp [edx+STREAM.magic], 'WAVE'
		440	jne .fail
168	serge	441
227	serge	442	cmp [edx+STREAM.size], STREAM_SIZE
		443	jne .fail
168	serge	444
227	serge	445	mov esi,[src]
		446	test esi, esi
		447	jz .fail
168	serge	448
		449	cmp esi, new_app_base
		450	jb .fail
		451
285	serge	452	mov edi, [offs]
		453	mov ecx, 0x8000
168	serge	454
285	serge	455	sub ecx, edi
		456	jbe .seg_1
168	serge	457
285	serge	458	sub [size], ecx
168	serge	459	jb .fail
		460
285	serge	461	add edi, [edx+STREAM.base]
		462	add edi, 0x1000
		463	shr ecx, 2
		464	cld
		465	rep movsd
		466	jmp @F
		467	.seg_1:
		468	add edi, [edx+STREAM.base]
		469	add edi, 0x1000
		470	@@:
		471	add edi, 0x1000
		472	mov ecx, [size]
		473	test ecx, ecx
		474	jz .done
		475	cmp ecx, 0x8000
168	serge	476	ja .fail
		477
227	serge	478	shr ecx, 2
		479	rep movsd
285	serge	480	.done:
227	serge	481	xor eax, eax
		482	inc eax
		483	ret
168	serge	484	.fail:
227	serge	485	xor eax, eax
		486	ret
168	serge	487	endp
		488
		489	align 4
		490	proc alloc_stream
		491
227	serge	492	mov esi, stream_map
168	serge	493
227	serge	494	pushf
		495	cli
168	serge	496
227	serge	497	bsf eax, [esi]
		498	jnz .find
		499	popf
		500	xor eax, eax
		501	ret
		502	.find:
		503	btr [esi], eax
		504	popf
		505	mov ebx, STREAM_SIZE
		506	mul ebx
		507	add eax, stream
		508	ret
168	serge	509	endp
		510
		511	align 4
		512	proc free_stream
227	serge	513	sub eax, stream
168	serge	514	mov ebx, STREAM_SIZE
227	serge	515	xor edx, edx
		516	div ebx
168	serge	517
227	serge	518	and edx, edx
168	serge	519	jnz .err
		520
227	serge	521	bts [stream_map], eax
		522	ret
168	serge	523	.err:
		524	xor eax, eax
227	serge	525	ret
168	serge	526	endp
		527
		528	align 4
		529	proc prepare_playlist
		530
		531	.restart:
		532	xor ebx, ebx
227	serge	533	xor edx, edx
		534	mov [play_count], 0
		535	mov ecx, [stream_count]
168	serge	536	jcxz .exit
		537	.l1:
		538	mov esi, [stream_list+ebx]
		539	test esi, esi
		540	jz .next
		541
		542	cmp [esi+STREAM.magic], 'WAVE'
		543	jne .next
		544
		545	cmp [esi+STREAM.size], STREAM_SIZE
		546	jne .next
		547
		548	mov eax,[esi+STREAM.notify_task]
		549	cmp eax, -1
		550	je .fail
		551
		552	call pid_to_slot
		553	test eax, eax
		554	jz .fail
		555
		556	cmp [esi+STREAM.flags], SND_PLAY;
227	serge	557	jne .next
168	serge	558	cmp [esi+STREAM.work_count], 16384
		559	jb .next
		560
		561	mov [play_list+edx], esi
227	serge	562	inc [play_count]
		563	add edx, 4
168	serge	564	.next:
227	serge	565	add ebx, 4
		566	loop .l1
168	serge	567	.exit:
227	serge	568	ret
168	serge	569	.fail:
		570	stdcall DestroyBuffer, esi
		571	jmp .restart
		572	endp
		573
		574	align 4
		575	proc prepare_updatelist
		576
227	serge	577	xor ebx, ebx
		578	xor edx, edx
		579	mov [play_count], 0
		580	mov ecx, [stream_count]
168	serge	581	jcxz .exit
		582	.l1:
227	serge	583	mov eax, [stream_list+ebx]
168	serge	584	test eax, eax
		585	jz .next
227	serge	586	cmp [eax+STREAM.flags], SND_PLAY
		587	jne .next
168	serge	588
227	serge	589	mov [play_list+edx], eax
		590	inc [play_count]
		591	add edx, 4
168	serge	592	.next:
227	serge	593	add ebx, 4
		594	loop .l1
168	serge	595	.exit:
227	serge	596	ret
168	serge	597	endp
		598
		599	align 4
		600	proc set_handler stdcall, hsrv:dword, handler_proc:dword
		601	locals
		602	handler dd ?
		603	io_code dd ?
		604	input dd ?
		605	inp_size dd ?
		606	output dd ?
		607	out_size dd ?
		608	val dd ?
		609	endl
		610
		611	mov eax, [hsrv]
		612	lea ecx, [handler_proc]
		613	xor ebx, ebx
		614
		615	mov [handler], eax
		616	mov [io_code], DEV_CALLBACK
		617	mov [input], ecx
		618	mov [inp_size], 4
		619	mov [output], ebx
		620	mov [out_size], 0
		621
		622	lea eax, [handler]
188	serge	623	stdcall ServiceHandler, eax
168	serge	624	ret
		625	endp
		626
		627	align 4
		628	proc dev_play stdcall, hsrv:dword
		629	locals
		630	handle dd ?
		631	io_code dd ?
		632	input dd ?
		633	inp_size dd ?
		634	output dd ?
		635	out_size dd ?
		636	val dd ?
		637	endl
		638
		639	mov eax, [hsrv]
		640	xor ebx, ebx
		641
		642	mov [handle], eax
		643	mov [io_code], DEV_PLAY
		644	mov [input], ebx
		645	mov [inp_size], ebx
		646	mov [output], ebx
		647	mov [out_size], ebx
		648
		649	lea eax, [handle]
188	serge	650	stdcall ServiceHandler, eax
168	serge	651	ret
		652	endp
		653
		654	include 'mixer.asm'
		655
		656	align 16
		657	resampler_params:
		658	;r_size r_end r_dt resampler_func
		659	dd 0,0,0,0 ; 0 PCM_ALL
		660	dd 16384, 0, 0, copy_stream ; 1 PCM_2_16_48
		661	dd 16384, 0, 0, m16_stereo ; 2 PCM_1_16_48
		662
		663	dd 16384, 0x08000000, 30109, resample_2 ; 3 PCM_2_16_44
		664	dd 8192, 0x08000000, 30109, resample_1 ; 4 PCM_1_16_44
		665
		666	dd 16384, 0x08000000, 21846, resample_2 ; 5 PCM_2_16_32
		667	dd 8192, 0x08000000, 21846, resample_1 ; 6 PCM_1_16_32
		668
		669	dd 16384, 0x08000000, 16384, resample_2 ; 7 PCM_2_16_24
		670	dd 8192, 0x08000000, 16384, resample_1 ; 8 PCM_1_16_24
		671
		672	dd 8192, 0x04000000, 15052, resample_2 ; 9 PCM_2_16_22
		673	dd 4096, 0x04000000, 15052, resample_1 ;10 PCM_1_16_22
		674
		675	dd 8192, 0x04000000, 10923, resample_2 ;11 PCM_2_16_16
		676	dd 4096, 0x04000000, 10923, resample_1 ;12 PCM_1_16_16
		677
		678	dd 8192, 0x04000000, 8192, resample_2 ;13 PCM_2_16_12
		679	dd 4096, 0x04000000, 8192, resample_1 ;14 PCM_1_16_12
		680
		681	dd 4096, 0x02000000, 7527, resample_2 ;15 PCM_2_16_11
		682	dd 2048, 0x02000000, 7527, resample_1 ;16 PCM_1_16_11
		683
		684	dd 4096, 0x02000000, 5462, resample_2 ;17 PCM_2_16_8
		685	dd 2048, 0x02000000, 5462, resample_1 ;18 PCM_1_16_8
		686
		687	dd 16384, 0, 0, s8_stereo ;19 PCM_2_8_48
		688	dd 8192, 0, 0, m8_stereo ;20 PCM_1_8_48
		689
		690	dd 8192, 0x08000000, 30109, resample_28 ;21 PCM_2_8_44
		691	dd 4096, 0x08000000, 30109, resample_18 ;22 PCM_1_8_44
		692
		693	dd 8192, 0x08000000, 21846, resample_28 ;23 PCM_2_8_32
		694	dd 4096, 0x08000000, 21846, resample_18 ;24 PCM_1_8_32
		695
		696	dd 8192, 0x08000000, 16384, resample_28 ;25 PCM_2_8_24
		697	dd 4096, 0x08000000, 16384, resample_18 ;26 PCM_1_8_24
		698
		699	dd 4096, 0x04000000, 15052, resample_28 ;27 PCM_2_8_22
		700	dd 2048, 0x04000000, 15052, resample_18 ;28 PCM_1_8_22
		701
		702	dd 4096, 0x04000000, 10923, resample_28 ;29 PCM_2_8_16
		703	dd 2048, 0x04000000, 10923, resample_18 ;30 PCM_1_8_16
		704
		705	dd 4096, 0x04000000, 8192, resample_28 ;31 PCM_2_8_12
		706	dd 2048, 0x04000000, 8192, resample_18 ;32 PCM_1_8_12
		707
		708	dd 2048, 0x02000000, 7527, resample_28 ;33 PCM_2_8_11
		709	dd 1024, 0x02000000, 7527, resample_18 ;34 PCM_1_8_11
		710
		711	dd 2048, 0x02000000, 5462, resample_28 ;35 PCM_2_8_8
		712	dd 1024, 0x02000000, 5462, resample_18 ;36 PCM_1_8_8
		713
281	serge	714	m7 dw 0x8000,0x8000,0x8000,0x8000
		715	mm80 dq 0x8080808080808080
		716	mm_mask dq 0xFF00FF00FF00FF00
168	serge	717
281	serge	718	stream_map dd 0xFFFF ; 16
285	serge	719	version dd 0x00030003
168	serge	720
281	serge	721	szInfinity db 'INFINITY',0
		722	szSound db 'SOUND',0
168	serge	723
		724	if DEBUG
281	serge	725	msgFail db 'Sound service not loaded',13,10,0
		726	msgPlay db 'Play buffer',13,10,0
		727	msgStop db 'Stop',13,10,0
		728	msgUser db 'User callback',13,10,0
		729	msgMem db 'Not enough memory',13,10,0
168	serge	730	end if
188	serge	731
		732	section '.data' data readable writable align 16
		733
281	serge	734	stream rb STREAM_SIZE*16
188	serge	735
281	serge	736	play_list rd 16
		737	mix_input rd 16
188	serge	738
281	serge	739	stream_list rd 17
		740	play_count rd 1
		741	stream_count rd 1
		742	hSound rd 1
		743	mix_buff rd 1
		744	mix_buff_map rd 1
188	serge	745

Subversion Repositories Kolibri OS

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