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


;
;   This file is part of the Infinity sound library.
;   (C) copyright Serge 2006
;   email: infinity_sound@mail.ru
;
;   This program is free software; you can redistribute it and/or modify
;   it under the terms of the GNU General Public License as published by
;   the Free Software Foundation; either version 2 of the License, or
;   (at your option) any later version.
;
;   This program is distributed in the hope that it will be useful,
;   but WITHOUT ANY WARRANTY; without even the implied warranty of
;   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;   GNU General Public License for more details.
 
align 4
proc new_mix stdcall, output:dword
           locals
             mixCounter  dd ?
             mixIndex  dd ?
             streamIndex dd ?
             inputCount  dd ?
             main_count  dd ?
             blockCount  dd ?
             mix_out  dd ?
           endl
 
           call prepare_playlist
 
           cmp [play_count], 0
           je .exit
           call FpuSave
           mov [main_count], 32;
.l00:
           mov [mix_buff_map], 0x0000FFFF;
           xor eax, eax
           mov [mixCounter], eax
           mov [mixIndex],eax
           mov [streamIndex], eax;
           mov ebx, [play_count]
           mov [inputCount], ebx
.l0:
           mov ecx, 4
.l1:
           mov ebx, [streamIndex]
           mov esi, [play_list+ebx*4]
           mov eax, [esi+STREAM.work_read]
           add [esi+STREAM.work_read], 512
 
           mov ebx, [mixIndex]
           mov [mix_input+ebx*4], eax
           inc [mixCounter]
           inc [mixIndex]
           inc [streamIndex]
           dec [inputCount]
           jz .m2
 
           dec ecx
           jnz .l1
 
           cmp [mixCounter], 4
           jnz .m2
 
           stdcall mix_4_1, [mix_input],[mix_input+4],[mix_input+8],[mix_input+12]
           sub [mixIndex],4
           mov ebx, [mixIndex]
           mov [mix_input+ebx*4], eax
           inc [mixIndex]
           mov [mixCounter], 0
 
           cmp [inputCount], 0
           jnz .l0
.m2:
           cmp [mixIndex], 1
           jne @f
           stdcall copy_mem, [output], [mix_input]
           jmp .m3
@@:
           cmp [mixIndex], 2
           jne @f
           stdcall mix_2_1, [output], [mix_input], [mix_input+4]
           jmp .m3
@@:
           cmp [mixIndex], 3
           jne @f
           stdcall mix_3_1, [output],[mix_input],[mix_input+4],[mix_input+8]
           jmp .m3
@@:
           stdcall final_mix, [output],[mix_input],[mix_input+4],[mix_input+8], [mix_input+12]
.m3:
           add [output],512
 
           sub [main_count], 1
           jnz .l00
 
           call update_stream
           emms
           call FpuRestore
           ret
.exit:
           mov edi, [output]
           mov ecx, 0x1000
           xor eax, eax
           cld
           rep stosd
           ret
endp
 
align 4
proc update_stream
           locals
             stream_index  dd ?
             ev_code       dd ?  ;EVENT
             ev_offs       dd ?
                           rd 4
           endl
 
           mov [stream_index], 0
.l1:
           mov edx, [stream_index]
           mov esi, [play_list+edx*4]
 
           mov eax, [esi+STREAM.work_read]
           cmp eax, [esi+STREAM.work_top]
           jb @f
           mov eax, [esi+STREAM.work_buff]
@@:
           mov [esi+STREAM.work_read], eax
 
           cmp [esi+STREAM.format], PCM_2_16_48
           je .copy
 
           sub [esi+STREAM.work_count], 16384
 
           cmp [esi+STREAM.work_count], 32768
           ja @f
 
           stdcall refill, esi
@@:
           inc [stream_index]
           dec [play_count]
           jnz .l1
           ret
.copy:
           mov ebx, esi
           mov edi, [ebx+STREAM.work_write]
           cmp edi, [ebx+STREAM.work_top]
           jb @f
           mov edi, [ebx+STREAM.work_buff]
           mov [ebx+STREAM.work_write], edi
@@:
           mov esi, [ebx+STREAM.curr_seg]
           mov ecx, 16384/4
           cld
           rep movsd
 
           mov [ebx+STREAM.work_write], edi
 
           cmp esi, [ebx+STREAM.lim_0]
           jb @f
 
           mov esi, [ebx+STREAM.seg_0]
           mov eax, [ebx+STREAM.lim_0]
           xchg esi, [ebx+STREAM.seg_1]
           xchg eax, [ebx+STREAM.lim_1]
           mov [ebx+STREAM.seg_0], esi
           mov [ebx+STREAM.lim_0], eax
@@:
           mov [ebx+STREAM.curr_seg], esi
 
           xor ecx, ecx
           cmp esi, [ebx+STREAM.notify_off2]
           je @f
 
           mov ecx,0x8000
           cmp esi, [ebx+STREAM.notify_off1]
           je @f
 
           inc [stream_index]
           dec [play_count]
           jnz .l1
           ret
@@:
           mov [ev_code], 0xFF000001
           mov [ev_offs], ecx
           mov eax, [ebx+STREAM.notify_task]
 
           lea edx, [ev_code]
           push ebx
           stdcall SendEvent, eax, edx
           pop ebx
           test eax, eax
           jnz .l_end
 
           not eax
           mov [ebx+STREAM.notify_task], eax      ;-1
.l_end:
           inc [stream_index]
           dec [play_count]
           jnz .l1
           ret
endp
 
align 4
proc refill stdcall, str:dword
           locals
             ev_code       dd ?  ;EVENT
             ev_offs       dd ?
                           rd 4
           endl
 
           mov ebx, [str]
           mov ecx, [ebx+STREAM.work_write]
           cmp ecx, [ebx+STREAM.work_top]
           jbe .m2
           mov esi, [ebx+STREAM.work_top]
           sub ecx, esi
           mov edi, [ebx+STREAM.work_buff]
           shr ecx, 2
           rep movsd    ;call memcpy
 
           mov [ebx+STREAM.work_write], edi
.m2:
           mov esi, [ebx+STREAM.curr_seg]
           mov edi, [ebx+STREAM.work_write]
 
 
           stdcall [ebx+STREAM.resample], edi, esi, \
           [ebx+STREAM.r_dt],[ebx+STREAM.r_size],[ebx+STREAM.r_end]
 
           mov ebx, [str]
 
           add [ebx+STREAM.work_count], eax;
           add [ebx+STREAM.work_write], eax;
 
           mov eax, [ebx+STREAM.curr_seg]
           add eax, [ebx+STREAM.r_size]
           cmp eax, [ebx+STREAM.lim_0]
           jb @f
 
           mov esi, [ebx+STREAM.seg_0]
           lea edi, [esi-128]
           add esi, 0x7F80
           mov ecx, 128/4
           cld
           rep movsd
 
           mov eax, [ebx+STREAM.seg_0]
           mov ecx, [ebx+STREAM.lim_0]
           xchg eax, [ebx+STREAM.seg_1]
           xchg ecx, [ebx+STREAM.lim_1]
           mov [ebx+STREAM.seg_0], eax
           mov [ebx+STREAM.lim_0], ecx
@@:
           mov [ebx+STREAM.curr_seg], eax
 
           xor ecx, ecx
           cmp eax, [ebx+STREAM.notify_off2]
           je @f
 
           mov ecx,0x8000
           cmp eax, [ebx+STREAM.notify_off1]
           je @f
           ret
@@:
           mov [ev_code], 0xFF000001
           mov [ev_offs], ecx
           mov eax, [ebx+STREAM.notify_task]
 
           lea edx, [ev_code]
           push ebx
           stdcall SendEvent, eax, edx
           pop ebx
           test eax, eax
           jnz @F
           not eax
           mov [ebx+STREAM.notify_task], eax      ;-1
@@:
	   ret
endp
 
align 4
proc resample_1 stdcall, dest:dword,src:dword,\
		       r_dt:dword, r_size:dword,r_end:dword
 
; dest equ esp+8
; src  equ esp+12
; r_dt equ esp+16
; r_size equ esp+20
 
;r_end equ esp+24
 
           mov edi, [dest]
           mov edx, [src]
           sub edx, 32*2
           mov eax, 16
 
align 16
.l1:
	   mov ecx, eax
	   mov esi, eax
	   and ecx, 0x7FFF
	   shr esi, 15
	   lea esi, [edx+esi*2]
 
	   movsx ebp, word [esi]
	   movsx esi, word [esi+2]
	   mov ebx, 32768
	   imul esi, ecx
	   sub ebx, ecx
	   imul ebx, ebp
	   lea ecx, [ebx+esi+16384]
	   sar ecx, 15
	   cmp ecx, 32767	  ; 00007fffH
	   jle @f
	   mov ecx, 32767	  ; 00007fffH
	   jmp .write
@@:
	   cmp ecx, -32768	  ; ffff8000H
	   jge .write
	   mov ecx, -32768	  ; ffff8000H
.write:
	   mov ebx, ecx
	   shl ebx, 16
	   mov bx, cx
	   mov [edi], ebx
	   add edi, 4
 
    add eax, [esp+16]
    cmp eax, [esp+24]
	   jb .l1
 
	   mov ebp, esp
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	   sub edi, [dest]
	   mov eax, edi
	   ret
endp
 
align 4
proc resample_18 stdcall, dest:dword,src:dword,\
		       r_dt:dword, r_size:dword,r_end:dword
 
 
 
 
 
 
 
 
	   mov edi, [dest]
           mov edx, [src]
           sub edx, 32
 
	   mov esi, 16
 
align 16
.l1:
	   mov ecx, esi
	   mov eax, esi
	   and ecx, 0x7FFF
	   shr eax, 15
	   lea eax, [edx+eax]
 
	   mov bx, word [eax]
	   sub bh, 0x80
	   sub bl, 0x80
	   movsx eax, bh
	   shl eax,8
	   movsx ebp, bl
	   shl ebp,8
	   mov ebx, 32768
	   imul eax, ecx
	   sub ebx, ecx
	   imul ebx, ebp
	   lea ecx, [ebx+eax+16384]
	   sar ecx, 15
	   cmp ecx, 32767	  ; 00007fffH
	   jle @f
	   mov ecx, 32767	  ; 00007fffH
	   jmp .write
@@:
	   cmp ecx, -32768	  ; ffff8000H
	   jge .write
	   mov ecx, -32768	  ; ffff8000H
.write:
	   mov ebx, ecx
	   shl ebx, 16
	   mov bx, cx
	   mov [edi], ebx
	   add edi, 4
 
    add esi, [esp+16]
    cmp esi, [esp+24]
	   jb .l1
 
	   mov ebp, esp
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	   sub edi, [dest]
	   mov eax, edi
	   ret
endp
 
align 4
proc copy_stream stdcall, dest:dword,src:dword,\
		       r_dt:dword, r_size:dword,r_end:dword
 
           mov ecx, [r_size]
           mov eax, ecx
           shr ecx, 2
           mov esi, [src]
           mov edi, [dest]
           rep movsd
           mov eax, 16384
           ret
endp
 
align 4
proc resample_2 stdcall, dest:dword,src:dword,\
		       r_dt:dword, r_size:dword,r_end:dword
 
 
 
 
           mov edx, [src]
 
 
 
           sub edx, 32*4
           mov edi, [dest]
           mov ebx, [r_dt]
           mov eax, 16
           emms
 
align 16
.l1:
           mov ecx, eax
           mov esi, eax
           and ecx, 0x7FFF
           shr esi, 15
           lea esi, [edx+esi*4]
 
           movq mm0, [esi]
           movq mm1, mm0
 
           movd mm2, ecx
           punpcklwd mm2, mm2
           movq mm3, qword [m7]    ;0x8000
 
           psubw mm3, mm2 ;        ;0x8000 - iconst
           punpckldq mm3, mm2
 
           pmulhw mm0, mm3
           pmullw mm1, mm3
 
           movq mm4, mm1
           punpcklwd mm1, mm0
           punpckhwd mm4, mm0
           paddd mm1, mm4
           psrad  mm1, 15
           packssdw mm1, mm1
           movd [edi], mm1
           add edi, 4
 
           add eax, ebx
           cmp eax, [r_end]
           jb .l1
           emms
 
 
 
 
 
 
 
 
 
 
 
 
 
 
           sub edi, [dest]
           mov eax, edi
           ret
endp
 
align 4
proc resample_28 stdcall, dest:dword,src:dword,\
		       r_dt:dword, r_size:dword,r_end:dword
 
 
 
 
           mov edx, [src]
 
 
 
           sub edx, 32*2
           mov edi, [dest]
           mov ebx, [r_dt]
           mov eax, 16
           emms
           movq mm7,[mm80]
           movq mm6,[mm_mask]
 
align 16
.l1:
	   mov ecx, eax
	   mov esi, eax
	   and ecx, 0x7FFF
	   shr esi, 15
	   lea esi, [edx+esi*2]
 
	   movq mm0, [esi]
	   psubb mm0,mm7
	   punpcklbw mm0,mm0
	   pand mm0,mm6
 
	   movq mm1, mm0
 
	   movd mm2, ecx
	   punpcklwd mm2, mm2
	   movq mm3, qword [m7] ;                  // 0x8000
 
	   psubw mm3, mm2	;         // 0x8000 - iconst
	   punpckldq mm3, mm2
 
	   pmulhw mm0, mm3
	   pmullw mm1, mm3
 
	   movq mm4, mm1
	   punpcklwd mm1, mm0
	   punpckhwd mm4, mm0
	   paddd mm1, mm4
	   psrad  mm1, 15
	   packssdw mm1, mm1
	   movd [edi], mm1
	   add edi, 4
 
	   add eax, ebx
	   cmp eax, [r_end]
	   jb .l1
	   emms
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	   sub edi, [dest]
	   mov eax, edi
	   ret
endp
 
 
proc m16_stereo stdcall, dest:dword,src:dword,\
		       r_dt:dword, r_size:dword,r_end:dword
 
	   mov esi, [src]
	   mov edi, [dest]
	   mov ecx, [r_size]
	   shr ecx,8
@@:
	   call m16_s_mmx
	   add edi, 128
	   add esi, 64
	   call m16_s_mmx
	   add edi, 128
	   add esi, 64
	   call m16_s_mmx
	   add edi, 128
	   add esi, 64
	   call m16_s_mmx
	   add edi, 128
	   add esi, 64
	   dec ecx
	   jnz @b
 
	   mov eax, [r_size]
	   add eax, eax
	   ret
endp
 
align 4
proc s8_stereo stdcall, dest:dword,src:dword,\
		       r_dt:dword, r_size:dword,r_end:dword
 
           mov esi, [src]
           mov edi, [dest]
           mov ecx, [r_size]
           shr ecx, 7
 
           movq mm7, [mm80]
           movq mm6, [mm_mask]
@@:
           call s8_s_mmx
           add edi, 64
           add esi, 32
           call s8_s_mmx
           add edi, 64
           add esi, 32
           call s8_s_mmx
           add edi, 64
           add esi, 32
           call s8_s_mmx
           add edi, 64
           add esi, 32
           dec ecx
           jnz @b
 
           mov eax, [r_size]
           add eax, eax
           ret
endp
 
proc m8_stereo stdcall, dest:dword,src:dword,\
		       r_dt:dword, r_size:dword,r_end:dword
 
           mov esi, [src]
           mov edi, [dest]
           mov ecx, [r_size]
           shr ecx, 6
 
           movq mm7, [mm80]
           movq mm6, [mm_mask]
@@:
           call m8_s_mmx
           add edi, 64
           add esi, 16
           call m8_s_mmx
           add edi, 64
           add esi, 16
           call m8_s_mmx
           add edi, 64
           add esi, 16
           call m8_s_mmx
           add edi, 64
           add esi, 16
                  dec ecx
           jnz @b
 
           mov eax, [r_size]
           add eax, eax
           add eax, eax
           ret
endp
 
align 4
proc alloc_mix_buff
 
           bsf eax, [mix_buff_map]
           jnz .find
           xor eax, eax
           ret
.find:
           btr [mix_buff_map], eax
           shl eax, 9
           add eax, [mix_buff]
           ret
endp
 
proc m16_s_mmx
 
	   movq    mm0, [esi]
	   movq    mm1, mm0
	   punpcklwd mm0, mm0
	   punpckhwd mm1, mm1
	   movq    [edi], mm0
	   movq    [edi+8], mm1
 
	   movq    mm0, [esi+8]
	   movq    mm1, mm0
	   punpcklwd mm0, mm0
	   punpckhwd mm1, mm1
	   movq    [edi+16], mm0
	   movq    [edi+24], mm1
 
	   movq    mm0, [esi+16]
	   movq    mm1, mm0
	   punpcklwd mm0, mm0
	   punpckhwd mm1, mm1
	   movq    [edi+32], mm0
	   movq    [edi+40], mm1
 
	   movq    mm0, [esi+24]
	   movq    mm1, mm0
	   punpcklwd mm0, mm0
	   punpckhwd mm1, mm1
	   movq    [edi+48], mm0
	   movq    [edi+56], mm1
 
	   movq    mm0, [esi+32]
	   movq    mm1, mm0
	   punpcklwd mm0, mm0
	   punpckhwd mm1, mm1
	   movq    [edi+64], mm0
	   movq    [edi+72], mm1
 
	   movq    mm0, [esi+40]
	   movq    mm1, mm0
	   punpcklwd mm0, mm0
	   punpckhwd mm1, mm1
	   movq    [edi+80], mm0
	   movq    [edi+88], mm1
 
 
	   movq    mm0, [esi+48]
	   movq    mm1, mm0
	   punpcklwd mm0, mm0
	   punpckhwd mm1, mm1
	   movq    [edi+96], mm0
	   movq    [edi+104], mm1
 
	   movq    mm0, [esi+56]
	   movq    mm1, mm0
	   punpcklwd mm0, mm0
	   punpckhwd mm1, mm1
	   movq    [edi+112], mm0
	   movq    [edi+120], mm1
 
	   ret
endp
 
align 4
proc s8_s_mmx
 
           movq    mm0, [esi]
           psubb   mm0, mm7
           movq    mm1, mm0
           punpcklbw mm0, mm0
           pand mm0, mm6
           punpckhbw mm1, mm1
           pand mm1, mm6
           movq    [edi], mm0
           movq    [edi+8], mm1
 
           movq    mm0, [esi+8]
           psubb   mm0, mm7
           movq    mm1, mm0
           punpcklbw mm0, mm0
           pand mm0, mm6
           punpckhbw mm1, mm1
           pand mm1, mm6
           movq    [edi+16], mm0
           movq    [edi+24], mm1
 
           movq    mm0, [esi+16]
           psubb   mm0, mm7
           movq    mm1, mm0
           punpcklbw mm0, mm0
           pand mm0, mm6
           punpckhbw mm1, mm1
           pand mm1, mm6
           movq    [edi+32], mm0
           movq    [edi+40], mm1
 
           movq    mm0, [esi+24]
           psubb   mm0, mm7
           movq    mm1, mm0
           punpcklbw mm0, mm0
           pand    mm0, mm6
           punpckhbw mm1, mm1
           pand    mm1, mm6
           movq    [edi+48], mm0
           movq    [edi+56], mm1
 
           ret
 
endp
 
align 4
proc m8_s_mmx
 
           movq    mm0, [esi]
           psubb   mm0, mm7
           movq    mm1, mm0
           punpcklbw mm0, mm0
           pand mm0, mm6
           punpckhbw mm1, mm1
           pand mm1, mm6
           movq mm2, mm0
           punpcklwd mm0, mm0
           punpckhwd mm2, mm2
 
           movq mm3, mm1
           punpcklwd mm1, mm1
           punpckhwd mm3, mm3
 
           movq    [edi], mm0
           movq    [edi+8], mm2
           movq    [edi+16], mm1
           movq    [edi+24], mm3
 
           movq    mm0, [esi+8]
           psubb   mm0, mm7
           movq    mm1, mm0
           punpcklbw mm0, mm0
           pand mm0, mm6
           punpckhbw mm1, mm1
           pand mm1, mm6
           movq mm2, mm0
           punpcklwd mm0, mm0
           punpckhwd mm2, mm2
 
           movq mm3, mm1
           punpcklwd mm1, mm1
           punpckhwd mm3, mm3
 
           movq    [edi+32], mm0
           movq    [edi+40], mm2
           movq    [edi+48], mm1
           movq    [edi+56], mm3
 
           ret
endp
 
 
align 4
proc mix_2_1 stdcall, output:dword, str0:dword, str1:dword
 
           mov edi, [output]
 
           stdcall mix_2_1_mmx, edi, [str0],[str1]
           add edi, 128
           add [str0], 128
           add [str1], 128
           stdcall mix_2_1_mmx, edi, [str0],[str1]
           add edi, 128
           add [str0], 128
           add [str1], 128
           stdcall mix_2_1_mmx, edi, [str0],[str1]
           add edi, 128
           add [str0], 128
           add [str1], 128
           stdcall mix_2_1_mmx, edi, [str0],[str1]
 
           ret
endp
 
 
align 4
proc mix_3_1 stdcall, output:dword, str0:dword, str1:dword, str2:dword
 
	   mov edi, [output]
 
	   stdcall mix_3_1_mmx, edi, [str0],[str1],[str2]
	   add edi, 128
	   add [str0], 128
	   add [str1], 128
	   add [str2], 128
	   stdcall mix_3_1_mmx, edi, [str0],[str1],[str2]
	   add edi, 128
	   add [str0], 128
	   add [str1], 128
	   add [str2], 128
	   stdcall mix_3_1_mmx, edi, [str0],[str1],[str2]
	   add edi, 128
	   add [str0], 128
	   add [str1], 128
	   add [str2], 128
	   stdcall mix_3_1_mmx, edi, [str0],[str1],[str2]
 
	   ret
endp
 
align 4
proc mix_4_1 stdcall, str0:dword, str1:dword,\
		      str2:dword, str3:dword
 
	   local output:DWORD
 
	   call alloc_mix_buff
	   and eax, eax
	   jz .err
	   mov [output], eax
 
	   mov edi, eax
 
	   stdcall mix_4_1_mmx, edi, [str0],[str1],[str2],[str3]
	   add edi, 128
	   add [str0], 128
	   add [str1], 128
	   add [str2], 128
	   add [str3], 128
	   stdcall mix_4_1_mmx, edi, [str0],[str1],[str2],[str3]
	   add edi, 128
	   add [str0], 128
	   add [str1], 128
	   add [str2], 128
	   add [str3], 128
	   stdcall mix_4_1_mmx, edi, [str0],[str1],[str2],[str3]
	   add edi, 128
	   add [str0], 128
	   add [str1], 128
	   add [str2], 128
	   add [str3], 128
	   stdcall mix_4_1_mmx, edi, [str0],[str1],[str2],[str3]
	   mov eax, [output]
	   ret
.err:
	   xor eax, eax
	   ret
endp
 
 
align 4
proc final_mix stdcall, output:dword, str0:dword, str1:dword,\
			str2:dword, str3:dword
 
	   mov edi, [output]
 
	   stdcall mix_4_1_mmx, edi, [str0],[str1],[str2],[str3]
	   add edi, 128
	   add [str0], 128
	   add [str1], 128
	   add [str2], 128
	   add [str3], 128
	   stdcall mix_4_1_mmx, edi, [str0],[str1],[str2],[str3]
	   add edi, 128
	   add [str0], 128
	   add [str1], 128
	   add [str2], 128
	   add [str3], 128
	   stdcall mix_4_1_mmx, edi, [str0],[str1],[str2],[str3]
	   add edi, 128
	   add [str0], 128
	   add [str1], 128
	   add [str2], 128
	   add [str3], 128
	   stdcall mix_4_1_mmx, edi, [str0],[str1],[str2],[str3]
 
	   ret
endp
 
align 4
proc mix_2_1_mmx stdcall, output:dword, str0:dword, str1:dword
 
           mov edx, [output]
           mov eax, [str0]
           mov ecx, [str1]
 
           movq mm0, [eax]
           paddsw mm0, [ecx]
           ; psraw   mm0, 1
           movq [edx], mm0
 
           movq mm1, [eax+8]
           paddsw mm1,[ecx+8]
           ; psraw   mm1, 1
           movq [edx+8], mm1
 
           movq mm2, [eax+16]
           paddsw mm2, [ecx+16]
           ; psraw   mm2, 1
           movq [edx+16], mm2
 
           movq mm3, [eax+24]
           paddsw mm3, [ecx+24]
           ; psraw   mm3, 1
           movq [edx+24], mm3
 
           movq mm0, [eax+32]
           paddsw mm0, [ecx+32]
           ; psraw   mm0, 1
           movq [edx+32], mm0
 
           movq mm1, [eax+40]
           paddsw mm1, [ecx+40]
           ; psraw   mm1, 1
           movq [edx+40], mm1
 
           movq mm2, [eax+48]
           paddsw mm2, [ecx+48]
           ; psraw   mm2, 1
           movq [edx+48], mm2
 
           movq mm3, [eax+56]
           paddsw mm3, [ecx+56]
           ; psraw   mm3, 1
           movq [edx+56], mm3
 
           movq mm0, [eax+64]
           paddsw mm0, [ecx+64]
           ; psraw   mm0, 1
           movq [edx+64], mm0
 
           movq mm1, [eax+72]
           paddsw mm1, [ecx+72]
           ; psraw   mm1, 1
           movq [edx+72], mm1
 
           movq mm2, [eax+80]
           paddsw mm2, [ecx+80]
           ; psraw   mm2, 1
           movq [edx+80], mm2
 
           movq mm3, [eax+88]
           paddsw mm3, [ecx+88]
           ; psraw   mm3, 1
           movq [edx+88], mm3
 
           movq mm0, [eax+96]
           paddsw mm0, [ecx+96]
           ; psraw   mm0, 1
           movq [edx+96], mm0
 
           movq mm1, [eax+104]
           paddsw mm1, [ecx+104]
           ; psraw   mm1, 1
           movq [edx+104], mm1
 
           movq mm2, [eax+112]
           paddsw mm2, [ecx+112]
           ; psraw   mm2, 1
           movq [edx+112], mm2
 
           movq mm3, [eax+120]
           paddsw mm3, [ecx+120]
           ; psraw   mm3, 1
           movq [edx+120], mm3
 
           ret
endp
 
align 4
proc mix_3_1_mmx stdcall, output:dword, str0:dword, str1:dword, str2:dword
 
           mov edx, [output]
           mov eax, [str0]
           mov ebx, [str1]
           mov ecx, [str2]
 
           movq mm0, [eax]
           paddsw mm0, [ebx]
           paddsw mm0, [ecx]
           movq [edx], mm0
 
           movq mm1, [eax+8]
           paddsw mm1,[ebx+8]
           paddsw mm1,[ecx+8]
           movq [edx+8], mm1
 
           movq mm2, [eax+16]
           paddsw mm2, [ebx+16]
           paddsw mm2, [ecx+16]
           movq [edx+16], mm2
 
           movq mm3, [eax+24]
           paddsw mm3, [ebx+24]
           paddsw mm3, [ecx+24]
           movq [edx+24], mm3
 
           movq mm0, [eax+32]
           paddsw mm0, [ebx+32]
           paddsw mm0, [ecx+32]
           movq [edx+32], mm0
 
           movq mm1, [eax+40]
           paddsw mm1, [ebx+40]
           paddsw mm1, [ecx+40]
           movq [edx+40], mm1
 
           movq mm2, [eax+48]
           paddsw mm2, [ebx+48]
           paddsw mm2, [ecx+48]
           movq [edx+48], mm2
 
           movq mm3, [eax+56]
           paddsw mm3, [ebx+56]
           paddsw mm3, [ecx+56]
           movq [edx+56], mm3
 
           movq mm0, [eax+64]
           paddsw mm0, [ebx+64]
           paddsw mm0, [ecx+64]
           movq [edx+64], mm0
 
           movq mm1, [eax+72]
           paddsw mm1, [ebx+72]
           paddsw mm1, [ecx+72]
           movq [edx+72], mm1
 
           movq mm2, [eax+80]
           paddsw mm2, [ebx+80]
           paddsw mm2, [ecx+80]
           movq [edx+80], mm2
 
           movq mm3, [eax+88]
           paddsw mm3, [ebx+88]
           paddsw mm3, [ecx+88]
           movq [edx+88], mm3
 
           movq mm0, [eax+96]
           paddsw mm0, [ebx+96]
           paddsw mm0, [ecx+96]
           movq [edx+96], mm0
 
           movq mm1, [eax+104]
           paddsw mm1, [ebx+104]
           paddsw mm1, [ecx+104]
           movq [edx+104], mm1
 
           movq mm2, [eax+112]
           paddsw mm2, [ebx+112]
           paddsw mm2, [ecx+112]
           movq [edx+112], mm2
 
           movq mm3, [eax+120]
           paddsw mm3, [ebx+120]
           paddsw mm3, [ecx+120]
           movq [edx+120], mm3
 
           ret
endp
 
align 4
proc mix_4_1_mmx stdcall, output:dword, str0:dword, str1:dword,\
                          str2:dword, str3:dword
 
           mov edx, [output]
           mov esi, [str0]
           mov eax, [str1]
           mov ebx, [str2]
           mov ecx, [str3]
 
           movq mm0, [esi]
           movq mm1, [eax]
           paddsw mm0, [ebx]
           paddsw mm1, [ecx]
           paddsw mm0, mm1
           movq [edx], mm0
 
           movq mm2, [esi+8]
           movq mm3, [eax+8]
           paddsw mm2, [ebx+8]
           paddsw mm3, [ecx+8]
           paddsw mm2, mm3
           movq [edx+8], mm2
 
           movq mm0, [esi+16]
           movq mm1, [eax+16]
           paddsw mm0, [ebx+16]
           paddsw mm1, [ecx+16]
           paddsw mm0, mm1
           movq [edx+16], mm0
 
           movq mm2, [esi+24]
           movq mm3, [eax+24]
           paddsw mm2, [ebx+24]
           paddsw mm3, [ecx+24]
           paddsw mm2, mm3
           movq [edx+24], mm2
 
           movq mm0, [esi+32]
           movq mm1, [eax+32]
           paddsw mm0, [ebx+32]
           paddsw mm1, [ecx+32]
           paddsw mm0, mm1
           movq [edx+32], mm0
 
           movq mm2, [esi+40]
           movq mm3, [eax+40]
           paddsw mm2, [ebx+40]
           paddsw mm3, [ecx+40]
           paddsw mm2, mm3
           movq [edx+40], mm2
 
           movq mm0, [esi+48]
           movq mm1, [eax+48]
           paddsw mm0, [ebx+48]
           paddsw mm1, [ecx+48]
           paddsw mm0, mm1
           movq [edx+48], mm0
 
           movq mm2, [esi+56]
           movq mm3, [eax+56]
           paddsw mm2, [ebx+56]
           paddsw mm3, [ecx+56]
           paddsw mm2, mm3
           movq [edx+56], mm2
 
           movq mm0, [esi+64]
           movq mm1, [eax+64]
           paddsw mm0, [ebx+64]
           paddsw mm1, [ecx+64]
           paddsw mm0, mm1
           movq [edx+64], mm0
 
           movq mm2, [esi+72]
           movq mm3, [eax+72]
           paddsw mm2, [ebx+72]
           paddsw mm3, [ecx+72]
           paddsw mm2, mm3
           movq [edx+72], mm2
 
           movq mm2, [esi+80]
           movq mm3, [eax+80]
           paddsw mm2, [ebx+80]
           paddsw mm3, [ecx+80]
           paddsw mm2, mm3
           movq [edx+80], mm2
 
           movq mm2, [esi+88]
           movq mm3, [eax+88]
           paddsw mm2, [ebx+88]
           paddsw mm3, [ecx+88]
           paddsw mm2, mm3
           movq [edx+88], mm2
 
           movq mm2, [esi+96]
           movq mm3, [eax+96]
           paddsw mm2, [ebx+96]
           paddsw mm3, [ecx+96]
           paddsw mm2, mm3
           movq [edx+96], mm2
 
           movq mm2, [esi+104]
           movq mm3, [eax+104]
           paddsw mm2, [ebx+104]
           paddsw mm3, [ecx+104]
           paddsw mm2, mm3
           movq [edx+104], mm2
 
           movq mm2, [esi+112]
           movq mm3, [eax+112]
           paddsw mm2, [ebx+112]
           paddsw mm3, [ecx+112]
           paddsw mm2, mm3
           movq [edx+112], mm2
 
           movq mm2, [esi+120]
           movq mm3, [eax+120]
           paddsw mm2, [ebx+120]
           paddsw mm3, [ecx+120]
           paddsw mm2, mm3
           movq [edx+120], mm2
 
           ret
endp
 
align 4
proc copy_mem stdcall, output:dword, input:dword
 
	   mov edi, [output]
	   mov esi, [input]
	   mov ecx, 0x80
.l1:
	   mov eax, [esi]
	   mov [edi], eax
	   add esi, 4
	   add edi, 4
	   loop .l1
 
	   ret
endp
 
proc memcpy
@@:
	   mov eax, [esi]
	   mov [edi], eax
	   add esi, 4
	   add edi, 4
	   dec ecx
	   jnz @B
	   ret
endp

Rev 281	Rev 285
1	;	1	;
2	; This file is part of the Infinity sound library.	2	; This file is part of the Infinity sound library.
3	; (C) copyright Serge 2006	3	; (C) copyright Serge 2006
4	; email: infinity_sound@mail.ru	4	; email: infinity_sound@mail.ru
5	;	5	;
6	; This program is free software; you can redistribute it and/or modify	6	; This program is free software; you can redistribute it and/or modify
7	; it under the terms of the GNU General Public License as published by	7	; it under the terms of the GNU General Public License as published by
8	; the Free Software Foundation; either version 2 of the License, or	8	; the Free Software Foundation; either version 2 of the License, or
9	; (at your option) any later version.	9	; (at your option) any later version.
10	;	10	;
11	; This program is distributed in the hope that it will be useful,	11	; This program is distributed in the hope that it will be useful,
12	; but WITHOUT ANY WARRANTY; without even the implied warranty of	12	; but WITHOUT ANY WARRANTY; without even the implied warranty of
13	; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	; GNU General Public License for more details.	14	; GNU General Public License for more details.
15		15
16	align 4	16	align 4
17	proc new_mix stdcall, output:dword	17	proc new_mix stdcall, output:dword
18	locals	18	locals
19	mixCounter dd ?	19	mixCounter dd ?
20	mixIndex dd ?	20	mixIndex dd ?
21	streamIndex dd ?	21	streamIndex dd ?
22	inputCount dd ?	22	inputCount dd ?
23	main_count dd ?	23	main_count dd ?
24	blockCount dd ?	24	blockCount dd ?
25	mix_out dd ?	25	mix_out dd ?
26	endl	26	endl
27		27
28	call prepare_playlist	28	call prepare_playlist
29		29
30	cmp [play_count], 0	30	cmp [play_count], 0
31	je .exit	31	je .exit
32	call FpuSave	32	call FpuSave
33	mov [main_count], 32;	33	mov [main_count], 32;
34	.l00:	34	.l00:
35	mov [mix_buff_map], 0x0000FFFF;	35	mov [mix_buff_map], 0x0000FFFF;
36	xor eax, eax	36	xor eax, eax
37	mov [mixCounter], eax	37	mov [mixCounter], eax
38	mov [mixIndex],eax	38	mov [mixIndex],eax
39	mov [streamIndex], eax;	39	mov [streamIndex], eax;
40	mov ebx, [play_count]	40	mov ebx, [play_count]
41	mov [inputCount], ebx	41	mov [inputCount], ebx
42	.l0:	42	.l0:
43	mov ecx, 4	43	mov ecx, 4
44	.l1:	44	.l1:
45	mov ebx, [streamIndex]	45	mov ebx, [streamIndex]
46	mov esi, [play_list+ebx*4]	46	mov esi, [play_list+ebx*4]
47	mov eax, [esi+STREAM.work_read]	47	mov eax, [esi+STREAM.work_read]
48	add [esi+STREAM.work_read], 512	48	add [esi+STREAM.work_read], 512
49		49
50	mov ebx, [mixIndex]	50	mov ebx, [mixIndex]
51	mov [mix_input+ebx*4], eax	51	mov [mix_input+ebx*4], eax
52	inc [mixCounter]	52	inc [mixCounter]
53	inc [mixIndex]	53	inc [mixIndex]
54	inc [streamIndex]	54	inc [streamIndex]
55	dec [inputCount]	55	dec [inputCount]
56	jz .m2	56	jz .m2
57		57
58	dec ecx	58	dec ecx
59	jnz .l1	59	jnz .l1
60		60
61	cmp [mixCounter], 4	61	cmp [mixCounter], 4
62	jnz .m2	62	jnz .m2
63		63
64	stdcall mix_4_1, [mix_input],[mix_input+4],[mix_input+8],[mix_input+12]	64	stdcall mix_4_1, [mix_input],[mix_input+4],[mix_input+8],[mix_input+12]
65	sub [mixIndex],4	65	sub [mixIndex],4
66	mov ebx, [mixIndex]	66	mov ebx, [mixIndex]
67	mov [mix_input+ebx*4], eax	67	mov [mix_input+ebx*4], eax
68	inc [mixIndex]	68	inc [mixIndex]
69	mov [mixCounter], 0	69	mov [mixCounter], 0
70		70
71	cmp [inputCount], 0	71	cmp [inputCount], 0
72	jnz .l0	72	jnz .l0
73	.m2:	73	.m2:
74	cmp [mixIndex], 1	74	cmp [mixIndex], 1
75	jne @f	75	jne @f
76	stdcall copy_mem, [output], [mix_input]	76	stdcall copy_mem, [output], [mix_input]
77	jmp .m3	77	jmp .m3
78	@@:	78	@@:
79	cmp [mixIndex], 2	79	cmp [mixIndex], 2
80	jne @f	80	jne @f
81	stdcall mix_2_1, [output], [mix_input], [mix_input+4]	81	stdcall mix_2_1, [output], [mix_input], [mix_input+4]
82	jmp .m3	82	jmp .m3
83	@@:	83	@@:
84	cmp [mixIndex], 3	84	cmp [mixIndex], 3
85	jne @f	85	jne @f
86	stdcall mix_3_1, [output],[mix_input],[mix_input+4],[mix_input+8]	86	stdcall mix_3_1, [output],[mix_input],[mix_input+4],[mix_input+8]
87	jmp .m3	87	jmp .m3
88	@@:	88	@@:
89	stdcall final_mix, [output],[mix_input],[mix_input+4],[mix_input+8], [mix_input+12]	89	stdcall final_mix, [output],[mix_input],[mix_input+4],[mix_input+8], [mix_input+12]
90	.m3:	90	.m3:
91	add [output],512	91	add [output],512
92		92
93	sub [main_count], 1	93	sub [main_count], 1
94	jnz .l00	94	jnz .l00
95		95
96	call update_stream	96	call update_stream
97	emms	97	emms
98	call FpuRestore	98	call FpuRestore
99	ret	99	ret
100	.exit:	100	.exit:
101	mov edi, [output]	101	mov edi, [output]
102	mov ecx, 0x1000	102	mov ecx, 0x1000
103	xor eax, eax	103	xor eax, eax
104	cld	104	cld
105	rep stosd	105	rep stosd
106	ret	106	ret
107	endp	107	endp
108		108
109	align 4	109	align 4
110	proc update_stream	110	proc update_stream
111	locals	111	locals
112	stream_index dd ?	112	stream_index dd ?
113	ev_code dd ? ;EVENT	113	ev_code dd ? ;EVENT
114	ev_offs dd ?	114	ev_offs dd ?
115	rd 4	115	rd 4
116	endl	116	endl
117		117
118	mov [stream_index], 0	118	mov [stream_index], 0
119	.l1:	119	.l1:
120	mov edx, [stream_index]	120	mov edx, [stream_index]
121	mov esi, [play_list+edx*4]	121	mov esi, [play_list+edx*4]
122		122
123	mov eax, [esi+STREAM.work_read]	123	mov eax, [esi+STREAM.work_read]
124	cmp eax, [esi+STREAM.work_top]	124	cmp eax, [esi+STREAM.work_top]
125	jb @f	125	jb @f
126	mov eax, [esi+STREAM.work_buff]	126	mov eax, [esi+STREAM.work_buff]
127	@@:	127	@@:
128	mov [esi+STREAM.work_read], eax	128	mov [esi+STREAM.work_read], eax
129		129
130	cmp [esi+STREAM.format], PCM_2_16_48	130	cmp [esi+STREAM.format], PCM_2_16_48
131	je .copy	131	je .copy
132		132
133	sub [esi+STREAM.work_count], 16384	133	sub [esi+STREAM.work_count], 16384
134		134
135	cmp [esi+STREAM.work_count], 32768	135	cmp [esi+STREAM.work_count], 32768
136	ja @f	136	ja @f
137		137
138	stdcall refill, esi	138	stdcall refill, esi
139	@@:	139	@@:
140	inc [stream_index]	140	inc [stream_index]
141	dec [play_count]	141	dec [play_count]
142	jnz .l1	142	jnz .l1
143	ret	143	ret
144	.copy:	144	.copy:
145	mov ebx, esi	145	mov ebx, esi
146	mov edi, [ebx+STREAM.work_write]	146	mov edi, [ebx+STREAM.work_write]
147	cmp edi, [ebx+STREAM.work_top]	147	cmp edi, [ebx+STREAM.work_top]
148	jb @f	148	jb @f
149	mov edi, [ebx+STREAM.work_buff]	149	mov edi, [ebx+STREAM.work_buff]
150	mov [ebx+STREAM.work_write], edi	150	mov [ebx+STREAM.work_write], edi
151	@@:	151	@@:
152	mov esi, [ebx+STREAM.curr_seg]	152	mov esi, [ebx+STREAM.curr_seg]
153	mov ecx, 16384/4	153	mov ecx, 16384/4
154	cld	154	cld
155	rep movsd	155	rep movsd
156		156
157	mov [ebx+STREAM.work_write], edi	157	mov [ebx+STREAM.work_write], edi
158		158
159	cmp esi, [ebx+STREAM.lim_0]	159	cmp esi, [ebx+STREAM.lim_0]
160	jb @f	160	jb @f
161		161
162	mov esi, [ebx+STREAM.seg_0]	162	mov esi, [ebx+STREAM.seg_0]
163	mov eax, [ebx+STREAM.lim_0]	163	mov eax, [ebx+STREAM.lim_0]
164	xchg esi, [ebx+STREAM.seg_1]	164	xchg esi, [ebx+STREAM.seg_1]
165	xchg eax, [ebx+STREAM.lim_1]	165	xchg eax, [ebx+STREAM.lim_1]
166	mov [ebx+STREAM.seg_0], esi	166	mov [ebx+STREAM.seg_0], esi
167	mov [ebx+STREAM.lim_0], eax	167	mov [ebx+STREAM.lim_0], eax
168	@@:	168	@@:
169	mov [ebx+STREAM.curr_seg], esi	169	mov [ebx+STREAM.curr_seg], esi
170		170
171	xor ecx, ecx	171	xor ecx, ecx
172	cmp esi, [ebx+STREAM.notify_off2]	172	cmp esi, [ebx+STREAM.notify_off2]
173	je @f	173	je @f
174		174
175	mov ecx,0x8000	175	mov ecx,0x8000
176	cmp esi, [ebx+STREAM.notify_off1]	176	cmp esi, [ebx+STREAM.notify_off1]
177	je @f	177	je @f
178		178
179	inc [stream_index]	179	inc [stream_index]
180	dec [play_count]	180	dec [play_count]
181	jnz .l1	181	jnz .l1
182	ret	182	ret
183	@@:	183	@@:
184	mov [ev_code], 0xFF000001	184	mov [ev_code], 0xFF000001
185	mov [ev_offs], ecx	185	mov [ev_offs], ecx
186	mov eax, [ebx+STREAM.notify_task]	186	mov eax, [ebx+STREAM.notify_task]
187		187
188	lea edx, [ev_code]	188	lea edx, [ev_code]
189	push ebx	189	push ebx
190	stdcall SendEvent, eax, edx	190	stdcall SendEvent, eax, edx
191	pop ebx	191	pop ebx
192	test eax, eax	192	test eax, eax
193	jnz .l_end	193	jnz .l_end
194		194
195	not eax	195	not eax
196	mov [ebx+STREAM.notify_task], eax ;-1	196	mov [ebx+STREAM.notify_task], eax ;-1
197	.l_end:	197	.l_end:
198	inc [stream_index]	198	inc [stream_index]
199	dec [play_count]	199	dec [play_count]
200	jnz .l1	200	jnz .l1
201	ret	201	ret
202	endp	202	endp
203		203
204	align 4	204	align 4
205	proc refill stdcall, str:dword	205	proc refill stdcall, str:dword
206	locals	206	locals
207	ev_code dd ? ;EVENT	207	ev_code dd ? ;EVENT
208	ev_offs dd ?	208	ev_offs dd ?
209	rd 4	209	rd 4
210	endl	210	endl
211		211
212	mov ebx, [str]	212	mov ebx, [str]
213	mov ecx, [ebx+STREAM.work_write]	213	mov ecx, [ebx+STREAM.work_write]
214	cmp ecx, [ebx+STREAM.work_top]	214	cmp ecx, [ebx+STREAM.work_top]
215	jbe .m2	215	jbe .m2
216	mov esi, [ebx+STREAM.work_top]	216	mov esi, [ebx+STREAM.work_top]
217	sub ecx, esi	217	sub ecx, esi
218	mov edi, [ebx+STREAM.work_buff]	218	mov edi, [ebx+STREAM.work_buff]
219	shr ecx, 2	219	shr ecx, 2
220	rep movsd ;call memcpy	220	rep movsd ;call memcpy
221		221
222	mov [ebx+STREAM.work_write], edi	222	mov [ebx+STREAM.work_write], edi
223	.m2:	223	.m2:
224	mov esi, [ebx+STREAM.curr_seg]	224	mov esi, [ebx+STREAM.curr_seg]
225	mov edi, [ebx+STREAM.work_write]	225	mov edi, [ebx+STREAM.work_write]
226	mov edx, [ebx+STREAM.r_buff]	-
227		226
228	stdcall [ebx+STREAM.resample], edi, esi, edx,\	227	stdcall [ebx+STREAM.resample], edi, esi, \
229	[ebx+STREAM.r_dt],[ebx+STREAM.r_size],[ebx+STREAM.r_end]	228	[ebx+STREAM.r_dt],[ebx+STREAM.r_size],[ebx+STREAM.r_end]
230		229
231	mov ebx, [str]	230	mov ebx, [str]
232		231
233	add [ebx+STREAM.work_count], eax;	232	add [ebx+STREAM.work_count], eax;
234	add [ebx+STREAM.work_write], eax;	233	add [ebx+STREAM.work_write], eax;
235		234
236	mov eax, [ebx+STREAM.curr_seg]	235	mov eax, [ebx+STREAM.curr_seg]
237	add eax, [ebx+STREAM.r_size]	236	add eax, [ebx+STREAM.r_size]
238	cmp eax, [ebx+STREAM.lim_0]	237	cmp eax, [ebx+STREAM.lim_0]
239	jb @f	238	jb @f
-		239
-		240	mov esi, [ebx+STREAM.seg_0]
-		241	lea edi, [esi-128]
-		242	add esi, 0x7F80
-		243	mov ecx, 128/4
-		244	cld
-		245	rep movsd
240		246
241	mov eax, [ebx+STREAM.seg_0]	247	mov eax, [ebx+STREAM.seg_0]
242	mov ecx, [ebx+STREAM.lim_0]	248	mov ecx, [ebx+STREAM.lim_0]
243	xchg eax, [ebx+STREAM.seg_1]	249	xchg eax, [ebx+STREAM.seg_1]
244	xchg ecx, [ebx+STREAM.lim_1]	250	xchg ecx, [ebx+STREAM.lim_1]
245	mov [ebx+STREAM.seg_0], eax	251	mov [ebx+STREAM.seg_0], eax
246	mov [ebx+STREAM.lim_0], ecx	252	mov [ebx+STREAM.lim_0], ecx
247	@@:	253	@@:
248	mov [ebx+STREAM.curr_seg], eax	254	mov [ebx+STREAM.curr_seg], eax
249		255
250	xor ecx, ecx	256	xor ecx, ecx
251	cmp eax, [ebx+STREAM.notify_off2]	257	cmp eax, [ebx+STREAM.notify_off2]
252	je @f	258	je @f
253		259
254	mov ecx,0x8000	260	mov ecx,0x8000
255	cmp eax, [ebx+STREAM.notify_off1]	261	cmp eax, [ebx+STREAM.notify_off1]
256	je @f	262	je @f
257	ret	263	ret
258	@@:	264	@@:
259	mov [ev_code], 0xFF000001	265	mov [ev_code], 0xFF000001
260	mov [ev_offs], ecx	266	mov [ev_offs], ecx
261	mov eax, [ebx+STREAM.notify_task]	267	mov eax, [ebx+STREAM.notify_task]
262		268
263	lea edx, [ev_code]	269	lea edx, [ev_code]
264	push ebx	270	push ebx
265	stdcall SendEvent, eax, edx	271	stdcall SendEvent, eax, edx
266	pop ebx	272	pop ebx
267	test eax, eax	273	test eax, eax
268	jnz @F	274	jnz @F
269	not eax	275	not eax
270	mov [ebx+STREAM.notify_task], eax ;-1	276	mov [ebx+STREAM.notify_task], eax ;-1
271	@@:	277	@@:
272	ret	278	ret
273	endp	279	endp
274		280
275	align 4	281	align 4
276	proc resample_1 stdcall, dest:dword,src:dword,r_buff:dword,\	282	proc resample_1 stdcall, dest:dword,src:dword,\
277	r_dt:dword, r_size:dword,r_end:dword	283	r_dt:dword, r_size:dword,r_end:dword
278		284
279	mov edi, [r_buff]	285	; dest equ esp+8
280	add edi, 32*2	286	; src equ esp+12
281	mov esi, [src]	287	; r_dt equ esp+16
282	mov ecx, [r_size]	288	; r_size equ esp+20
283	shr ecx, 2	-
284	rep movsd	289	;r_end equ esp+24
285		290
-		291	mov edi, [dest]
286	mov edi, [dest]	292	mov edx, [src]
287	mov edx, [r_buff]	293	sub edx, 32*2
288	mov eax, 16	294	mov eax, 16
289		295
290	align 16	296	align 16
291	.l1:	297	.l1:
292	mov ecx, eax	298	mov ecx, eax
293	mov esi, eax	299	mov esi, eax
294	and ecx, 0x7FFF	300	and ecx, 0x7FFF
295	shr esi, 15	301	shr esi, 15
296	lea esi, [edx+esi*2]	302	lea esi, [edx+esi*2]
297		303
298	movsx ebp, word [esi]	304	movsx ebp, word [esi]
299	movsx esi, word [esi+2]	305	movsx esi, word [esi+2]
300	mov ebx, 32768	306	mov ebx, 32768
301	imul esi, ecx	307	imul esi, ecx
302	sub ebx, ecx	308	sub ebx, ecx
303	imul ebx, ebp	309	imul ebx, ebp
304	lea ecx, [ebx+esi+16384]	310	lea ecx, [ebx+esi+16384]
305	sar ecx, 15	311	sar ecx, 15
306	cmp ecx, 32767 ; 00007fffH	312	cmp ecx, 32767 ; 00007fffH
307	jle @f	313	jle @f
308	mov ecx, 32767 ; 00007fffH	314	mov ecx, 32767 ; 00007fffH
309	jmp .write	315	jmp .write
310	@@:	316	@@:
311	cmp ecx, -32768 ; ffff8000H	317	cmp ecx, -32768 ; ffff8000H
312	jge .write	318	jge .write
313	mov ecx, -32768 ; ffff8000H	319	mov ecx, -32768 ; ffff8000H
314	.write:	320	.write:
315	mov ebx, ecx	321	mov ebx, ecx
316	shl ebx, 16	322	shl ebx, 16
317	mov bx, cx	323	mov bx, cx
318	mov [edi], ebx	324	mov [edi], ebx
319	add edi, 4	325	add edi, 4
320		326
321	add eax, [esp+20] ;rdt	327	add eax, [esp+16]
322	cmp eax, [esp+28] ;r_end	328	cmp eax, [esp+24]
323	jb .l1	329	jb .l1
324		330
325	mov ebp, esp	331	mov ebp, esp
326		-
327	mov esi, [src]	-
328	add esi, [r_size]	-
329	sub esi, 32*2	-
330	mov edx, [r_buff]	-
331	mov ecx, 16	-
332	@@:	-
333	mov ebx, [esi]	-
334	mov [edx], ebx	-
335	add esi, 4	-
336	add edx, 4	-
337	dec ecx	-
338	jnz @B	-
339		332
340	sub edi, [dest]	333	sub edi, [dest]
341	mov eax, edi	334	mov eax, edi
342	ret	335	ret
343	endp	336	endp
344		337
345	align 4	338	align 4
346	proc resample_18 stdcall, dest:dword,src:dword,r_buff:dword,\	339	proc resample_18 stdcall, dest:dword,src:dword,\
347	r_dt:dword, r_size:dword,r_end:dword	340	r_dt:dword, r_size:dword,r_end:dword
348		-
349	mov edi, [r_buff]	-
350	add edi, 32	-
351	mov esi, [src]	-
352	mov ecx, [r_size]	-
353	shr ecx, 2	-
354	rep movsd	341
355		342
-		343	mov edi, [dest]
-		344	mov edx, [src]
356	mov edi, [dest]	345	sub edx, 32
357	mov edx, [r_buff]	346
358	mov esi, 16	347	mov esi, 16
359		348
360	align 16	349	align 16
361	.l1:	350	.l1:
362	mov ecx, esi	351	mov ecx, esi
363	mov eax, esi	352	mov eax, esi
364	and ecx, 0x7FFF	353	and ecx, 0x7FFF
365	shr eax, 15	354	shr eax, 15
366	lea eax, [edx+eax]	355	lea eax, [edx+eax]
367		356
368	mov bx, word [eax]	357	mov bx, word [eax]
369	sub bh, 0x80	358	sub bh, 0x80
370	sub bl, 0x80	359	sub bl, 0x80
371	movsx eax, bh	360	movsx eax, bh
372	shl eax,8	361	shl eax,8
373	movsx ebp, bl	362	movsx ebp, bl
374	shl ebp,8	363	shl ebp,8
375	mov ebx, 32768	364	mov ebx, 32768
376	imul eax, ecx	365	imul eax, ecx
377	sub ebx, ecx	366	sub ebx, ecx
378	imul ebx, ebp	367	imul ebx, ebp
379	lea ecx, [ebx+eax+16384]	368	lea ecx, [ebx+eax+16384]
380	sar ecx, 15	369	sar ecx, 15
381	cmp ecx, 32767 ; 00007fffH	370	cmp ecx, 32767 ; 00007fffH
382	jle @f	371	jle @f
383	mov ecx, 32767 ; 00007fffH	372	mov ecx, 32767 ; 00007fffH
384	jmp .write	373	jmp .write
385	@@:	374	@@:
386	cmp ecx, -32768 ; ffff8000H	375	cmp ecx, -32768 ; ffff8000H
387	jge .write	376	jge .write
388	mov ecx, -32768 ; ffff8000H	377	mov ecx, -32768 ; ffff8000H
389	.write:	378	.write:
390	mov ebx, ecx	379	mov ebx, ecx
391	shl ebx, 16	380	shl ebx, 16
392	mov bx, cx	381	mov bx, cx
393	mov [edi], ebx	382	mov [edi], ebx
394	add edi, 4	383	add edi, 4
395		384
396	add esi, [esp+20] ;rdt	385	add esi, [esp+16]
397	cmp esi, [esp+28] ;r_end	386	cmp esi, [esp+24]
398	jb .l1	387	jb .l1
399		388
400	mov ebp, esp	389	mov ebp, esp
401		-
402	mov esi, [src]	-
403	add esi, [r_size]	-
404	sub esi, 32	-
405	mov edx, [r_buff]	-
406	mov ecx, 8	-
407	@@:	-
408	mov ebx, [esi]	-
409	mov [edx], ebx	-
410	add esi, 4	-
411	add edx, 4	-
412	dec ecx	-
413	jnz @B	-
414		-
415	sub edi, [dest]	390	sub edi, [dest]
416	mov eax, edi	391	mov eax, edi
417	ret	392	ret
418	endp	393	endp
419		394
420	align 4	395	align 4
421	proc copy_stream stdcall, dest:dword,src:dword,r_buff:dword,\	396	proc copy_stream stdcall, dest:dword,src:dword,\
422	r_dt:dword, r_size:dword,r_end:dword	397	r_dt:dword, r_size:dword,r_end:dword
423		398
424	mov ecx, [r_size]	399	mov ecx, [r_size]
425	mov eax, ecx	400	mov eax, ecx
426	shr ecx, 2	401	shr ecx, 2
427	mov esi, [src]	402	mov esi, [src]
428	mov edi, [dest]	403	mov edi, [dest]
429	rep movsd	404	rep movsd
430	mov eax, 16384	405	mov eax, 16384
431	ret	406	ret
432	endp	407	endp
433		408
434	align 4	409	align 4
435	proc resample_2 stdcall, dest:dword,src:dword,r_buff:dword,\	410	proc resample_2 stdcall, dest:dword,src:dword,\
436	r_dt:dword, r_size:dword,r_end:dword	411	r_dt:dword, r_size:dword,r_end:dword
437		-
438	mov edi, [r_buff]	-
439	add edi, 32*4	412
440	mov esi, [src]	-
441	mov ecx, [r_size]	413	mov edx, [src]
442	shr ecx, 2	-
443	rep movsd ;call memcpy	-
444		-
445	mov edx, [r_buff]	414	sub edx, 32*4
446	mov edi, [dest]	415	mov edi, [dest]
447	mov ebx, [r_dt]	416	mov ebx, [r_dt]
448	mov eax, 16	417	mov eax, 16
449	emms	418	emms
450		419
451	align 16	420	align 16
452	.l1:	421	.l1:
453	mov ecx, eax	422	mov ecx, eax
454	mov esi, eax	423	mov esi, eax
455	and ecx, 0x7FFF	424	and ecx, 0x7FFF
456	shr esi, 15	425	shr esi, 15
457	lea esi, [edx+esi*4]	426	lea esi, [edx+esi*4]
458		427
459	movq mm0, [esi]	428	movq mm0, [esi]
460	movq mm1, mm0	429	movq mm1, mm0
461		430
462	movd mm2, ecx	431	movd mm2, ecx
463	punpcklwd mm2, mm2	432	punpcklwd mm2, mm2
464	movq mm3, qword [m7] ; // 0x8000	433	movq mm3, qword [m7] ;0x8000
465		434
466	psubw mm3, mm2 ; // 0x8000 - iconst	435	psubw mm3, mm2 ; ;0x8000 - iconst
467	punpckldq mm3, mm2	436	punpckldq mm3, mm2
468		437
469	pmulhw mm0, mm3	438	pmulhw mm0, mm3
470	pmullw mm1, mm3	439	pmullw mm1, mm3
471		440
472	movq mm4, mm1	441	movq mm4, mm1
473	punpcklwd mm1, mm0	442	punpcklwd mm1, mm0
474	punpckhwd mm4, mm0	443	punpckhwd mm4, mm0
475	paddd mm1, mm4	444	paddd mm1, mm4
476	psrad mm1, 15	445	psrad mm1, 15
477	packssdw mm1, mm1	446	packssdw mm1, mm1
478	movd [edi], mm1	447	movd [edi], mm1
479	add edi, 4	448	add edi, 4
480		449
481	add eax, ebx	450	add eax, ebx
482	cmp eax, [r_end]	451	cmp eax, [r_end]
483	jb .l1	452	jb .l1
484	emms	453	emms
485		-
486	mov esi, [src]	-
487	add esi, [r_size]	-
488	sub esi, 32*4	-
489	mov edx, [r_buff]	-
490	mov ecx, 32	-

Subversion Repositories Kolibri OS

(root)/kernel/trunk/drivers/mixer.asm @ 378 – Rev 281 → 285