• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1;  vim:filetype=nasm ts=8
2
3;  libFLAC - Free Lossless Audio Codec library
4;  Copyright (C) 2001-2009  Josh Coalson
5;  Copyright (C) 2011-2016  Xiph.Org Foundation
6;
7;  Redistribution and use in source and binary forms, with or without
8;  modification, are permitted provided that the following conditions
9;  are met:
10;
11;  - Redistributions of source code must retain the above copyright
12;  notice, this list of conditions and the following disclaimer.
13;
14;  - Redistributions in binary form must reproduce the above copyright
15;  notice, this list of conditions and the following disclaimer in the
16;  documentation and/or other materials provided with the distribution.
17;
18;  - Neither the name of the Xiph.org Foundation nor the names of its
19;  contributors may be used to endorse or promote products derived from
20;  this software without specific prior written permission.
21;
22;  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23;  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24;  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25;  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
26;  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27;  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28;  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29;  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30;  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31;  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32;  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33
34%include "nasm.h"
35
36	data_section
37
38cglobal FLAC__lpc_compute_autocorrelation_asm_ia32
39cglobal FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4_old
40cglobal FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8_old
41cglobal FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12_old
42cglobal FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_16_old
43cglobal FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32
44cglobal FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx
45cglobal FLAC__lpc_compute_residual_from_qlp_coefficients_wide_asm_ia32
46cglobal FLAC__lpc_restore_signal_asm_ia32
47cglobal FLAC__lpc_restore_signal_asm_ia32_mmx
48cglobal FLAC__lpc_restore_signal_wide_asm_ia32
49
50	code_section
51
52; **********************************************************************
53;
54; void FLAC__lpc_compute_autocorrelation_asm(const FLAC__real data[], unsigned data_len, unsigned lag, FLAC__real autoc[])
55; {
56;	FLAC__real d;
57;	unsigned sample, coeff;
58;	const unsigned limit = data_len - lag;
59;
60;	FLAC__ASSERT(lag > 0);
61;	FLAC__ASSERT(lag <= data_len);
62;
63;	for(coeff = 0; coeff < lag; coeff++)
64;		autoc[coeff] = 0.0;
65;	for(sample = 0; sample <= limit; sample++) {
66;		d = data[sample];
67;		for(coeff = 0; coeff < lag; coeff++)
68;			autoc[coeff] += d * data[sample+coeff];
69;	}
70;	for(; sample < data_len; sample++) {
71;		d = data[sample];
72;		for(coeff = 0; coeff < data_len - sample; coeff++)
73;			autoc[coeff] += d * data[sample+coeff];
74;	}
75; }
76;
77	ALIGN 16
78cident FLAC__lpc_compute_autocorrelation_asm_ia32
79	;[esp + 28] == autoc[]
80	;[esp + 24] == lag
81	;[esp + 20] == data_len
82	;[esp + 16] == data[]
83
84	;ASSERT(lag > 0)
85	;ASSERT(lag <= 33)
86	;ASSERT(lag <= data_len)
87
88.begin:
89	push	esi
90	push	edi
91	push	ebx
92
93	;	for(coeff = 0; coeff < lag; coeff++)
94	;		autoc[coeff] = 0.0;
95	mov	edi, [esp + 28]			; edi == autoc
96	mov	ecx, [esp + 24]			; ecx = # of dwords (=lag) of 0 to write
97	xor	eax, eax
98	rep	stosd
99
100	;	const unsigned limit = data_len - lag;
101	mov	eax, [esp + 24]			; eax == lag
102	mov	ecx, [esp + 20]
103	sub	ecx, eax			; ecx == limit
104
105	mov	edi, [esp + 28]			; edi == autoc
106	mov	esi, [esp + 16]			; esi == data
107	inc	ecx				; we are looping <= limit so we add one to the counter
108
109	;	for(sample = 0; sample <= limit; sample++) {
110	;		d = data[sample];
111	;		for(coeff = 0; coeff < lag; coeff++)
112	;			autoc[coeff] += d * data[sample+coeff];
113	;	}
114	fld	dword [esi]			; ST = d <- data[sample]
115	; each iteration is 11 bytes so we need (-eax)*11, so we do (-12*eax + eax)
116	lea	edx, [eax + eax*2]
117	neg	edx
118	lea	edx, [eax + edx*4 + .jumper1_0 - .get_eip1]
119	call	.mov_eip_to_ebx
120.get_eip1:
121	add	edx, ebx
122	inc	edx				; compensate for the shorter opcode on the last iteration
123	inc	edx				; compensate for the shorter opcode on the last iteration
124	inc	edx				; compensate for the shorter opcode on the last iteration
125	cmp	eax, 33
126	jne	.loop1_start
127	sub	edx, byte 9			; compensate for the longer opcodes on the first iteration
128.loop1_start:
129	jmp	edx
130
131.mov_eip_to_ebx:
132	mov	ebx, [esp]
133	ret
134
135	fld	st0				; ST = d d
136	fmul	dword [esi + (32*4)]		; ST = d*data[sample+32] d		WATCHOUT: not a byte displacement here!
137	fadd	dword [edi + (32*4)]		; ST = autoc[32]+d*data[sample+32] d	WATCHOUT: not a byte displacement here!
138	fstp	dword [edi + (32*4)]		; autoc[32]+=d*data[sample+32]  ST = d	WATCHOUT: not a byte displacement here!
139	fld	st0				; ST = d d
140	fmul	dword [esi + (31*4)]		; ST = d*data[sample+31] d
141	fadd	dword [edi + (31*4)]		; ST = autoc[31]+d*data[sample+31] d
142	fstp	dword [edi + (31*4)]		; autoc[31]+=d*data[sample+31]  ST = d
143	fld	st0				; ST = d d
144	fmul	dword [esi + (30*4)]		; ST = d*data[sample+30] d
145	fadd	dword [edi + (30*4)]		; ST = autoc[30]+d*data[sample+30] d
146	fstp	dword [edi + (30*4)]		; autoc[30]+=d*data[sample+30]  ST = d
147	fld	st0				; ST = d d
148	fmul	dword [esi + (29*4)]		; ST = d*data[sample+29] d
149	fadd	dword [edi + (29*4)]		; ST = autoc[29]+d*data[sample+29] d
150	fstp	dword [edi + (29*4)]		; autoc[29]+=d*data[sample+29]  ST = d
151	fld	st0				; ST = d d
152	fmul	dword [esi + (28*4)]		; ST = d*data[sample+28] d
153	fadd	dword [edi + (28*4)]		; ST = autoc[28]+d*data[sample+28] d
154	fstp	dword [edi + (28*4)]		; autoc[28]+=d*data[sample+28]  ST = d
155	fld	st0				; ST = d d
156	fmul	dword [esi + (27*4)]		; ST = d*data[sample+27] d
157	fadd	dword [edi + (27*4)]		; ST = autoc[27]+d*data[sample+27] d
158	fstp	dword [edi + (27*4)]		; autoc[27]+=d*data[sample+27]  ST = d
159	fld	st0				; ST = d d
160	fmul	dword [esi + (26*4)]		; ST = d*data[sample+26] d
161	fadd	dword [edi + (26*4)]		; ST = autoc[26]+d*data[sample+26] d
162	fstp	dword [edi + (26*4)]		; autoc[26]+=d*data[sample+26]  ST = d
163	fld	st0				; ST = d d
164	fmul	dword [esi + (25*4)]		; ST = d*data[sample+25] d
165	fadd	dword [edi + (25*4)]		; ST = autoc[25]+d*data[sample+25] d
166	fstp	dword [edi + (25*4)]		; autoc[25]+=d*data[sample+25]  ST = d
167	fld	st0				; ST = d d
168	fmul	dword [esi + (24*4)]		; ST = d*data[sample+24] d
169	fadd	dword [edi + (24*4)]		; ST = autoc[24]+d*data[sample+24] d
170	fstp	dword [edi + (24*4)]		; autoc[24]+=d*data[sample+24]  ST = d
171	fld	st0				; ST = d d
172	fmul	dword [esi + (23*4)]		; ST = d*data[sample+23] d
173	fadd	dword [edi + (23*4)]		; ST = autoc[23]+d*data[sample+23] d
174	fstp	dword [edi + (23*4)]		; autoc[23]+=d*data[sample+23]  ST = d
175	fld	st0				; ST = d d
176	fmul	dword [esi + (22*4)]		; ST = d*data[sample+22] d
177	fadd	dword [edi + (22*4)]		; ST = autoc[22]+d*data[sample+22] d
178	fstp	dword [edi + (22*4)]		; autoc[22]+=d*data[sample+22]  ST = d
179	fld	st0				; ST = d d
180	fmul	dword [esi + (21*4)]		; ST = d*data[sample+21] d
181	fadd	dword [edi + (21*4)]		; ST = autoc[21]+d*data[sample+21] d
182	fstp	dword [edi + (21*4)]		; autoc[21]+=d*data[sample+21]  ST = d
183	fld	st0				; ST = d d
184	fmul	dword [esi + (20*4)]		; ST = d*data[sample+20] d
185	fadd	dword [edi + (20*4)]		; ST = autoc[20]+d*data[sample+20] d
186	fstp	dword [edi + (20*4)]		; autoc[20]+=d*data[sample+20]  ST = d
187	fld	st0				; ST = d d
188	fmul	dword [esi + (19*4)]		; ST = d*data[sample+19] d
189	fadd	dword [edi + (19*4)]		; ST = autoc[19]+d*data[sample+19] d
190	fstp	dword [edi + (19*4)]		; autoc[19]+=d*data[sample+19]  ST = d
191	fld	st0				; ST = d d
192	fmul	dword [esi + (18*4)]		; ST = d*data[sample+18] d
193	fadd	dword [edi + (18*4)]		; ST = autoc[18]+d*data[sample+18] d
194	fstp	dword [edi + (18*4)]		; autoc[18]+=d*data[sample+18]  ST = d
195	fld	st0				; ST = d d
196	fmul	dword [esi + (17*4)]		; ST = d*data[sample+17] d
197	fadd	dword [edi + (17*4)]		; ST = autoc[17]+d*data[sample+17] d
198	fstp	dword [edi + (17*4)]		; autoc[17]+=d*data[sample+17]  ST = d
199	fld	st0				; ST = d d
200	fmul	dword [esi + (16*4)]		; ST = d*data[sample+16] d
201	fadd	dword [edi + (16*4)]		; ST = autoc[16]+d*data[sample+16] d
202	fstp	dword [edi + (16*4)]		; autoc[16]+=d*data[sample+16]  ST = d
203	fld	st0				; ST = d d
204	fmul	dword [esi + (15*4)]		; ST = d*data[sample+15] d
205	fadd	dword [edi + (15*4)]		; ST = autoc[15]+d*data[sample+15] d
206	fstp	dword [edi + (15*4)]		; autoc[15]+=d*data[sample+15]  ST = d
207	fld	st0				; ST = d d
208	fmul	dword [esi + (14*4)]		; ST = d*data[sample+14] d
209	fadd	dword [edi + (14*4)]		; ST = autoc[14]+d*data[sample+14] d
210	fstp	dword [edi + (14*4)]		; autoc[14]+=d*data[sample+14]  ST = d
211	fld	st0				; ST = d d
212	fmul	dword [esi + (13*4)]		; ST = d*data[sample+13] d
213	fadd	dword [edi + (13*4)]		; ST = autoc[13]+d*data[sample+13] d
214	fstp	dword [edi + (13*4)]		; autoc[13]+=d*data[sample+13]  ST = d
215	fld	st0				; ST = d d
216	fmul	dword [esi + (12*4)]		; ST = d*data[sample+12] d
217	fadd	dword [edi + (12*4)]		; ST = autoc[12]+d*data[sample+12] d
218	fstp	dword [edi + (12*4)]		; autoc[12]+=d*data[sample+12]  ST = d
219	fld	st0				; ST = d d
220	fmul	dword [esi + (11*4)]		; ST = d*data[sample+11] d
221	fadd	dword [edi + (11*4)]		; ST = autoc[11]+d*data[sample+11] d
222	fstp	dword [edi + (11*4)]		; autoc[11]+=d*data[sample+11]  ST = d
223	fld	st0				; ST = d d
224	fmul	dword [esi + (10*4)]		; ST = d*data[sample+10] d
225	fadd	dword [edi + (10*4)]		; ST = autoc[10]+d*data[sample+10] d
226	fstp	dword [edi + (10*4)]		; autoc[10]+=d*data[sample+10]  ST = d
227	fld	st0				; ST = d d
228	fmul	dword [esi + ( 9*4)]		; ST = d*data[sample+9] d
229	fadd	dword [edi + ( 9*4)]		; ST = autoc[9]+d*data[sample+9] d
230	fstp	dword [edi + ( 9*4)]		; autoc[9]+=d*data[sample+9]  ST = d
231	fld	st0				; ST = d d
232	fmul	dword [esi + ( 8*4)]		; ST = d*data[sample+8] d
233	fadd	dword [edi + ( 8*4)]		; ST = autoc[8]+d*data[sample+8] d
234	fstp	dword [edi + ( 8*4)]		; autoc[8]+=d*data[sample+8]  ST = d
235	fld	st0				; ST = d d
236	fmul	dword [esi + ( 7*4)]		; ST = d*data[sample+7] d
237	fadd	dword [edi + ( 7*4)]		; ST = autoc[7]+d*data[sample+7] d
238	fstp	dword [edi + ( 7*4)]		; autoc[7]+=d*data[sample+7]  ST = d
239	fld	st0				; ST = d d
240	fmul	dword [esi + ( 6*4)]		; ST = d*data[sample+6] d
241	fadd	dword [edi + ( 6*4)]		; ST = autoc[6]+d*data[sample+6] d
242	fstp	dword [edi + ( 6*4)]		; autoc[6]+=d*data[sample+6]  ST = d
243	fld	st0				; ST = d d
244	fmul	dword [esi + ( 5*4)]		; ST = d*data[sample+4] d
245	fadd	dword [edi + ( 5*4)]		; ST = autoc[4]+d*data[sample+4] d
246	fstp	dword [edi + ( 5*4)]		; autoc[4]+=d*data[sample+4]  ST = d
247	fld	st0				; ST = d d
248	fmul	dword [esi + ( 4*4)]		; ST = d*data[sample+4] d
249	fadd	dword [edi + ( 4*4)]		; ST = autoc[4]+d*data[sample+4] d
250	fstp	dword [edi + ( 4*4)]		; autoc[4]+=d*data[sample+4]  ST = d
251	fld	st0				; ST = d d
252	fmul	dword [esi + ( 3*4)]		; ST = d*data[sample+3] d
253	fadd	dword [edi + ( 3*4)]		; ST = autoc[3]+d*data[sample+3] d
254	fstp	dword [edi + ( 3*4)]		; autoc[3]+=d*data[sample+3]  ST = d
255	fld	st0				; ST = d d
256	fmul	dword [esi + ( 2*4)]		; ST = d*data[sample+2] d
257	fadd	dword [edi + ( 2*4)]		; ST = autoc[2]+d*data[sample+2] d
258	fstp	dword [edi + ( 2*4)]		; autoc[2]+=d*data[sample+2]  ST = d
259	fld	st0				; ST = d d
260	fmul	dword [esi + ( 1*4)]		; ST = d*data[sample+1] d
261	fadd	dword [edi + ( 1*4)]		; ST = autoc[1]+d*data[sample+1] d
262	fstp	dword [edi + ( 1*4)]		; autoc[1]+=d*data[sample+1]  ST = d
263	fld	st0				; ST = d d
264	fmul	dword [esi]			; ST = d*data[sample] d			WATCHOUT: no displacement byte here!
265	fadd	dword [edi]			; ST = autoc[0]+d*data[sample] d	WATCHOUT: no displacement byte here!
266	fstp	dword [edi]			; autoc[0]+=d*data[sample]  ST = d	WATCHOUT: no displacement byte here!
267.jumper1_0:
268
269	fstp	st0				; pop d, ST = empty
270	add	esi, byte 4			; sample++
271	dec	ecx
272	jz	.loop1_end
273	fld	dword [esi]			; ST = d <- data[sample]
274	jmp	edx
275.loop1_end:
276
277	;	for(; sample < data_len; sample++) {
278	;		d = data[sample];
279	;		for(coeff = 0; coeff < data_len - sample; coeff++)
280	;			autoc[coeff] += d * data[sample+coeff];
281	;	}
282	mov	ecx, [esp + 24]			; ecx <- lag
283	dec	ecx				; ecx <- lag - 1
284	jz	near .end			; skip loop if 0 (i.e. lag == 1)
285
286	fld	dword [esi]			; ST = d <- data[sample]
287	mov	eax, ecx			; eax <- lag - 1 == data_len - sample the first time through
288	; each iteration is 11 bytes so we need (-eax)*11, so we do (-12*eax + eax)
289	lea	edx, [eax + eax*2]
290	neg	edx
291	lea	edx, [eax + edx*4 + .jumper2_0 - .get_eip2]
292	call	.mov_eip_to_ebx
293.get_eip2:
294	add	edx, ebx
295	inc	edx				; compensate for the shorter opcode on the last iteration
296	inc	edx				; compensate for the shorter opcode on the last iteration
297	inc	edx				; compensate for the shorter opcode on the last iteration
298	jmp	edx
299
300	fld	st0				; ST = d d
301	fmul	dword [esi + (31*4)]		; ST = d*data[sample+31] d
302	fadd	dword [edi + (31*4)]		; ST = autoc[31]+d*data[sample+31] d
303	fstp	dword [edi + (31*4)]		; autoc[31]+=d*data[sample+31]  ST = d
304	fld	st0				; ST = d d
305	fmul	dword [esi + (30*4)]		; ST = d*data[sample+30] d
306	fadd	dword [edi + (30*4)]		; ST = autoc[30]+d*data[sample+30] d
307	fstp	dword [edi + (30*4)]		; autoc[30]+=d*data[sample+30]  ST = d
308	fld	st0				; ST = d d
309	fmul	dword [esi + (29*4)]		; ST = d*data[sample+29] d
310	fadd	dword [edi + (29*4)]		; ST = autoc[29]+d*data[sample+29] d
311	fstp	dword [edi + (29*4)]		; autoc[29]+=d*data[sample+29]  ST = d
312	fld	st0				; ST = d d
313	fmul	dword [esi + (28*4)]		; ST = d*data[sample+28] d
314	fadd	dword [edi + (28*4)]		; ST = autoc[28]+d*data[sample+28] d
315	fstp	dword [edi + (28*4)]		; autoc[28]+=d*data[sample+28]  ST = d
316	fld	st0				; ST = d d
317	fmul	dword [esi + (27*4)]		; ST = d*data[sample+27] d
318	fadd	dword [edi + (27*4)]		; ST = autoc[27]+d*data[sample+27] d
319	fstp	dword [edi + (27*4)]		; autoc[27]+=d*data[sample+27]  ST = d
320	fld	st0				; ST = d d
321	fmul	dword [esi + (26*4)]		; ST = d*data[sample+26] d
322	fadd	dword [edi + (26*4)]		; ST = autoc[26]+d*data[sample+26] d
323	fstp	dword [edi + (26*4)]		; autoc[26]+=d*data[sample+26]  ST = d
324	fld	st0				; ST = d d
325	fmul	dword [esi + (25*4)]		; ST = d*data[sample+25] d
326	fadd	dword [edi + (25*4)]		; ST = autoc[25]+d*data[sample+25] d
327	fstp	dword [edi + (25*4)]		; autoc[25]+=d*data[sample+25]  ST = d
328	fld	st0				; ST = d d
329	fmul	dword [esi + (24*4)]		; ST = d*data[sample+24] d
330	fadd	dword [edi + (24*4)]		; ST = autoc[24]+d*data[sample+24] d
331	fstp	dword [edi + (24*4)]		; autoc[24]+=d*data[sample+24]  ST = d
332	fld	st0				; ST = d d
333	fmul	dword [esi + (23*4)]		; ST = d*data[sample+23] d
334	fadd	dword [edi + (23*4)]		; ST = autoc[23]+d*data[sample+23] d
335	fstp	dword [edi + (23*4)]		; autoc[23]+=d*data[sample+23]  ST = d
336	fld	st0				; ST = d d
337	fmul	dword [esi + (22*4)]		; ST = d*data[sample+22] d
338	fadd	dword [edi + (22*4)]		; ST = autoc[22]+d*data[sample+22] d
339	fstp	dword [edi + (22*4)]		; autoc[22]+=d*data[sample+22]  ST = d
340	fld	st0				; ST = d d
341	fmul	dword [esi + (21*4)]		; ST = d*data[sample+21] d
342	fadd	dword [edi + (21*4)]		; ST = autoc[21]+d*data[sample+21] d
343	fstp	dword [edi + (21*4)]		; autoc[21]+=d*data[sample+21]  ST = d
344	fld	st0				; ST = d d
345	fmul	dword [esi + (20*4)]		; ST = d*data[sample+20] d
346	fadd	dword [edi + (20*4)]		; ST = autoc[20]+d*data[sample+20] d
347	fstp	dword [edi + (20*4)]		; autoc[20]+=d*data[sample+20]  ST = d
348	fld	st0				; ST = d d
349	fmul	dword [esi + (19*4)]		; ST = d*data[sample+19] d
350	fadd	dword [edi + (19*4)]		; ST = autoc[19]+d*data[sample+19] d
351	fstp	dword [edi + (19*4)]		; autoc[19]+=d*data[sample+19]  ST = d
352	fld	st0				; ST = d d
353	fmul	dword [esi + (18*4)]		; ST = d*data[sample+18] d
354	fadd	dword [edi + (18*4)]		; ST = autoc[18]+d*data[sample+18] d
355	fstp	dword [edi + (18*4)]		; autoc[18]+=d*data[sample+18]  ST = d
356	fld	st0				; ST = d d
357	fmul	dword [esi + (17*4)]		; ST = d*data[sample+17] d
358	fadd	dword [edi + (17*4)]		; ST = autoc[17]+d*data[sample+17] d
359	fstp	dword [edi + (17*4)]		; autoc[17]+=d*data[sample+17]  ST = d
360	fld	st0				; ST = d d
361	fmul	dword [esi + (16*4)]		; ST = d*data[sample+16] d
362	fadd	dword [edi + (16*4)]		; ST = autoc[16]+d*data[sample+16] d
363	fstp	dword [edi + (16*4)]		; autoc[16]+=d*data[sample+16]  ST = d
364	fld	st0				; ST = d d
365	fmul	dword [esi + (15*4)]		; ST = d*data[sample+15] d
366	fadd	dword [edi + (15*4)]		; ST = autoc[15]+d*data[sample+15] d
367	fstp	dword [edi + (15*4)]		; autoc[15]+=d*data[sample+15]  ST = d
368	fld	st0				; ST = d d
369	fmul	dword [esi + (14*4)]		; ST = d*data[sample+14] d
370	fadd	dword [edi + (14*4)]		; ST = autoc[14]+d*data[sample+14] d
371	fstp	dword [edi + (14*4)]		; autoc[14]+=d*data[sample+14]  ST = d
372	fld	st0				; ST = d d
373	fmul	dword [esi + (13*4)]		; ST = d*data[sample+13] d
374	fadd	dword [edi + (13*4)]		; ST = autoc[13]+d*data[sample+13] d
375	fstp	dword [edi + (13*4)]		; autoc[13]+=d*data[sample+13]  ST = d
376	fld	st0				; ST = d d
377	fmul	dword [esi + (12*4)]		; ST = d*data[sample+12] d
378	fadd	dword [edi + (12*4)]		; ST = autoc[12]+d*data[sample+12] d
379	fstp	dword [edi + (12*4)]		; autoc[12]+=d*data[sample+12]  ST = d
380	fld	st0				; ST = d d
381	fmul	dword [esi + (11*4)]		; ST = d*data[sample+11] d
382	fadd	dword [edi + (11*4)]		; ST = autoc[11]+d*data[sample+11] d
383	fstp	dword [edi + (11*4)]		; autoc[11]+=d*data[sample+11]  ST = d
384	fld	st0				; ST = d d
385	fmul	dword [esi + (10*4)]		; ST = d*data[sample+10] d
386	fadd	dword [edi + (10*4)]		; ST = autoc[10]+d*data[sample+10] d
387	fstp	dword [edi + (10*4)]		; autoc[10]+=d*data[sample+10]  ST = d
388	fld	st0				; ST = d d
389	fmul	dword [esi + ( 9*4)]		; ST = d*data[sample+9] d
390	fadd	dword [edi + ( 9*4)]		; ST = autoc[9]+d*data[sample+9] d
391	fstp	dword [edi + ( 9*4)]		; autoc[9]+=d*data[sample+9]  ST = d
392	fld	st0				; ST = d d
393	fmul	dword [esi + ( 8*4)]		; ST = d*data[sample+8] d
394	fadd	dword [edi + ( 8*4)]		; ST = autoc[8]+d*data[sample+8] d
395	fstp	dword [edi + ( 8*4)]		; autoc[8]+=d*data[sample+8]  ST = d
396	fld	st0				; ST = d d
397	fmul	dword [esi + ( 7*4)]		; ST = d*data[sample+7] d
398	fadd	dword [edi + ( 7*4)]		; ST = autoc[7]+d*data[sample+7] d
399	fstp	dword [edi + ( 7*4)]		; autoc[7]+=d*data[sample+7]  ST = d
400	fld	st0				; ST = d d
401	fmul	dword [esi + ( 6*4)]		; ST = d*data[sample+6] d
402	fadd	dword [edi + ( 6*4)]		; ST = autoc[6]+d*data[sample+6] d
403	fstp	dword [edi + ( 6*4)]		; autoc[6]+=d*data[sample+6]  ST = d
404	fld	st0				; ST = d d
405	fmul	dword [esi + ( 5*4)]		; ST = d*data[sample+4] d
406	fadd	dword [edi + ( 5*4)]		; ST = autoc[4]+d*data[sample+4] d
407	fstp	dword [edi + ( 5*4)]		; autoc[4]+=d*data[sample+4]  ST = d
408	fld	st0				; ST = d d
409	fmul	dword [esi + ( 4*4)]		; ST = d*data[sample+4] d
410	fadd	dword [edi + ( 4*4)]		; ST = autoc[4]+d*data[sample+4] d
411	fstp	dword [edi + ( 4*4)]		; autoc[4]+=d*data[sample+4]  ST = d
412	fld	st0				; ST = d d
413	fmul	dword [esi + ( 3*4)]		; ST = d*data[sample+3] d
414	fadd	dword [edi + ( 3*4)]		; ST = autoc[3]+d*data[sample+3] d
415	fstp	dword [edi + ( 3*4)]		; autoc[3]+=d*data[sample+3]  ST = d
416	fld	st0				; ST = d d
417	fmul	dword [esi + ( 2*4)]		; ST = d*data[sample+2] d
418	fadd	dword [edi + ( 2*4)]		; ST = autoc[2]+d*data[sample+2] d
419	fstp	dword [edi + ( 2*4)]		; autoc[2]+=d*data[sample+2]  ST = d
420	fld	st0				; ST = d d
421	fmul	dword [esi + ( 1*4)]		; ST = d*data[sample+1] d
422	fadd	dword [edi + ( 1*4)]		; ST = autoc[1]+d*data[sample+1] d
423	fstp	dword [edi + ( 1*4)]		; autoc[1]+=d*data[sample+1]  ST = d
424	fld	st0				; ST = d d
425	fmul	dword [esi]			; ST = d*data[sample] d			WATCHOUT: no displacement byte here!
426	fadd	dword [edi]			; ST = autoc[0]+d*data[sample] d	WATCHOUT: no displacement byte here!
427	fstp	dword [edi]			; autoc[0]+=d*data[sample]  ST = d	WATCHOUT: no displacement byte here!
428.jumper2_0:
429
430	fstp	st0				; pop d, ST = empty
431	add	esi, byte 4			; sample++
432	dec	ecx
433	jz	.loop2_end
434	add	edx, byte 11			; adjust our inner loop counter by adjusting the jump target
435	fld	dword [esi]			; ST = d <- data[sample]
436	jmp	edx
437.loop2_end:
438
439.end:
440	pop	ebx
441	pop	edi
442	pop	esi
443	ret
444
445	ALIGN 16
446cident FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_4_old
447	;[esp + 16] == autoc[]
448	;[esp + 12] == lag
449	;[esp + 8] == data_len
450	;[esp + 4] == data[]
451
452	;ASSERT(lag > 0)
453	;ASSERT(lag <= 4)
454	;ASSERT(lag <= data_len)
455
456	;	for(coeff = 0; coeff < lag; coeff++)
457	;		autoc[coeff] = 0.0;
458	xorps	xmm5, xmm5
459
460	mov	edx, [esp + 8]			; edx == data_len
461	mov	eax, [esp + 4]			; eax == &data[sample] <- &data[0]
462
463	movss	xmm0, [eax]			; xmm0 = 0,0,0,data[0]
464	add	eax, 4
465	movaps	xmm2, xmm0			; xmm2 = 0,0,0,data[0]
466	shufps	xmm0, xmm0, 0			; xmm0 == data[sample],data[sample],data[sample],data[sample] = data[0],data[0],data[0],data[0]
467.warmup:					; xmm2 == data[sample-3],data[sample-2],data[sample-1],data[sample]
468	mulps	xmm0, xmm2			; xmm0 = xmm0 * xmm2
469	addps	xmm5, xmm0			; xmm5 += xmm0 * xmm2
470	dec	edx
471	jz	.loop_end
472	ALIGN 16
473.loop_start:
474	; start by reading the next sample
475	movss	xmm0, [eax]			; xmm0 = 0,0,0,data[sample]
476	add	eax, 4
477	shufps	xmm0, xmm0, 0			; xmm0 = data[sample],data[sample],data[sample],data[sample]
478	shufps	xmm2, xmm2, 93h			; 93h=2-1-0-3 => xmm2 gets rotated left by one float
479	movss	xmm2, xmm0
480	mulps	xmm0, xmm2			; xmm0 = xmm0 * xmm2
481	addps	xmm5, xmm0			; xmm5 += xmm0 * xmm2
482	dec	edx
483	jnz	.loop_start
484.loop_end:
485	; store autoc
486	mov	edx, [esp + 16]			; edx == autoc
487	movups	[edx], xmm5
488
489.end:
490	ret
491
492	ALIGN 16
493cident FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_8_old
494	;[esp + 16] == autoc[]
495	;[esp + 12] == lag
496	;[esp + 8] == data_len
497	;[esp + 4] == data[]
498
499	;ASSERT(lag > 0)
500	;ASSERT(lag <= 8)
501	;ASSERT(lag <= data_len)
502
503	;	for(coeff = 0; coeff < lag; coeff++)
504	;		autoc[coeff] = 0.0;
505	xorps	xmm5, xmm5
506	xorps	xmm6, xmm6
507
508	mov	edx, [esp + 8]			; edx == data_len
509	mov	eax, [esp + 4]			; eax == &data[sample] <- &data[0]
510
511	movss	xmm0, [eax]			; xmm0 = 0,0,0,data[0]
512	add	eax, 4
513	movaps	xmm2, xmm0			; xmm2 = 0,0,0,data[0]
514	shufps	xmm0, xmm0, 0			; xmm0 == data[sample],data[sample],data[sample],data[sample] = data[0],data[0],data[0],data[0]
515	movaps	xmm1, xmm0			; xmm1 == data[sample],data[sample],data[sample],data[sample] = data[0],data[0],data[0],data[0]
516	xorps	xmm3, xmm3			; xmm3 = 0,0,0,0
517.warmup:					; xmm3:xmm2 == data[sample-7],data[sample-6],...,data[sample]
518	mulps	xmm0, xmm2
519	mulps	xmm1, xmm3			; xmm1:xmm0 = xmm1:xmm0 * xmm3:xmm2
520	addps	xmm5, xmm0
521	addps	xmm6, xmm1			; xmm6:xmm5 += xmm1:xmm0 * xmm3:xmm2
522	dec	edx
523	jz	.loop_end
524	ALIGN 16
525.loop_start:
526	; start by reading the next sample
527	movss	xmm0, [eax]			; xmm0 = 0,0,0,data[sample]
528	; here we reorder the instructions; see the (#) indexes for a logical order
529	shufps	xmm2, xmm2, 93h			; (3) 93h=2-1-0-3 => xmm2 gets rotated left by one float
530	add	eax, 4				; (0)
531	shufps	xmm3, xmm3, 93h			; (4) 93h=2-1-0-3 => xmm3 gets rotated left by one float
532	shufps	xmm0, xmm0, 0			; (1) xmm0 = data[sample],data[sample],data[sample],data[sample]
533	movss	xmm3, xmm2			; (5)
534	movaps	xmm1, xmm0			; (2) xmm1 = data[sample],data[sample],data[sample],data[sample]
535	movss	xmm2, xmm0			; (6)
536	mulps	xmm1, xmm3			; (8)
537	mulps	xmm0, xmm2			; (7) xmm1:xmm0 = xmm1:xmm0 * xmm3:xmm2
538	addps	xmm6, xmm1			; (10)
539	addps	xmm5, xmm0			; (9) xmm6:xmm5 += xmm1:xmm0 * xmm3:xmm2
540	dec	edx
541	jnz	.loop_start
542.loop_end:
543	; store autoc
544	mov	edx, [esp + 16]			; edx == autoc
545	movups	[edx], xmm5
546	movups	[edx + 16], xmm6
547
548.end:
549	ret
550
551	ALIGN 16
552cident FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_12_old
553	;[esp + 16] == autoc[]
554	;[esp + 12] == lag
555	;[esp + 8] == data_len
556	;[esp + 4] == data[]
557
558	;ASSERT(lag > 0)
559	;ASSERT(lag <= 12)
560	;ASSERT(lag <= data_len)
561
562	;	for(coeff = 0; coeff < lag; coeff++)
563	;		autoc[coeff] = 0.0;
564	xorps	xmm5, xmm5
565	xorps	xmm6, xmm6
566	xorps	xmm7, xmm7
567
568	mov	edx, [esp + 8]			; edx == data_len
569	mov	eax, [esp + 4]			; eax == &data[sample] <- &data[0]
570
571	movss	xmm0, [eax]			; xmm0 = 0,0,0,data[0]
572	add	eax, 4
573	movaps	xmm2, xmm0			; xmm2 = 0,0,0,data[0]
574	shufps	xmm0, xmm0, 0			; xmm0 == data[sample],data[sample],data[sample],data[sample] = data[0],data[0],data[0],data[0]
575	xorps	xmm3, xmm3			; xmm3 = 0,0,0,0
576	xorps	xmm4, xmm4			; xmm4 = 0,0,0,0
577.warmup:					; xmm3:xmm2 == data[sample-7],data[sample-6],...,data[sample]
578	movaps	xmm1, xmm0
579	mulps	xmm1, xmm2
580	addps	xmm5, xmm1
581	movaps	xmm1, xmm0
582	mulps	xmm1, xmm3
583	addps	xmm6, xmm1
584	mulps	xmm0, xmm4
585	addps	xmm7, xmm0			; xmm7:xmm6:xmm5 += xmm0:xmm0:xmm0 * xmm4:xmm3:xmm2
586	dec	edx
587	jz	.loop_end
588	ALIGN 16
589.loop_start:
590	; start by reading the next sample
591	movss	xmm0, [eax]			; xmm0 = 0,0,0,data[sample]
592	add	eax, 4
593	shufps	xmm0, xmm0, 0			; xmm0 = data[sample],data[sample],data[sample],data[sample]
594
595	; shift xmm4:xmm3:xmm2 left by one float
596	shufps	xmm2, xmm2, 93h			; 93h=2-1-0-3 => xmm2 gets rotated left by one float
597	shufps	xmm3, xmm3, 93h			; 93h=2-1-0-3 => xmm3 gets rotated left by one float
598	shufps	xmm4, xmm4, 93h			; 93h=2-1-0-3 => xmm4 gets rotated left by one float
599	movss	xmm4, xmm3
600	movss	xmm3, xmm2
601	movss	xmm2, xmm0
602
603	; xmm7:xmm6:xmm5 += xmm0:xmm0:xmm0 * xmm4:xmm3:xmm2
604	movaps	xmm1, xmm0
605	mulps	xmm1, xmm2
606	addps	xmm5, xmm1
607	movaps	xmm1, xmm0
608	mulps	xmm1, xmm3
609	addps	xmm6, xmm1
610	mulps	xmm0, xmm4
611	addps	xmm7, xmm0
612
613	dec	edx
614	jnz	.loop_start
615.loop_end:
616	; store autoc
617	mov	edx, [esp + 16]			; edx == autoc
618	movups	[edx], xmm5
619	movups	[edx + 16], xmm6
620	movups	[edx + 32], xmm7
621
622.end:
623	ret
624
625	ALIGN 16
626cident FLAC__lpc_compute_autocorrelation_asm_ia32_sse_lag_16_old
627	;[ebp + 20] == autoc[]
628	;[ebp + 16] == lag
629	;[ebp + 12] == data_len
630	;[ebp +  8] == data[]
631	;[esp] == __m128
632	;[esp + 16] == __m128
633
634	push	ebp
635	mov	ebp, esp
636	and	esp, -16 ; stack realign for SSE instructions 'movaps' and 'addps'
637	sub	esp, 32
638
639	;ASSERT(lag > 0)
640	;ASSERT(lag <= 16)
641	;ASSERT(lag <= data_len)
642	;ASSERT(data_len > 0)
643
644	;	for(coeff = 0; coeff < lag; coeff++)
645	;		autoc[coeff] = 0.0;
646	xorps	xmm5, xmm5
647	xorps	xmm6, xmm6
648	movaps	[esp], xmm5
649	movaps	[esp + 16], xmm6
650
651	mov	edx, [ebp + 12]			; edx == data_len
652	mov	eax, [ebp +  8]			; eax == &data[sample] <- &data[0]
653
654	movss	xmm0, [eax]			; xmm0 = 0,0,0,data[0]
655	add	eax, 4
656	movaps	xmm1, xmm0			; xmm1 = 0,0,0,data[0]
657	shufps	xmm0, xmm0, 0			; xmm0 == data[sample],data[sample],data[sample],data[sample] = data[0],data[0],data[0],data[0]
658	xorps	xmm2, xmm2			; xmm2 = 0,0,0,0
659	xorps	xmm3, xmm3			; xmm3 = 0,0,0,0
660	xorps	xmm4, xmm4			; xmm4 = 0,0,0,0
661	movaps	xmm7, xmm0
662	mulps	xmm7, xmm1
663	addps	xmm5, xmm7
664	dec	edx
665	jz	.loop_end
666	ALIGN 16
667.loop_start:
668	; start by reading the next sample
669	movss	xmm0, [eax]			; xmm0 = 0,0,0,data[sample]
670	add	eax, 4
671	shufps	xmm0, xmm0, 0			; xmm0 = data[sample],data[sample],data[sample],data[sample]
672
673	; shift xmm4:xmm3:xmm2:xmm1 left by one float
674	shufps	xmm1, xmm1, 93h
675	shufps	xmm2, xmm2, 93h
676	shufps	xmm3, xmm3, 93h
677	shufps	xmm4, xmm4, 93h
678	movss	xmm4, xmm3
679	movss	xmm3, xmm2
680	movss	xmm2, xmm1
681	movss	xmm1, xmm0
682
683	; xmmB:xmmA:xmm6:xmm5 += xmm0:xmm0:xmm0:xmm0 * xmm4:xmm3:xmm2:xmm1
684	movaps	xmm7, xmm0
685	mulps	xmm7, xmm1
686	addps	xmm5, xmm7
687	movaps	xmm7, xmm0
688	mulps	xmm7, xmm2
689	addps	xmm6, xmm7
690	movaps	xmm7, xmm0
691	mulps	xmm7, xmm3
692	mulps	xmm0, xmm4
693	addps	xmm7, [esp]
694	addps	xmm0, [esp + 16]
695	movaps	[esp], xmm7
696	movaps	[esp + 16], xmm0
697
698	dec	edx
699	jnz	.loop_start
700.loop_end:
701	; store autoc
702	mov	edx, [ebp + 20]			; edx == autoc
703	movups	[edx], xmm5
704	movups	[edx + 16], xmm6
705	movaps	xmm5, [esp]
706	movaps	xmm6, [esp + 16]
707	movups	[edx + 32], xmm5
708	movups	[edx + 48], xmm6
709.end:
710	mov	esp, ebp
711	pop	ebp
712	ret
713
714;void FLAC__lpc_compute_residual_from_qlp_coefficients(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[])
715;
716;	for(i = 0; i < data_len; i++) {
717;		sum = 0;
718;		for(j = 0; j < order; j++)
719;			sum += qlp_coeff[j] * data[i-j-1];
720;		residual[i] = data[i] - (sum >> lp_quantization);
721;	}
722;
723	ALIGN	16
724cident FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32
725	;[esp + 40]	residual[]
726	;[esp + 36]	lp_quantization
727	;[esp + 32]	order
728	;[esp + 28]	qlp_coeff[]
729	;[esp + 24]	data_len
730	;[esp + 20]	data[]
731
732	;ASSERT(order > 0)
733
734	push	ebp
735	push	ebx
736	push	esi
737	push	edi
738
739	mov	esi, [esp + 20]			; esi = data[]
740	mov	edi, [esp + 40]			; edi = residual[]
741	mov	eax, [esp + 32]			; eax = order
742	mov	ebx, [esp + 24]			; ebx = data_len
743
744	test	ebx, ebx
745	jz	near .end			; do nothing if data_len == 0
746.begin:
747	cmp	eax, byte 1
748	jg	short .i_1more
749
750	mov	ecx, [esp + 28]
751	mov	edx, [ecx]			; edx = qlp_coeff[0]
752	mov	eax, [esi - 4]			; eax = data[-1]
753	mov	ecx, [esp + 36]			; cl = lp_quantization
754	ALIGN	16
755.i_1_loop_i:
756	imul	eax, edx
757	sar	eax, cl
758	neg	eax
759	add	eax, [esi]
760	mov	[edi], eax
761	mov	eax, [esi]
762	add	edi, byte 4
763	add	esi, byte 4
764	dec	ebx
765	jnz	.i_1_loop_i
766
767	jmp	.end
768
769.i_1more:
770	cmp	eax, byte 32			; for order <= 32 there is a faster routine
771	jbe	short .i_32
772
773	; This version is here just for completeness, since FLAC__MAX_LPC_ORDER == 32
774	ALIGN 16
775.i_32more_loop_i:
776	xor	ebp, ebp
777	mov	ecx, [esp + 32]
778	mov	edx, ecx
779	shl	edx, 2
780	add	edx, [esp + 28]
781	neg	ecx
782	ALIGN	16
783.i_32more_loop_j:
784	sub	edx, byte 4
785	mov	eax, [edx]
786	imul	eax, [esi + 4 * ecx]
787	add	ebp, eax
788	inc	ecx
789	jnz	short .i_32more_loop_j
790
791	mov	ecx, [esp + 36]
792	sar	ebp, cl
793	neg	ebp
794	add	ebp, [esi]
795	mov	[edi], ebp
796	add	esi, byte 4
797	add	edi, byte 4
798
799	dec	ebx
800	jnz	.i_32more_loop_i
801
802	jmp	.end
803
804.mov_eip_to_eax:
805	mov	eax, [esp]
806	ret
807
808.i_32:
809	sub	edi, esi
810	neg	eax
811	lea	edx, [eax + eax * 8 + .jumper_0 - .get_eip0]
812	call	.mov_eip_to_eax
813.get_eip0:
814	add	edx, eax
815	inc	edx
816	mov	eax, [esp + 28]			; eax = qlp_coeff[]
817	xor	ebp, ebp
818	jmp	edx
819
820	mov	ecx, [eax + 124]
821	imul	ecx, [esi - 128]
822	add	ebp, ecx
823	mov	ecx, [eax + 120]
824	imul	ecx, [esi - 124]
825	add	ebp, ecx
826	mov	ecx, [eax + 116]
827	imul	ecx, [esi - 120]
828	add	ebp, ecx
829	mov	ecx, [eax + 112]
830	imul	ecx, [esi - 116]
831	add	ebp, ecx
832	mov	ecx, [eax + 108]
833	imul	ecx, [esi - 112]
834	add	ebp, ecx
835	mov	ecx, [eax + 104]
836	imul	ecx, [esi - 108]
837	add	ebp, ecx
838	mov	ecx, [eax + 100]
839	imul	ecx, [esi - 104]
840	add	ebp, ecx
841	mov	ecx, [eax + 96]
842	imul	ecx, [esi - 100]
843	add	ebp, ecx
844	mov	ecx, [eax + 92]
845	imul	ecx, [esi - 96]
846	add	ebp, ecx
847	mov	ecx, [eax + 88]
848	imul	ecx, [esi - 92]
849	add	ebp, ecx
850	mov	ecx, [eax + 84]
851	imul	ecx, [esi - 88]
852	add	ebp, ecx
853	mov	ecx, [eax + 80]
854	imul	ecx, [esi - 84]
855	add	ebp, ecx
856	mov	ecx, [eax + 76]
857	imul	ecx, [esi - 80]
858	add	ebp, ecx
859	mov	ecx, [eax + 72]
860	imul	ecx, [esi - 76]
861	add	ebp, ecx
862	mov	ecx, [eax + 68]
863	imul	ecx, [esi - 72]
864	add	ebp, ecx
865	mov	ecx, [eax + 64]
866	imul	ecx, [esi - 68]
867	add	ebp, ecx
868	mov	ecx, [eax + 60]
869	imul	ecx, [esi - 64]
870	add	ebp, ecx
871	mov	ecx, [eax + 56]
872	imul	ecx, [esi - 60]
873	add	ebp, ecx
874	mov	ecx, [eax + 52]
875	imul	ecx, [esi - 56]
876	add	ebp, ecx
877	mov	ecx, [eax + 48]
878	imul	ecx, [esi - 52]
879	add	ebp, ecx
880	mov	ecx, [eax + 44]
881	imul	ecx, [esi - 48]
882	add	ebp, ecx
883	mov	ecx, [eax + 40]
884	imul	ecx, [esi - 44]
885	add	ebp, ecx
886	mov	ecx, [eax + 36]
887	imul	ecx, [esi - 40]
888	add	ebp, ecx
889	mov	ecx, [eax + 32]
890	imul	ecx, [esi - 36]
891	add	ebp, ecx
892	mov	ecx, [eax + 28]
893	imul	ecx, [esi - 32]
894	add	ebp, ecx
895	mov	ecx, [eax + 24]
896	imul	ecx, [esi - 28]
897	add	ebp, ecx
898	mov	ecx, [eax + 20]
899	imul	ecx, [esi - 24]
900	add	ebp, ecx
901	mov	ecx, [eax + 16]
902	imul	ecx, [esi - 20]
903	add	ebp, ecx
904	mov	ecx, [eax + 12]
905	imul	ecx, [esi - 16]
906	add	ebp, ecx
907	mov	ecx, [eax + 8]
908	imul	ecx, [esi - 12]
909	add	ebp, ecx
910	mov	ecx, [eax + 4]
911	imul	ecx, [esi - 8]
912	add	ebp, ecx
913	mov	ecx, [eax]			; there is one byte missing
914	imul	ecx, [esi - 4]
915	add	ebp, ecx
916.jumper_0:
917
918	mov	ecx, [esp + 36]
919	sar	ebp, cl
920	neg	ebp
921	add	ebp, [esi]
922	mov	[edi + esi], ebp
923	add	esi, byte 4
924
925	dec	ebx
926	jz	short .end
927	xor	ebp, ebp
928	jmp	edx
929
930.end:
931	pop	edi
932	pop	esi
933	pop	ebx
934	pop	ebp
935	ret
936
937; WATCHOUT: this routine works on 16 bit data which means bits-per-sample for
938; the channel and qlp_coeffs must be <= 16.  Especially note that this routine
939; cannot be used for side-channel coded 16bps channels since the effective bps
940; is 17.
941	ALIGN	16
942cident FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32_mmx
943	;[esp + 40]	residual[]
944	;[esp + 36]	lp_quantization
945	;[esp + 32]	order
946	;[esp + 28]	qlp_coeff[]
947	;[esp + 24]	data_len
948	;[esp + 20]	data[]
949
950	;ASSERT(order > 0)
951
952	push	ebp
953	push	ebx
954	push	esi
955	push	edi
956
957	mov	esi, [esp + 20]			; esi = data[]
958	mov	edi, [esp + 40]			; edi = residual[]
959	mov	eax, [esp + 32]			; eax = order
960	mov	ebx, [esp + 24]			; ebx = data_len
961
962	test	ebx, ebx
963	jz	near .end			; do nothing if data_len == 0
964	dec	ebx
965	test	ebx, ebx
966	jz	near .last_one
967
968	mov	edx, [esp + 28]			; edx = qlp_coeff[]
969	movd	mm6, [esp + 36]			; mm6 = 0:lp_quantization
970	mov	ebp, esp
971
972	and	esp, 0xfffffff8
973
974	xor	ecx, ecx
975.copy_qlp_loop:
976	push	word [edx + 4 * ecx]
977	inc	ecx
978	cmp	ecx, eax
979	jnz	short .copy_qlp_loop
980
981	and	ecx, 0x3
982	test	ecx, ecx
983	je	short .za_end
984	sub	ecx, byte 4
985.za_loop:
986	push	word 0
987	inc	eax
988	inc	ecx
989	jnz	short .za_loop
990.za_end:
991
992	movq	mm5, [esp + 2 * eax - 8]
993	movd	mm4, [esi - 16]
994	punpckldq	mm4, [esi - 12]
995	movd	mm0, [esi - 8]
996	punpckldq	mm0, [esi - 4]
997	packssdw	mm4, mm0
998
999	cmp	eax, byte 4
1000	jnbe	short .mmx_4more
1001
1002	ALIGN	16
1003.mmx_4_loop_i:
1004	movd	mm1, [esi]
1005	movq	mm3, mm4
1006	punpckldq	mm1, [esi + 4]
1007	psrlq	mm4, 16
1008	movq	mm0, mm1
1009	psllq	mm0, 48
1010	por	mm4, mm0
1011	movq	mm2, mm4
1012	psrlq	mm4, 16
1013	pxor	mm0, mm0
1014	punpckhdq	mm0, mm1
1015	pmaddwd	mm3, mm5
1016	pmaddwd	mm2, mm5
1017	psllq	mm0, 16
1018	por	mm4, mm0
1019	movq	mm0, mm3
1020	punpckldq	mm3, mm2
1021	punpckhdq	mm0, mm2
1022	paddd	mm3, mm0
1023	psrad	mm3, mm6
1024	psubd	mm1, mm3
1025	movd	[edi], mm1
1026	punpckhdq	mm1, mm1
1027	movd	[edi + 4], mm1
1028
1029	add	edi, byte 8
1030	add	esi, byte 8
1031
1032	sub	ebx, 2
1033	jg	.mmx_4_loop_i
1034	jmp	.mmx_end
1035
1036.mmx_4more:
1037	shl	eax, 2
1038	neg	eax
1039	add	eax, byte 16
1040
1041	ALIGN	16
1042.mmx_4more_loop_i:
1043	movd	mm1, [esi]
1044	punpckldq	mm1, [esi + 4]
1045	movq	mm3, mm4
1046	psrlq	mm4, 16
1047	movq	mm0, mm1
1048	psllq	mm0, 48
1049	por	mm4, mm0
1050	movq	mm2, mm4
1051	psrlq	mm4, 16
1052	pxor	mm0, mm0
1053	punpckhdq	mm0, mm1
1054	pmaddwd	mm3, mm5
1055	pmaddwd	mm2, mm5
1056	psllq	mm0, 16
1057	por	mm4, mm0
1058
1059	mov	ecx, esi
1060	add	ecx, eax
1061	mov	edx, esp
1062
1063	ALIGN	16
1064.mmx_4more_loop_j:
1065	movd	mm0, [ecx - 16]
1066	movd	mm7, [ecx - 8]
1067	punpckldq	mm0, [ecx - 12]
1068	punpckldq	mm7, [ecx - 4]
1069	packssdw	mm0, mm7
1070	pmaddwd	mm0, [edx]
1071	punpckhdq	mm7, mm7
1072	paddd	mm3, mm0
1073	movd	mm0, [ecx - 12]
1074	punpckldq	mm0, [ecx - 8]
1075	punpckldq	mm7, [ecx]
1076	packssdw	mm0, mm7
1077	pmaddwd	mm0, [edx]
1078	paddd	mm2, mm0
1079
1080	add	edx, byte 8
1081	add	ecx, byte 16
1082	cmp	ecx, esi
1083	jnz	.mmx_4more_loop_j
1084
1085	movq	mm0, mm3
1086	punpckldq	mm3, mm2
1087	punpckhdq	mm0, mm2
1088	paddd	mm3, mm0
1089	psrad	mm3, mm6
1090	psubd	mm1, mm3
1091	movd	[edi], mm1
1092	punpckhdq	mm1, mm1
1093	movd	[edi + 4], mm1
1094
1095	add	edi, byte 8
1096	add	esi, byte 8
1097
1098	sub	ebx, 2
1099	jg	near .mmx_4more_loop_i
1100
1101.mmx_end:
1102	emms
1103	mov	esp, ebp
1104.last_one:
1105	mov	eax, [esp + 32]
1106	inc	ebx
1107	jnz	near FLAC__lpc_compute_residual_from_qlp_coefficients_asm_ia32.begin
1108
1109.end:
1110	pop	edi
1111	pop	esi
1112	pop	ebx
1113	pop	ebp
1114	ret
1115
1116; **********************************************************************
1117;
1118; void FLAC__lpc_restore_signal(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[])
1119; {
1120; 	unsigned i, j;
1121; 	FLAC__int32 sum;
1122;
1123; 	FLAC__ASSERT(order > 0);
1124;
1125; 	for(i = 0; i < data_len; i++) {
1126; 		sum = 0;
1127; 		for(j = 0; j < order; j++)
1128; 			sum += qlp_coeff[j] * data[i-j-1];
1129; 		data[i] = residual[i] + (sum >> lp_quantization);
1130; 	}
1131; }
1132	ALIGN	16
1133cident FLAC__lpc_restore_signal_asm_ia32
1134	;[esp + 40]	data[]
1135	;[esp + 36]	lp_quantization
1136	;[esp + 32]	order
1137	;[esp + 28]	qlp_coeff[]
1138	;[esp + 24]	data_len
1139	;[esp + 20]	residual[]
1140
1141	;ASSERT(order > 0)
1142
1143	push	ebp
1144	push	ebx
1145	push	esi
1146	push	edi
1147
1148	mov	esi, [esp + 20]			; esi = residual[]
1149	mov	edi, [esp + 40]			; edi = data[]
1150	mov	eax, [esp + 32]			; eax = order
1151	mov	ebx, [esp + 24]			; ebx = data_len
1152
1153	test	ebx, ebx
1154	jz	near .end			; do nothing if data_len == 0
1155
1156.begin:
1157	cmp	eax, byte 1
1158	jg	short .x87_1more
1159
1160	mov	ecx, [esp + 28]
1161	mov	edx, [ecx]
1162	mov	eax, [edi - 4]
1163	mov	ecx, [esp + 36]
1164	ALIGN	16
1165.x87_1_loop_i:
1166	imul	eax, edx
1167	sar	eax, cl
1168	add	eax, [esi]
1169	mov	[edi], eax
1170	add	esi, byte 4
1171	add	edi, byte 4
1172	dec	ebx
1173	jnz	.x87_1_loop_i
1174
1175	jmp	.end
1176
1177.x87_1more:
1178	cmp	eax, byte 32			; for order <= 32 there is a faster routine
1179	jbe	short .x87_32
1180
1181	; This version is here just for completeness, since FLAC__MAX_LPC_ORDER == 32
1182	ALIGN 16
1183.x87_32more_loop_i:
1184	xor	ebp, ebp
1185	mov	ecx, [esp + 32]
1186	mov	edx, ecx
1187	shl	edx, 2
1188	add	edx, [esp + 28]
1189	neg	ecx
1190	ALIGN	16
1191.x87_32more_loop_j:
1192	sub	edx, byte 4
1193	mov	eax, [edx]
1194	imul	eax, [edi + 4 * ecx]
1195	add	ebp, eax
1196	inc	ecx
1197	jnz	short .x87_32more_loop_j
1198
1199	mov	ecx, [esp + 36]
1200	sar	ebp, cl
1201	add	ebp, [esi]
1202	mov	[edi], ebp
1203	add	edi, byte 4
1204	add	esi, byte 4
1205
1206	dec	ebx
1207	jnz	.x87_32more_loop_i
1208
1209	jmp	.end
1210
1211.mov_eip_to_eax:
1212	mov	eax, [esp]
1213	ret
1214
1215.x87_32:
1216	sub	esi, edi
1217	neg	eax
1218	lea	edx, [eax + eax * 8 + .jumper_0 - .get_eip0]
1219	call	.mov_eip_to_eax
1220.get_eip0:
1221	add	edx, eax
1222	inc	edx				; compensate for the shorter opcode on the last iteration
1223	mov	eax, [esp + 28]			; eax = qlp_coeff[]
1224	xor	ebp, ebp
1225	jmp	edx
1226
1227	mov	ecx, [eax + 124]		; ecx =  qlp_coeff[31]
1228	imul	ecx, [edi - 128]		; ecx =  qlp_coeff[31] * data[i-32]
1229	add	ebp, ecx			; sum += qlp_coeff[31] * data[i-32]
1230	mov	ecx, [eax + 120]		; ecx =  qlp_coeff[30]
1231	imul	ecx, [edi - 124]		; ecx =  qlp_coeff[30] * data[i-31]
1232	add	ebp, ecx			; sum += qlp_coeff[30] * data[i-31]
1233	mov	ecx, [eax + 116]		; ecx =  qlp_coeff[29]
1234	imul	ecx, [edi - 120]		; ecx =  qlp_coeff[29] * data[i-30]
1235	add	ebp, ecx			; sum += qlp_coeff[29] * data[i-30]
1236	mov	ecx, [eax + 112]		; ecx =  qlp_coeff[28]
1237	imul	ecx, [edi - 116]		; ecx =  qlp_coeff[28] * data[i-29]
1238	add	ebp, ecx			; sum += qlp_coeff[28] * data[i-29]
1239	mov	ecx, [eax + 108]		; ecx =  qlp_coeff[27]
1240	imul	ecx, [edi - 112]		; ecx =  qlp_coeff[27] * data[i-28]
1241	add	ebp, ecx			; sum += qlp_coeff[27] * data[i-28]
1242	mov	ecx, [eax + 104]		; ecx =  qlp_coeff[26]
1243	imul	ecx, [edi - 108]		; ecx =  qlp_coeff[26] * data[i-27]
1244	add	ebp, ecx			; sum += qlp_coeff[26] * data[i-27]
1245	mov	ecx, [eax + 100]		; ecx =  qlp_coeff[25]
1246	imul	ecx, [edi - 104]		; ecx =  qlp_coeff[25] * data[i-26]
1247	add	ebp, ecx			; sum += qlp_coeff[25] * data[i-26]
1248	mov	ecx, [eax + 96]			; ecx =  qlp_coeff[24]
1249	imul	ecx, [edi - 100]		; ecx =  qlp_coeff[24] * data[i-25]
1250	add	ebp, ecx			; sum += qlp_coeff[24] * data[i-25]
1251	mov	ecx, [eax + 92]			; ecx =  qlp_coeff[23]
1252	imul	ecx, [edi - 96]			; ecx =  qlp_coeff[23] * data[i-24]
1253	add	ebp, ecx			; sum += qlp_coeff[23] * data[i-24]
1254	mov	ecx, [eax + 88]			; ecx =  qlp_coeff[22]
1255	imul	ecx, [edi - 92]			; ecx =  qlp_coeff[22] * data[i-23]
1256	add	ebp, ecx			; sum += qlp_coeff[22] * data[i-23]
1257	mov	ecx, [eax + 84]			; ecx =  qlp_coeff[21]
1258	imul	ecx, [edi - 88]			; ecx =  qlp_coeff[21] * data[i-22]
1259	add	ebp, ecx			; sum += qlp_coeff[21] * data[i-22]
1260	mov	ecx, [eax + 80]			; ecx =  qlp_coeff[20]
1261	imul	ecx, [edi - 84]			; ecx =  qlp_coeff[20] * data[i-21]
1262	add	ebp, ecx			; sum += qlp_coeff[20] * data[i-21]
1263	mov	ecx, [eax + 76]			; ecx =  qlp_coeff[19]
1264	imul	ecx, [edi - 80]			; ecx =  qlp_coeff[19] * data[i-20]
1265	add	ebp, ecx			; sum += qlp_coeff[19] * data[i-20]
1266	mov	ecx, [eax + 72]			; ecx =  qlp_coeff[18]
1267	imul	ecx, [edi - 76]			; ecx =  qlp_coeff[18] * data[i-19]
1268	add	ebp, ecx			; sum += qlp_coeff[18] * data[i-19]
1269	mov	ecx, [eax + 68]			; ecx =  qlp_coeff[17]
1270	imul	ecx, [edi - 72]			; ecx =  qlp_coeff[17] * data[i-18]
1271	add	ebp, ecx			; sum += qlp_coeff[17] * data[i-18]
1272	mov	ecx, [eax + 64]			; ecx =  qlp_coeff[16]
1273	imul	ecx, [edi - 68]			; ecx =  qlp_coeff[16] * data[i-17]
1274	add	ebp, ecx			; sum += qlp_coeff[16] * data[i-17]
1275	mov	ecx, [eax + 60]			; ecx =  qlp_coeff[15]
1276	imul	ecx, [edi - 64]			; ecx =  qlp_coeff[15] * data[i-16]
1277	add	ebp, ecx			; sum += qlp_coeff[15] * data[i-16]
1278	mov	ecx, [eax + 56]			; ecx =  qlp_coeff[14]
1279	imul	ecx, [edi - 60]			; ecx =  qlp_coeff[14] * data[i-15]
1280	add	ebp, ecx			; sum += qlp_coeff[14] * data[i-15]
1281	mov	ecx, [eax + 52]			; ecx =  qlp_coeff[13]
1282	imul	ecx, [edi - 56]			; ecx =  qlp_coeff[13] * data[i-14]
1283	add	ebp, ecx			; sum += qlp_coeff[13] * data[i-14]
1284	mov	ecx, [eax + 48]			; ecx =  qlp_coeff[12]
1285	imul	ecx, [edi - 52]			; ecx =  qlp_coeff[12] * data[i-13]
1286	add	ebp, ecx			; sum += qlp_coeff[12] * data[i-13]
1287	mov	ecx, [eax + 44]			; ecx =  qlp_coeff[11]
1288	imul	ecx, [edi - 48]			; ecx =  qlp_coeff[11] * data[i-12]
1289	add	ebp, ecx			; sum += qlp_coeff[11] * data[i-12]
1290	mov	ecx, [eax + 40]			; ecx =  qlp_coeff[10]
1291	imul	ecx, [edi - 44]			; ecx =  qlp_coeff[10] * data[i-11]
1292	add	ebp, ecx			; sum += qlp_coeff[10] * data[i-11]
1293	mov	ecx, [eax + 36]			; ecx =  qlp_coeff[ 9]
1294	imul	ecx, [edi - 40]			; ecx =  qlp_coeff[ 9] * data[i-10]
1295	add	ebp, ecx			; sum += qlp_coeff[ 9] * data[i-10]
1296	mov	ecx, [eax + 32]			; ecx =  qlp_coeff[ 8]
1297	imul	ecx, [edi - 36]			; ecx =  qlp_coeff[ 8] * data[i- 9]
1298	add	ebp, ecx			; sum += qlp_coeff[ 8] * data[i- 9]
1299	mov	ecx, [eax + 28]			; ecx =  qlp_coeff[ 7]
1300	imul	ecx, [edi - 32]			; ecx =  qlp_coeff[ 7] * data[i- 8]
1301	add	ebp, ecx			; sum += qlp_coeff[ 7] * data[i- 8]
1302	mov	ecx, [eax + 24]			; ecx =  qlp_coeff[ 6]
1303	imul	ecx, [edi - 28]			; ecx =  qlp_coeff[ 6] * data[i- 7]
1304	add	ebp, ecx			; sum += qlp_coeff[ 6] * data[i- 7]
1305	mov	ecx, [eax + 20]			; ecx =  qlp_coeff[ 5]
1306	imul	ecx, [edi - 24]			; ecx =  qlp_coeff[ 5] * data[i- 6]
1307	add	ebp, ecx			; sum += qlp_coeff[ 5] * data[i- 6]
1308	mov	ecx, [eax + 16]			; ecx =  qlp_coeff[ 4]
1309	imul	ecx, [edi - 20]			; ecx =  qlp_coeff[ 4] * data[i- 5]
1310	add	ebp, ecx			; sum += qlp_coeff[ 4] * data[i- 5]
1311	mov	ecx, [eax + 12]			; ecx =  qlp_coeff[ 3]
1312	imul	ecx, [edi - 16]			; ecx =  qlp_coeff[ 3] * data[i- 4]
1313	add	ebp, ecx			; sum += qlp_coeff[ 3] * data[i- 4]
1314	mov	ecx, [eax + 8]			; ecx =  qlp_coeff[ 2]
1315	imul	ecx, [edi - 12]			; ecx =  qlp_coeff[ 2] * data[i- 3]
1316	add	ebp, ecx			; sum += qlp_coeff[ 2] * data[i- 3]
1317	mov	ecx, [eax + 4]			; ecx =  qlp_coeff[ 1]
1318	imul	ecx, [edi - 8]			; ecx =  qlp_coeff[ 1] * data[i- 2]
1319	add	ebp, ecx			; sum += qlp_coeff[ 1] * data[i- 2]
1320	mov	ecx, [eax]			; ecx =  qlp_coeff[ 0] (NOTE: one byte missing from instruction)
1321	imul	ecx, [edi - 4]			; ecx =  qlp_coeff[ 0] * data[i- 1]
1322	add	ebp, ecx			; sum += qlp_coeff[ 0] * data[i- 1]
1323.jumper_0:
1324
1325	mov	ecx, [esp + 36]
1326	sar	ebp, cl				; ebp = (sum >> lp_quantization)
1327	add	ebp, [esi + edi]		; ebp = residual[i] + (sum >> lp_quantization)
1328	mov	[edi], ebp			; data[i] = residual[i] + (sum >> lp_quantization)
1329	add	edi, byte 4
1330
1331	dec	ebx
1332	jz	short .end
1333	xor	ebp, ebp
1334	jmp	edx
1335
1336.end:
1337	pop	edi
1338	pop	esi
1339	pop	ebx
1340	pop	ebp
1341	ret
1342
1343; WATCHOUT: this routine works on 16 bit data which means bits-per-sample for
1344; the channel and qlp_coeffs must be <= 16.  Especially note that this routine
1345; cannot be used for side-channel coded 16bps channels since the effective bps
1346; is 17.
1347; WATCHOUT: this routine requires that each data array have a buffer of up to
1348; 3 zeroes in front (at negative indices) for alignment purposes, i.e. for each
1349; channel n, data[n][-1] through data[n][-3] should be accessible and zero.
1350	ALIGN	16
1351cident FLAC__lpc_restore_signal_asm_ia32_mmx
1352	;[esp + 40]	data[]
1353	;[esp + 36]	lp_quantization
1354	;[esp + 32]	order
1355	;[esp + 28]	qlp_coeff[]
1356	;[esp + 24]	data_len
1357	;[esp + 20]	residual[]
1358
1359	;ASSERT(order > 0)
1360
1361	push	ebp
1362	push	ebx
1363	push	esi
1364	push	edi
1365
1366	mov	esi, [esp + 20]
1367	mov	edi, [esp + 40]
1368	mov	eax, [esp + 32]
1369	mov	ebx, [esp + 24]
1370
1371	test	ebx, ebx
1372	jz	near .end			; do nothing if data_len == 0
1373	cmp	eax, byte 4
1374	jb	near FLAC__lpc_restore_signal_asm_ia32.begin
1375
1376	mov	edx, [esp + 28]
1377	movd	mm6, [esp + 36]
1378	mov	ebp, esp
1379
1380	and	esp, 0xfffffff8
1381
1382	xor	ecx, ecx
1383.copy_qlp_loop:
1384	push	word [edx + 4 * ecx]
1385	inc	ecx
1386	cmp	ecx, eax
1387	jnz	short .copy_qlp_loop
1388
1389	and	ecx, 0x3
1390	test	ecx, ecx
1391	je	short .za_end
1392	sub	ecx, byte 4
1393.za_loop:
1394	push	word 0
1395	inc	eax
1396	inc	ecx
1397	jnz	short .za_loop
1398.za_end:
1399
1400	movq	mm5, [esp + 2 * eax - 8]
1401	movd	mm4, [edi - 16]
1402	punpckldq	mm4, [edi - 12]
1403	movd	mm0, [edi - 8]
1404	punpckldq	mm0, [edi - 4]
1405	packssdw	mm4, mm0
1406
1407	cmp	eax, byte 4
1408	jnbe	short .mmx_4more
1409
1410	ALIGN	16
1411.mmx_4_loop_i:
1412	movq	mm7, mm4
1413	pmaddwd	mm7, mm5
1414	movq	mm0, mm7
1415	punpckhdq	mm7, mm7
1416	paddd	mm7, mm0
1417	psrad	mm7, mm6
1418	movd	mm1, [esi]
1419	paddd	mm7, mm1
1420	movd	[edi], mm7
1421	psllq	mm7, 48
1422	psrlq	mm4, 16
1423	por	mm4, mm7
1424
1425	add	esi, byte 4
1426	add	edi, byte 4
1427
1428	dec	ebx
1429	jnz	.mmx_4_loop_i
1430	jmp	.mmx_end
1431.mmx_4more:
1432	shl	eax, 2
1433	neg	eax
1434	add	eax, byte 16
1435	ALIGN	16
1436.mmx_4more_loop_i:
1437	mov	ecx, edi
1438	add	ecx, eax
1439	mov	edx, esp
1440
1441	movq	mm7, mm4
1442	pmaddwd	mm7, mm5
1443
1444	ALIGN	16
1445.mmx_4more_loop_j:
1446	movd	mm0, [ecx - 16]
1447	punpckldq	mm0, [ecx - 12]
1448	movd	mm1, [ecx - 8]
1449	punpckldq	mm1, [ecx - 4]
1450	packssdw	mm0, mm1
1451	pmaddwd	mm0, [edx]
1452	paddd	mm7, mm0
1453
1454	add	edx, byte 8
1455	add	ecx, byte 16
1456	cmp	ecx, edi
1457	jnz	.mmx_4more_loop_j
1458
1459	movq	mm0, mm7
1460	punpckhdq	mm7, mm7
1461	paddd	mm7, mm0
1462	psrad	mm7, mm6
1463	movd	mm1, [esi]
1464	paddd	mm7, mm1
1465	movd	[edi], mm7
1466	psllq	mm7, 48
1467	psrlq	mm4, 16
1468	por	mm4, mm7
1469
1470	add	esi, byte 4
1471	add	edi, byte 4
1472
1473	dec	ebx
1474	jnz	short .mmx_4more_loop_i
1475.mmx_end:
1476	emms
1477	mov	esp, ebp
1478
1479.end:
1480	pop	edi
1481	pop	esi
1482	pop	ebx
1483	pop	ebp
1484	ret
1485
1486
1487; **********************************************************************
1488;
1489;void FLAC__lpc_compute_residual_from_qlp_coefficients_wide(const FLAC__int32 *data, unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 residual[])
1490; {
1491; 	unsigned i, j;
1492; 	FLAC__int64 sum;
1493;
1494; 	FLAC__ASSERT(order > 0);
1495;
1496;	for(i = 0; i < data_len; i++) {
1497;		sum = 0;
1498;		for(j = 0; j < order; j++)
1499;			sum += qlp_coeff[j] * (FLAC__int64)data[i-j-1];
1500;		residual[i] = data[i] - (FLAC__int32)(sum >> lp_quantization);
1501;	}
1502; }
1503	ALIGN	16
1504cident FLAC__lpc_compute_residual_from_qlp_coefficients_wide_asm_ia32
1505	;[esp + 40]	residual[]
1506	;[esp + 36]	lp_quantization
1507	;[esp + 32]	order
1508	;[esp + 28]	qlp_coeff[]
1509	;[esp + 24]	data_len
1510	;[esp + 20]	data[]
1511
1512	;ASSERT(order > 0)
1513	;ASSERT(order <= 32)
1514	;ASSERT(lp_quantization <= 31)
1515
1516	push	ebp
1517	push	ebx
1518	push	esi
1519	push	edi
1520
1521	mov	ebx, [esp + 24]			; ebx = data_len
1522	test	ebx, ebx
1523	jz	near .end			; do nothing if data_len == 0
1524
1525.begin:
1526	mov	eax, [esp + 32]			; eax = order
1527	cmp	eax, 1
1528	jg	short .i_32
1529
1530	mov	esi, [esp + 40]			; esi = residual[]
1531	mov	edi, [esp + 20]			; edi = data[]
1532	mov	ecx, [esp + 28]			; ecx = qlp_coeff[]
1533	mov	ebp, [ecx]			; ebp = qlp_coeff[0]
1534	mov	eax, [edi - 4]			; eax = data[-1]
1535	mov	ecx, [esp + 36]			; cl = lp_quantization
1536	ALIGN	16
1537.i_1_loop_i:
1538	imul	ebp				; edx:eax = qlp_coeff[0] * (FLAC__int64)data[i-1]
1539	shrd	eax, edx, cl			; 0 <= lp_quantization <= 15
1540	neg	eax
1541	add	eax, [edi]
1542	mov	[esi], eax
1543	mov	eax, [edi]
1544	add	esi, 4
1545	add	edi, 4
1546	dec	ebx
1547	jnz	.i_1_loop_i
1548	jmp	.end
1549
1550.mov_eip_to_eax:
1551	mov	eax, [esp]
1552	ret
1553
1554.i_32:	; eax = order
1555	neg	eax
1556	add	eax, eax
1557	lea	ebp, [eax + eax * 4 + .jumper_0 - .get_eip0]
1558	call	.mov_eip_to_eax
1559.get_eip0:
1560	add	ebp, eax
1561	inc	ebp				; compensate for the shorter opcode on the last iteration
1562
1563	mov	ebx, [esp + 28]			; ebx = qlp_coeff[]
1564	mov	edi, [esp + 20]			; edi = data[]
1565	sub	[esp + 40], edi			; residual[] -= data[]
1566
1567	xor	ecx, ecx
1568	xor	esi, esi
1569	jmp	ebp
1570
1571;eax = --
1572;edx = --
1573;ecx = 0
1574;esi = 0
1575;
1576;ebx = qlp_coeff[]
1577;edi = data[]
1578;ebp = @address
1579
1580	mov	eax, [ebx + 124]		; eax =  qlp_coeff[31]
1581	imul	dword [edi - 128]		; edx:eax =  qlp_coeff[31] * data[i-32]
1582	add	ecx, eax
1583	adc	esi, edx			; sum += qlp_coeff[31] * data[i-32]
1584
1585	mov	eax, [ebx + 120]		; eax =  qlp_coeff[30]
1586	imul	dword [edi - 124]		; edx:eax =  qlp_coeff[30] * data[i-31]
1587	add	ecx, eax
1588	adc	esi, edx			; sum += qlp_coeff[30] * data[i-31]
1589
1590	mov	eax, [ebx + 116]
1591	imul	dword [edi - 120]
1592	add	ecx, eax
1593	adc	esi, edx
1594
1595	mov	eax, [ebx + 112]
1596	imul	dword [edi - 116]
1597	add	ecx, eax
1598	adc	esi, edx
1599
1600	mov	eax, [ebx + 108]
1601	imul	dword [edi - 112]
1602	add	ecx, eax
1603	adc	esi, edx
1604
1605	mov	eax, [ebx + 104]
1606	imul	dword [edi - 108]
1607	add	ecx, eax
1608	adc	esi, edx
1609
1610	mov	eax, [ebx + 100]
1611	imul	dword [edi - 104]
1612	add	ecx, eax
1613	adc	esi, edx
1614
1615	mov	eax, [ebx + 96]
1616	imul	dword [edi - 100]
1617	add	ecx, eax
1618	adc	esi, edx
1619
1620	mov	eax, [ebx + 92]
1621	imul	dword [edi - 96]
1622	add	ecx, eax
1623	adc	esi, edx
1624
1625	mov	eax, [ebx + 88]
1626	imul	dword [edi - 92]
1627	add	ecx, eax
1628	adc	esi, edx
1629
1630	mov	eax, [ebx + 84]
1631	imul	dword [edi - 88]
1632	add	ecx, eax
1633	adc	esi, edx
1634
1635	mov	eax, [ebx + 80]
1636	imul	dword [edi - 84]
1637	add	ecx, eax
1638	adc	esi, edx
1639
1640	mov	eax, [ebx + 76]
1641	imul	dword [edi - 80]
1642	add	ecx, eax
1643	adc	esi, edx
1644
1645	mov	eax, [ebx + 72]
1646	imul	dword [edi - 76]
1647	add	ecx, eax
1648	adc	esi, edx
1649
1650	mov	eax, [ebx + 68]
1651	imul	dword [edi - 72]
1652	add	ecx, eax
1653	adc	esi, edx
1654
1655	mov	eax, [ebx + 64]
1656	imul	dword [edi - 68]
1657	add	ecx, eax
1658	adc	esi, edx
1659
1660	mov	eax, [ebx + 60]
1661	imul	dword [edi - 64]
1662	add	ecx, eax
1663	adc	esi, edx
1664
1665	mov	eax, [ebx + 56]
1666	imul	dword [edi - 60]
1667	add	ecx, eax
1668	adc	esi, edx
1669
1670	mov	eax, [ebx + 52]
1671	imul	dword [edi - 56]
1672	add	ecx, eax
1673	adc	esi, edx
1674
1675	mov	eax, [ebx + 48]
1676	imul	dword [edi - 52]
1677	add	ecx, eax
1678	adc	esi, edx
1679
1680	mov	eax, [ebx + 44]
1681	imul	dword [edi - 48]
1682	add	ecx, eax
1683	adc	esi, edx
1684
1685	mov	eax, [ebx + 40]
1686	imul	dword [edi - 44]
1687	add	ecx, eax
1688	adc	esi, edx
1689
1690	mov	eax, [ebx + 36]
1691	imul	dword [edi - 40]
1692	add	ecx, eax
1693	adc	esi, edx
1694
1695	mov	eax, [ebx + 32]
1696	imul	dword [edi - 36]
1697	add	ecx, eax
1698	adc	esi, edx
1699
1700	mov	eax, [ebx + 28]
1701	imul	dword [edi - 32]
1702	add	ecx, eax
1703	adc	esi, edx
1704
1705	mov	eax, [ebx + 24]
1706	imul	dword [edi - 28]
1707	add	ecx, eax
1708	adc	esi, edx
1709
1710	mov	eax, [ebx + 20]
1711	imul	dword [edi - 24]
1712	add	ecx, eax
1713	adc	esi, edx
1714
1715	mov	eax, [ebx + 16]
1716	imul	dword [edi - 20]
1717	add	ecx, eax
1718	adc	esi, edx
1719
1720	mov	eax, [ebx + 12]
1721	imul	dword [edi - 16]
1722	add	ecx, eax
1723	adc	esi, edx
1724
1725	mov	eax, [ebx + 8]
1726	imul	dword [edi - 12]
1727	add	ecx, eax
1728	adc	esi, edx
1729
1730	mov	eax, [ebx + 4]
1731	imul	dword [edi - 8]
1732	add	ecx, eax
1733	adc	esi, edx
1734
1735	mov	eax, [ebx]			; eax =  qlp_coeff[ 0] (NOTE: one byte missing from instruction)
1736	imul	dword [edi - 4]			; edx:eax =  qlp_coeff[ 0] * data[i- 1]
1737	add	ecx, eax
1738	adc	esi, edx			; sum += qlp_coeff[ 0] * data[i- 1]
1739
1740.jumper_0:
1741	mov	edx, ecx
1742;esi:edx = sum
1743	mov	ecx, [esp + 36]			; cl = lp_quantization
1744	shrd	edx, esi, cl			; edx = (sum >> lp_quantization)
1745;eax = --
1746;ecx = --
1747;edx = sum >> lp_q
1748;esi = --
1749	neg	edx				; edx = -(sum >> lp_quantization)
1750	mov	eax, [esp + 40]			; residual[] - data[]
1751	add	edx, [edi]			; edx = data[i] - (sum >> lp_quantization)
1752	mov	[edi + eax], edx
1753	add	edi, 4
1754
1755	dec	dword [esp + 24]
1756	jz	short .end
1757	xor	ecx, ecx
1758	xor	esi, esi
1759	jmp	ebp
1760
1761.end:
1762	pop	edi
1763	pop	esi
1764	pop	ebx
1765	pop	ebp
1766	ret
1767
1768; **********************************************************************
1769;
1770; void FLAC__lpc_restore_signal_wide(const FLAC__int32 residual[], unsigned data_len, const FLAC__int32 qlp_coeff[], unsigned order, int lp_quantization, FLAC__int32 data[])
1771; {
1772; 	unsigned i, j;
1773; 	FLAC__int64 sum;
1774;
1775; 	FLAC__ASSERT(order > 0);
1776;
1777; 	for(i = 0; i < data_len; i++) {
1778; 		sum = 0;
1779; 		for(j = 0; j < order; j++)
1780; 			sum += qlp_coeff[j] * (FLAC__int64)data[i-j-1];
1781; 		data[i] = residual[i] + (FLAC__int32)(sum >> lp_quantization);
1782; 	}
1783; }
1784	ALIGN	16
1785cident FLAC__lpc_restore_signal_wide_asm_ia32
1786	;[esp + 40]	data[]
1787	;[esp + 36]	lp_quantization
1788	;[esp + 32]	order
1789	;[esp + 28]	qlp_coeff[]
1790	;[esp + 24]	data_len
1791	;[esp + 20]	residual[]
1792
1793	;ASSERT(order > 0)
1794	;ASSERT(order <= 32)
1795	;ASSERT(lp_quantization <= 31)
1796
1797	push	ebp
1798	push	ebx
1799	push	esi
1800	push	edi
1801
1802	mov	ebx, [esp + 24]			; ebx = data_len
1803	test	ebx, ebx
1804	jz	near .end			; do nothing if data_len == 0
1805
1806.begin:
1807	mov	eax, [esp + 32]			; eax = order
1808	cmp	eax, 1
1809	jg	short .x87_32
1810
1811	mov	esi, [esp + 20]			; esi = residual[]
1812	mov	edi, [esp + 40]			; edi = data[]
1813	mov	ecx, [esp + 28]			; ecx = qlp_coeff[]
1814	mov	ebp, [ecx]			; ebp = qlp_coeff[0]
1815	mov	eax, [edi - 4]			; eax = data[-1]
1816	mov	ecx, [esp + 36]			; cl = lp_quantization
1817	ALIGN	16
1818.x87_1_loop_i:
1819	imul	ebp				; edx:eax = qlp_coeff[0] * (FLAC__int64)data[i-1]
1820	shrd	eax, edx, cl			; 0 <= lp_quantization <= 15
1821;
1822	add	eax, [esi]
1823	mov	[edi], eax
1824;
1825	add	esi, 4
1826	add	edi, 4
1827	dec	ebx
1828	jnz	.x87_1_loop_i
1829	jmp	.end
1830
1831.mov_eip_to_eax:
1832	mov	eax, [esp]
1833	ret
1834
1835.x87_32:	; eax = order
1836	neg	eax
1837	add	eax, eax
1838	lea	ebp, [eax + eax * 4 + .jumper_0 - .get_eip0]
1839	call	.mov_eip_to_eax
1840.get_eip0:
1841	add	ebp, eax
1842	inc	ebp				; compensate for the shorter opcode on the last iteration
1843
1844	mov	ebx, [esp + 28]			; ebx = qlp_coeff[]
1845	mov	edi, [esp + 40]			; esi = data[]
1846	sub	[esp + 20], edi			; residual[] -= data[]
1847
1848	xor	ecx, ecx
1849	xor	esi, esi
1850	jmp	ebp
1851
1852;eax = --
1853;edx = --
1854;ecx = 0
1855;esi = 0
1856;
1857;ebx = qlp_coeff[]
1858;edi = data[]
1859;ebp = @address
1860
1861	mov	eax, [ebx + 124]		; eax =  qlp_coeff[31]
1862	imul	dword [edi - 128]		; edx:eax =  qlp_coeff[31] * data[i-32]
1863	add	ecx, eax
1864	adc	esi, edx			; sum += qlp_coeff[31] * data[i-32]
1865
1866	mov	eax, [ebx + 120]		; eax =  qlp_coeff[30]
1867	imul	dword [edi - 124]		; edx:eax =  qlp_coeff[30] * data[i-31]
1868	add	ecx, eax
1869	adc	esi, edx			; sum += qlp_coeff[30] * data[i-31]
1870
1871	mov	eax, [ebx + 116]
1872	imul	dword [edi - 120]
1873	add	ecx, eax
1874	adc	esi, edx
1875
1876	mov	eax, [ebx + 112]
1877	imul	dword [edi - 116]
1878	add	ecx, eax
1879	adc	esi, edx
1880
1881	mov	eax, [ebx + 108]
1882	imul	dword [edi - 112]
1883	add	ecx, eax
1884	adc	esi, edx
1885
1886	mov	eax, [ebx + 104]
1887	imul	dword [edi - 108]
1888	add	ecx, eax
1889	adc	esi, edx
1890
1891	mov	eax, [ebx + 100]
1892	imul	dword [edi - 104]
1893	add	ecx, eax
1894	adc	esi, edx
1895
1896	mov	eax, [ebx + 96]
1897	imul	dword [edi - 100]
1898	add	ecx, eax
1899	adc	esi, edx
1900
1901	mov	eax, [ebx + 92]
1902	imul	dword [edi - 96]
1903	add	ecx, eax
1904	adc	esi, edx
1905
1906	mov	eax, [ebx + 88]
1907	imul	dword [edi - 92]
1908	add	ecx, eax
1909	adc	esi, edx
1910
1911	mov	eax, [ebx + 84]
1912	imul	dword [edi - 88]
1913	add	ecx, eax
1914	adc	esi, edx
1915
1916	mov	eax, [ebx + 80]
1917	imul	dword [edi - 84]
1918	add	ecx, eax
1919	adc	esi, edx
1920
1921	mov	eax, [ebx + 76]
1922	imul	dword [edi - 80]
1923	add	ecx, eax
1924	adc	esi, edx
1925
1926	mov	eax, [ebx + 72]
1927	imul	dword [edi - 76]
1928	add	ecx, eax
1929	adc	esi, edx
1930
1931	mov	eax, [ebx + 68]
1932	imul	dword [edi - 72]
1933	add	ecx, eax
1934	adc	esi, edx
1935
1936	mov	eax, [ebx + 64]
1937	imul	dword [edi - 68]
1938	add	ecx, eax
1939	adc	esi, edx
1940
1941	mov	eax, [ebx + 60]
1942	imul	dword [edi - 64]
1943	add	ecx, eax
1944	adc	esi, edx
1945
1946	mov	eax, [ebx + 56]
1947	imul	dword [edi - 60]
1948	add	ecx, eax
1949	adc	esi, edx
1950
1951	mov	eax, [ebx + 52]
1952	imul	dword [edi - 56]
1953	add	ecx, eax
1954	adc	esi, edx
1955
1956	mov	eax, [ebx + 48]
1957	imul	dword [edi - 52]
1958	add	ecx, eax
1959	adc	esi, edx
1960
1961	mov	eax, [ebx + 44]
1962	imul	dword [edi - 48]
1963	add	ecx, eax
1964	adc	esi, edx
1965
1966	mov	eax, [ebx + 40]
1967	imul	dword [edi - 44]
1968	add	ecx, eax
1969	adc	esi, edx
1970
1971	mov	eax, [ebx + 36]
1972	imul	dword [edi - 40]
1973	add	ecx, eax
1974	adc	esi, edx
1975
1976	mov	eax, [ebx + 32]
1977	imul	dword [edi - 36]
1978	add	ecx, eax
1979	adc	esi, edx
1980
1981	mov	eax, [ebx + 28]
1982	imul	dword [edi - 32]
1983	add	ecx, eax
1984	adc	esi, edx
1985
1986	mov	eax, [ebx + 24]
1987	imul	dword [edi - 28]
1988	add	ecx, eax
1989	adc	esi, edx
1990
1991	mov	eax, [ebx + 20]
1992	imul	dword [edi - 24]
1993	add	ecx, eax
1994	adc	esi, edx
1995
1996	mov	eax, [ebx + 16]
1997	imul	dword [edi - 20]
1998	add	ecx, eax
1999	adc	esi, edx
2000
2001	mov	eax, [ebx + 12]
2002	imul	dword [edi - 16]
2003	add	ecx, eax
2004	adc	esi, edx
2005
2006	mov	eax, [ebx + 8]
2007	imul	dword [edi - 12]
2008	add	ecx, eax
2009	adc	esi, edx
2010
2011	mov	eax, [ebx + 4]
2012	imul	dword [edi - 8]
2013	add	ecx, eax
2014	adc	esi, edx
2015
2016	mov	eax, [ebx]			; eax =  qlp_coeff[ 0] (NOTE: one byte missing from instruction)
2017	imul	dword [edi - 4]			; edx:eax =  qlp_coeff[ 0] * data[i- 1]
2018	add	ecx, eax
2019	adc	esi, edx			; sum += qlp_coeff[ 0] * data[i- 1]
2020
2021.jumper_0:
2022	mov	edx, ecx
2023;esi:edx = sum
2024	mov	ecx, [esp + 36]			; cl = lp_quantization
2025	shrd	edx, esi, cl			; edx = (sum >> lp_quantization)
2026;eax = --
2027;ecx = --
2028;edx = sum >> lp_q
2029;esi = --
2030;
2031	mov	eax, [esp + 20]			; residual[] - data[]
2032	add	edx, [edi + eax]		; edx = residual[i] + (sum >> lp_quantization)
2033	mov	[edi], edx			; data[i] = residual[i] + (sum >> lp_quantization)
2034	add	edi, 4
2035
2036	dec	dword [esp + 24]
2037	jz	short .end
2038	xor	ecx, ecx
2039	xor	esi, esi
2040	jmp	ebp
2041
2042.end:
2043	pop	edi
2044	pop	esi
2045	pop	ebx
2046	pop	ebp
2047	ret
2048
2049; end
2050