Merge remote-tracking branch 'qatar/master'
[ffmpeg.git] / libavcodec / x86 / mpegaudiodec_mmx.c
1 /*
2  * MMX optimized MP3 decoding functions
3  * Copyright (c) 2010 Vitor Sessak
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "libavutil/cpu.h"
23 #include "libavutil/x86_cpu.h"
24 #include "libavcodec/dsputil.h"
25 #include "libavcodec/mpegaudiodsp.h"
26
27 void ff_imdct36_float_sse(float *out, float *buf, float *in, float *win);
28 void ff_imdct36_float_sse2(float *out, float *buf, float *in, float *win);
29 void ff_imdct36_float_sse3(float *out, float *buf, float *in, float *win);
30 void ff_imdct36_float_ssse3(float *out, float *buf, float *in, float *win);
31 void ff_imdct36_float_avx(float *out, float *buf, float *in, float *win);
32 void ff_four_imdct36_float_sse(float *out, float *buf, float *in, float *win,
33                                float *tmpbuf);
34 void ff_four_imdct36_float_avx(float *out, float *buf, float *in, float *win,
35                                float *tmpbuf);
36
37 DECLARE_ALIGNED(16, static float, mdct_win_sse)[2][4][4*40];
38
39 #define MACS(rt, ra, rb) rt+=(ra)*(rb)
40 #define MLSS(rt, ra, rb) rt-=(ra)*(rb)
41
42 #define SUM8(op, sum, w, p)               \
43 {                                         \
44     op(sum, (w)[0 * 64], (p)[0 * 64]);    \
45     op(sum, (w)[1 * 64], (p)[1 * 64]);    \
46     op(sum, (w)[2 * 64], (p)[2 * 64]);    \
47     op(sum, (w)[3 * 64], (p)[3 * 64]);    \
48     op(sum, (w)[4 * 64], (p)[4 * 64]);    \
49     op(sum, (w)[5 * 64], (p)[5 * 64]);    \
50     op(sum, (w)[6 * 64], (p)[6 * 64]);    \
51     op(sum, (w)[7 * 64], (p)[7 * 64]);    \
52 }
53
54 static void apply_window(const float *buf, const float *win1,
55                          const float *win2, float *sum1, float *sum2, int len)
56 {
57     x86_reg count = - 4*len;
58     const float *win1a = win1+len;
59     const float *win2a = win2+len;
60     const float *bufa  = buf+len;
61     float *sum1a = sum1+len;
62     float *sum2a = sum2+len;
63
64
65 #define MULT(a, b)                                 \
66     "movaps " #a "(%1,%0), %%xmm1           \n\t"  \
67     "movaps " #a "(%3,%0), %%xmm2           \n\t"  \
68     "mulps         %%xmm2, %%xmm1           \n\t"  \
69     "subps         %%xmm1, %%xmm0           \n\t"  \
70     "mulps  " #b "(%2,%0), %%xmm2           \n\t"  \
71     "subps         %%xmm2, %%xmm4           \n\t"  \
72
73     __asm__ volatile(
74             "1:                                   \n\t"
75             "xorps       %%xmm0, %%xmm0           \n\t"
76             "xorps       %%xmm4, %%xmm4           \n\t"
77
78             MULT(   0,   0)
79             MULT( 256,  64)
80             MULT( 512, 128)
81             MULT( 768, 192)
82             MULT(1024, 256)
83             MULT(1280, 320)
84             MULT(1536, 384)
85             MULT(1792, 448)
86
87             "movaps      %%xmm0, (%4,%0)          \n\t"
88             "movaps      %%xmm4, (%5,%0)          \n\t"
89             "add            $16,  %0              \n\t"
90             "jl              1b                   \n\t"
91             :"+&r"(count)
92             :"r"(win1a), "r"(win2a), "r"(bufa), "r"(sum1a), "r"(sum2a)
93             );
94
95 #undef MULT
96 }
97
98 static void apply_window_mp3(float *in, float *win, int *unused, float *out,
99                              int incr)
100 {
101     LOCAL_ALIGNED_16(float, suma, [17]);
102     LOCAL_ALIGNED_16(float, sumb, [17]);
103     LOCAL_ALIGNED_16(float, sumc, [17]);
104     LOCAL_ALIGNED_16(float, sumd, [17]);
105
106     float sum;
107
108     /* copy to avoid wrap */
109     memcpy(in + 512, in, 32 * sizeof(*in));
110
111     apply_window(in + 16, win     , win + 512, suma, sumc, 16);
112     apply_window(in + 32, win + 48, win + 640, sumb, sumd, 16);
113
114     SUM8(MACS, suma[0], win + 32, in + 48);
115
116     sumc[ 0] = 0;
117     sumb[16] = 0;
118     sumd[16] = 0;
119
120 #define SUMS(suma, sumb, sumc, sumd, out1, out2)               \
121             "movups " #sumd "(%4),       %%xmm0          \n\t" \
122             "shufps         $0x1b,       %%xmm0, %%xmm0  \n\t" \
123             "subps  " #suma "(%1),       %%xmm0          \n\t" \
124             "movaps        %%xmm0," #out1 "(%0)          \n\t" \
125 \
126             "movups " #sumc "(%3),       %%xmm0          \n\t" \
127             "shufps         $0x1b,       %%xmm0, %%xmm0  \n\t" \
128             "addps  " #sumb "(%2),       %%xmm0          \n\t" \
129             "movaps        %%xmm0," #out2 "(%0)          \n\t"
130
131     if (incr == 1) {
132         __asm__ volatile(
133             SUMS( 0, 48,  4, 52,  0, 112)
134             SUMS(16, 32, 20, 36, 16,  96)
135             SUMS(32, 16, 36, 20, 32,  80)
136             SUMS(48,  0, 52,  4, 48,  64)
137
138             :"+&r"(out)
139             :"r"(&suma[0]), "r"(&sumb[0]), "r"(&sumc[0]), "r"(&sumd[0])
140             :"memory"
141             );
142         out += 16*incr;
143     } else {
144         int j;
145         float *out2 = out + 32 * incr;
146         out[0  ]  = -suma[   0];
147         out += incr;
148         out2 -= incr;
149         for(j=1;j<16;j++) {
150             *out  = -suma[   j] + sumd[16-j];
151             *out2 =  sumb[16-j] + sumc[   j];
152             out  += incr;
153             out2 -= incr;
154         }
155     }
156
157     sum = 0;
158     SUM8(MLSS, sum, win + 16 + 32, in + 32);
159     *out = sum;
160 }
161
162
163 #define DECL_IMDCT_BLOCKS(CPU1, CPU2)                                       \
164 static void imdct36_blocks_ ## CPU1(float *out, float *buf, float *in,      \
165                                int count, int switch_point, int block_type) \
166 {                                                                           \
167     int align_end = count - (count & 3);                                \
168     int j;                                                              \
169     for (j = 0; j < align_end; j+= 4) {                                 \
170         LOCAL_ALIGNED_16(float, tmpbuf, [1024]);                        \
171         float *win = mdct_win_sse[switch_point && j < 4][block_type];   \
172         /* apply window & overlap with previous buffer */               \
173                                                                         \
174         /* select window */                                             \
175         ff_four_imdct36_float_ ## CPU2(out, buf, in, win, tmpbuf);      \
176         in      += 4*18;                                                \
177         buf     += 4*18;                                                \
178         out     += 4;                                                   \
179     }                                                                   \
180     for (; j < count; j++) {                                            \
181         /* apply window & overlap with previous buffer */               \
182                                                                         \
183         /* select window */                                             \
184         int win_idx = (switch_point && j < 2) ? 0 : block_type;         \
185         float *win = ff_mdct_win_float[win_idx + (4 & -(j & 1))];       \
186                                                                         \
187         ff_imdct36_float_ ## CPU1(out, buf, in, win);                   \
188                                                                         \
189         in  += 18;                                                      \
190         buf++;                                                          \
191         out++;                                                          \
192     }                                                                   \
193 }
194
195 DECL_IMDCT_BLOCKS(sse,sse)
196 DECL_IMDCT_BLOCKS(sse2,sse)
197 DECL_IMDCT_BLOCKS(sse3,sse)
198 DECL_IMDCT_BLOCKS(ssse3,sse)
199 DECL_IMDCT_BLOCKS(avx,avx)
200
201 void ff_mpadsp_init_mmx(MPADSPContext *s)
202 {
203     int mm_flags = av_get_cpu_flags();
204
205     int i, j;
206     for (j = 0; j < 4; j++) {
207         for (i = 0; i < 40; i ++) {
208             mdct_win_sse[0][j][4*i    ] = ff_mdct_win_float[j    ][i];
209             mdct_win_sse[0][j][4*i + 1] = ff_mdct_win_float[j + 4][i];
210             mdct_win_sse[0][j][4*i + 2] = ff_mdct_win_float[j    ][i];
211             mdct_win_sse[0][j][4*i + 3] = ff_mdct_win_float[j + 4][i];
212             mdct_win_sse[1][j][4*i    ] = ff_mdct_win_float[0    ][i];
213             mdct_win_sse[1][j][4*i + 1] = ff_mdct_win_float[4    ][i];
214             mdct_win_sse[1][j][4*i + 2] = ff_mdct_win_float[j    ][i];
215             mdct_win_sse[1][j][4*i + 3] = ff_mdct_win_float[j + 4][i];
216         }
217     }
218
219     if (mm_flags & AV_CPU_FLAG_SSE2) {
220         s->apply_window_float = apply_window_mp3;
221     }
222 #if HAVE_YASM
223     if (mm_flags & AV_CPU_FLAG_AVX && HAVE_AVX) {
224         s->imdct36_blocks_float = imdct36_blocks_avx;
225 #if HAVE_SSE
226     } else if (mm_flags & AV_CPU_FLAG_SSSE3) {
227         s->imdct36_blocks_float = imdct36_blocks_ssse3;
228     } else if (mm_flags & AV_CPU_FLAG_SSE3) {
229         s->imdct36_blocks_float = imdct36_blocks_sse3;
230     } else if (mm_flags & AV_CPU_FLAG_SSE2) {
231         s->imdct36_blocks_float = imdct36_blocks_sse2;
232     } else if (mm_flags & AV_CPU_FLAG_SSE) {
233         s->imdct36_blocks_float = imdct36_blocks_sse;
234 #endif /* HAVE_SSE */
235     }
236 #endif /* HAVE_YASM */
237 }