WebSVN – Kolibri OS – Diff – /drivers/audio/infinity/mixer.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2006-2014. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
;   (C) copyright Serge 2006
;   email: infinity_sound@mail.ru
 
 
align 4
 
mix_list rd 32*3
 
align 4
proc new_mix stdcall, output:dword
           locals
             main_count   rd 1
             fpu_state    rb 528   ;512+16
           endl
 
        mov     [main_count], 32
        call    prepare_playlist
        cmp     [play_count], 0
        je      .clear
 
        lea     eax, [fpu_state+16]
        and     eax, -16            ;must be 16b aligned
        invoke  FpuSave
 
        call    update_streams
.mix:
        lea     eax, [mix_list]
        call    do_mix_list
        test    eax, eax
        je      .done
 
if USE_SSE2_MIXER
 
        cmp     eax, 1
        ja      @F
                                    ;use fast path
        mov     edi, [output]
        lea     edx, [mix_list]
        call    mix_fast
        jmp     .next
@@:
        cmp     eax, 2
        ja      @F
 
        mov     edi, [output]
        lea     edx, [mix_list]
        call    mix_fast_2_stream
        jmp     .next
@@:
 
end if
 
        lea     ebx, [mix_list]
        stdcall mix_all, [output], ebx, eax
.next:
        add     [output], 512
        dec     [main_count]
        jnz     .mix
.exit:
        lea     eax, [fpu_state+16]
        and     eax, -16
        invoke  FpuRestore
        ret
.done:
        mov     ecx, [main_count]
        shl     ecx, 7    ;ecx*= 512/4
 
        mov     edi, [output]
        xor     eax, eax
        cld
        rep stosd
        jmp     .exit
.clear:
        mov     edi, [output]
        mov     ecx, 4096
        xor     eax, eax
        cld
        rep stosd
        ret
endp
 
align 4
proc update_streams
           locals
             stream_index  dd ?
             event         rd 6
           endl
 
        mov     [stream_index], 0
.l1:
        mov     edx, [stream_index]
        mov     esi, [play_list+edx*4]
 
        add     dword [esi+STREAM.time_stamp], 4096
        adc     dword [esi+STREAM.time_stamp+4], 0
        mov     dword [esi+STREAM.last_ts], 0
 
        mov     eax, [esi+STREAM.out_rp]
        cmp     eax, [esi+STREAM.out_top]
        jb      @f
        sub     eax, 64*1024
@@:
        mov     [esi+STREAM.out_rp], eax
 
        cmp     [esi+STREAM.out_count], 16384
        ja      .skip
 
        test    [esi+STREAM.format], PCM_RING
        jnz     .ring
 
        stdcall refill, esi
.skip:
        inc     [stream_index]
        dec     [play_count]
        jnz     .l1
        ret
.ring:
        stdcall refill_ring, esi
        jmp     .skip
endp
 
align 4
proc refill stdcall, str:dword
           locals
             r_size    rd 1
           endl
 
        mov     ebx, [str]
        mov     edi, [ebx+STREAM.out_wp]
        cmp     edi, [ebx+STREAM.out_top]
        jb      @F
        sub     edi, 0x10000
        mov     [ebx+STREAM.out_wp], edi
@@:
        mov     eax, [ebx+STREAM.in_count]
        test    eax, eax
        jz      .done
 
        mov     ecx, [ebx+STREAM.r_size]
        cmp     eax, ecx
        jle     @F
 
        mov     eax, ecx
@@:
        mov     ecx, eax
        cmp     word [ebx+STREAM.format], PCM_1_16_8
        ja      @F
 
        shr     eax, 1                  ;two channles
@@:
        test    [ebx+STREAM.format], 1  ;even formats mono
        jz      @F
 
        shr     eax, 1                  ;eax= samples
@@:
        shl     eax, 15   ;eax*=32768 =r_end
 
        mov     [r_size], ecx
 
        mov     esi, [ebx+STREAM.in_rp]
        mov     edi, [ebx+STREAM.out_wp]
 
        stdcall [ebx+STREAM.resample], edi, esi, \
                [ebx+STREAM.r_dt], ecx, eax
 
        mov     ebx, [str]
 
        add     [ebx+STREAM.out_count], eax;
        add     [ebx+STREAM.out_wp], eax;
 
        mov     eax, [ebx+STREAM.in_rp]
        mov     ecx, [r_size]
        add     eax, ecx
        add     [ebx+STREAM.in_free], ecx
        sub     [ebx+STREAM.in_count], ecx
 
        cmp     eax, [ebx+STREAM.in_top]
        jb      @f
 
        sub     eax, [ebx+STREAM.in_size]
@@:
        mov     [ebx+STREAM.in_rp], eax
 
.done:
        mov     eax, [ebx+STREAM.notify_event]
        test    eax, eax
        jz      .exit
 
        mov     ebx, [ebx+STREAM.notify_id]
        mov     edx, EVENT_WATCHED
        xor     esi, esi
        invoke  RaiseEvent   ;eax, ebx, edx, esi
.exit:
        ret
endp
 
align 4
proc refill_ring stdcall, str:dword
           locals
             event     rd 6
           endl
 
        mov     ebx, [str]
        mov     edi, [ebx+STREAM.out_wp]
        cmp     edi, [ebx+STREAM.out_top]
        jb      @F
        sub     edi, 0x10000
        mov     [ebx+STREAM.out_wp], edi
@@:
        mov     ecx, [ebx+STREAM.r_size]
        mov     eax, ecx
        cmp     word [ebx+STREAM.format], PCM_1_16_8
        ja      @F
 
        shr     eax, 1                  ;two channles
@@:
        test    [ebx+STREAM.format], 1  ;even formats mono
        jz      @F
 
        shr     eax, 1                  ;eax= samples
@@:
        shl     eax, 15   ;eax*=32768 =r_end
 
        mov     esi, [ebx+STREAM.in_rp]
        mov     edi, [ebx+STREAM.out_wp]
 
        stdcall [ebx+STREAM.resample], edi, esi, \
                [ebx+STREAM.r_dt], ecx, eax
 
        mov     ebx, [str]
 
        add     [ebx+STREAM.out_count], eax;
        add     [ebx+STREAM.out_wp], eax;
 
        mov     eax, [ebx+STREAM.in_rp]
        mov     ecx, [ebx+STREAM.r_size]
        add     eax, ecx
        add     [ebx+STREAM.in_free], ecx
        sub     [ebx+STREAM.in_count], ecx
 
        cmp     eax, [ebx+STREAM.in_top]
        jb      @f
 
        sub     eax, [ebx+STREAM.in_size]
@@:
        mov     [ebx+STREAM.in_rp], eax
 
        sub     eax, [ebx+STREAM.in_base]
        sub     eax, 128
        lea     esi, [event]
 
        mov     dword [esi], RT_INP_EMPTY
        mov     dword [esi+4], 0
        mov     dword [esi+8], ebx
        mov     dword [esi+12], eax
 
        mov     eax, [ebx+STREAM.notify_event]
        test    eax, eax
        jz      .exit
 
        mov     ebx, [ebx+STREAM.notify_id]
        xor     edx, edx
        invoke  RaiseEvent   ;eax, ebx, edx, esi
.exit:
        ret
endp
 
if USE_SSE2_MIXER
 
align 4
proc mix_all stdcall, dest:dword, list:dword, count:dword
 
        mov     edi, [dest]
        mov     ebx, 32
.mix:
        mov     edx, [list]
        mov     ecx, [count]
 
        mov     eax, [edx]
 
        movdqa  xmm1, [eax]
        movss   xmm2, [edx+4]
        movss   xmm3, [edx+8]
 
        punpcklwd xmm0, xmm1
        punpckhwd xmm1, xmm1
 
        shufps  xmm2, xmm3, 0
        shufps  xmm2, xmm2, 0x88
 
        psrad   xmm0, 16
        psrad   xmm1, 16
        cvtdq2ps xmm0, xmm0
        cvtdq2ps xmm1, xmm1
        mulps   xmm0, xmm2
        mulps   xmm1, xmm2
 
.mix_loop:
        add     dword [edx], 16
        add     edx, 12
        dec     ecx
        jz      @F
 
        mov     eax, [edx]
 
        movdqa  xmm3, [eax]
        movss   xmm4, [edx+4]
        movss   xmm5, [edx+8]
 
        punpcklwd xmm2, xmm3
        punpckhwd xmm3, xmm3
 
        shufps  xmm4, xmm5, 0
        shufps  xmm4, xmm4, 0x88
 
        psrad   xmm2, 16
        psrad   xmm3, 16
 
        cvtdq2ps xmm2, xmm2
        cvtdq2ps xmm3, xmm3
 
        mulps   xmm2, xmm4
        mulps   xmm3, xmm4
        addps   xmm0, xmm2
        addps   xmm1, xmm3
 
        jmp     .mix_loop
@@:
        cvtps2dq xmm0, xmm0
        cvtps2dq xmm1, xmm1
        packssdw xmm0, xmm0
        packssdw xmm1, xmm1
        punpcklqdq xmm0, xmm1
        movntdq [edi], xmm0
 
        add     edi, 16
        dec     ebx
        jnz     .mix
 
        ret
endp
 
; param
;  edi = dest
;  edx = mix_list
 
align 4
mix_fast:
 
        mov     ebx, 32
        mov     eax, [edx]
 
        movss   xmm2, [edx+4]        ; vol Lf
        movss   xmm3, [edx+8]        ; vol Rf
        shufps  xmm2, xmm3, 0        ; Rf Rf Lf Lf
        shufps  xmm2, xmm2, 0x88     ; volume level  Rf Lf Rf Lf
.mix:
        movdqa  xmm1, [eax]          ; R3w L3w  R2w L2w  R1w L1w  R0w L0w
        add     eax, 16
        punpcklwd xmm0, xmm1         ; R1w R1w  L1w L1W  R0w R0w  L0w L0w
        punpckhwd xmm1, xmm1         ; R3w R3w  L3w L3w  R2w R2w  L2w L2w
 
        psrad   xmm0, 16             ; R1d L1d R0d L0d
        psrad   xmm1, 16             ; R3d L3d R2d L2d
 
        cvtdq2ps xmm0, xmm0          ; time to use all power
        cvtdq2ps xmm1, xmm1          ; of the dark side
 
        mulps   xmm0, xmm2           ; R1f' L1f' R0f' L0f'
        mulps   xmm1, xmm2           ; R3f' L3f' R2f' L2f'
 
        cvtps2dq xmm0, xmm0          ; R1d' L1d' R0d' L0d'
        cvtps2dq xmm1, xmm1          ; R3d' L3d' R2d' L2d'
        packssdw xmm0, xmm0          ; R1w' L1w'  R0w' L0w'  R1w' L1w'  R0w' L0w'
        packssdw xmm1, xmm1          ; R3w' L3w'  R2w' L2w'  R3w' L3w'  R2w' L2w'
        punpcklqdq xmm0, xmm1        ; R3w' L3w'  R2w' L2w'  R1w' L1w'  R0w' L0w'
        movntdq [edi], xmm0
 
        add     edi, 16
        dec     ebx
        jnz     .mix
 
        ret
 
align 4
mix_fast_2_stream:
 
        mov     ebx, 32
        mov     eax, [edx]
 
        movss   xmm4, [edx+4]        ; vol Lf
        movss   xmm5, [edx+8]        ; vol Rf
        mov     ecx, [edx+12]
 
        movss   xmm6, [edx+16]       ; vol Lf
        movss   xmm7, [edx+20]       ; vol Rf
 
        shufps  xmm4, xmm5, 0        ; Rf Rf Lf Lf
        shufps  xmm4, xmm4, 0x88     ; volume level  Rf Lf Rf Lf
 
        shufps  xmm6, xmm7, 0        ; Rf Rf Lf Lf
        shufps  xmm6, xmm6, 0x88     ; volume level  Rf Lf Rf Lf
 
.mix:
        movdqa  xmm1, [eax]          ; R3w L3w  R2w L2w  R1w L1w  R0w L0w
        movdqa  xmm3, [ecx]          ; R3w L3w  R2w L2w  R1w L1w  R0w L0w
 
        add     eax, 16
        add     ecx, 16
 
        punpcklwd xmm0, xmm1         ; R1w R1w  L1w L1W  R0w R0w  L0w L0w
        punpckhwd xmm1, xmm1         ; R3w R3w  L3w L3w  R2w R2w  L2w L2w
 
        psrad   xmm0, 16             ; R1d L1d R0d L0d
        psrad   xmm1, 16             ; R3d L3d R2d L2d
 
        cvtdq2ps xmm0, xmm0          ; time to use all power
        cvtdq2ps xmm1, xmm1          ; of the dark side
 
        mulps   xmm0, xmm4           ; R1f' L1f' R0f' L0f'
        mulps   xmm1, xmm4           ; R3f' L3f' R2f' L2f'
 
        punpcklwd xmm2, xmm3         ; R1w R1w  L1w L1W  R0w R0w  L0w L0w
        punpckhwd xmm3, xmm3         ; R3w R3w  L3w L3w  R2w R2w  L2w L2w
 
        psrad   xmm2, 16             ; R1d L1d R0d L0d
        psrad   xmm3, 16             ; R3d L3d R2d L2d
 
        cvtdq2ps xmm2, xmm2          ; time to use all power
        cvtdq2ps xmm3, xmm3          ; of the dark side
 
        mulps   xmm2, xmm6           ; R1f' L1f' R0f' L0f'
        mulps   xmm3, xmm6           ; R3f' L3f' R2f' L2f'
 
        addps   xmm0, xmm2
        addps   xmm1, xmm3
 
        cvtps2dq xmm0, xmm0          ; R1d' L1d' R0d' L0d'
        cvtps2dq xmm1, xmm1          ; R3d' L3d' R2d' L2d'
        packssdw xmm0, xmm0          ; R1w' L1w'  R0w' L0w'  R1w' L1w'  R0w' L0w'
        packssdw xmm1, xmm1          ; R3w' L3w'  R2w' L2w'  R3w' L3w'  R2w' L2w'
        punpcklqdq xmm0, xmm1        ; R3w' L3w'  R2w' L2w'  R1w' L1w'  R0w' L0w'
        movntdq [edi], xmm0
 
        add     edi, 16
        dec     ebx
        jnz     .mix
 
        ret
 
else                                    ; fixed point mmx version
 
align 4
proc mix_all stdcall, dest:dword, list:dword, count:dword
 
        mov     edi, [dest]
        mov     ebx, 64
.mix:
        mov     edx, [list]
        mov     ecx, [count]
 
        mov     eax, [edx]
 
        movq    mm0, [eax]
 
        movd    mm1, [edx+4]
        punpckldq mm1, mm1
        pmulhw  mm0, mm1
        psllw   mm0, 1
 
.mix_loop:
        add     dword [edx], 8
        add     edx, 12
        dec     ecx
        jz      @F
 
        mov     eax, [edx]
        movq    mm1, [eax]
        movd    mm2, [edx+4]
        punpckldq mm2, mm2
        pmulhw  mm1, mm2
        psllw   mm1, 1
        paddsw  mm0, mm1
        jmp     .mix_loop
@@:
        movq    [edi], mm0
        add     edi, 8
        dec     ebx
        jnz     .mix
 
        ret
endp
 
end if
 
 
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 4
.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 4
.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]
        cld
        rep movsd
        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 4
.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 4
.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
 
align 4
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]
        mov     eax, [str0]
        mov     ebx, [str1]
        mov     esi, 128
        call    [mix_2_core]   ;edi, eax, ebx
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        call    [mix_2_core]   ;edi, eax, ebx
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        call    [mix_2_core]   ;edi, eax, ebx
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        call    [mix_2_core]   ;edi, eax, ebx
        ret
endp
 
align 4
proc mix_3_1 stdcall, output:dword, str0:dword, str1:dword, str2:dword
 
        mov     edi, [output]
        mov     eax, [str0]
        mov     ebx, [str1]
        mov     ecx, [str2]
        mov     esi, 128
        call    [mix_3_core]
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        add     ecx, esi
        call    [mix_3_core]
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        add     ecx, esi
        call    [mix_3_core]
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        add     ecx, esi
        call    [mix_3_core]
        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
        mov     eax, [str0]
        mov     ebx, [str1]
        mov     ecx, [str2]
        mov     edx, [str3]
        mov     esi, 128
        call    [mix_4_core]  ;edi, eax, ebx, ecx, edx
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        add     ecx, esi
        add     edx, esi
        call    [mix_4_core]  ;edi, eax, ebx, ecx, edx
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        add     ecx, esi
        add     edx, esi
        call    [mix_4_core]  ;edi, eax, ebx, ecx, edx
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        add     ecx, esi
        add     edx, esi
        call    [mix_4_core]  ;edi, eax, ebx, ecx, edx
        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]
 
        mov     eax, [str0]
        mov     ebx, [str1]
        mov     ecx, [str2]
        mov     edx, [str3]
        mov     esi, 128
        call    [mix_4_core]  ;edi, eax, ebx, ecx, edx
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        add     ecx, esi
        add     edx, esi
        call    [mix_4_core]  ;edi, eax, ebx, ecx, edx
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        add     ecx, esi
        add     edx, esi
        call    [mix_4_core]  ;edi, eax, ebx, ecx, edx
 
        add     edi, esi
        add     eax, esi
        add     ebx, esi
        add     ecx, esi
        add     edx, esi
        call    [mix_4_core]  ;edi, eax, ebx, ecx, edx
        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
 
if 0
 
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
 
        dec     [main_count]
        jnz     .l00
 
        call    update_stream
        emms
        call    FpuRestore
        ret
.exit:
        mov     edi, [output]
        mov     ecx, 0x1000
        xor     eax, eax
        cld
        rep stosd
        ret
endp
 
end if

Rev 2455	Rev 5077
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2006-2011. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2006-2014. 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	; (C) copyright Serge 2006	8	; (C) copyright Serge 2006
9	; email: infinity_sound@mail.ru	9	; email: infinity_sound@mail.ru
10		10
11		11
12	align 4	12	align 4
13		13
14	mix_list rd 32*3	14	mix_list rd 32*3
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	main_count rd 1	19	main_count rd 1
20	fpu_state rb 528 ;512+16	20	fpu_state rb 528 ;512+16
21	endl	21	endl
22		22
23	mov [main_count], 32	23	mov [main_count], 32
24	call prepare_playlist	24	call prepare_playlist
25	cmp [play_count], 0	25	cmp [play_count], 0
26	je .clear	26	je .clear
27		27
28	lea eax, [fpu_state+16]	28	lea eax, [fpu_state+16]
29	and eax, -16 ;must be 16b aligned	29	and eax, -16 ;must be 16b aligned
30	call FpuSave	30	invoke FpuSave
31		31
32	call update_streams	32	call update_streams
33	.mix:	33	.mix:
34	lea eax, [mix_list]	34	lea eax, [mix_list]
35	call do_mix_list	35	call do_mix_list
36	test eax, eax	36	test eax, eax
37	je .done	37	je .done
38		38
39	if USE_SSE2_MIXER	39	if USE_SSE2_MIXER
40		40
41	cmp eax, 1	41	cmp eax, 1
42	ja @F	42	ja @F
43	;use fast path	43	;use fast path
44	mov edi, [output]	44	mov edi, [output]
45	lea edx, [mix_list]	45	lea edx, [mix_list]
46	call mix_fast	46	call mix_fast
47	jmp .next	47	jmp .next
48	@@:	48	@@:
49	cmp eax, 2	49	cmp eax, 2
50	ja @F	50	ja @F
51		51
52	mov edi, [output]	52	mov edi, [output]
53	lea edx, [mix_list]	53	lea edx, [mix_list]
54	call mix_fast_2_stream	54	call mix_fast_2_stream
55	jmp .next	55	jmp .next
56	@@:	56	@@:
57		57
58	end if	58	end if
59		59
60	lea ebx, [mix_list]	60	lea ebx, [mix_list]
61	stdcall mix_all, [output], ebx, eax	61	stdcall mix_all, [output], ebx, eax
62	.next:	62	.next:
63	add [output], 512	63	add [output], 512
64	dec [main_count]	64	dec [main_count]
65	jnz .mix	65	jnz .mix
66	.exit:	66	.exit:
67	lea eax, [fpu_state+16]	67	lea eax, [fpu_state+16]
68	and eax, -16	68	and eax, -16
69	call FpuRestore	69	invoke FpuRestore
70	ret	70	ret
71	.done:	71	.done:
72	mov ecx, [main_count]	72	mov ecx, [main_count]
73	shl ecx, 7 ;ecx*= 512/4	73	shl ecx, 7 ;ecx*= 512/4
74		74
75	mov edi, [output]	75	mov edi, [output]
76	xor eax, eax	76	xor eax, eax
77	cld	77	cld
78	rep stosd	78	rep stosd
79	jmp .exit	79	jmp .exit
80	.clear:	80	.clear:
81	mov edi, [output]	81	mov edi, [output]
82	mov ecx, 4096	82	mov ecx, 4096
83	xor eax, eax	83	xor eax, eax
84	cld	84	cld
85	rep stosd	85	rep stosd
86	ret	86	ret
87	endp	87	endp
88		88
89	align 4	89	align 4
90	proc update_streams	90	proc update_streams
91	locals	91	locals
92	stream_index dd ?	92	stream_index dd ?
93	event rd 6	93	event rd 6
94	endl	94	endl
95		95
96	mov [stream_index], 0	96	mov [stream_index], 0
97	.l1:	97	.l1:
98	mov edx, [stream_index]	98	mov edx, [stream_index]
99	mov esi, [play_list+edx*4]	99	mov esi, [play_list+edx*4]
100		100
101	add dword [esi+STREAM.time_stamp], 4096	101	add dword [esi+STREAM.time_stamp], 4096
102	adc dword [esi+STREAM.time_stamp+4], 0	102	adc dword [esi+STREAM.time_stamp+4], 0
103	mov dword [esi+STREAM.last_ts], 0	103	mov dword [esi+STREAM.last_ts], 0
104		104
105	mov eax, [esi+STREAM.out_rp]	105	mov eax, [esi+STREAM.out_rp]
106	cmp eax, [esi+STREAM.out_top]	106	cmp eax, [esi+STREAM.out_top]
107	jb @f	107	jb @f
108	sub eax, 64*1024	108	sub eax, 64*1024
109	@@:	109	@@:
110	mov [esi+STREAM.out_rp], eax	110	mov [esi+STREAM.out_rp], eax
111		111
112	cmp [esi+STREAM.out_count], 16384	112	cmp [esi+STREAM.out_count], 16384
113	ja .skip	113	ja .skip
114		114
115	test [esi+STREAM.format], PCM_RING	115	test [esi+STREAM.format], PCM_RING
116	jnz .ring	116	jnz .ring
117		117
118	stdcall refill, esi	118	stdcall refill, esi
119	.skip:	119	.skip:
120	inc [stream_index]	120	inc [stream_index]
121	dec [play_count]	121	dec [play_count]
122	jnz .l1	122	jnz .l1
123	ret	123	ret
124	.ring:	124	.ring:
125	stdcall refill_ring, esi	125	stdcall refill_ring, esi
126	jmp .skip	126	jmp .skip
127	endp	127	endp
128		128
129	align 4	129	align 4
130	proc refill stdcall, str:dword	130	proc refill stdcall, str:dword
131	locals	131	locals
132	r_size rd 1	132	r_size rd 1
133	endl	133	endl
134		134
135	mov ebx, [str]	135	mov ebx, [str]
136	mov edi, [ebx+STREAM.out_wp]	136	mov edi, [ebx+STREAM.out_wp]
137	cmp edi, [ebx+STREAM.out_top]	137	cmp edi, [ebx+STREAM.out_top]
138	jb @F	138	jb @F
139	sub edi, 0x10000	139	sub edi, 0x10000
140	mov [ebx+STREAM.out_wp], edi	140	mov [ebx+STREAM.out_wp], edi
141	@@:	141	@@:
142	mov eax, [ebx+STREAM.in_count]	142	mov eax, [ebx+STREAM.in_count]
143	test eax, eax	143	test eax, eax
144	jz .done	144	jz .done
145		145
146	mov ecx, [ebx+STREAM.r_size]	146	mov ecx, [ebx+STREAM.r_size]
147	cmp eax, ecx	147	cmp eax, ecx
148	jle @F	148	jle @F
149		149
150	mov eax, ecx	150	mov eax, ecx
151	@@:	151	@@:
152	mov ecx, eax	152	mov ecx, eax
153	cmp word [ebx+STREAM.format], PCM_1_16_8	153	cmp word [ebx+STREAM.format], PCM_1_16_8
154	ja @F	154	ja @F
155		155
156	shr eax, 1 ;two channles	156	shr eax, 1 ;two channles
157	@@:	157	@@:
158	test [ebx+STREAM.format], 1 ;even formats mono	158	test [ebx+STREAM.format], 1 ;even formats mono
159	jz @F	159	jz @F
160		160
161	shr eax, 1 ;eax= samples	161	shr eax, 1 ;eax= samples
162	@@:	162	@@:
163	shl eax, 15 ;eax*=32768 =r_end	163	shl eax, 15 ;eax*=32768 =r_end
164		164
165	mov [r_size], ecx	165	mov [r_size], ecx
166		166
167	mov esi, [ebx+STREAM.in_rp]	167	mov esi, [ebx+STREAM.in_rp]
168	mov edi, [ebx+STREAM.out_wp]	168	mov edi, [ebx+STREAM.out_wp]
169		169
170	stdcall [ebx+STREAM.resample], edi, esi, \	170	stdcall [ebx+STREAM.resample], edi, esi, \
171	[ebx+STREAM.r_dt], ecx, eax	171	[ebx+STREAM.r_dt], ecx, eax
172		172
173	mov ebx, [str]	173	mov ebx, [str]
174		174
175	add [ebx+STREAM.out_count], eax;	175	add [ebx+STREAM.out_count], eax;
176	add [ebx+STREAM.out_wp], eax;	176	add [ebx+STREAM.out_wp], eax;
177		177
178	mov eax, [ebx+STREAM.in_rp]	178	mov eax, [ebx+STREAM.in_rp]
179	mov ecx, [r_size]	179	mov ecx, [r_size]
180	add eax, ecx	180	add eax, ecx
181	add [ebx+STREAM.in_free], ecx	181	add [ebx+STREAM.in_free], ecx
182	sub [ebx+STREAM.in_count], ecx	182	sub [ebx+STREAM.in_count], ecx
183		183
184	cmp eax, [ebx+STREAM.in_top]	184	cmp eax, [ebx+STREAM.in_top]
185	jb @f	185	jb @f
186		186
187	sub eax, [ebx+STREAM.in_size]	187	sub eax, [ebx+STREAM.in_size]
188	@@:	188	@@:
189	mov [ebx+STREAM.in_rp], eax	189	mov [ebx+STREAM.in_rp], eax
190		190
191	.done:	191	.done:
192	mov eax, [ebx+STREAM.notify_event]	192	mov eax, [ebx+STREAM.notify_event]
193	test eax, eax	193	test eax, eax
194	jz .exit	194	jz .exit
195		195
196	mov ebx, [ebx+STREAM.notify_id]	196	mov ebx, [ebx+STREAM.notify_id]
197	mov edx, EVENT_WATCHED	197	mov edx, EVENT_WATCHED
198	xor esi, esi	198	xor esi, esi
199	call RaiseEvent ;eax, ebx, edx, esi	199	invoke RaiseEvent ;eax, ebx, edx, esi
200	.exit:	200	.exit:
201	ret	201	ret
202	endp	202	endp
203		203
204	align 4	204	align 4
205	proc refill_ring stdcall, str:dword	205	proc refill_ring stdcall, str:dword
206	locals	206	locals
207	event rd 6	207	event rd 6
208	endl	208	endl
209		209
210	mov ebx, [str]	210	mov ebx, [str]
211	mov edi, [ebx+STREAM.out_wp]	211	mov edi, [ebx+STREAM.out_wp]
212	cmp edi, [ebx+STREAM.out_top]	212	cmp edi, [ebx+STREAM.out_top]
213	jb @F	213	jb @F
214	sub edi, 0x10000	214	sub edi, 0x10000
215	mov [ebx+STREAM.out_wp], edi	215	mov [ebx+STREAM.out_wp], edi
216	@@:	216	@@:
217	mov ecx, [ebx+STREAM.r_size]	217	mov ecx, [ebx+STREAM.r_size]
218	mov eax, ecx	218	mov eax, ecx
219	cmp word [ebx+STREAM.format], PCM_1_16_8	219	cmp word [ebx+STREAM.format], PCM_1_16_8
220	ja @F	220	ja @F
221		221
222	shr eax, 1 ;two channles	222	shr eax, 1 ;two channles
223	@@:	223	@@:
224	test [ebx+STREAM.format], 1 ;even formats mono	224	test [ebx+STREAM.format], 1 ;even formats mono
225	jz @F	225	jz @F
226		226
227	shr eax, 1 ;eax= samples	227	shr eax, 1 ;eax= samples
228	@@:	228	@@:
229	shl eax, 15 ;eax*=32768 =r_end	229	shl eax, 15 ;eax*=32768 =r_end
230		230
231	mov esi, [ebx+STREAM.in_rp]	231	mov esi, [ebx+STREAM.in_rp]
232	mov edi, [ebx+STREAM.out_wp]	232	mov edi, [ebx+STREAM.out_wp]
233		233
234	stdcall [ebx+STREAM.resample], edi, esi, \	234	stdcall [ebx+STREAM.resample], edi, esi, \
235	[ebx+STREAM.r_dt], ecx, eax	235	[ebx+STREAM.r_dt], ecx, eax
236		236
237	mov ebx, [str]	237	mov ebx, [str]
238		238
239	add [ebx+STREAM.out_count], eax;	239	add [ebx+STREAM.out_count], eax;
240	add [ebx+STREAM.out_wp], eax;	240	add [ebx+STREAM.out_wp], eax;
241		241
242	mov eax, [ebx+STREAM.in_rp]	242	mov eax, [ebx+STREAM.in_rp]
243	mov ecx, [ebx+STREAM.r_size]	243	mov ecx, [ebx+STREAM.r_size]
244	add eax, ecx	244	add eax, ecx
245	add [ebx+STREAM.in_free], ecx	245	add [ebx+STREAM.in_free], ecx
246	sub [ebx+STREAM.in_count], ecx	246	sub [ebx+STREAM.in_count], ecx
247		247
248	cmp eax, [ebx+STREAM.in_top]	248	cmp eax, [ebx+STREAM.in_top]
249	jb @f	249	jb @f
250		250
251	sub eax, [ebx+STREAM.in_size]	251	sub eax, [ebx+STREAM.in_size]
252	@@:	252	@@:
253	mov [ebx+STREAM.in_rp], eax	253	mov [ebx+STREAM.in_rp], eax
254		254
255	sub eax, [ebx+STREAM.in_base]	255	sub eax, [ebx+STREAM.in_base]
256	sub eax, 128	256	sub eax, 128
257	lea esi, [event]	257	lea esi, [event]
258		258
259	mov dword [esi], RT_INP_EMPTY	259	mov dword [esi], RT_INP_EMPTY
260	mov dword [esi+4], 0	260	mov dword [esi+4], 0
261	mov dword [esi+8], ebx	261	mov dword [esi+8], ebx
262	mov dword [esi+12], eax	262	mov dword [esi+12], eax
263		263
264	mov eax, [ebx+STREAM.notify_event]	264	mov eax, [ebx+STREAM.notify_event]
265	test eax, eax	265	test eax, eax
266	jz .exit	266	jz .exit
267		267
268	mov ebx, [ebx+STREAM.notify_id]	268	mov ebx, [ebx+STREAM.notify_id]
269	xor edx, edx	269	xor edx, edx
270	call RaiseEvent ;eax, ebx, edx, esi	270	invoke RaiseEvent ;eax, ebx, edx, esi
271	.exit:	271	.exit:
272	ret	272	ret
273	endp	273	endp
274		274
275	if USE_SSE2_MIXER	275	if USE_SSE2_MIXER
276		276
277	align 4	277	align 4
278	proc mix_all stdcall, dest:dword, list:dword, count:dword	278	proc mix_all stdcall, dest:dword, list:dword, count:dword
279		279
280	mov edi, [dest]	280	mov edi, [dest]
281	mov ebx, 32	281	mov ebx, 32
282	.mix:	282	.mix:
283	mov edx, [list]	283	mov edx, [list]
284	mov ecx, [count]	284	mov ecx, [count]
285		285
286	mov eax, [edx]	286	mov eax, [edx]
287		287
288	movdqa xmm1, [eax]	288	movdqa xmm1, [eax]
289	movss xmm2, [edx+4]	289	movss xmm2, [edx+4]
290	movss xmm3, [edx+8]	290	movss xmm3, [edx+8]
291		291
292	punpcklwd xmm0, xmm1	292	punpcklwd xmm0, xmm1
293	punpckhwd xmm1, xmm1	293	punpckhwd xmm1, xmm1
294		294
295	shufps xmm2, xmm3, 0	295	shufps xmm2, xmm3, 0
296	shufps xmm2, xmm2, 0x88	296	shufps xmm2, xmm2, 0x88
297		297
298	psrad xmm0, 16	298	psrad xmm0, 16
299	psrad xmm1, 16	299	psrad xmm1, 16
300	cvtdq2ps xmm0, xmm0	300	cvtdq2ps xmm0, xmm0
301	cvtdq2ps xmm1, xmm1	301	cvtdq2ps xmm1, xmm1
302	mulps xmm0, xmm2	302	mulps xmm0, xmm2
303	mulps xmm1, xmm2	303	mulps xmm1, xmm2
304		304
305	.mix_loop:	305	.mix_loop:
306	add dword [edx], 16	306	add dword [edx], 16
307	add edx, 12	307	add edx, 12
308	dec ecx	308	dec ecx
309	jz @F	309	jz @F
310		310
311	mov eax, [edx]	311	mov eax, [edx]
312		312
313	movdqa xmm3, [eax]	313	movdqa xmm3, [eax]
314	movss xmm4, [edx+4]	314	movss xmm4, [edx+4]
315	movss xmm5, [edx+8]	315	movss xmm5, [edx+8]
316		316
317	punpcklwd xmm2, xmm3	317	punpcklwd xmm2, xmm3
318	punpckhwd xmm3, xmm3	318	punpckhwd xmm3, xmm3
319		319
320	shufps xmm4, xmm5, 0	320	shufps xmm4, xmm5, 0
321	shufps xmm4, xmm4, 0x88	321	shufps xmm4, xmm4, 0x88
322		322
323	psrad xmm2, 16	323	psrad xmm2, 16
324	psrad xmm3, 16	324	psrad xmm3, 16
325		325
326	cvtdq2ps xmm2, xmm2	326	cvtdq2ps xmm2, xmm2
327	cvtdq2ps xmm3, xmm3	327	cvtdq2ps xmm3, xmm3
328		328
329	mulps xmm2, xmm4	329	mulps xmm2, xmm4
330	mulps xmm3, xmm4	330	mulps xmm3, xmm4
331	addps xmm0, xmm2	331	addps xmm0, xmm2
332	addps xmm1, xmm3	332	addps xmm1, xmm3
333		333
334	jmp .mix_loop	334	jmp .mix_loop
335	@@:	335	@@:
336	cvtps2dq xmm0, xmm0	336	cvtps2dq xmm0, xmm0
337	cvtps2dq xmm1, xmm1	337	cvtps2dq xmm1, xmm1
338	packssdw xmm0, xmm0	338	packssdw xmm0, xmm0
339	packssdw xmm1, xmm1	339	packssdw xmm1, xmm1
340	punpcklqdq xmm0, xmm1	340	punpcklqdq xmm0, xmm1
341	movntdq [edi], xmm0	341	movntdq [edi], xmm0
342		342
343	add edi, 16	343	add edi, 16
344	dec ebx	344	dec ebx
345	jnz .mix	345	jnz .mix
346		346
347	ret	347	ret
348	endp	348	endp
349		349
350	; param	350	; param
351	; edi = dest	351	; edi = dest
352	; edx = mix_list	352	; edx = mix_list
353		353
354	align 4	354	align 4
355	mix_fast:	355	mix_fast:
356		356
357	mov ebx, 32	357	mov ebx, 32
358	mov eax, [edx]	358	mov eax, [edx]
359		359
360	movss xmm2, [edx+4] ; vol Lf	360	movss xmm2, [edx+4] ; vol Lf
361	movss xmm3, [edx+8] ; vol Rf	361	movss xmm3, [edx+8] ; vol Rf
362	shufps xmm2, xmm3, 0 ; Rf Rf Lf Lf	362	shufps xmm2, xmm3, 0 ; Rf Rf Lf Lf
363	shufps xmm2, xmm2, 0x88 ; volume level Rf Lf Rf Lf	363	shufps xmm2, xmm2, 0x88 ; volume level Rf Lf Rf Lf
364	.mix:	364	.mix:
365	movdqa xmm1, [eax] ; R3w L3w R2w L2w R1w L1w R0w L0w	365	movdqa xmm1, [eax] ; R3w L3w R2w L2w R1w L1w R0w L0w
366	add eax, 16	366	add eax, 16
367	punpcklwd xmm0, xmm1 ; R1w R1w L1w L1W R0w R0w L0w L0w	367	punpcklwd xmm0, xmm1 ; R1w R1w L1w L1W R0w R0w L0w L0w
368	punpckhwd xmm1, xmm1 ; R3w R3w L3w L3w R2w R2w L2w L2w	368	punpckhwd xmm1, xmm1 ; R3w R3w L3w L3w R2w R2w L2w L2w
369		369
370	psrad xmm0, 16 ; R1d L1d R0d L0d	370	psrad xmm0, 16 ; R1d L1d R0d L0d
371	psrad xmm1, 16 ; R3d L3d R2d L2d	371	psrad xmm1, 16 ; R3d L3d R2d L2d
372		372
373	cvtdq2ps xmm0, xmm0 ; time to use all power	373	cvtdq2ps xmm0, xmm0 ; time to use all power
374	cvtdq2ps xmm1, xmm1 ; of the dark side	374	cvtdq2ps xmm1, xmm1 ; of the dark side
375		375
376	mulps xmm0, xmm2 ; R1f' L1f' R0f' L0f'	376	mulps xmm0, xmm2 ; R1f' L1f' R0f' L0f'
377	mulps xmm1, xmm2 ; R3f' L3f' R2f' L2f'	377	mulps xmm1, xmm2 ; R3f' L3f' R2f' L2f'
378		378
379	cvtps2dq xmm0, xmm0 ; R1d' L1d' R0d' L0d'	379	cvtps2dq xmm0, xmm0 ; R1d' L1d' R0d' L0d'
380	cvtps2dq xmm1, xmm1 ; R3d' L3d' R2d' L2d'	380	cvtps2dq xmm1, xmm1 ; R3d' L3d' R2d' L2d'
381	packssdw xmm0, xmm0 ; R1w' L1w' R0w' L0w' R1w' L1w' R0w' L0w'	381	packssdw xmm0, xmm0 ; R1w' L1w' R0w' L0w' R1w' L1w' R0w' L0w'
382	packssdw xmm1, xmm1 ; R3w' L3w' R2w' L2w' R3w' L3w' R2w' L2w'	382	packssdw xmm1, xmm1 ; R3w' L3w' R2w' L2w' R3w' L3w' R2w' L2w'
383	punpcklqdq xmm0, xmm1 ; R3w' L3w' R2w' L2w' R1w' L1w' R0w' L0w'	383	punpcklqdq xmm0, xmm1 ; R3w' L3w' R2w' L2w' R1w' L1w' R0w' L0w'
384	movntdq [edi], xmm0	384	movntdq [edi], xmm0
385		385
386	add edi, 16	386	add edi, 16
387	dec ebx	387	dec ebx
388	jnz .mix	388	jnz .mix
389		389
390	ret	390	ret
391		391
392	align 4	392	align 4
393	mix_fast_2_stream:	393	mix_fast_2_stream:
394		394
395	mov ebx, 32	395	mov ebx, 32
396	mov eax, [edx]	396	mov eax, [edx]
397		397
398	movss xmm4, [edx+4] ; vol Lf	398	movss xmm4, [edx+4] ; vol Lf
399	movss xmm5, [edx+8] ; vol Rf	399	movss xmm5, [edx+8] ; vol Rf
400	mov ecx, [edx+12]	400	mov ecx, [edx+12]
401		401
402	movss xmm6, [edx+16] ; vol Lf	402	movss xmm6, [edx+16] ; vol Lf
403	movss xmm7, [edx+20] ; vol Rf	403	movss xmm7, [edx+20] ; vol Rf
404		404
405	shufps xmm4, xmm5, 0 ; Rf Rf Lf Lf	405	shufps xmm4, xmm5, 0 ; Rf Rf Lf Lf
406	shufps xmm4, xmm4, 0x88 ; volume level Rf Lf Rf Lf	406	shufps xmm4, xmm4, 0x88 ; volume level Rf Lf Rf Lf
407		407
408	shufps xmm6, xmm7, 0 ; Rf Rf Lf Lf	408	shufps xmm6, xmm7, 0 ; Rf Rf Lf Lf
409	shufps xmm6, xmm6, 0x88 ; volume level Rf Lf Rf Lf	409	shufps xmm6, xmm6, 0x88 ; volume level Rf Lf Rf Lf
410		410
411	.mix:	411	.mix:
412	movdqa xmm1, [eax] ; R3w L3w R2w L2w R1w L1w R0w L0w	412	movdqa xmm1, [eax] ; R3w L3w R2w L2w R1w L1w R0w L0w
413	movdqa xmm3, [ecx] ; R3w L3w R2w L2w R1w L1w R0w L0w	413	movdqa xmm3, [ecx] ; R3w L3w R2w L2w R1w L1w R0w L0w
414		414
415	add eax, 16	415	add eax, 16
416	add ecx, 16	416	add ecx, 16
417		417
418	punpcklwd xmm0, xmm1 ; R1w R1w L1w L1W R0w R0w L0w L0w	418	punpcklwd xmm0, xmm1 ; R1w R1w L1w L1W R0w R0w L0w L0w
419	punpckhwd xmm1, xmm1 ; R3w R3w L3w L3w R2w R2w L2w L2w	419	punpckhwd xmm1, xmm1 ; R3w R3w L3w L3w R2w R2w L2w L2w
420		420
421	psrad xmm0, 16 ; R1d L1d R0d L0d	421	psrad xmm0, 16 ; R1d L1d R0d L0d
422	psrad xmm1, 16 ; R3d L3d R2d L2d	422	psrad xmm1, 16 ; R3d L3d R2d L2d
423		423
424	cvtdq2ps xmm0, xmm0 ; time to use all power	424	cvtdq2ps xmm0, xmm0 ; time to use all power
425	cvtdq2ps xmm1, xmm1 ; of the dark side	425	cvtdq2ps xmm1, xmm1 ; of the dark side
426		426
427	mulps xmm0, xmm4 ; R1f' L1f' R0f' L0f'	427	mulps xmm0, xmm4 ; R1f' L1f' R0f' L0f'
428	mulps xmm1, xmm4 ; R3f' L3f' R2f' L2f'	428	mulps xmm1, xmm4 ; R3f' L3f' R2f' L2f'
429		429
430	punpcklwd xmm2, xmm3 ; R1w R1w L1w L1W R0w R0w L0w L0w	430	punpcklwd xmm2, xmm3 ; R1w R1w L1w L1W R0w R0w L0w L0w
431	punpckhwd xmm3, xmm3 ; R3w R3w L3w L3w R2w R2w L2w L2w	431	punpckhwd xmm3, xmm3 ; R3w R3w L3w L3w R2w R2w L2w L2w
432		432
433	psrad xmm2, 16 ; R1d L1d R0d L0d	433	psrad xmm2, 16 ; R1d L1d R0d L0d
434	psrad xmm3, 16 ; R3d L3d R2d L2d	434	psrad xmm3, 16 ; R3d L3d R2d L2d
435		435
436	cvtdq2ps xmm2, xmm2 ; time to use all power	436	cvtdq2ps xmm2, xmm2 ; time to use all power
437	cvtdq2ps xmm3, xmm3 ; of the dark side	437	cvtdq2ps xmm3, xmm3 ; of the dark side
438		438
439	mulps xmm2, xmm6 ; R1f' L1f' R0f' L0f'	439	mulps xmm2, xmm6 ; R1f' L1f' R0f' L0f'
440	mulps xmm3, xmm6 ; R3f' L3f' R2f' L2f'	440	mulps xmm3, xmm6 ; R3f' L3f' R2f' L2f'
441		441
442	addps xmm0, xmm2	442	addps xmm0, xmm2
443	addps xmm1, xmm3	443	addps xmm1, xmm3
444		444
445	cvtps2dq xmm0, xmm0 ; R1d' L1d' R0d' L0d'	445	cvtps2dq xmm0, xmm0 ; R1d' L1d' R0d' L0d'
446	cvtps2dq xmm1, xmm1 ; R3d' L3d' R2d' L2d'	446	cvtps2dq xmm1, xmm1 ; R3d' L3d' R2d' L2d'
447	packssdw xmm0, xmm0 ; R1w' L1w' R0w' L0w' R1w' L1w' R0w' L0w'	447	packssdw xmm0, xmm0 ; R1w' L1w' R0w' L0w' R1w' L1w' R0w' L0w'
448	packssdw xmm1, xmm1 ; R3w' L3w' R2w' L2w' R3w' L3w' R2w' L2w'	448	packssdw xmm1, xmm1 ; R3w' L3w' R2w' L2w' R3w' L3w' R2w' L2w'
449	punpcklqdq xmm0, xmm1 ; R3w' L3w' R2w' L2w' R1w' L1w' R0w' L0w'	449	punpcklqdq xmm0, xmm1 ; R3w' L3w' R2w' L2w' R1w' L1w' R0w' L0w'
450	movntdq [edi], xmm0	450	movntdq [edi], xmm0
451		451
452	add edi, 16	452	add edi, 16
453	dec ebx	453	dec ebx
454	jnz .mix	454	jnz .mix
455		455
456	ret	456	ret
457		457
458	else ; fixed point mmx version	458	else ; fixed point mmx version
459		459
460	align 4	460	align 4
461	proc mix_all stdcall, dest:dword, list:dword, count:dword	461	proc mix_all stdcall, dest:dword, list:dword, count:dword
462		462
463	mov edi, [dest]	463	mov edi, [dest]
464	mov ebx, 64	464	mov ebx, 64
465	.mix:	465	.mix:
466	mov edx, [list]	466	mov edx, [list]
467	mov ecx, [count]	467	mov ecx, [count]
468		468
469	mov eax, [edx]	469	mov eax, [edx]
470		470
471	movq mm0, [eax]	471	movq mm0, [eax]
472		472
473	movd mm1, [edx+4]	473	movd mm1, [edx+4]
474	punpckldq mm1, mm1	474	punpckldq mm1, mm1
475	pmulhw mm0, mm1	475	pmulhw mm0, mm1
476	psllw mm0, 1	476	psllw mm0, 1
477		477
478	.mix_loop:	478	.mix_loop:
479	add dword [edx], 8	479	add dword [edx], 8
480	add edx, 12	480	add edx, 12
481	dec ecx	481	dec ecx
482	jz @F	482	jz @F
483		483
484	mov eax, [edx]	484	mov eax, [edx]
485	movq mm1, [eax]	485	movq mm1, [eax]
486	movd mm2, [edx+4]	486	movd mm2, [edx+4]
487	punpckldq mm2, mm2	487	punpckldq mm2, mm2
488	pmulhw mm1, mm2	488	pmulhw mm1, mm2
489	psllw mm1, 1	489	psllw mm1, 1
490	paddsw mm0, mm1	490	paddsw mm0, mm1
491	jmp .mix_loop	491	jmp .mix_loop
492	@@:	492	@@:
493	movq [edi], mm0	493	movq [edi], mm0
494	add edi, 8	494	add edi, 8
495	dec ebx	495	dec ebx
496	jnz .mix	496	jnz .mix
497		497
498	ret	498	ret
499	endp	499	endp
500		500

Subversion Repositories Kolibri OS

(root)/drivers/audio/infinity/mixer.asm @ 5363 – Rev 2455 → 5077