summaryrefslogtreecommitdiff
path: root/attic/muse_qt4_evolution/al/dspSSE.cpp
diff options
context:
space:
mode:
authorRobert Jonsson <spamatica@gmail.com>2011-09-15 12:14:55 +0000
committerRobert Jonsson <spamatica@gmail.com>2011-09-15 12:14:55 +0000
commitb0546e5e7f7044019892543c6c82029db8d564a7 (patch)
tree1b96a6260900f3fbf3513fb48a5a72aa89052dc8 /attic/muse_qt4_evolution/al/dspSSE.cpp
parent583c73d1a07154d3d2672d65d8cce6495f490454 (diff)
moved attic to a branch of it's own
Diffstat (limited to 'attic/muse_qt4_evolution/al/dspSSE.cpp')
-rw-r--r--attic/muse_qt4_evolution/al/dspSSE.cpp531
1 files changed, 0 insertions, 531 deletions
diff --git a/attic/muse_qt4_evolution/al/dspSSE.cpp b/attic/muse_qt4_evolution/al/dspSSE.cpp
deleted file mode 100644
index 0f3d84b9..00000000
--- a/attic/muse_qt4_evolution/al/dspSSE.cpp
+++ /dev/null
@@ -1,531 +0,0 @@
-/*
- Copyright (C) 2005 Paul Davis
-
- 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.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
- Author: Sampo Savolainen
-
- $Id: sse_functions.s 988 2006-10-17 20:40:39Z paul $
-*/
-
-
-#; void x86_sse_mix_buffers_with_gain (float *dst, float *src, long nframes, float gain);
-
-.globl x86_sse_mix_buffers_with_gain
- .type x86_sse_mix_buffers_with_gain,@function
-
-x86_sse_mix_buffers_with_gain:
-#; 8(%ebp) = float *dst = %edi
-#; 12(%ebp) = float *src = %esi
-#; 16(%ebp) = long nframes = %ecx
-#; 20(%ebp) = float gain = st(0)
-
- pushl %ebp
- movl %esp, %ebp
-
- #; save the registers
-#; pushl %eax
- pushl %ebx
-#; pushl %ecx
- pushl %edi
- pushl %esi
-
- #; if nframes == 0, go to end
- movl 16(%ebp), %ecx #; nframes
- cmp $0, %ecx
- je .MBWG_END
-
- #; Check for alignment
-
- movl 8(%ebp), %edi #; dst
- movl 12(%ebp), %esi #; src
-
- movl %edi, %eax
- andl $12, %eax #; mask alignemnt offset
-
- movl %esi, %ebx
- andl $12, %ebx #; mask alignment offset
-
- cmp %eax, %ebx
- jne .MBWG_NONALIGN #; if not aligned, calculate manually
-
- #; if we are aligned
- cmp $0, %ebx
- jz .MBWG_SSE
-
- #; Pre-loop, we need to run 1-3 frames "manually" without
- #; SSE instructions
-
- movss 20(%ebp), %xmm1 #; xmm1
-
-.MBWG_PRELOOP:
-
- movss (%esi), %xmm0
- mulss %xmm1, %xmm0
- addss (%edi), %xmm0
- movss %xmm0, (%edi)
-
- addl $4, %edi #; dst++
- addl $4, %esi #; src++
- decl %ecx #; nframes--
- jz .MBWG_END
-
-#; cmp $0, %ecx
-#; je .MBWG_END #; if we run out of frames, go to end
-
- addl $4, %ebx
-
- cmp $16, %ebx #; test if we've reached 16 byte alignment
- jne .MBWG_PRELOOP
-
-
-.MBWG_SSE:
-
- cmp $4, %ecx #; we know it's not zero, but if it's not >=4, then
- jnge .MBWG_NONALIGN #; we jump straight to the "normal" code
-
- #; copy gain to fill %xmm1
- movss 20(%ebp), %xmm1
- shufps $0x00, %xmm1, %xmm1
-
-
-.MBWG_SSELOOP:
-
- movaps (%esi), %xmm0 #; source => xmm0
- mulps %xmm1, %xmm0 #; apply gain to source
- addps (%edi), %xmm0 #; mix with destination
- movaps %xmm0, (%edi) #; copy result to destination
-
- addl $16, %edi #; dst+=4
- addl $16, %esi #; src+=4
-
- subl $4, %ecx #; nframes-=4
- cmp $4, %ecx
- jge .MBWG_SSELOOP
-
- cmp $0, %ecx
- je .MBWG_END
-
- #; if there are remaining frames, the nonalign code will do nicely
- #; for the rest 1-3 frames.
-
-.MBWG_NONALIGN:
- #; not aligned!
-
- movss 20(%ebp), %xmm1 #; gain => xmm1
-
-.MBWG_NONALIGNLOOP:
-
- movss (%esi), %xmm0
- mulss %xmm1, %xmm0
- addss (%edi), %xmm0
- movss %xmm0, (%edi)
-
- addl $4, %edi
- addl $4, %esi
-
- decl %ecx
- jnz .MBWG_NONALIGNLOOP
-
-.MBWG_END:
-
- popl %esi
- popl %edi
-#; popl %ecx
- popl %ebx
-#; popl %eax
-
- #; return
- leave
- ret
-
-.size x86_sse_mix_buffers_with_gain, .-x86_sse_mix_buffers_with_gain
-
-
-
-
-#; void x86_sse_mix_buffers_no_gain (float *dst, float *src, long nframes);
-
-.globl x86_sse_mix_buffers_no_gain
- .type x86_sse_mix_buffers_no_gain,@function
-
-x86_sse_mix_buffers_no_gain:
-#; 8(%ebp) = float *dst = %edi
-#; 12(%ebp) = float *src = %esi
-#; 16(%ebp) = long nframes = %ecx
-
- pushl %ebp
- movl %esp, %ebp
-
- #; save the registers
-#; pushl %eax
- pushl %ebx
-#; pushl %ecx
- pushl %edi
- pushl %esi
-
- #; the real function
-
- #; if nframes == 0, go to end
- movl 16(%ebp), %ecx #; nframes
- cmp $0, %ecx
- je .MBNG_END
-
- #; Check for alignment
-
- movl 8(%ebp), %edi #; dst
- movl 12(%ebp), %esi #; src
-
- movl %edi, %eax
- andl $12, %eax #; mask alignemnt offset
-
- movl %esi, %ebx
- andl $12, %ebx #; mask alignment offset
-
- cmp %eax, %ebx
- jne .MBNG_NONALIGN #; if not aligned, calculate manually
-
- cmp $0, %ebx
- je .MBNG_SSE
-
- #; Pre-loop, we need to run 1-3 frames "manually" without
- #; SSE instructions
-
-.MBNG_PRELOOP:
-
- movss (%esi), %xmm0
- addss (%edi), %xmm0
- movss %xmm0, (%edi)
-
- addl $4, %edi #; dst++
- addl $4, %esi #; src++
- decl %ecx #; nframes--
- jz .MBNG_END
- addl $4, %ebx
-
- cmp $16, %ebx #; test if we've reached 16 byte alignment
- jne .MBNG_PRELOOP
-
-.MBNG_SSE:
-
- cmp $4, %ecx #; if there are frames left, but less than 4
- jnge .MBNG_NONALIGN #; we can't run SSE
-
-.MBNG_SSELOOP:
-
- movaps (%esi), %xmm0 #; source => xmm0
- addps (%edi), %xmm0 #; mix with destination
- movaps %xmm0, (%edi) #; copy result to destination
-
- addl $16, %edi #; dst+=4
- addl $16, %esi #; src+=4
-
- subl $4, %ecx #; nframes-=4
- cmp $4, %ecx
- jge .MBNG_SSELOOP
-
- cmp $0, %ecx
- je .MBNG_END
-
- #; if there are remaining frames, the nonalign code will do nicely
- #; for the rest 1-3 frames.
-
-.MBNG_NONALIGN:
- #; not aligned!
-
- movss (%esi), %xmm0 #; src => xmm0
- addss (%edi), %xmm0 #; xmm0 += dst
- movss %xmm0, (%edi) #; xmm0 => dst
-
- addl $4, %edi
- addl $4, %esi
-
- decl %ecx
- jnz .MBNG_NONALIGN
-
-.MBNG_END:
-
- popl %esi
- popl %edi
-#; popl %ecx
- popl %ebx
-#; popl %eax
-
- #; return
- leave
- ret
-
-.size x86_sse_mix_buffers_no_gain, .-x86_sse_mix_buffers_no_gain
-
-
-
-
-#; void x86_sse_apply_gain_to_buffer (float *buf, long nframes, float gain);
-
-.globl x86_sse_apply_gain_to_buffer
- .type x86_sse_apply_gain_to_buffer,@function
-
-x86_sse_apply_gain_to_buffer:
-#; 8(%ebp) = float *buf = %edi
-#; 12(%ebp) = long nframes = %ecx
-#; 16(%ebp) = float gain = st(0)
-
- pushl %ebp
- movl %esp, %ebp
-
- #; save %edi
- pushl %edi
-
- #; the real function
-
- #; if nframes == 0, go to end
- movl 12(%ebp), %ecx #; nframes
- cmp $0, %ecx
- je .AG_END
-
- #; create the gain buffer in %xmm1
- movss 16(%ebp), %xmm1
- shufps $0x00, %xmm1, %xmm1
-
- #; Check for alignment
-
- movl 8(%ebp), %edi #; buf
- movl %edi, %edx #; buf => %edx
- andl $12, %edx #; mask bits 1 & 2, result = 0, 4, 8 or 12
- jz .AG_SSE #; if buffer IS aligned
-
- #; PRE-LOOP
- #; we iterate 1-3 times, doing normal x87 float comparison
- #; so we reach a 16 byte aligned "buf" (=%edi) value
-
-.AGLP_START:
-
- #; Load next value from the buffer
- movss (%edi), %xmm0
- mulss %xmm1, %xmm0
- movss %xmm0, (%edi)
-
- #; increment buffer, decrement counter
- addl $4, %edi #; buf++;
-
- decl %ecx #; nframes--
- jz .AG_END #; if we run out of frames, we go to the end
-
- addl $4, %edx #; one non-aligned byte less
- cmp $16, %edx
- jne .AGLP_START #; if more non-aligned frames exist, we do a do-over
-
-.AG_SSE:
-
- #; We have reached the 16 byte aligned "buf" ("edi") value
-
- #; Figure out how many loops we should do
- movl %ecx, %eax #; copy remaining nframes to %eax for division
- movl $0, %edx #; 0 the edx register
-
-
- pushl %edi
- movl $4, %edi
- divl %edi #; %edx = remainder == 0
- popl %edi
-
- #; %eax = SSE iterations
- cmp $0, %eax
- je .AGPOST_START
-
-
-.AGLP_SSE:
-
- movaps (%edi), %xmm0
- mulps %xmm1, %xmm0
- movaps %xmm0, (%edi)
-
- addl $16, %edi
-#; subl $4, %ecx #; nframes-=4
-
- decl %eax
- jnz .AGLP_SSE
-
- #; Next we need to post-process all remaining frames
- #; the remaining frame count is in %ecx
-
- #; if no remaining frames, jump to the end
-#; cmp $0, %ecx
- andl $3, %ecx #; nframes % 4
- je .AG_END
-
-.AGPOST_START:
-
- movss (%edi), %xmm0
- mulss %xmm1, %xmm0
- movss %xmm0, (%edi)
-
- #; increment buffer, decrement counter
- addl $4, %edi #; buf++;
-
- decl %ecx #; nframes--
- jnz .AGPOST_START #; if we run out of frames, we go to the end
-
-.AG_END:
-
-
- popl %edi
-
- #; return
- leave
- ret
-
-.size x86_sse_apply_gain_to_buffer, .-x86_sse_apply_gain_to_buffer
-#; end proc
-
-
-
-#; float x86_sse_compute_peak(float *buf, long nframes, float current);
-
-.globl x86_sse_compute_peak
- .type x86_sse_compute_peak,@function
-
-x86_sse_compute_peak:
-#; 8(%ebp) = float *buf = %edi
-#; 12(%ebp) = long nframes = %ecx
-#; 16(%ebp) = float current = st(0)
-
- pushl %ebp
- movl %esp, %ebp
-
- #; save %edi
- pushl %edi
-
- #; the real function
-
- #; Load "current" in xmm0
- movss 16(%ebp), %xmm0
-
- #; if nframes == 0, go to end
- movl 12(%ebp), %ecx #; nframes
- cmp $0, %ecx
- je .CP_END
-
- #; create the "abs" mask in %xmm2
- pushl $2147483647
- movss (%esp), %xmm2
- addl $4, %esp
- shufps $0x00, %xmm2, %xmm2
-
- #; Check for alignment
-
- movl 8(%ebp), %edi #; buf
- movl %edi, %edx #; buf => %edx
- andl $12, %edx #; mask bits 1 & 2, result = 0, 4, 8 or 12
- jz .CP_SSE #; if buffer IS aligned
-
- #; PRE-LOOP
- #; we iterate 1-3 times, doing normal x87 float comparison
- #; so we reach a 16 byte aligned "buf" (=%edi) value
-
-.LP_START:
-
- #; Load next value from the buffer
- movss (%edi), %xmm1
- andps %xmm2, %xmm1
- maxss %xmm1, %xmm0
-
- #; increment buffer, decrement counter
- addl $4, %edi #; buf++;
-
- decl %ecx #; nframes--
- jz .CP_END #; if we run out of frames, we go to the end
-
- addl $4, %edx #; one non-aligned byte less
- cmp $16, %edx
- jne .LP_START #; if more non-aligned frames exist, we do a do-over
-
-.CP_SSE:
-
- #; We have reached the 16 byte aligned "buf" ("edi") value
-
- #; Figure out how many loops we should do
- movl %ecx, %eax #; copy remaining nframes to %eax for division
-
- shr $2,%eax #; unsigned divide by 4
- jz .POST_START
-
- #; %eax = SSE iterations
-
- #; current maximum is at %xmm0, but we need to ..
- shufps $0x00, %xmm0, %xmm0 #; shuffle "current" to all 4 FP's
-
- #;prefetcht0 16(%edi)
-
-.LP_SSE:
-
- movaps (%edi), %xmm1
- andps %xmm2, %xmm1
- maxps %xmm1, %xmm0
-
- addl $16, %edi
-
- decl %eax
- jnz .LP_SSE
-
- #; Calculate the maximum value contained in the 4 FP's in %xmm0
- movaps %xmm0, %xmm1
- shufps $0x4e, %xmm1, %xmm1 #; shuffle left & right pairs (1234 => 3412)
- maxps %xmm1, %xmm0 #; maximums of the two pairs
- movaps %xmm0, %xmm1
- shufps $0xb1, %xmm1, %xmm1 #; shuffle the floats inside the two pairs (1234 => 2143)
- maxps %xmm1, %xmm0
-
- #; now every float in %xmm0 is the same value, current maximum value
-
- #; Next we need to post-process all remaining frames
- #; the remaining frame count is in %ecx
-
- #; if no remaining frames, jump to the end
-
- andl $3, %ecx #; nframes % 4
- jz .CP_END
-
-.POST_START:
-
- movss (%edi), %xmm1
- andps %xmm2, %xmm1
- maxss %xmm1, %xmm0
-
- addl $4, %edi #; buf++;
-
- decl %ecx #; nframes--;
- jnz .POST_START
-
-.CP_END:
-
- #; Load the value from xmm0 to the float stack for returning
- movss %xmm0, 16(%ebp)
- flds 16(%ebp)
-
- popl %edi
-
- #; return
- leave
- ret
-
-.size x86_sse_compute_peak, .-x86_sse_compute_peak
-#; end proc
-
-#ifdef __ELF__
-.section .note.GNU-stack,"",%progbits
-#endif
-
-