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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2006-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; Serge 2006-2008
; email: infinity_sound@mail.ru
 
format MS COFF
 
DEBUG             equ 1
 
 
include 'proc32.inc'
include 'main.inc'
include 'imports.inc'
 
 
CURRENT_API     equ   0x0101      ;1.01
COMPATIBLE_API  equ   0x0100      ;1.00
 
API_VERSION     equ   (COMPATIBLE_API shl 16) or CURRENT_API
SOUND_VERSION   equ   CURRENT_API
 
 
 
 
 
 
 
 
 
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
 
USE_SSE2_MIXER    equ 0  ;floating point mixer. Disabled by default
 
 
 
 
OS_BASE           equ 0x80000000
 
CAPS_SSE2         equ 26
PG_SW             equ 0x003
 
public START
public service_proc
public version
 
RT_INP_EMPTY      equ 0xFF000001
RT_OUT_EMPTY      equ 0xFF000002
RT_INP_FULL       equ 0xFF000003
RT_OUT_FULL       equ 0xFF000004
 
EVENT_WATCHED     equ 0x10000000
EVENT_SIGNALED    equ 0x20000000
MANUAL_RESET      equ 0x40000000
MANUAL_DESTROY    equ 0x80000000
 
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 0
 
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
 
end if
           stdcall set_handler, [hSound], new_mix
           mov [eng_state], SND_STOP
           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, SRV_GETVERSION
           jne @F
           mov eax, [edi+output]
           cmp [edi+out_size], 4
           jne .fail
           mov eax, [eax]
           mov [eax], dword API_VERSION
           xor eax, eax
           ret
@@:
           cmp eax, SND_CREATE_BUFF
           jne @F
           mov ebx, [edi+input]
           stdcall CreateBuffer,[ebx],[ebx+4]
           mov edi, [ioctl]
           mov ecx, [edi+output]
           mov ecx, [ecx]
           mov [ecx], ebx
           ret
@@:
           mov ebx, [edi+input]
           mov edx, [ebx]
 
           cmp [edx+STREAM.magic], 'WAVE'
           jne .fail
 
           cmp [edx+STREAM.size], STREAM_SIZE
           jne .fail
 
           cmp eax, SND_DESTROY_BUFF
           jne @F
           mov eax, edx
           call DestroyBuffer    ;edx= stream
           ret
@@:
           cmp eax, SND_SETFORMAT
           jne @F
           stdcall SetFormat,edx,[ebx+4]
           ret
@@:
           cmp eax, SND_GETFORMAT
           jne @F
 
           movzx eax, word [edx+STREAM.format]
           mov ecx, [edi+output]
           mov ecx, [ecx]
           mov [ecx], eax
           xor eax, eax
           ret
@@:
           cmp eax, SND_RESET
           jne @F
           stdcall ResetBuffer,edx,[ebx+4]
           ret
@@:
           cmp eax, SND_SETPOS
           jne @F
           stdcall SetBufferPos,edx,[ebx+4]
           ret
@@:
           cmp eax, SND_GETPOS
           jne @F
           stdcall GetBufferPos, edx
           mov edi, [ioctl]
           mov ecx, [edi+output]
           mov ecx, [ecx]
           mov [ecx], ebx
           ret
@@:
           cmp eax, SND_SETBUFF
           jne @F
           mov eax, [ebx+4]
           stdcall set_buffer, edx,eax,[ebx+8],[ebx+12]
           ret
@@:
           cmp eax, SND_SETVOLUME
           jne @F
           stdcall SetBufferVol,edx,[ebx+4],[ebx+8]
           ret
@@:
           cmp eax, SND_GETVOLUME
           jne @F
 
           mov eax, [edi+output]
           mov ecx, [eax]
           mov eax, [eax+4]
           stdcall GetBufferVol,edx,ecx,eax
           ret
@@:
           cmp eax, SND_SETPAN
           jne @F
           stdcall SetBufferPan,edx,[ebx+4]
           ret
@@:
           cmp eax, SND_GETPAN
           jne @F
           mov eax, [edx+STREAM.pan]
           mov ebx, [edi+output]
           mov ebx, [ebx]
           mov [ebx], eax
           xor eax, eax
           ret
@@:
           cmp eax, SND_OUT
           jne @F
 
           mov eax, [ebx+4]
           stdcall wave_out, edx,eax,[ebx+8]
           ret
@@:
           cmp eax, SND_PLAY
           jne @F
 
           stdcall play_buffer, edx,[ebx+4]
           ret
@@:
           cmp eax, SND_STOP
           jne @F
 
           stdcall stop_buffer, edx
           ret
@@:
           cmp eax, SND_GETBUFFSIZE
           jne @F
           mov eax, [edx+STREAM.in_size]
           mov ecx, [edi+output]
           mov ecx, [ecx]
           mov [ecx], eax
           xor eax, eax
           ret
@@:
           cmp eax, SND_GETFREESPACE
           jne @F
 
           test [edx+STREAM.format], PCM_OUT
           jz .fail
 
           mov ebx, [edx+STREAM.in_free]
           mov ecx, [edi+output]
           mov [ecx], ebx
           xor eax, eax
           ret
@@:
.fail:
           or eax, -1
           ret
endp
 
restore   handle
restore   io_code
restore   input
restore   inp_size
restore   output
restore   out_size
 
align 4
proc CreateBuffer stdcall, format:dword, size:dword
           locals
             str         dd ?
             ring_size   dd ?
             ring_pages  dd ?
           endl
 
           mov eax, [format]
           cmp ax, PCM_1_8_8
           ja .fail
 
           test eax, PCM_OUT
           jnz .test_out
           test eax, PCM_RING
           jnz .test_ring
;staic
           test eax, PCM_STATIC
           jz .test_out                   ;use PCM_OUT as default format
           jmp .test_ok
.test_out:
           test eax, PCM_RING+PCM_STATIC
           jnz .fail
           or [format], PCM_OUT           ;force set
           jmp .test_ok
.test_ring:
           test eax, PCM_OUT+PCM_STATIC
           jnz .fail
.test_ok:
 
           call GetPid
           mov ebx, eax
           mov eax, STREAM_SIZE
 
           call CreateObject
           test eax, eax
           jz .fail
           mov [str], eax
 
           mov ebx, [format]
           mov [eax+STREAM.format], ebx
 
           xor ecx, ecx
           movzx ebx, bx
           cmp ebx, 19
           jb @f
           mov ecx, 0x80808080
@@:
           mov [eax+STREAM.r_silence], ecx
 
           shl ebx, 2
           lea ebx, [ebx+ebx*2]     ;ebx*=12
 
           mov ecx, [resampler_params+ebx]
           mov edx, [resampler_params+ebx+4]
           mov esi, [resampler_params+ebx+8]
 
           mov [eax+STREAM.r_size],ecx
           mov [eax+STREAM.r_dt],  edx
           mov [eax+STREAM.resample], esi
           xor ecx, ecx
           mov [eax+STREAM.l_vol], ecx
           mov [eax+STREAM.r_vol], ecx
           mov dword [eax+STREAM.l_amp], 0x7FFF7FFF
           mov [eax+STREAM.pan], ecx
 
           test [format], PCM_STATIC
           jnz .static
 
; ring and waveout
 
           mov ebx, 0x10000
           test [format], PCM_RING
           jz .waveout
 
           mov ebx, [eax+STREAM.r_size]
           add ebx, 4095
           and ebx, -4096
           add ebx, ebx
.waveout:
           mov [ring_size], ebx
           mov eax, ebx
           shr ebx, 12
           mov [ring_pages], ebx
 
           stdcall CreateRingBuffer, eax, PG_SW
 
           mov edi, [str]
           mov ecx, [ring_size]
           mov [edi+STREAM.in_base], eax
           mov [edi+STREAM.in_size], ecx
           add eax, 128
        ;   sub ecx, 128
           mov [edi+STREAM.in_wp], eax
           mov [edi+STREAM.in_rp], eax
           mov [edi+STREAM.in_count], 0
 
           mov [edi+STREAM.in_free], ecx
           add eax, ecx
           mov [edi+STREAM.in_top], eax
 
           jmp .out_buff
.static:
           mov ecx, [size]
           add ecx, 128          ;resampler required
           mov [eax+STREAM.in_size], ecx
           stdcall KernelAlloc, ecx
 
           mov edi, [str]
           mov [edi+STREAM.in_base], eax
           add eax, 128
           mov [edi+STREAM.in_wp], eax
           mov [edi+STREAM.in_rp], eax
           mov ebx, [size]
           mov [edi+STREAM.in_count], ebx
           mov [edi+STREAM.in_free], ebx
           add eax, ebx
           mov [edi+STREAM.in_top], eax
 
.out_buff:
           stdcall AllocKernelSpace, dword 128*1024
 
           mov edi, [str]
           mov [edi+STREAM.out_base], eax
           mov [edi+STREAM.out_wp], eax
           mov [edi+STREAM.out_rp], eax
           mov [edi+STREAM.out_count], 0
           add eax, 64*1024
           mov [edi+STREAM.out_top], eax
 
           stdcall AllocPages, dword 64/4
           mov edi, [str]
           mov ebx, [edi+STREAM.out_base]
           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 ecx, [edi+STREAM.in_top]
           mov edi, [edi+STREAM.in_base]
           sub ecx, edi
           xor eax, eax
           shr ecx, 2
           cld
           rep stosd
 
           mov edi, [str]
           mov edi, [edi+STREAM.out_base]
           mov ecx, (64*1024)/4
           rep stosd
 
           xor edx, edx
           mov ebx, MANUAL_DESTROY
           call CreateEvent
 
           mov ebx, [str]
           mov [ebx+STREAM.notify_event], eax
           mov [ebx+STREAM.notify_id], edx
 
           mov [ebx+STREAM.magic], 'WAVE'
           mov [ebx+STREAM.destroy], DestroyBuffer.destroy
           mov [ebx+STREAM.size], STREAM_SIZE
           mov [ebx+STREAM.flags], SND_STOP
 
           pushf
           cli
           mov eax, str.fd-FD_OFFSET
           mov edx, [eax+STREAM.str_fd]
           mov [ebx+STREAM.str_fd], edx
           mov [ebx+STREAM.str_bk], eax
           mov [eax+STREAM.str_fd], ebx
           mov [edx+STREAM.str_bk], ebx
           popf
 
           xor eax, eax
           ret
.fail:
           xor ebx, ebx
           or eax, -1
           ret
endp
 
;param
; eax= buffer handle
 
align 4
DestroyBuffer:
           .handle  equ esp       ;local
 
           mov [eax+STREAM.flags], SND_STOP
.destroy:
           push eax
 
           pushfd
           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.in_base]
           mov eax, [.handle]
           stdcall KernelFree, [eax+STREAM.out_base]
 
           pop eax               ;restore stack
           call DestroyObject    ;eax= stream
           xor eax, eax
           ret
.fail:
           or eax, -1
           ret
restore .handle
 
align 4
proc SetFormat stdcall, str:dword, format:dword
 
           cmp word [format], PCM_1_8_8
           ja .fail
 
           mov edx, [str]
           mov [edx+STREAM.flags], SND_STOP
 
           test [edx+STREAM.format], PCM_RING
           jnz .fail
 
;           mov eax,[edx+STREAM.out_base]
;           mov [edx+STREAM.out_wp], eax
;           mov [edx+STREAM.out_rp], eax
;           mov [edx+STREAM.out_count], 0
 
           movzx eax, word [format]
           mov word [edx+STREAM.format], ax
 
           xor ebx, ebx
           cmp eax, 19
           jb @f
           mov ebx, 0x80808080
@@:
           mov [edx+STREAM.r_silence], ebx
 
           shl eax, 2
           lea eax, [eax+eax*2]     ;eax*=12
 
           mov edi, [resampler_params+eax]
           mov ecx, [resampler_params+eax+4]
           mov ebx, [resampler_params+eax+8]
 
           mov [edx+STREAM.r_size],edi
           mov [edx+STREAM.r_dt],  ecx
           mov [edx+STREAM.resample], ebx
 
           mov edi, [edx+STREAM.in_base]
           mov ecx, 128/4
           mov eax, [edx+STREAM.r_silence]
           cld
           rep stosd
           xor eax, eax
           ret
.fail:
           or eax, -1
           ret
endp
 
; for static buffers only
; use waveout for streams
 
align 4
proc set_buffer stdcall, str:dword,src:dword,offs:dword,size:dword
 
           mov edx, [str]
           test [edx+STREAM.format], PCM_OUT
           jnz .fail
 
           mov esi, [src]
           mov edi, [offs]
           add edi, [edx+STREAM.in_base]
           add edi, 128
 
           cmp edi, [edx+STREAM.in_top]
           jae .fail
 
           mov ecx, [size]
           lea ebx, [ecx+edi]
           sub ebx, [edx+STREAM.in_top]
           jb @F
           sub ecx, ebx
@@:
           shr ecx, 2
           cld
           rep movsd
           xor eax,eax
           ret
.fail:
           or eax, -1
           ret
endp
 
; for stream buffers only
 
align 4
proc wave_out stdcall, str:dword,src:dword,size:dword
           locals
             state_saved  dd ?
             fpu_state    rb 528
           endl
 
           mov edx, [str]
           mov eax, [edx+STREAM.format]
           test eax, PCM_OUT
           jz .fail
 
           cmp ax, PCM_ALL
           je .fail
 
           mov esi,[src]
           test esi, esi
           jz .fail
 
           cmp esi, OS_BASE
           jae .fail
 
           mov [state_saved], 0
 
.main_loop:
           mov edx, [str]
 
           mov ebx, [size]
           test ebx, ebx
           jz .done
 
           cmp [edx+STREAM.flags], SND_STOP
           jne .fill
 
           mov edi, [edx+STREAM.in_base]
           mov ecx, 128/4
           mov eax, [edx+STREAM.r_silence]
           cld
           rep stosd
 
           mov ecx, [edx+STREAM.in_size]
           sub ecx, 128
           mov [edx+STREAM.in_wp], edi
           mov [edx+STREAM.in_rp], edi
           mov [edx+STREAM.in_count], 0
           mov [edx+STREAM.in_free], ecx
 
           mov eax,[edx+STREAM.out_base]
           mov [edx+STREAM.out_wp], eax
           mov [edx+STREAM.out_rp], eax
           mov [edx+STREAM.out_count], 0
.fill:
           mov ecx, [edx+STREAM.in_free]
           test ecx, ecx
           jz .wait
 
           cmp ecx, ebx
           jbe @F
 
           mov ecx, ebx
@@:
           sub [size], ecx
           add [edx+STREAM.in_count], ecx
           sub [edx+STREAM.in_free], ecx
 
           shr ecx, 2
           mov edi, [edx+STREAM.in_wp]
           mov esi, [src]
           cld
           rep movsd
 
           mov [src], esi
           cmp edi, [edx+STREAM.in_top]
           jb @F
           sub edi, [edx+STREAM.in_size]
@@:
           mov [edx+STREAM.in_wp], edi
 
           cmp [edx+STREAM.out_count], 32768
           jae .skip
 
           cmp [state_saved], 0
           jne @F
           lea eax, [fpu_state+15]
           and eax, -16
           call FpuSave
           mov [state_saved], 1
@@:
           stdcall refill, edx
.skip:
           mov edx, [str]
           mov [edx+STREAM.flags], SND_PLAY
           cmp [eng_state], SND_PLAY
           je .main_loop
 
           stdcall dev_play, [hSound]
           mov [eng_state], SND_PLAY
           jmp .main_loop
.wait:
           mov edx, [str]
           mov eax, [edx+STREAM.notify_event]
           mov ebx, [edx+STREAM.notify_id]
           call WaitEvent   ;eax ebx
           jmp .main_loop
.done:
           cmp [state_saved], 1
           jne @F
 
           lea eax, [fpu_state+15]
           and eax, -16
           call FpuRestore
@@:
           xor eax, eax
           ret
.fail:
           or eax, -1
           ret
endp
 
; both static and stream
; reset all but not clear buffers
 
 
; flags reserved
;  RESET_INPUT  equ 1   ;reserved reset and clear input buffer
;  RESET_OUTPUT equ 2   ;reserved reset and clear output buffer
;  RESET_ALL    equ 3
 
 
align 4
proc ResetBuffer stdcall, str:dword, flags:dword
 
           mov edx, [str]
           mov [edx+STREAM.flags], SND_STOP
 
           mov edi, [edx+STREAM.in_base]
           mov ecx, 128/4
           mov eax, [edx+STREAM.r_silence]
           cld
           rep stosd
 
           mov [edx+STREAM.in_wp], edi
           mov [edx+STREAM.in_rp], edi
 
           test [edx+STREAM.flags], PCM_STATIC
           jnz .static
           mov [edx+STREAM.in_count], 0
           jmp @F
.static:
           mov eax, [edx+STREAM.in_size]
           mov [edx+STREAM.in_count], eax
@@:
 
           mov eax, [edx+STREAM.in_size]
           sub eax, 128
           mov [edx+STREAM.in_free], eax
 
           xor eax, eax
           mov ebx,[edx+STREAM.out_base]
           mov [edx+STREAM.out_wp], ebx
           mov [edx+STREAM.out_rp], ebx
           mov [edx+STREAM.out_count], eax
           ret
.fail:
           or eax, -1
           ret
endp
 
; for static buffers only
 
align 4
proc SetBufferPos stdcall, str:dword, pos:dword
 
           mov edx, [str]
           test [edx+STREAM.format], PCM_STATIC
           jz .fail
 
           mov [edx+STREAM.flags], SND_STOP
 
           mov eax, [pos]
           add eax, [edx+STREAM.in_base]
           mov ebx, [edx+STREAM.in_top]
           add eax, 128
 
           cmp eax, ebx
           jae .fail
 
           mov [edx+STREAM.in_rp], eax
           sub ebx, eax
           mov [edx+STREAM.in_count], ebx
           xor eax, eax
           ret
.fail:
           or eax, -1
           ret
endp
 
align 4
proc GetBufferPos stdcall, str:dword
 
           mov edx, [str]
           test [edx+STREAM.format], PCM_STATIC
           jz .fail
 
           mov ebx, [edx+STREAM.in_rp]
           sub ebx, [edx+STREAM.in_base]
           sub ebx, 128
           xor eax, eax
           ret
.fail:
           xor ebx,ebx
           or eax, -1
           ret
endp
 
; both
 
align 4
proc SetBufferVol stdcall, str:dword,l_vol:dword,r_vol:dword
 
           mov edx, [str]
           stdcall set_vol_param,[l_vol],[r_vol],[edx+STREAM.pan]
           ret
endp
 
proc set_vol_param stdcall, l_vol:dword,r_vol:dword,pan:dword
           locals
             _600    dd ?
             _32767  dd ?
             state   rb 108
           endl
 
           mov [_600], 0x44160000   ;600.0
           mov [_32767], 32767
 
           lea ebx, [state]
           fnsave [ebx]
 
           movq mm0, qword [l_vol]
           pminsw mm0, qword [vol_max]
           pmaxsw mm0, qword [vol_min]
           movq qword [l_vol], mm0
           movq qword [edx+STREAM.l_vol], mm0
 
           movd mm1,[pan]
           pminsw mm1, qword [pan_max]
           pmaxsw mm1, qword [vol_min]
           movd [edx+STREAM.pan], mm1
 
           cmp word [edx+STREAM.pan], 0
           jl @F
 
           psubsw mm0,mm1
           pminsw mm0, qword [vol_max]
           pmaxsw mm0, qword [vol_min]
           movd [l_vol],mm0
           jmp .calc_amp
@@:
           punpckhdq mm0,mm0
           paddsw mm0,mm1
           pminsw mm0, qword [vol_max]
           pmaxsw mm0, qword [vol_min]
           movd [r_vol], mm0
.calc_amp:
           emms
           fild word [l_vol]
 
           call .calc
 
           fistp word [edx+STREAM.l_amp]
           fstp dword [edx+STREAM.l_amp_f]
           fstp st0
 
           fild word [r_vol]
 
           call .calc
 
           fistp word [edx+STREAM.r_amp]
           fstp dword [edx+STREAM.r_amp_f]
           fstp st0
 
           fnclex
           lea ebx, [state]
           frstor [ebx]
 
           xor eax, eax
           inc eax
           ret
.calc:
           fdiv dword [_600]
           fld st0
           frndint
           fxch st1
           fsub st, st1
           f2xm1
           fld1
           faddp st1, st0
           fscale
           fld st0
           fimul dword [_32767]
           ret 0
endp
 
align 4
proc GetBufferVol stdcall, str:dword,p_lvol:dword,p_rvol:dword
 
           mov edx, [str]
           mov eax, [p_lvol]
           movsx ecx, word [edx+STREAM.l_vol]
           mov [eax], ecx
 
           mov eax, [p_rvol]
           movsx ecx, word [edx+STREAM.r_vol]
           mov [eax], ecx
           xor eax, eax
           ret
endp
 
align 4
proc SetBufferPan stdcall, str:dword,pan:dword
 
           mov edx, [str]
           stdcall set_vol_param,[edx+STREAM.l_vol],\
                                 [edx+STREAM.r_vol],[pan]
           ret
endp
 
; for static and ring buffers only
 
align 4
proc play_buffer stdcall, str:dword, flags:dword
 
           mov ebx, [str]
           mov eax, [ebx+STREAM.format]
           test eax, PCM_OUT
           jnz .fail
 
           cmp ax, PCM_ALL
           je .fail
 
           mov [ebx+STREAM.flags], SND_PLAY
           cmp [eng_state], SND_PLAY
           je .done
 
           stdcall  dev_play, [hSound]
           mov [eng_state], SND_PLAY
.done:
           test [flags], PLAY_SYNC
           jz @F
 
           mov edx, [str]
.wait:
           mov eax, [edx+STREAM.notify_event]
           mov ebx, [edx+STREAM.notify_id]
           call WaitEvent   ;eax ebx
 
           mov edx, [str]
           cmp [edx+STREAM.flags], SND_STOP
           jne .wait
@@:
           xor eax, eax
           ret
.fail:
           or eax, -1
           ret
endp
 
; for static and ring buffers only
 
align 4
proc stop_buffer stdcall, str:dword
 
           mov edx, [str]
           test [edx+STREAM.format], PCM_STATIC+PCM_RING
           jz .fail
 
           mov [edx+STREAM.flags], SND_STOP
 
;           stdcall [ServiceHandler], [hSound], dword DEV_STOP, 0
 
           mov eax, [edx+STREAM.notify_event]
           mov ebx, [edx+STREAM.notify_id]
           call ClearEvent   ;eax ebx
 
           xor eax, eax
           ret
.fail:
           or eax, -1
           ret
endp
 
; param
;  eax= mix_list
 
align 4
do_mix_list:
 
           xor edx, edx
           mov esi, str.fd-FD_OFFSET
           mov ebx, [esi+STREAM.str_fd]
@@:
           cmp ebx, esi
           je .done
 
           cmp [ebx+STREAM.magic], 'WAVE'
           jne .next
 
           cmp [ebx+STREAM.size], STREAM_SIZE
           jne .next
 
           cmp [ebx+STREAM.flags], SND_PLAY;
           jne .next
 
           mov ecx, [ebx+STREAM.out_count]
           test ecx, ecx
           jnz .l1
 
           test [ebx+STREAM.format], PCM_RING
           jnz .next
           mov [ebx+STREAM.flags], SND_STOP
           jmp .next
.l1:
           cmp ecx, 512
           jae .add_buff
 
           mov edi, [ebx+STREAM.out_rp]
           add edi, ecx
           sub ecx, 512
           neg ecx
           push eax
           xor eax, eax
           cld
           rep stosb
           pop eax
 
           mov [ebx+STREAM.out_count], 512
 
.add_buff:
           mov ecx, [ebx+STREAM.out_rp]
           mov [eax],ecx
 
if USE_SSE2_MIXER
           mov edi, dword [ebx+STREAM.l_amp_f]
           mov [eax+4], edi
           mov edi, dword [ebx+STREAM.r_amp_f]
           mov [eax+8], edi
else
           mov edi, dword [ebx+STREAM.l_amp]
           mov [eax+4], edi
end if
           add [ebx+STREAM.out_rp], 512
           sub [ebx+STREAM.out_count], 512
 
           add eax, 12
           inc edx
.next:
           mov ebx, [ebx+STREAM.str_fd]
           jmp @B
.done:
           mov eax, edx
           ret
 
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
 
           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
 
if 0
align 4
dword2str:
      mov  esi, hex_buff
      mov ecx, -8
@@:
      rol eax, 4
      mov ebx, eax
      and ebx, 0x0F
      mov bl, [ebx+hexletters]
      mov [8+esi+ecx], bl
      inc ecx
      jnz @B
      ret
 
hexletters   db '0123456789ABCDEF'
hex_buff     db 8 dup(0),13,10,0
 
end if
 
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_dt   resampler_func
     dd 0,0,0                                  ; 0  PCM_ALL
     dd 16384,      0, copy_stream    ; 1  PCM_2_16_48
     dd  8192,      0, m16_stereo     ; 2  PCM_1_16_48
 
     dd 16384,  30109, resample_2     ; 3  PCM_2_16_44
     dd  8192,  30109, resample_1     ; 4  PCM_1_16_44
 
     dd 16384,  21846, resample_2     ; 5  PCM_2_16_32
     dd  8192,  21846, resample_1     ; 6  PCM_1_16_32
 
     dd 16384,  16384, resample_2     ; 7  PCM_2_16_24
     dd  8192,  16384, resample_1     ; 8  PCM_1_16_24
 
     dd  8192,  15052, resample_2     ; 9  PCM_2_16_22
     dd  4096,  15052, resample_1     ;10  PCM_1_16_22
 
     dd  8192,  10923, resample_2     ;11  PCM_2_16_16
     dd  4096,  10923, resample_1     ;12  PCM_1_16_16
 
     dd  8192,   8192, resample_2     ;13  PCM_2_16_12
     dd  4096,   8192, resample_1     ;14  PCM_1_16_12
 
     dd  4096,   7527, resample_2     ;15  PCM_2_16_11
     dd  2048,   7527, resample_1     ;16  PCM_1_16_11
 
     dd  4096,   5462, resample_2     ;17  PCM_2_16_8
     dd  2048,   5462, resample_1     ;18  PCM_1_16_8
 
     dd 16384,      0, s8_stereo      ;19  PCM_2_8_48
     dd  8192,      0, m8_stereo      ;20  PCM_1_8_48
 
     dd  8192,  30109, resample_28    ;21  PCM_2_8_44
     dd  4096,  30109, resample_18    ;22  PCM_1_8_44
 
     dd  8192,  21846, resample_28    ;23  PCM_2_8_32
     dd  4096,  21846, resample_18    ;24  PCM_1_8_32
 
     dd  8192,  16384, resample_28    ;25  PCM_2_8_24
     dd  4096,  16384, resample_18    ;26  PCM_1_8_24
 
     dd  4096,  15052, resample_28    ;27  PCM_2_8_22
     dd  2048,  15052, resample_18    ;28  PCM_1_8_22
 
     dd  4096,  10923, resample_28    ;29  PCM_2_8_16
     dd  2048,  10923, resample_18    ;30  PCM_1_8_16
 
     dd  4096,   8192, resample_28    ;31  PCM_2_8_12
     dd  2048,   8192, resample_18    ;32  PCM_1_8_12
 
     dd  2048,   7527, resample_28    ;33  PCM_2_8_11
     dd  1024,   7527, resample_18    ;34  PCM_1_8_11
 
     dd  2048,   5462, resample_28    ;35  PCM_2_8_8
     dd  1024,   5462, resample_18    ;36  PCM_1_8_8
 
m7            dw 0x8000,0x8000,0x8000,0x8000
mm80          dq 0x8080808080808080
mm_mask       dq 0xFF00FF00FF00FF00
 
vol_max       dd 0x00000000,0x00000000
vol_min       dd 0x0000D8F0,0x0000D8F0
pan_max       dd 0x00002710,0x00002710
 
;stream_map    dd 0xFFFF       ; 16
version       dd (5 shl 16) or SOUND_VERSION
 
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
msgWaveout    db 'Play waveout', 13,10,0
msgSetVolume  db 'Set volume',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
eng_state     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 695	Rev 802
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2006-2008. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2006-2008. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	; Serge 2006-2008	8	; Serge 2006-2008
9	; email: infinity_sound@mail.ru	9	; email: infinity_sound@mail.ru
10		10
11	format MS COFF	11	format MS COFF
-		12
-		13	DEBUG equ 1
-		14
-		15
-		16	include 'proc32.inc'
-		17	include 'main.inc'
-		18	include 'imports.inc'
12		19
13		20
14	CURRENT_API equ 0x0101 ;1.01	21	CURRENT_API equ 0x0101 ;1.01
15	COMPATIBLE_API equ 0x0100 ;1.00	22	COMPATIBLE_API equ 0x0100 ;1.00
16		23
17	API_VERSION equ (COMPATIBLE_API shl 16) or CURRENT_API	24	API_VERSION equ (COMPATIBLE_API shl 16) or CURRENT_API
18	SOUND_VERSION equ CURRENT_API	25	SOUND_VERSION equ CURRENT_API
19		26
20		-
21	include 'proc32.inc'	-
22		-
23	;include 'system.inc'	-
24	include 'main.inc'	-
25		-
26	include 'imports.inc'	-
27		27
28	FORCE_MMX equ 0 ;set to 1 to force use mmx or	28	FORCE_MMX equ 0 ;set to 1 to force use mmx or
29	FORCE_MMX_128 equ 0 ;integer sse2 extensions	29	FORCE_MMX_128 equ 0 ;integer sse2 extensions
30	;and reduce driver size	30	;and reduce driver size
31		31
32	;USE_SSE equ 0	32	;USE_SSE equ 0
33		33
34	USE_SSE2_MIXER equ 0 ;floating point mixer. Disabled by default	34	USE_SSE2_MIXER equ 0 ;floating point mixer. Disabled by default
35		-
36	DEBUG equ 1	-
37		-
38		35
39	OS_BASE equ 0x80000000	36	OS_BASE equ 0x80000000
40		37
41	CAPS_SSE2 equ 26	38	CAPS_SSE2 equ 26
42	PG_SW equ 0x003	39	PG_SW equ 0x003
43		40
44	public START	41	public START
45	public service_proc	42	public service_proc
46	public version	43	public version
47		44
48	RT_INP_EMPTY equ 0xFF000001	45	RT_INP_EMPTY equ 0xFF000001
49	RT_OUT_EMPTY equ 0xFF000002	46	RT_OUT_EMPTY equ 0xFF000002
50	RT_INP_FULL equ 0xFF000003	47	RT_INP_FULL equ 0xFF000003
51	RT_OUT_FULL equ 0xFF000004	48	RT_OUT_FULL equ 0xFF000004
52		49
53	EVENT_WATCHED equ 0x10000000	50	EVENT_WATCHED equ 0x10000000
54	EVENT_SIGNALED equ 0x20000000	51	EVENT_SIGNALED equ 0x20000000
55	MANUAL_RESET equ 0x40000000	52	MANUAL_RESET equ 0x40000000
56	MANUAL_DESTROY equ 0x80000000	53	MANUAL_DESTROY equ 0x80000000
57		54
58	DEV_PLAY equ 1	55	DEV_PLAY equ 1
59	DEV_STOP equ 2	56	DEV_STOP equ 2
60	DEV_CALLBACK equ 3	57	DEV_CALLBACK equ 3
61		58
62	struc IOCTL	59	struc IOCTL
63	{ .handle dd ?	60	{ .handle dd ?
64	.io_code dd ?	61	.io_code dd ?
65	.input dd ?	62	.input dd ?
66	.inp_size dd ?	63	.inp_size dd ?
67	.output dd ?	64	.output dd ?
68	.out_size dd ?	65	.out_size dd ?
69	}	66	}
70		67
71	virtual at 0	68	virtual at 0
72	IOCTL IOCTL	69	IOCTL IOCTL
73	end virtual	70	end virtual
74		71
75	section '.flat' code readable align 16	72	section '.flat' code readable align 16
76		73
77	proc START stdcall, state:dword	74	proc START stdcall, state:dword
78		75
79	cmp [state], 1	76	cmp [state], 1
80	jne .exit	77	jne .exit
81		78
82	stdcall GetService, szSound	79	stdcall GetService, szSound
83	test eax, eax	80	test eax, eax
84	jz .fail	81	jz .fail
85	mov [hSound], eax	82	mov [hSound], eax
86		83
87	stdcall KernelAlloc, 16*512	84	stdcall KernelAlloc, 16*512
88	test eax, eax	85	test eax, eax
89	jz .out_of_mem	86	jz .out_of_mem
90	mov [mix_buff], eax	87	mov [mix_buff], eax
91		88
92	mov eax, str.fd-FD_OFFSET	89	mov eax, str.fd-FD_OFFSET
93	mov [str.fd], eax	90	mov [str.fd], eax
94	mov [str.bk], eax	91	mov [str.bk], eax
95		92
96	if FORCE_MMX	93	if FORCE_MMX
97	if FORCE_MMX_128	94	if FORCE_MMX_128
98	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10	95	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
99	stop	96	stop
100	end if	97	end if
101	mov [mix_2_core], mmx_mix_2	98	mov [mix_2_core], mmx_mix_2
102	mov [mix_3_core], mmx_mix_3	99	mov [mix_3_core], mmx_mix_3
103	mov [mix_4_core], mmx_mix_4	100	mov [mix_4_core], mmx_mix_4
104	end if	101	end if
105		102
106	if FORCE_MMX_128	103	if FORCE_MMX_128
107	if FORCE_MMX	104	if FORCE_MMX
108	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10	105	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
109	stop	106	stop
110	end if	107	end if
111	mov [mix_2_core], mmx128_mix_2	108	mov [mix_2_core], mmx128_mix_2
112	mov [mix_3_core], mmx128_mix_3	109	mov [mix_3_core], mmx128_mix_3
113	mov [mix_4_core], mmx128_mix_4	110	mov [mix_4_core], mmx128_mix_4
114	end if	111	end if
115		112
116	if 0	113	if 0
117		114
118	if ~(FORCE_MMX or FORCE_MMX_128) ;autodetect	115	if ~(FORCE_MMX or FORCE_MMX_128) ;autodetect
119	mov eax, 1	116	mov eax, 1
120	cpuid	117	cpuid
121	bt edx, CAPS_SSE2	118	bt edx, CAPS_SSE2
122	jc .mmx128	119	jc .mmx128
123	;old 64-bit mmx	120	;old 64-bit mmx
124	mov [mix_2_core], mmx_mix_2	121	mov [mix_2_core], mmx_mix_2
125	mov [mix_3_core], mmx_mix_3	122	mov [mix_3_core], mmx_mix_3
126	mov [mix_4_core], mmx_mix_4	123	mov [mix_4_core], mmx_mix_4
127	jmp @F	124	jmp @F
128	.mmx128: ;128-bit integer sse2 extensions	125	.mmx128: ;128-bit integer sse2 extensions
129	mov [mix_2_core], mmx128_mix_2	126	mov [mix_2_core], mmx128_mix_2
130	mov [mix_3_core], mmx128_mix_3	127	mov [mix_3_core], mmx128_mix_3
131	mov [mix_4_core], mmx128_mix_4	128	mov [mix_4_core], mmx128_mix_4
132	@@:	129	@@:
133	end if	130	end if
134		131
135	end if	132	end if
136	stdcall set_handler, [hSound], new_mix	133	stdcall set_handler, [hSound], new_mix
137	mov [eng_state], SND_STOP	134	mov [eng_state], SND_STOP
138	stdcall RegService, szInfinity, service_proc	135	stdcall RegService, szInfinity, service_proc
139	ret	136	ret
140	.fail:	137	.fail:
141	if DEBUG	138	if DEBUG
142	mov esi, msgFail	139	mov esi, msgFail
143	call SysMsgBoardStr	140	call SysMsgBoardStr
144	end if	141	end if
145	.exit:	142	.exit:
146	xor eax, eax	143	xor eax, eax
147	ret	144	ret
148		145
149	.out_of_mem:	146	.out_of_mem:
150	if DEBUG	147	if DEBUG
151	mov esi, msgMem	148	mov esi, msgMem
152	call SysMsgBoardStr	149	call SysMsgBoardStr
153	end if	150	end if
154	xor eax, eax	151	xor eax, eax
155	ret	152	ret
156	endp	153	endp
157		154
158	handle equ IOCTL.handle	155	handle equ IOCTL.handle
159	io_code equ IOCTL.io_code	156	io_code equ IOCTL.io_code
160	input equ IOCTL.input	157	input equ IOCTL.input
161	inp_size equ IOCTL.inp_size	158	inp_size equ IOCTL.inp_size
162	output equ IOCTL.output	159	output equ IOCTL.output
163	out_size equ IOCTL.out_size	160	out_size equ IOCTL.out_size
164		161
165	align 4	162	align 4
166	proc service_proc stdcall, ioctl:dword	163	proc service_proc stdcall, ioctl:dword
167		164
168	mov edi, [ioctl]	165	mov edi, [ioctl]
169	mov eax, [edi+io_code]	166	mov eax, [edi+io_code]
170		167
171	cmp eax, SRV_GETVERSION	168	cmp eax, SRV_GETVERSION
172	jne @F	169	jne @F
173	mov eax, [edi+output]	170	mov eax, [edi+output]
174	cmp [edi+out_size], 4	171	cmp [edi+out_size], 4
175	jne .fail	172	jne .fail
176	mov eax, [eax]	173	mov eax, [eax]
177	mov [eax], dword API_VERSION	174	mov [eax], dword API_VERSION
178	xor eax, eax	175	xor eax, eax
179	ret	176	ret
180	@@:	177	@@:
181	cmp eax, SND_CREATE_BUFF	178	cmp eax, SND_CREATE_BUFF
182	jne @F	179	jne @F
183	mov ebx, [edi+input]	180	mov ebx, [edi+input]
184	stdcall CreateBuffer,[ebx],[ebx+4]	181	stdcall CreateBuffer,[ebx],[ebx+4]
185	mov edi, [ioctl]	182	mov edi, [ioctl]
186	mov ecx, [edi+output]	183	mov ecx, [edi+output]
187	mov ecx, [ecx]	184	mov ecx, [ecx]
188	mov [ecx], ebx	185	mov [ecx], ebx
189	ret	186	ret
190	@@:	187	@@:
191	mov ebx, [edi+input]	188	mov ebx, [edi+input]
192	mov edx, [ebx]	189	mov edx, [ebx]
193		190
194	cmp [edx+STREAM.magic], 'WAVE'	191	cmp [edx+STREAM.magic], 'WAVE'
195	jne .fail	192	jne .fail
196		193
197	cmp [edx+STREAM.size], STREAM_SIZE	194	cmp [edx+STREAM.size], STREAM_SIZE
198	jne .fail	195	jne .fail
199		196
200	cmp eax, SND_DESTROY_BUFF	197	cmp eax, SND_DESTROY_BUFF
201	jne @F	198	jne @F
202	mov eax, edx	199	mov eax, edx
203	call DestroyBuffer ;edx= stream	200	call DestroyBuffer ;edx= stream
204	ret	201	ret
205	@@:	202	@@:
206	cmp eax, SND_SETFORMAT	203	cmp eax, SND_SETFORMAT
207	jne @F	204	jne @F
208	stdcall SetFormat,edx,[ebx+4]	205	stdcall SetFormat,edx,[ebx+4]
209	ret	206	ret
210	@@:	207	@@:
211	cmp eax, SND_GETFORMAT	208	cmp eax, SND_GETFORMAT
212	jne @F	209	jne @F
213		210
214	movzx eax, word [edx+STREAM.format]	211	movzx eax, word [edx+STREAM.format]
215	mov ecx, [edi+output]	212	mov ecx, [edi+output]
216	mov ecx, [ecx]	213	mov ecx, [ecx]
217	mov [ecx], eax	214	mov [ecx], eax
218	xor eax, eax	215	xor eax, eax
219	ret	216	ret
220	@@:	217	@@:
221	cmp eax, SND_RESET	218	cmp eax, SND_RESET
222	jne @F	219	jne @F
223	stdcall ResetBuffer,edx,[ebx+4]	220	stdcall ResetBuffer,edx,[ebx+4]
224	ret	221	ret
225	@@:	222	@@:
226	cmp eax, SND_SETPOS	223	cmp eax, SND_SETPOS
227	jne @F	224	jne @F
228	stdcall SetBufferPos,edx,[ebx+4]	225	stdcall SetBufferPos,edx,[ebx+4]
229	ret	226	ret
230	@@:	227	@@:
231	cmp eax, SND_GETPOS	228	cmp eax, SND_GETPOS
232	jne @F	229	jne @F
233	stdcall GetBufferPos, edx	230	stdcall GetBufferPos, edx
234	mov edi, [ioctl]	231	mov edi, [ioctl]
235	mov ecx, [edi+output]	232	mov ecx, [edi+output]
236	mov ecx, [ecx]	233	mov ecx, [ecx]
237	mov [ecx], ebx	234	mov [ecx], ebx
238	ret	235	ret
239	@@:	236	@@:
240	cmp eax, SND_SETBUFF	237	cmp eax, SND_SETBUFF
241	jne @F	238	jne @F
242	mov eax, [ebx+4]	239	mov eax, [ebx+4]
243	stdcall set_buffer, edx,eax,[ebx+8],[ebx+12]	240	stdcall set_buffer, edx,eax,[ebx+8],[ebx+12]
244	ret	241	ret
245	@@:	242	@@:
246	cmp eax, SND_SETVOLUME	243	cmp eax, SND_SETVOLUME
247	jne @F	244	jne @F
248	stdcall SetBufferVol,edx,[ebx+4],[ebx+8]	245	stdcall SetBufferVol,edx,[ebx+4],[ebx+8]
249	ret	246	ret
250	@@:	247	@@:
251	cmp eax, SND_GETVOLUME	248	cmp eax, SND_GETVOLUME
252	jne @F	249	jne @F
253		250
254	mov eax, [edi+output]	251	mov eax, [edi+output]
255	mov ecx, [eax]	252	mov ecx, [eax]
256	mov eax, [eax+4]	253	mov eax, [eax+4]
257	stdcall GetBufferVol,edx,ecx,eax	254	stdcall GetBufferVol,edx,ecx,eax
258	ret	255	ret
259	@@:	256	@@:
260	cmp eax, SND_SETPAN	257	cmp eax, SND_SETPAN
261	jne @F	258	jne @F
262	stdcall SetBufferPan,edx,[ebx+4]	259	stdcall SetBufferPan,edx,[ebx+4]
263	ret	260	ret
264	@@:	261	@@:
265	cmp eax, SND_GETPAN	262	cmp eax, SND_GETPAN
266	jne @F	263	jne @F
267	mov eax, [edx+STREAM.pan]	264	mov eax, [edx+STREAM.pan]
268	mov ebx, [edi+output]	265	mov ebx, [edi+output]
269	mov ebx, [ebx]	266	mov ebx, [ebx]
270	mov [ebx], eax	267	mov [ebx], eax
271	xor eax, eax	268	xor eax, eax
272	ret	269	ret
273	@@:	270	@@:
274	cmp eax, SND_OUT	271	cmp eax, SND_OUT
275	jne @F	272	jne @F
276		273
277	mov eax, [ebx+4]	274	mov eax, [ebx+4]
278	stdcall wave_out, edx,eax,[ebx+8]	275	stdcall wave_out, edx,eax,[ebx+8]
279	ret	276	ret
280	@@:	277	@@:
281	cmp eax, SND_PLAY	278	cmp eax, SND_PLAY
282	jne @F	279	jne @F
283		280
284	stdcall play_buffer, edx,[ebx+4]	281	stdcall play_buffer, edx,[ebx+4]
285	ret	282	ret
286	@@:	283	@@:
287	cmp eax, SND_STOP	284	cmp eax, SND_STOP
288	jne @F	285	jne @F
289		286
290	stdcall stop_buffer, edx	287	stdcall stop_buffer, edx
291	ret	288	ret
292	@@:	289	@@:
293	cmp eax, SND_GETBUFFSIZE	290	cmp eax, SND_GETBUFFSIZE
294	jne @F	291	jne @F
295	mov eax, [edx+STREAM.in_size]	292	mov eax, [edx+STREAM.in_size]
296	mov ecx, [edi+output]	293	mov ecx, [edi+output]
297	mov ecx, [ecx]	294	mov ecx, [ecx]
298	mov [ecx], eax	295	mov [ecx], eax
299	xor eax, eax	296	xor eax, eax
300	ret	297	ret
301	@@:	298	@@:
302	cmp eax, SND_GETFREESPACE	299	cmp eax, SND_GETFREESPACE
303	jne @F	300	jne @F
304		301
305	test [edx+STREAM.format], PCM_OUT	302	test [edx+STREAM.format], PCM_OUT
306	jz .fail	303	jz .fail
307		304
308	mov ebx, [edx+STREAM.in_free]	305	mov ebx, [edx+STREAM.in_free]
309	mov ecx, [edi+output]	306	mov ecx, [edi+output]
310	mov [ecx], ebx	307	mov [ecx], ebx
311	xor eax, eax	308	xor eax, eax
312	ret	309	ret
313	@@:	310	@@:
314	.fail:	311	.fail:
315	or eax, -1	312	or eax, -1
316	ret	313	ret
317	endp	314	endp
318		315
319	restore handle	316	restore handle
320	restore io_code	317	restore io_code
321	restore input	318	restore input
322	restore inp_size	319	restore inp_size
323	restore output	320	restore output
324	restore out_size	321	restore out_size
325		322
326	align 4	323	align 4
327	proc CreateBuffer stdcall, format:dword, size:dword	324	proc CreateBuffer stdcall, format:dword, size:dword
328	locals	325	locals
329	str dd ?	326	str dd ?
330	ring_size dd ?	327	ring_size dd ?
331	ring_pages dd ?	328	ring_pages dd ?
332	endl	329	endl
333		330
334	mov eax, [format]	331	mov eax, [format]
335	cmp ax, PCM_1_8_8	332	cmp ax, PCM_1_8_8
336	ja .fail	333	ja .fail
337		334
338	test eax, PCM_OUT	335	test eax, PCM_OUT
339	jnz .test_out	336	jnz .test_out
340	test eax, PCM_RING	337	test eax, PCM_RING
341	jnz .test_ring	338	jnz .test_ring
342	;staic	339	;staic
343	test eax, PCM_STATIC	340	test eax, PCM_STATIC
344	jz .test_out ;use PCM_OUT as default format	341	jz .test_out ;use PCM_OUT as default format
345	jmp .test_ok	342	jmp .test_ok
346	.test_out:	343	.test_out:
347	test eax, PCM_RING+PCM_STATIC	344	test eax, PCM_RING+PCM_STATIC
348	jnz .fail	345	jnz .fail
349	or [format], PCM_OUT ;force set	346	or [format], PCM_OUT ;force set
350	jmp .test_ok	347	jmp .test_ok
351	.test_ring:	348	.test_ring:
352	test eax, PCM_OUT+PCM_STATIC	349	test eax, PCM_OUT+PCM_STATIC
353	jnz .fail	350	jnz .fail
354	.test_ok:	351	.test_ok:
355		352
356	call GetPid	353	call GetPid
357	mov ebx, eax	354	mov ebx, eax
358	mov eax, STREAM_SIZE	355	mov eax, STREAM_SIZE
359		356
360	call CreateObject	357	call CreateObject
361	test eax, eax	358	test eax, eax
362	jz .fail	359	jz .fail
363	mov [str], eax	360	mov [str], eax
364		361
365	mov ebx, [format]	362	mov ebx, [format]
366	mov [eax+STREAM.format], ebx	363	mov [eax+STREAM.format], ebx
367		364
368	xor ecx, ecx	365	xor ecx, ecx
369	movzx ebx, bx	366	movzx ebx, bx
370	cmp ebx, 19	367	cmp ebx, 19
371	jb @f	368	jb @f
372	mov ecx, 0x80808080	369	mov ecx, 0x80808080
373	@@:	370	@@:
374	mov [eax+STREAM.r_silence], ecx	371	mov [eax+STREAM.r_silence], ecx
375		372
376	shl ebx, 2	373	shl ebx, 2
377	lea ebx, [ebx+ebx2] ;ebx=12	374	lea ebx, [ebx+ebx2] ;ebx=12
378		375
379	mov ecx, [resampler_params+ebx]	376	mov ecx, [resampler_params+ebx]
380	mov edx, [resampler_params+ebx+4]	377	mov edx, [resampler_params+ebx+4]
381	mov esi, [resampler_params+ebx+8]	378	mov esi, [resampler_params+ebx+8]
382		379
383	mov [eax+STREAM.r_size],ecx	380	mov [eax+STREAM.r_size],ecx
384	mov [eax+STREAM.r_dt], edx	381	mov [eax+STREAM.r_dt], edx
385	mov [eax+STREAM.resample], esi	382	mov [eax+STREAM.resample], esi
386	xor ecx, ecx	383	xor ecx, ecx
387	mov [eax+STREAM.l_vol], ecx	384	mov [eax+STREAM.l_vol], ecx
388	mov [eax+STREAM.r_vol], ecx	385	mov [eax+STREAM.r_vol], ecx
389	mov dword [eax+STREAM.l_amp], 0x7FFF7FFF	386	mov dword [eax+STREAM.l_amp], 0x7FFF7FFF
390	mov [eax+STREAM.pan], ecx	387	mov [eax+STREAM.pan], ecx
391		388
392	test [format], PCM_STATIC	389	test [format], PCM_STATIC
393	jnz .static	390	jnz .static
394		391
395	; ring and waveout	392	; ring and waveout
396		393
397	mov ebx, 0x10000	394	mov ebx, 0x10000
398	test [format], PCM_RING	395	test [format], PCM_RING
399	jz .waveout	396	jz .waveout
400		397
401	mov ebx, [eax+STREAM.r_size]	398	mov ebx, [eax+STREAM.r_size]
402	add ebx, 4095	399	add ebx, 4095
403	and ebx, -4096	400	and ebx, -4096
404	add ebx, ebx	401	add ebx, ebx
405	.waveout:	402	.waveout:
406	mov [ring_size], ebx	403	mov [ring_size], ebx
407	mov eax, ebx	404	mov eax, ebx
408	shr ebx, 12	405	shr ebx, 12
409	mov [ring_pages], ebx	406	mov [ring_pages], ebx
410		407
411	stdcall CreateRingBuffer, eax, PG_SW	408	stdcall CreateRingBuffer, eax, PG_SW
412		409
413	mov edi, [str]	410	mov edi, [str]
414	mov ecx, [ring_size]	411	mov ecx, [ring_size]
415	mov [edi+STREAM.in_base], eax	412	mov [edi+STREAM.in_base], eax
416	mov [edi+STREAM.in_size], ecx	413	mov [edi+STREAM.in_size], ecx
417	add eax, 128	414	add eax, 128
418	; sub ecx, 128	415	; sub ecx, 128
419	mov [edi+STREAM.in_wp], eax	416	mov [edi+STREAM.in_wp], eax
420	mov [edi+STREAM.in_rp], eax	417	mov [edi+STREAM.in_rp], eax
421	mov [edi+STREAM.in_count], 0	418	mov [edi+STREAM.in_count], 0
422		419
423	mov [edi+STREAM.in_free], ecx	420	mov [edi+STREAM.in_free], ecx
424	add eax, ecx	421	add eax, ecx
425	mov [edi+STREAM.in_top], eax	422	mov [edi+STREAM.in_top], eax
426		423
427	jmp .out_buff	424	jmp .out_buff
428	.static:	425	.static:
429	mov ecx, [size]	426	mov ecx, [size]
430	add ecx, 128 ;resampler required	427	add ecx, 128 ;resampler required
431	mov [eax+STREAM.in_size], ecx	428	mov [eax+STREAM.in_size], ecx
432	stdcall KernelAlloc, ecx	429	stdcall KernelAlloc, ecx
433		430
434	mov edi, [str]	431	mov edi, [str]
435	mov [edi+STREAM.in_base], eax	432	mov [edi+STREAM.in_base], eax
436	add eax, 128	433	add eax, 128
437	mov [edi+STREAM.in_wp], eax	434	mov [edi+STREAM.in_wp], eax
438	mov [edi+STREAM.in_rp], eax	435	mov [edi+STREAM.in_rp], eax
439	mov ebx, [size]	436	mov ebx, [size]
440	mov [edi+STREAM.in_count], ebx	437	mov [edi+STREAM.in_count], ebx
441	mov [edi+STREAM.in_free], ebx	438	mov [edi+STREAM.in_free], ebx
442	add eax, ebx	439	add eax, ebx
443	mov [edi+STREAM.in_top], eax	440	mov [edi+STREAM.in_top], eax
444		441
445	.out_buff:	442	.out_buff:
446	stdcall AllocKernelSpace, dword 128*1024	443	stdcall AllocKernelSpace, dword 128*1024
447		444
448	mov edi, [str]	445	mov edi, [str]
449	mov [edi+STREAM.out_base], eax	446	mov [edi+STREAM.out_base], eax
450	mov [edi+STREAM.out_wp], eax	447	mov [edi+STREAM.out_wp], eax
451	mov [edi+STREAM.out_rp], eax	448	mov [edi+STREAM.out_rp], eax
452	mov [edi+STREAM.out_count], 0	449	mov [edi+STREAM.out_count], 0
453	add eax, 64*1024	450	add eax, 64*1024
454	mov [edi+STREAM.out_top], eax	451	mov [edi+STREAM.out_top], eax
455		452
456	stdcall AllocPages, dword 64/4	453	stdcall AllocPages, dword 64/4
457	mov edi, [str]	454	mov edi, [str]
458	mov ebx, [edi+STREAM.out_base]	455	mov ebx, [edi+STREAM.out_base]
459	mov ecx, 16	456	mov ecx, 16
460	or eax, PG_SW	457	or eax, PG_SW
461	push eax	458	push eax
462	push ebx	459	push ebx
463	call CommitPages ;eax, ebx, ecx	460	call CommitPages ;eax, ebx, ecx
464	mov ecx, 16	461	mov ecx, 16
465	pop ebx	462	pop ebx
466	pop eax	463	pop eax
467	add ebx, 64*1024	464	add ebx, 64*1024
468	call CommitPages ;double mapped	465	call CommitPages ;double mapped
469		466
470	mov edi, [str]	467	mov edi, [str]
471	mov ecx, [edi+STREAM.in_top]	468	mov ecx, [edi+STREAM.in_top]
472	mov edi, [edi+STREAM.in_base]	469	mov edi, [edi+STREAM.in_base]
473	sub ecx, edi	470	sub ecx, edi
474	xor eax, eax	471	xor eax, eax
475	shr ecx, 2	472	shr ecx, 2
476	cld	473	cld
477	rep stosd	474	rep stosd
478		475
479	mov edi, [str]	476	mov edi, [str]
480	mov edi, [edi+STREAM.out_base]	477	mov edi, [edi+STREAM.out_base]
481	mov ecx, (64*1024)/4	478	mov ecx, (64*1024)/4
482	rep stosd	479	rep stosd
483		480
484	xor edx, edx	481	xor edx, edx
485	mov ebx, MANUAL_DESTROY	482	mov ebx, MANUAL_DESTROY
486	call CreateEvent	483	call CreateEvent
487		484
488	mov ebx, [str]	485	mov ebx, [str]
489	mov [ebx+STREAM.notify_event], eax	486	mov [ebx+STREAM.notify_event], eax
490	mov [ebx+STREAM.notify_id], edx	487	mov [ebx+STREAM.notify_id], edx
491		488
492	mov [ebx+STREAM.magic], 'WAVE'	489	mov [ebx+STREAM.magic], 'WAVE'
493	mov [ebx+STREAM.destroy], DestroyBuffer.destroy	490	mov [ebx+STREAM.destroy], DestroyBuffer.destroy

Subversion Repositories Kolibri OS

(root)/kernel/trunk/drivers/infinity.asm – Rev 695 → 802