← Back to branch summary

~ubuntu-branches/debian/experimental/libav/experimental

« back to all changes in this revision

Viewing changes to libavcodec/x86/dcadsp.asm

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2014-08-10 09:45:02 UTC
  • mfrom: (1.1.28) (2.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140810094502-p8pds4kq0zpig5oq
Tags: 6:11~alpha1-1
http://bugs.debian.org/749164
* New upstream Release v11
  - Fixes Unchecked conversion from double to enum (Closes: #749164)
* Add some post v11_alpha1 patches from upstream
* All SONAMEs bumped because of internal changes, but external API is
  promised to have not changed

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/x86/dcadsp.asm
26
26
 
27
27
SECTION_TEXT
28
28
 
29
 
; void int8x8_fmul_int32_sse2(float *dst, const int8_t *src, int scale)
30
 
%macro INT8X8_FMUL_INT32 0
31
 
cglobal int8x8_fmul_int32, 3,3,5, dst, src, scale
32
 
    cvtsi2ss    m0, scalem
 
29
; void decode_hf(float dst[DCA_SUBBANDS][8], const int32_t vq_num[DCA_SUBBANDS],
 
30
;                const int8_t hf_vq[1024][32], intptr_t vq_offset,
 
31
;                int32_t scale[DCA_SUBBANDS][2], intptr_t start, intptr_t end)
 
32
 
 
33
%macro DECODE_HF 0
 
34
cglobal decode_hf, 6,6,5, dst, num, src, offset, scale, start, end
 
35
    lea       srcq, [srcq + offsetq]
 
36
    shl     startq, 2
 
37
    mov    offsetd, endm
 
38
%define DICT offsetq
 
39
    shl    offsetq, 2
 
40
    mov       endm, offsetq
 
41
.loop:
 
42
%if ARCH_X86_64
 
43
    mov    offsetd, [scaleq + 2 * startq]
 
44
    cvtsi2ss    m0, offsetd
 
45
%else
 
46
    cvtsi2ss    m0, [scaleq + 2 * startq]
 
47
%endif
 
48
    mov    offsetd, [numq + startq]
33
49
    mulss       m0, [pf_inv16]
 
50
    shl       DICT, 5
34
51
    shufps      m0, m0, 0
35
52
%if cpuflag(sse2)
36
53
%if cpuflag(sse4)
37
 
    pmovsxbd    m1, [srcq+0]
38
 
    pmovsxbd    m2, [srcq+4]
 
54
    pmovsxbd    m1, [srcq + DICT + 0]
 
55
    pmovsxbd    m2, [srcq + DICT + 4]
39
56
%else
40
 
    movq        m1, [srcq]
 
57
    movq        m1, [srcq + DICT]
41
58
    punpcklbw   m1, m1
42
59
    mova        m2, m1
43
60
    punpcklwd   m1, m1
48
65
    cvtdq2ps    m1, m1
49
66
    cvtdq2ps    m2, m2
50
67
%else
51
 
    movd       mm0, [srcq+0]
52
 
    movd       mm1, [srcq+4]
 
68
    movd       mm0, [srcq + DICT + 0]
 
69
    movd       mm1, [srcq + DICT + 4]
53
70
    punpcklbw  mm0, mm0
54
71
    punpcklbw  mm1, mm1
55
72
    movq       mm2, mm0
67
84
    cvtpi2ps    m3, mm2
68
85
    cvtpi2ps    m4, mm3
69
86
    shufps      m0, m0, 0
70
 
    emms
71
87
    shufps      m1, m3, q1010
72
88
    shufps      m2, m4, q1010
73
89
%endif
74
90
    mulps       m1, m0
75
91
    mulps       m2, m0
76
 
    mova [dstq+ 0], m1
77
 
    mova [dstq+16], m2
 
92
    mova [dstq + 8 * startq +  0], m1
 
93
    mova [dstq + 8 * startq + 16], m2
 
94
    add     startq, 4
 
95
    cmp     startq, endm
 
96
    jl       .loop
 
97
.end:
 
98
%if notcpuflag(sse2)
 
99
    emms
 
100
%endif
78
101
    REP_RET
79
102
%endmacro
80
103
 
81
104
%if ARCH_X86_32
82
105
INIT_XMM sse
83
 
INT8X8_FMUL_INT32
 
106
DECODE_HF
84
107
%endif
85
108
 
86
109
INIT_XMM sse2
87
 
INT8X8_FMUL_INT32
 
110
DECODE_HF
88
111
 
89
112
INIT_XMM sse4
90
 
INT8X8_FMUL_INT32
 
113
DECODE_HF
 
114
 
 
115
; %1=v0/v1  %2=in1  %3=in2
 
116
%macro FIR_LOOP 2-3
 
117
.loop%1:
 
118
%define va          m1
 
119
%define vb          m2
 
120
%if %1
 
121
%define OFFSET      0
 
122
%else
 
123
%define OFFSET      NUM_COEF*count
 
124
%endif
 
125
; for v0, incrementing and for v1, decrementing
 
126
    mova        va, [cf0q + OFFSET]
 
127
    mova        vb, [cf0q + OFFSET + 4*NUM_COEF]
 
128
%if %0 == 3
 
129
    mova        m4, [cf0q + OFFSET + mmsize]
 
130
    mova        m0, [cf0q + OFFSET + 4*NUM_COEF + mmsize]
 
131
%endif
 
132
    mulps       va, %2
 
133
    mulps       vb, %2
 
134
%if %0 == 3
 
135
    mulps       m4, %3
 
136
    mulps       m0, %3
 
137
    addps       va, m4
 
138
    addps       vb, m0
 
139
%endif
 
140
    ; va = va1 va2 va3 va4
 
141
    ; vb = vb1 vb2 vb3 vb4
 
142
%if %1
 
143
    SWAP        va, vb
 
144
%endif
 
145
    mova        m4, va
 
146
    unpcklps    va, vb ; va3 vb3 va4 vb4
 
147
    unpckhps    m4, vb ; va1 vb1 va2 vb2
 
148
    addps       m4, va ; va1+3 vb1+3 va2+4 vb2+4
 
149
    movhlps     vb, m4 ; va1+3  vb1+3
 
150
    addps       vb, m4 ; va0..4 vb0..4
 
151
    movh    [outq + count], vb
 
152
%if %1
 
153
    sub       cf0q, 8*NUM_COEF
 
154
%endif
 
155
    add      count, 8
 
156
    jl   .loop%1
 
157
%endmacro
 
158
 
 
159
; void dca_lfe_fir(float *out, float *in, float *coefs)
 
160
%macro DCA_LFE_FIR 1
 
161
cglobal dca_lfe_fir%1, 3,3,6-%1, out, in, cf0
 
162
%define IN1       m3
 
163
%define IN2       m5
 
164
%define count     inq
 
165
%define NUM_COEF  4*(2-%1)
 
166
%define NUM_OUT   32*(%1+1)
 
167
 
 
168
    movu     IN1, [inq + 4 - 1*mmsize]
 
169
    shufps   IN1, IN1, q0123
 
170
%if %1 == 0
 
171
    movu     IN2, [inq + 4 - 2*mmsize]
 
172
    shufps   IN2, IN2, q0123
 
173
%endif
 
174
 
 
175
    mov    count, -4*NUM_OUT
 
176
    add     cf0q, 4*NUM_COEF*NUM_OUT
 
177
    add     outq, 4*NUM_OUT
 
178
    ; compute v0 first
 
179
%if %1 == 0
 
180
    FIR_LOOP   0, IN1, IN2
 
181
%else
 
182
    FIR_LOOP   0, IN1
 
183
%endif
 
184
    shufps   IN1, IN1, q0123
 
185
    mov    count, -4*NUM_OUT
 
186
    ; cf1 already correctly positioned
 
187
    add     outq, 4*NUM_OUT          ; outq now at out2
 
188
    sub     cf0q, 8*NUM_COEF
 
189
%if %1 == 0
 
190
    shufps   IN2, IN2, q0123
 
191
    FIR_LOOP   1, IN2, IN1
 
192
%else
 
193
    FIR_LOOP   1, IN1
 
194
%endif
 
195
    RET
 
196
%endmacro
 
197
 
 
198
INIT_XMM sse
 
199
DCA_LFE_FIR 0
 
200
DCA_LFE_FIR 1
 
201
 
 
202
%macro SETZERO 1
 
203
%if cpuflag(sse2) && notcpuflag(avx)
 
204
    pxor          %1, %1
 
205
%else
 
206
    xorps         %1, %1, %1
 
207
%endif
 
208
%endmacro
 
209
 
 
210
%macro SHUF 3
 
211
%if cpuflag(avx)
 
212
    mova          %3, [%2 - 16]
 
213
    vperm2f128    %1, %3, %3, 1
 
214
    vshufps       %1, %1, %1, q0123
 
215
%elif cpuflag(sse2)
 
216
    pshufd        %1, [%2], q0123
 
217
%else
 
218
    mova          %1, [%2]
 
219
    shufps        %1, %1, q0123
 
220
%endif
 
221
%endmacro
 
222
 
 
223
%macro INNER_LOOP   1
 
224
    ; reading backwards:  ptr1 = synth_buf + j + i; ptr2 = synth_buf + j - i
 
225
    ;~ a += window[i + j]      * (-synth_buf[15 - i + j])
 
226
    ;~ b += window[i + j + 16] * (synth_buf[i + j])
 
227
    SHUF          m5,  ptr2 + j + (15 - 3) * 4, m6
 
228
    mova          m6, [ptr1 + j]
 
229
%if ARCH_X86_64
 
230
    SHUF         m11,  ptr2 + j + (15 - 3) * 4 - mmsize, m12
 
231
    mova         m12, [ptr1 + j + mmsize]
 
232
%endif
 
233
%if cpuflag(fma3)
 
234
    fmaddps       m2, m6,  [win + %1 + j + 16 * 4], m2
 
235
    fnmaddps      m1, m5,  [win + %1 + j], m1
 
236
%if ARCH_X86_64
 
237
    fmaddps       m8, m12, [win + %1 + j + mmsize + 16 * 4], m8
 
238
    fnmaddps      m7, m11, [win + %1 + j + mmsize], m7
 
239
%endif
 
240
%else ; non-FMA
 
241
    mulps         m6, m6,  [win + %1 + j + 16 * 4]
 
242
    mulps         m5, m5,  [win + %1 + j]
 
243
%if ARCH_X86_64
 
244
    mulps        m12, m12, [win + %1 + j + mmsize + 16 * 4]
 
245
    mulps        m11, m11, [win + %1 + j + mmsize]
 
246
%endif
 
247
    addps         m2, m2, m6
 
248
    subps         m1, m1, m5
 
249
%if ARCH_X86_64
 
250
    addps         m8, m8, m12
 
251
    subps         m7, m7, m11
 
252
%endif
 
253
%endif ; cpuflag(fma3)
 
254
    ;~ c += window[i + j + 32] * (synth_buf[16 + i + j])
 
255
    ;~ d += window[i + j + 48] * (synth_buf[31 - i + j])
 
256
    SHUF          m6,  ptr2 + j + (31 - 3) * 4, m5
 
257
    mova          m5, [ptr1 + j + 16 * 4]
 
258
%if ARCH_X86_64
 
259
    SHUF         m12,  ptr2 + j + (31 - 3) * 4 - mmsize, m11
 
260
    mova         m11, [ptr1 + j + mmsize + 16 * 4]
 
261
%endif
 
262
%if cpuflag(fma3)
 
263
    fmaddps       m3, m5,  [win + %1 + j + 32 * 4], m3
 
264
    fmaddps       m4, m6,  [win + %1 + j + 48 * 4], m4
 
265
%if ARCH_X86_64
 
266
    fmaddps       m9, m11, [win + %1 + j + mmsize + 32 * 4], m9
 
267
    fmaddps      m10, m12, [win + %1 + j + mmsize + 48 * 4], m10
 
268
%endif
 
269
%else ; non-FMA
 
270
    mulps         m5, m5,  [win + %1 + j + 32 * 4]
 
271
    mulps         m6, m6,  [win + %1 + j + 48 * 4]
 
272
%if ARCH_X86_64
 
273
    mulps        m11, m11, [win + %1 + j + mmsize + 32 * 4]
 
274
    mulps        m12, m12, [win + %1 + j + mmsize + 48 * 4]
 
275
%endif
 
276
    addps         m3, m3, m5
 
277
    addps         m4, m4, m6
 
278
%if ARCH_X86_64
 
279
    addps         m9, m9, m11
 
280
    addps        m10, m10, m12
 
281
%endif
 
282
%endif ; cpuflag(fma3)
 
283
    sub            j, 64 * 4
 
284
%endmacro
 
285
 
 
286
; void ff_synth_filter_inner_<opt>(float *synth_buf, float synth_buf2[32],
 
287
;                                  const float window[512], float out[32],
 
288
;                                  intptr_t offset, float scale)
 
289
%macro SYNTH_FILTER 0
 
290
cglobal synth_filter_inner, 0, 6 + 4 * ARCH_X86_64, 7 + 6 * ARCH_X86_64, \
 
291
                              synth_buf, synth_buf2, window, out, off, scale
 
292
%define scale m0
 
293
%if ARCH_X86_32 || WIN64
 
294
%if cpuflag(sse2) && notcpuflag(avx)
 
295
    movd       scale, scalem
 
296
    SPLATD        m0
 
297
%else
 
298
    VBROADCASTSS  m0, scalem
 
299
%endif
 
300
; Make sure offset is in a register and not on the stack
 
301
%define OFFQ  r4q
 
302
%else
 
303
    SPLATD      xmm0
 
304
%if cpuflag(avx)
 
305
    vinsertf128   m0, m0, xmm0, 1
 
306
%endif
 
307
%define OFFQ  offq
 
308
%endif
 
309
    ; prepare inner counter limit 1
 
310
    mov          r5q, 480
 
311
    sub          r5q, offmp
 
312
    and          r5q, -64
 
313
    shl          r5q, 2
 
314
%if ARCH_X86_32 || notcpuflag(avx)
 
315
    mov         OFFQ, r5q
 
316
%define i        r5q
 
317
    mov            i, 16 * 4 - (ARCH_X86_64 + 1) * mmsize  ; main loop counter
 
318
%else
 
319
%define i 0
 
320
%define OFFQ  r5q
 
321
%endif
 
322
 
 
323
%define buf2     synth_buf2q
 
324
%if ARCH_X86_32
 
325
    mov         buf2, synth_buf2mp
 
326
%endif
 
327
.mainloop
 
328
    ; m1 = a  m2 = b  m3 = c  m4 = d
 
329
    SETZERO       m3
 
330
    SETZERO       m4
 
331
    mova          m1, [buf2 + i]
 
332
    mova          m2, [buf2 + i + 16 * 4]
 
333
%if ARCH_X86_32
 
334
%define ptr1     r0q
 
335
%define ptr2     r1q
 
336
%define win      r2q
 
337
%define j        r3q
 
338
    mov          win, windowm
 
339
    mov         ptr1, synth_bufm
 
340
%if ARCH_X86_32 || notcpuflag(avx)
 
341
    add          win, i
 
342
    add         ptr1, i
 
343
%endif
 
344
%else ; ARCH_X86_64
 
345
%define ptr1     r6q
 
346
%define ptr2     r7q ; must be loaded
 
347
%define win      r8q
 
348
%define j        r9q
 
349
    SETZERO       m9
 
350
    SETZERO      m10
 
351
    mova          m7, [buf2 + i + mmsize]
 
352
    mova          m8, [buf2 + i + mmsize + 16 * 4]
 
353
    lea          win, [windowq + i]
 
354
    lea         ptr1, [synth_bufq + i]
 
355
%endif
 
356
    mov         ptr2, synth_bufmp
 
357
    ; prepare the inner loop counter
 
358
    mov            j, OFFQ
 
359
%if ARCH_X86_32 || notcpuflag(avx)
 
360
    sub         ptr2, i
 
361
%endif
 
362
.loop1:
 
363
    INNER_LOOP  0
 
364
    jge       .loop1
 
365
 
 
366
    mov            j, 448 * 4
 
367
    sub            j, OFFQ
 
368
    jz          .end
 
369
    sub         ptr1, j
 
370
    sub         ptr2, j
 
371
    add          win, OFFQ ; now at j-64, so define OFFSET
 
372
    sub            j, 64 * 4
 
373
.loop2:
 
374
    INNER_LOOP  64 * 4
 
375
    jge       .loop2
 
376
 
 
377
.end:
 
378
%if ARCH_X86_32
 
379
    mov         buf2, synth_buf2m ; needed for next iteration anyway
 
380
    mov         outq, outmp       ; j, which will be set again during it
 
381
%endif
 
382
    ;~ out[i]      = a * scale;
 
383
    ;~ out[i + 16] = b * scale;
 
384
    mulps         m1, m1, scale
 
385
    mulps         m2, m2, scale
 
386
%if ARCH_X86_64
 
387
    mulps         m7, m7, scale
 
388
    mulps         m8, m8, scale
 
389
%endif
 
390
    ;~ synth_buf2[i]      = c;
 
391
    ;~ synth_buf2[i + 16] = d;
 
392
    mova   [buf2 + i +  0 * 4], m3
 
393
    mova   [buf2 + i + 16 * 4], m4
 
394
%if ARCH_X86_64
 
395
    mova   [buf2 + i +  0 * 4 + mmsize], m9
 
396
    mova   [buf2 + i + 16 * 4 + mmsize], m10
 
397
%endif
 
398
    ;~ out[i]      = a;
 
399
    ;~ out[i + 16] = a;
 
400
    mova   [outq + i +  0 * 4], m1
 
401
    mova   [outq + i + 16 * 4], m2
 
402
%if ARCH_X86_64
 
403
    mova   [outq + i +  0 * 4 + mmsize], m7
 
404
    mova   [outq + i + 16 * 4 + mmsize], m8
 
405
%endif
 
406
%if ARCH_X86_32 || notcpuflag(avx)
 
407
    sub            i, (ARCH_X86_64 + 1) * mmsize
 
408
    jge    .mainloop
 
409
%endif
 
410
    RET
 
411
%endmacro
 
412
 
 
413
%if ARCH_X86_32
 
414
INIT_XMM sse
 
415
SYNTH_FILTER
 
416
%endif
 
417
INIT_XMM sse2
 
418
SYNTH_FILTER
 
419
INIT_YMM avx
 
420
SYNTH_FILTER
 
421
INIT_YMM fma3
 
422
SYNTH_FILTER