kolibrios-gitea/kernel/branches/Kolibri-acpi/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]
        mov     ebx, [ebx+4]
        mov     dword [edx+STREAM.time_base], eax
        mov     dword [edx+STREAM.time_base+4], ebx
        xor     eax, eax
        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