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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2006-2011. 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
DEV_GET_POS       equ 9
 
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
 
srv_calls  dd service_proc.srv_getversion       ; 0
           dd service_proc.snd_create_buff      ; 1
           dd service_proc.snd_destroy_buff     ; 2
           dd service_proc.snd_setformat        ; 3
           dd service_proc.snd_getformat        ; 4
           dd service_proc.snd_reset            ; 5
           dd service_proc.snd_setpos           ; 6
           dd service_proc.snd_getpos           ; 7
           dd service_proc.snd_setbuff          ; 8
           dd service_proc.snd_out              ; 9
           dd service_proc.snd_play             ; 10
           dd service_proc.snd_stop             ; 11
           dd service_proc.snd_setvolume        ; 12
           dd service_proc.snd_getvolume        ; 13
           dd service_proc.snd_setpan           ; 14
           dd service_proc.snd_getpan           ; 15
           dd service_proc.snd_getbuffsize      ; 16
           dd service_proc.snd_getfreespace     ; 17
           dd service_proc.snd_settimebase      ; 18
           dd service_proc.snd_gettimestamp     ; 19
srv_calls_end:
 
proc service_proc stdcall, ioctl:dword
 
        mov     edi, [ioctl]
        mov     eax, [edi+io_code]
 
        cmp     eax, (srv_calls_end-srv_calls)/4
        ja      .fail
 
        cmp     eax, SND_DESTROY_BUFF
        jb      @F
 
;           cmp [edi+inp_size], 4
;           jb .fali
 
        mov     ebx, [edi+input]
        mov     edx, [ebx]
 
        cmp     [edx+STREAM.magic], 'WAVE'
        jne     .fail
 
        cmp     [edx+STREAM.size], STREAM.sizeof
        jne     .fail
 
@@:
        jmp     [srv_calls+eax*4]
 
 
.fail:
        mov     eax, -1
        ret
 
align 4
.srv_getversion:
        mov     eax, [edi+output]
        cmp     [edi+out_size], 4
        jne     .fail
        mov     eax, [eax]
        mov     [eax], dword API_VERSION
        xor     eax, eax
        ret
 
align 4
.snd_create_buff:
        mov     ebx, [edi+input]
        stdcall CreateBuffer, [ebx], [ebx+4]
        mov     edi, [ioctl]
        mov     ecx, [edi+output]
        mov     ecx, [ecx]
        mov     [ecx], ebx
        ret
 
align 4
.snd_destroy_buff:
        mov     eax, edx
        call    DestroyBuffer
        ret
 
align 4
.snd_setformat:
        stdcall SetFormat, edx, [ebx+4]
        ret
 
align 4
.snd_getformat:
        movzx   eax, word [edx+STREAM.format]
        mov     ecx, [edi+output]
        mov     ecx, [ecx]
        mov     [ecx], eax
        xor     eax, eax
        ret
 
align 4
.snd_reset:
        stdcall ResetBuffer, edx, [ebx+4]
        ret
 
align 4
.snd_setpos:
        stdcall SetBufferPos, edx, [ebx+4]
        ret
 
align 4
.snd_getpos:
        stdcall GetBufferPos, edx
        mov     edi, [ioctl]
        mov     ecx, [edi+output]
        mov     ecx, [ecx]
        mov     [ecx], ebx
        ret
 
align 4
.snd_setbuff:
        mov     eax, [ebx+4]
        stdcall set_buffer, edx, eax, [ebx+8], [ebx+12]
        ret
 
align 4
.snd_out:
        mov     eax, [ebx+4]
        stdcall wave_out, edx, eax, [ebx+8]
        ret
 
align 4
.snd_play:
        stdcall play_buffer, edx, [ebx+4]
        ret
 
align 4
.snd_stop:
        stdcall stop_buffer, edx
        ret
 
align 4
.snd_setvolume:
        stdcall SetBufferVol, edx, [ebx+4], [ebx+8]
        ret
 
align 4
.snd_getvolume:
        mov     eax, [edi+output]
        mov     ecx, [eax]
        mov     eax, [eax+4]
        stdcall GetBufferVol, edx, ecx, eax
        ret
align 4
.snd_setpan:
        stdcall SetBufferPan, edx, [ebx+4]
        ret
 
align 4
.snd_getpan:
        mov     eax, [edx+STREAM.pan]
        mov     ebx, [edi+output]
        mov     ebx, [ebx]
        mov     [ebx], eax
        xor     eax, eax
        ret
 
align 4
.snd_getbuffsize:
        mov     eax, [edx+STREAM.in_size]
        mov     ecx, [edi+output]
        mov     ecx, [ecx]
        mov     [ecx], eax
        xor     eax, eax
        ret
 
align 4
.snd_getfreespace:
        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
align 4
.snd_settimebase:
        cmp     [edi+inp_size], 12
        jne     .fail
 
        mov     eax, [ebx+4]
        mov     ebx, [ebx+8]
 
        pushfd
        cli
        mov     dword [edx+STREAM.time_base], eax
        mov     dword [edx+STREAM.time_base+4], ebx
        xor     eax, eax
        mov     dword [edx+STREAM.time_stamp], eax
        mov     dword [edx+STREAM.time_stamp+4], eax
        popfd
 
        ret
 
align 4
.snd_gettimestamp:
        cmp     [edi+out_size], 8
        jne     .fail
 
        pushfd
        cli
 
        xor     ebx, ebx
        push    48
        push    ebx            ; local storage
 
        cmp     [edx+STREAM.flags], SND_STOP
        je      @F
 
        mov     eax, esp
 
        push    ebx
        push    ecx
        push    edx
        push    esi
        push    edi
 
        push    4              ;.out_size
        push    eax            ;.output
        push    ebx            ;.inp_size
        push    ebx            ;.input
        push    DEV_GET_POS    ;.code
        push    dword [hSound] ;.handle
        mov     eax, esp
 
        stdcall ServiceHandler, eax
        add     esp, 6*4
 
        pop     edi
        pop     esi
        pop     edx
        pop     ecx
        pop     ebx
 
        test    eax, eax
        jz      @F
 
        mov     dword [esp], 0  ; clear offset
@@:
        mov     edi, [edi+output]
 
        emms
        fild    qword [edx+STREAM.time_stamp]
        fiadd   dword [esp]     ; primary buffer offset
        fidiv   dword [esp+4]   ; total_samples / frequency
        fadd    qword [edx+STREAM.time_base]
        fstp    qword [edi]
        add     esp, 8
 
        popfd
 
        xor     eax, eax
        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.sizeof
 
        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
        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]
        xor     ebx, ebx
 
        mov     [edi+STREAM.out_base], eax
        mov     [edi+STREAM.out_wp], eax
        mov     [edi+STREAM.out_rp], eax
        mov     [edi+STREAM.out_count], ebx
        add     eax, 64*1024
        mov     [edi+STREAM.out_top], eax
 
        mov     dword [edi+STREAM.time_base], ebx
        mov     dword [edi+STREAM.time_base+4], ebx
 
        mov     dword [edi+STREAM.time_stamp], ebx
        mov     dword [edi+STREAM.time_stamp+4], ebx
        mov     dword [edi+STREAM.last_ts], ebx
 
        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     esi, esi
        mov     ecx, 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.sizeof
        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:
        cli
 
        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:
        sti
        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:
        sti
        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 minw stdcall, arg1:dword, arg2:dword
        mov     ax, word [arg1]
        cmp     ax, word [arg2]
        jle     @f
        mov     eax, [arg2]
@@:
        ret
endp
 
proc maxw stdcall, arg1:dword, arg2:dword
        mov     ax, word [arg1]
        cmp     ax, word [arg2]
        jge     @f
        mov     eax, [arg2]
@@:
        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]
 
        stdcall minw, [l_vol], [vol_max]
        stdcall maxw, eax, [vol_min]
        mov     [l_vol], eax
        mov     [edx+STREAM.l_vol], eax
        stdcall minw, [r_vol], [vol_max+4]
        stdcall maxw, eax, [vol_min+4]
        mov     [r_vol], eax
        mov     [edx+STREAM.r_vol], eax
 
        stdcall minw, [pan], [pan_max]
        stdcall maxw, eax, [vol_min]
        mov     [edx+STREAM.pan], eax
 
        cmp     word [edx+STREAM.pan], 0
        jl      @f
 
        mov     ebx, [l_vol]
        sub     ebx, eax
        stdcall minw, ebx, [vol_max]
        stdcall maxw, eax, [vol_min]
        mov     [l_vol], eax
        jmp     .calc_amp
@@:
        mov     ebx, [r_vol]
        add     ebx, [pan]
        stdcall minw, ebx, [vol_max+4]
        stdcall maxw, eax, [vol_min+4]
        mov     [r_vol], eax
.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.sizeof
        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.sizeof
        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 2455	Rev 2694
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2006-2011. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2006-2011. 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		12
13	DEBUG equ 1	13	DEBUG equ 1
14		14
15		15
16	include 'proc32.inc'	16	include 'proc32.inc'
17	include 'main.inc'	17	include 'main.inc'
18	include 'imports.inc'	18	include 'imports.inc'
19		19
20		20
21	CURRENT_API equ 0x0101 ;1.01	21	CURRENT_API equ 0x0101 ;1.01
22	COMPATIBLE_API equ 0x0100 ;1.00	22	COMPATIBLE_API equ 0x0100 ;1.00
23		23
24	API_VERSION equ (COMPATIBLE_API shl 16) or CURRENT_API	24	API_VERSION equ (COMPATIBLE_API shl 16) or CURRENT_API
25	SOUND_VERSION equ CURRENT_API	25	SOUND_VERSION equ CURRENT_API
26		26
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		35
36	OS_BASE equ 0x80000000	36	OS_BASE equ 0x80000000
37		37
38	CAPS_SSE2 equ 26	38	CAPS_SSE2 equ 26
39	PG_SW equ 0x003	39	PG_SW equ 0x003
40		40
41	public START	41	public START
42	public service_proc	42	public service_proc
43	public version	43	public version
44		44
45	RT_INP_EMPTY equ 0xFF000001	45	RT_INP_EMPTY equ 0xFF000001
46	RT_OUT_EMPTY equ 0xFF000002	46	RT_OUT_EMPTY equ 0xFF000002
47	RT_INP_FULL equ 0xFF000003	47	RT_INP_FULL equ 0xFF000003
48	RT_OUT_FULL equ 0xFF000004	48	RT_OUT_FULL equ 0xFF000004
49		49
50	EVENT_WATCHED equ 0x10000000	50	EVENT_WATCHED equ 0x10000000
51	EVENT_SIGNALED equ 0x20000000	51	EVENT_SIGNALED equ 0x20000000
52	MANUAL_RESET equ 0x40000000	52	MANUAL_RESET equ 0x40000000
53	MANUAL_DESTROY equ 0x80000000	53	MANUAL_DESTROY equ 0x80000000
54		54
55	DEV_PLAY equ 1	55	DEV_PLAY equ 1
56	DEV_STOP equ 2	56	DEV_STOP equ 2
57	DEV_CALLBACK equ 3	57	DEV_CALLBACK equ 3
58	DEV_GET_POS equ 9	58	DEV_GET_POS equ 9
59		59
60	struc IOCTL	60	struc IOCTL
61	{ .handle dd ?	61	{ .handle dd ?
62	.io_code dd ?	62	.io_code dd ?
63	.input dd ?	63	.input dd ?
64	.inp_size dd ?	64	.inp_size dd ?
65	.output dd ?	65	.output dd ?
66	.out_size dd ?	66	.out_size dd ?
67	}	67	}
68		68
69	virtual at 0	69	virtual at 0
70	IOCTL IOCTL	70	IOCTL IOCTL
71	end virtual	71	end virtual
72		72
73	section '.flat' code readable align 16	73	section '.flat' code readable align 16
74		74
75	proc START stdcall, state:dword	75	proc START stdcall, state:dword
76		76
77	cmp [state], 1	77	cmp [state], 1
78	jne .exit	78	jne .exit
79		79
80	stdcall GetService, szSound	80	stdcall GetService, szSound
81	test eax, eax	81	test eax, eax
82	jz .fail	82	jz .fail
83	mov [hSound], eax	83	mov [hSound], eax
84		84
85	stdcall KernelAlloc, 16*512	85	stdcall KernelAlloc, 16*512
86	test eax, eax	86	test eax, eax
87	jz .out_of_mem	87	jz .out_of_mem
88	mov [mix_buff], eax	88	mov [mix_buff], eax
89		89
90	mov eax, str.fd-FD_OFFSET	90	mov eax, str.fd-FD_OFFSET
91	mov [str.fd], eax	91	mov [str.fd], eax
92	mov [str.bk], eax	92	mov [str.bk], eax
93		93
94	if FORCE_MMX	94	if FORCE_MMX
95	if FORCE_MMX_128	95	if FORCE_MMX_128
96	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10	96	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
97	stop	97	stop
98	end if	98	end if
99	mov [mix_2_core], mmx_mix_2	99	mov [mix_2_core], mmx_mix_2
100	mov [mix_3_core], mmx_mix_3	100	mov [mix_3_core], mmx_mix_3
101	mov [mix_4_core], mmx_mix_4	101	mov [mix_4_core], mmx_mix_4
102	end if	102	end if
103		103
104	if FORCE_MMX_128	104	if FORCE_MMX_128
105	if FORCE_MMX	105	if FORCE_MMX
106	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10	106	display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
107	stop	107	stop
108	end if	108	end if
109	mov [mix_2_core], mmx128_mix_2	109	mov [mix_2_core], mmx128_mix_2
110	mov [mix_3_core], mmx128_mix_3	110	mov [mix_3_core], mmx128_mix_3
111	mov [mix_4_core], mmx128_mix_4	111	mov [mix_4_core], mmx128_mix_4
112	end if	112	end if
113		113
114	if 0	114	if 0
115		115
116	if ~(FORCE_MMX or FORCE_MMX_128) ;autodetect	116	if ~(FORCE_MMX or FORCE_MMX_128) ;autodetect
117	mov eax, 1	117	mov eax, 1
118	cpuid	118	cpuid
119	bt edx, CAPS_SSE2	119	bt edx, CAPS_SSE2
120	jc .mmx128	120	jc .mmx128
121	;old 64-bit mmx	121	;old 64-bit mmx
122	mov [mix_2_core], mmx_mix_2	122	mov [mix_2_core], mmx_mix_2
123	mov [mix_3_core], mmx_mix_3	123	mov [mix_3_core], mmx_mix_3
124	mov [mix_4_core], mmx_mix_4	124	mov [mix_4_core], mmx_mix_4
125	jmp @F	125	jmp @F
126	.mmx128: ;128-bit integer sse2 extensions	126	.mmx128: ;128-bit integer sse2 extensions
127	mov [mix_2_core], mmx128_mix_2	127	mov [mix_2_core], mmx128_mix_2
128	mov [mix_3_core], mmx128_mix_3	128	mov [mix_3_core], mmx128_mix_3
129	mov [mix_4_core], mmx128_mix_4	129	mov [mix_4_core], mmx128_mix_4
130	@@:	130	@@:
131	end if	131	end if
132		132
133	end if	133	end if
134	stdcall set_handler, [hSound], new_mix	134	stdcall set_handler, [hSound], new_mix
135	mov [eng_state], SND_STOP	135	mov [eng_state], SND_STOP
136	stdcall RegService, szInfinity, service_proc	136	stdcall RegService, szInfinity, service_proc
137	ret	137	ret
138	.fail:	138	.fail:
139	if DEBUG	139	if DEBUG
140	mov esi, msgFail	140	mov esi, msgFail
141	call SysMsgBoardStr	141	call SysMsgBoardStr
142	end if	142	end if
143	.exit:	143	.exit:
144	xor eax, eax	144	xor eax, eax
145	ret	145	ret
146		146
147	.out_of_mem:	147	.out_of_mem:
148	if DEBUG	148	if DEBUG
149	mov esi, msgMem	149	mov esi, msgMem
150	call SysMsgBoardStr	150	call SysMsgBoardStr
151	end if	151	end if
152	xor eax, eax	152	xor eax, eax
153	ret	153	ret
154	endp	154	endp
155		155
156	handle equ IOCTL.handle	156	handle equ IOCTL.handle
157	io_code equ IOCTL.io_code	157	io_code equ IOCTL.io_code
158	input equ IOCTL.input	158	input equ IOCTL.input
159	inp_size equ IOCTL.inp_size	159	inp_size equ IOCTL.inp_size
160	output equ IOCTL.output	160	output equ IOCTL.output
161	out_size equ IOCTL.out_size	161	out_size equ IOCTL.out_size
162		162
163		163
164		164
165	align 4	165	align 4
166		166
167	srv_calls dd service_proc.srv_getversion ; 0	167	srv_calls dd service_proc.srv_getversion ; 0
168	dd service_proc.snd_create_buff ; 1	168	dd service_proc.snd_create_buff ; 1
169	dd service_proc.snd_destroy_buff ; 2	169	dd service_proc.snd_destroy_buff ; 2
170	dd service_proc.snd_setformat ; 3	170	dd service_proc.snd_setformat ; 3
171	dd service_proc.snd_getformat ; 4	171	dd service_proc.snd_getformat ; 4
172	dd service_proc.snd_reset ; 5	172	dd service_proc.snd_reset ; 5
173	dd service_proc.snd_setpos ; 6	173	dd service_proc.snd_setpos ; 6
174	dd service_proc.snd_getpos ; 7	174	dd service_proc.snd_getpos ; 7
175	dd service_proc.snd_setbuff ; 8	175	dd service_proc.snd_setbuff ; 8
176	dd service_proc.snd_out ; 9	176	dd service_proc.snd_out ; 9
177	dd service_proc.snd_play ; 10	177	dd service_proc.snd_play ; 10
178	dd service_proc.snd_stop ; 11	178	dd service_proc.snd_stop ; 11
179	dd service_proc.snd_setvolume ; 12	179	dd service_proc.snd_setvolume ; 12
180	dd service_proc.snd_getvolume ; 13	180	dd service_proc.snd_getvolume ; 13
181	dd service_proc.snd_setpan ; 14	181	dd service_proc.snd_setpan ; 14
182	dd service_proc.snd_getpan ; 15	182	dd service_proc.snd_getpan ; 15
183	dd service_proc.snd_getbuffsize ; 16	183	dd service_proc.snd_getbuffsize ; 16
184	dd service_proc.snd_getfreespace ; 17	184	dd service_proc.snd_getfreespace ; 17
185	dd service_proc.snd_settimebase ; 18	185	dd service_proc.snd_settimebase ; 18
186	dd service_proc.snd_gettimestamp ; 19	186	dd service_proc.snd_gettimestamp ; 19
187	srv_calls_end:	187	srv_calls_end:
188		188
189	proc service_proc stdcall, ioctl:dword	189	proc service_proc stdcall, ioctl:dword
190		190
191	mov edi, [ioctl]	191	mov edi, [ioctl]
192	mov eax, [edi+io_code]	192	mov eax, [edi+io_code]
193		193
194	cmp eax, (srv_calls_end-srv_calls)/4	194	cmp eax, (srv_calls_end-srv_calls)/4
195	ja .fail	195	ja .fail
196		196
197	cmp eax, SND_DESTROY_BUFF	197	cmp eax, SND_DESTROY_BUFF
198	jb @F	198	jb @F
199		199
200	; cmp [edi+inp_size], 4	200	; cmp [edi+inp_size], 4
201	; jb .fali	201	; jb .fali
202		202
203	mov ebx, [edi+input]	203	mov ebx, [edi+input]
204	mov edx, [ebx]	204	mov edx, [ebx]
205		205
206	cmp [edx+STREAM.magic], 'WAVE'	206	cmp [edx+STREAM.magic], 'WAVE'
207	jne .fail	207	jne .fail
208		208
209	cmp [edx+STREAM.size], STREAM.sizeof	209	cmp [edx+STREAM.size], STREAM.sizeof
210	jne .fail	210	jne .fail
211		211
212	@@:	212	@@:
213	jmp [srv_calls+eax*4]	213	jmp [srv_calls+eax*4]
214		214
215		215
216	.fail:	216	.fail:
217	mov eax, -1	217	mov eax, -1
218	ret	218	ret
219		219
220	align 4	220	align 4
221	.srv_getversion:	221	.srv_getversion:
222	mov eax, [edi+output]	222	mov eax, [edi+output]
223	cmp [edi+out_size], 4	223	cmp [edi+out_size], 4
224	jne .fail	224	jne .fail
225	mov eax, [eax]	225	mov eax, [eax]
226	mov [eax], dword API_VERSION	226	mov [eax], dword API_VERSION
227	xor eax, eax	227	xor eax, eax
228	ret	228	ret
229		229
230	align 4	230	align 4
231	.snd_create_buff:	231	.snd_create_buff:
232	mov ebx, [edi+input]	232	mov ebx, [edi+input]
233	stdcall CreateBuffer, [ebx], [ebx+4]	233	stdcall CreateBuffer, [ebx], [ebx+4]
234	mov edi, [ioctl]	234	mov edi, [ioctl]
235	mov ecx, [edi+output]	235	mov ecx, [edi+output]
236	mov ecx, [ecx]	236	mov ecx, [ecx]
237	mov [ecx], ebx	237	mov [ecx], ebx
238	ret	238	ret
239		239
240	align 4	240	align 4
241	.snd_destroy_buff:	241	.snd_destroy_buff:
242	mov eax, edx	242	mov eax, edx
243	call DestroyBuffer	243	call DestroyBuffer
244	ret	244	ret
245		245
246	align 4	246	align 4
247	.snd_setformat:	247	.snd_setformat:
248	stdcall SetFormat, edx, [ebx+4]	248	stdcall SetFormat, edx, [ebx+4]
249	ret	249	ret
250		250
251	align 4	251	align 4
252	.snd_getformat:	252	.snd_getformat:
253	movzx eax, word [edx+STREAM.format]	253	movzx eax, word [edx+STREAM.format]
254	mov ecx, [edi+output]	254	mov ecx, [edi+output]
255	mov ecx, [ecx]	255	mov ecx, [ecx]
256	mov [ecx], eax	256	mov [ecx], eax
257	xor eax, eax	257	xor eax, eax
258	ret	258	ret
259		259
260	align 4	260	align 4
261	.snd_reset:	261	.snd_reset:
262	stdcall ResetBuffer, edx, [ebx+4]	262	stdcall ResetBuffer, edx, [ebx+4]
263	ret	263	ret
264		264
265	align 4	265	align 4
266	.snd_setpos:	266	.snd_setpos:
267	stdcall SetBufferPos, edx, [ebx+4]	267	stdcall SetBufferPos, edx, [ebx+4]
268	ret	268	ret
269		269
270	align 4	270	align 4
271	.snd_getpos:	271	.snd_getpos:
272	stdcall GetBufferPos, edx	272	stdcall GetBufferPos, edx
273	mov edi, [ioctl]	273	mov edi, [ioctl]
274	mov ecx, [edi+output]	274	mov ecx, [edi+output]
275	mov ecx, [ecx]	275	mov ecx, [ecx]
276	mov [ecx], ebx	276	mov [ecx], ebx
277	ret	277	ret
278		278
279	align 4	279	align 4
280	.snd_setbuff:	280	.snd_setbuff:
281	mov eax, [ebx+4]	281	mov eax, [ebx+4]
282	stdcall set_buffer, edx, eax, [ebx+8], [ebx+12]	282	stdcall set_buffer, edx, eax, [ebx+8], [ebx+12]
283	ret	283	ret
284		284
285	align 4	285	align 4
286	.snd_out:	286	.snd_out:
287	mov eax, [ebx+4]	287	mov eax, [ebx+4]
288	stdcall wave_out, edx, eax, [ebx+8]	288	stdcall wave_out, edx, eax, [ebx+8]
289	ret	289	ret
290		290
291	align 4	291	align 4
292	.snd_play:	292	.snd_play:
293	stdcall play_buffer, edx, [ebx+4]	293	stdcall play_buffer, edx, [ebx+4]
294	ret	294	ret
295		295
296	align 4	296	align 4
297	.snd_stop:	297	.snd_stop:
298	stdcall stop_buffer, edx	298	stdcall stop_buffer, edx
299	ret	299	ret
300		300
301	align 4	301	align 4
302	.snd_setvolume:	302	.snd_setvolume:
303	stdcall SetBufferVol, edx, [ebx+4], [ebx+8]	303	stdcall SetBufferVol, edx, [ebx+4], [ebx+8]
304	ret	304	ret
305		305
306	align 4	306	align 4
307	.snd_getvolume:	307	.snd_getvolume:
308	mov eax, [edi+output]	308	mov eax, [edi+output]
309	mov ecx, [eax]	309	mov ecx, [eax]
310	mov eax, [eax+4]	310	mov eax, [eax+4]
311	stdcall GetBufferVol, edx, ecx, eax	311	stdcall GetBufferVol, edx, ecx, eax
312	ret	312	ret
313	align 4	313	align 4
314	.snd_setpan:	314	.snd_setpan:
315	stdcall SetBufferPan, edx, [ebx+4]	315	stdcall SetBufferPan, edx, [ebx+4]
316	ret	316	ret
317		317
318	align 4	318	align 4
319	.snd_getpan:	319	.snd_getpan:
320	mov eax, [edx+STREAM.pan]	320	mov eax, [edx+STREAM.pan]
321	mov ebx, [edi+output]	321	mov ebx, [edi+output]
322	mov ebx, [ebx]	322	mov ebx, [ebx]
323	mov [ebx], eax	323	mov [ebx], eax
324	xor eax, eax	324	xor eax, eax
325	ret	325	ret
326		326
327	align 4	327	align 4
328	.snd_getbuffsize:	328	.snd_getbuffsize:
329	mov eax, [edx+STREAM.in_size]	329	mov eax, [edx+STREAM.in_size]
330	mov ecx, [edi+output]	330	mov ecx, [edi+output]
331	mov ecx, [ecx]	331	mov ecx, [ecx]
332	mov [ecx], eax	332	mov [ecx], eax
333	xor eax, eax	333	xor eax, eax
334	ret	334	ret
335		335
336	align 4	336	align 4
337	.snd_getfreespace:	337	.snd_getfreespace:
338	test [edx+STREAM.format], PCM_OUT	338	test [edx+STREAM.format], PCM_OUT
339	jz .fail	339	jz .fail
340		340
341	mov ebx, [edx+STREAM.in_free]	341	mov ebx, [edx+STREAM.in_free]
342	mov ecx, [edi+output]	342	mov ecx, [edi+output]
343	mov [ecx], ebx	343	mov [ecx], ebx
344	xor eax, eax	344	xor eax, eax
345	ret	345	ret
346	align 4	346	align 4
347	.snd_settimebase:	347	.snd_settimebase:
348	cmp [edi+inp_size], 12	348	cmp [edi+inp_size], 12
349	jne .fail	349	jne .fail
350		350
351	mov eax, [ebx]	351	mov eax, [ebx+4]
-		352	mov ebx, [ebx+8]
-		353
-		354	pushfd
352	mov ebx, [ebx+4]	355	cli
353	mov dword [edx+STREAM.time_base], eax	356	mov dword [edx+STREAM.time_base], eax
354	mov dword [edx+STREAM.time_base+4], ebx	357	mov dword [edx+STREAM.time_base+4], ebx
355	xor eax, eax	358	xor eax, eax
-		359	mov dword [edx+STREAM.time_stamp], eax
-		360	mov dword [edx+STREAM.time_stamp+4], eax
-		361	popfd
-		362
356	ret	363	ret
-		364
357		365	align 4
358	.snd_gettimestamp:	366	.snd_gettimestamp:
359	cmp [edi+out_size], 8	367	cmp [edi+out_size], 8
360	jne .fail	368	jne .fail
361		369
362	pushfd	370	pushfd
363	cli	371	cli
364		372
365	xor ebx, ebx	373	xor ebx, ebx
366	push 48	374	push 48
367	push ebx ; local storage	375	push ebx ; local storage
368		376
369	cmp [edx+STREAM.flags], SND_STOP	377	cmp [edx+STREAM.flags], SND_STOP
370	je @F	378	je @F
371		379
372	mov eax, esp	380	mov eax, esp
-		381
-		382	push ebx
373		383	push ecx
-		384	push edx
374	push edx	385	push esi
375	push edi	386	push edi
376		387
377	push 4 ;.out_size	388	push 4 ;.out_size
378	push eax ;.output	389	push eax ;.output
379	push ebx ;.inp_size	390	push ebx ;.inp_size
380	push ebx ;.input	391	push ebx ;.input
381	push DEV_GET_POS ;.code	392	push DEV_GET_POS ;.code
382	push dword [hSound] ;.handle	393	push dword [hSound] ;.handle
383	mov eax, esp	394	mov eax, esp
384		395
385	stdcall ServiceHandler, eax	396	stdcall ServiceHandler, eax
386	add esp, 6*4	397	add esp, 6*4
387		398
388	pop edi	399	pop edi
-		400	pop esi
389	pop edx	401	pop edx
-		402	pop ecx
-		403	pop ebx
390		404
391	test eax, eax	405	test eax, eax
392	jz @F	406	jz @F
393		407
394	mov dword [esp], 0 ; clear offset	408	mov dword [esp], 0 ; clear offset
395	@@:	409	@@:
396	mov edi, [edi+output]	410	mov edi, [edi+output]
397		411
398	emms	412	emms
399	fild qword [edx+STREAM.time_stamp]	413	fild qword [edx+STREAM.time_stamp]
400	fiadd dword [esp] ; primary buffer offset	414	fiadd dword [esp] ; primary buffer offset
401	fidiv dword [esp+4] ; total_samples / frequency	415	fidiv dword [esp+4] ; total_samples / frequency
402	fadd qword [edx+STREAM.time_base]	416	fadd qword [edx+STREAM.time_base]
403	fstp qword [edi]	417	fstp qword [edi]
404	add esp, 8	418	add esp, 8
405		419
406	popfd	420	popfd
407		421
408	xor eax, eax	422	xor eax, eax
409	ret	423	ret
410	endp	424	endp
411		425
412		426
413	restore handle	427	restore handle
414	restore io_code	428	restore io_code
415	restore input	429	restore input
416	restore inp_size	430	restore inp_size
417	restore output	431	restore output
418	restore out_size	432	restore out_size
419		433
420	align 4	434	align 4
421	proc CreateBuffer stdcall, format:dword, size:dword	435	proc CreateBuffer stdcall, format:dword, size:dword
422	locals	436	locals
423	str dd ?	437	str dd ?
424	ring_size dd ?	438	ring_size dd ?
425	ring_pages dd ?	439	ring_pages dd ?
426	endl	440	endl
427		441
428	mov eax, [format]	442	mov eax, [format]
429	cmp ax, PCM_1_8_8	443	cmp ax, PCM_1_8_8
430	ja .fail	444	ja .fail
431		445
432	test eax, PCM_OUT	446	test eax, PCM_OUT
433	jnz .test_out	447	jnz .test_out
434	test eax, PCM_RING	448	test eax, PCM_RING
435	jnz .test_ring	449	jnz .test_ring
436	;staic	450	;staic
437	test eax, PCM_STATIC	451	test eax, PCM_STATIC
438	jz .test_out ;use PCM_OUT as default format	452	jz .test_out ;use PCM_OUT as default format
439	jmp .test_ok	453	jmp .test_ok
440	.test_out:	454	.test_out:
441	test eax, PCM_RING+PCM_STATIC	455	test eax, PCM_RING+PCM_STATIC
442	jnz .fail	456	jnz .fail
443	or [format], PCM_OUT ;force set	457	or [format], PCM_OUT ;force set
444	jmp .test_ok	458	jmp .test_ok
445	.test_ring:	459	.test_ring:
446	test eax, PCM_OUT+PCM_STATIC	460	test eax, PCM_OUT+PCM_STATIC
447	jnz .fail	461	jnz .fail
448	.test_ok:	462	.test_ok:
449		463
450	call GetPid	464	call GetPid
451	mov ebx, eax	465	mov ebx, eax
452	mov eax, STREAM.sizeof	466	mov eax, STREAM.sizeof
453		467
454	call CreateObject	468	call CreateObject
455	test eax, eax	469	test eax, eax
456	jz .fail	470	jz .fail
457	mov [str], eax	471	mov [str], eax
458		472
459	mov ebx, [format]	473	mov ebx, [format]
460	mov [eax+STREAM.format], ebx	474	mov [eax+STREAM.format], ebx
461		475
462	xor ecx, ecx	476	xor ecx, ecx
463	movzx ebx, bx	477	movzx ebx, bx
464	cmp ebx, 19	478	cmp ebx, 19
465	jb @f	479	jb @f
466	mov ecx, 0x80808080	480	mov ecx, 0x80808080
467	@@:	481	@@:
468	mov [eax+STREAM.r_silence], ecx	482	mov [eax+STREAM.r_silence], ecx
469		483
470	shl ebx, 2	484	shl ebx, 2
471	lea ebx, [ebx+ebx2] ;ebx=12	485	lea ebx, [ebx+ebx2] ;ebx=12
472		486
473	mov ecx, [resampler_params+ebx]	487	mov ecx, [resampler_params+ebx]
474	mov edx, [resampler_params+ebx+4]	488	mov edx, [resampler_params+ebx+4]
475	mov esi, [resampler_params+ebx+8]	489	mov esi, [resampler_params+ebx+8]
476		490
477	mov [eax+STREAM.r_size], ecx	491	mov [eax+STREAM.r_size], ecx
478	mov [eax+STREAM.r_dt], edx	492	mov [eax+STREAM.r_dt], edx
479	mov [eax+STREAM.resample], esi	493	mov [eax+STREAM.resample], esi
480	xor ecx, ecx	494	xor ecx, ecx
481	mov [eax+STREAM.l_vol], ecx	495	mov [eax+STREAM.l_vol], ecx
482	mov [eax+STREAM.r_vol], ecx	496	mov [eax+STREAM.r_vol], ecx
483	mov dword [eax+STREAM.l_amp], 0x7FFF7FFF	497	mov dword [eax+STREAM.l_amp], 0x7FFF7FFF
484	mov [eax+STREAM.pan], ecx	498	mov [eax+STREAM.pan], ecx
485		499
486	test [format], PCM_STATIC	500	test [format], PCM_STATIC

Subversion Repositories Kolibri OS

(root)/kernel/trunk/drivers/infinity.asm – Rev 2455 → 2694