mpegaudiodec: interleave iMDCT buffer to simplify future SIMD implementations
[ffmpeg.git] / libavcodec / mpegaudiodsp_template.c
1 /*
2  * Copyright (c) 2001, 2002 Fabrice Bellard
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <stdint.h>
22
23 #include "libavutil/mem.h"
24 #include "dct32.h"
25 #include "mathops.h"
26 #include "mpegaudiodsp.h"
27 #include "mpegaudio.h"
28 #include "mpegaudiodata.h"
29
30 #if CONFIG_FLOAT
31 #define RENAME(n) n##_float
32
33 static inline float round_sample(float *sum)
34 {
35     float sum1=*sum;
36     *sum = 0;
37     return sum1;
38 }
39
40 #define MACS(rt, ra, rb) rt+=(ra)*(rb)
41 #define MULS(ra, rb) ((ra)*(rb))
42 #define MLSS(rt, ra, rb) rt-=(ra)*(rb)
43
44 #else
45
46 #define RENAME(n) n##_fixed
47 #define OUT_SHIFT (WFRAC_BITS + FRAC_BITS - 15)
48
49 static inline int round_sample(int64_t *sum)
50 {
51     int sum1;
52     sum1 = (int)((*sum) >> OUT_SHIFT);
53     *sum &= (1<<OUT_SHIFT)-1;
54     return av_clip_int16(sum1);
55 }
56
57 #   define MULS(ra, rb) MUL64(ra, rb)
58 #   define MACS(rt, ra, rb) MAC64(rt, ra, rb)
59 #   define MLSS(rt, ra, rb) MLS64(rt, ra, rb)
60 #endif
61
62 DECLARE_ALIGNED(16, MPA_INT, RENAME(ff_mpa_synth_window))[512+256];
63
64 #define SUM8(op, sum, w, p)               \
65 {                                         \
66     op(sum, (w)[0 * 64], (p)[0 * 64]);    \
67     op(sum, (w)[1 * 64], (p)[1 * 64]);    \
68     op(sum, (w)[2 * 64], (p)[2 * 64]);    \
69     op(sum, (w)[3 * 64], (p)[3 * 64]);    \
70     op(sum, (w)[4 * 64], (p)[4 * 64]);    \
71     op(sum, (w)[5 * 64], (p)[5 * 64]);    \
72     op(sum, (w)[6 * 64], (p)[6 * 64]);    \
73     op(sum, (w)[7 * 64], (p)[7 * 64]);    \
74 }
75
76 #define SUM8P2(sum1, op1, sum2, op2, w1, w2, p) \
77 {                                               \
78     INTFLOAT tmp;\
79     tmp = p[0 * 64];\
80     op1(sum1, (w1)[0 * 64], tmp);\
81     op2(sum2, (w2)[0 * 64], tmp);\
82     tmp = p[1 * 64];\
83     op1(sum1, (w1)[1 * 64], tmp);\
84     op2(sum2, (w2)[1 * 64], tmp);\
85     tmp = p[2 * 64];\
86     op1(sum1, (w1)[2 * 64], tmp);\
87     op2(sum2, (w2)[2 * 64], tmp);\
88     tmp = p[3 * 64];\
89     op1(sum1, (w1)[3 * 64], tmp);\
90     op2(sum2, (w2)[3 * 64], tmp);\
91     tmp = p[4 * 64];\
92     op1(sum1, (w1)[4 * 64], tmp);\
93     op2(sum2, (w2)[4 * 64], tmp);\
94     tmp = p[5 * 64];\
95     op1(sum1, (w1)[5 * 64], tmp);\
96     op2(sum2, (w2)[5 * 64], tmp);\
97     tmp = p[6 * 64];\
98     op1(sum1, (w1)[6 * 64], tmp);\
99     op2(sum2, (w2)[6 * 64], tmp);\
100     tmp = p[7 * 64];\
101     op1(sum1, (w1)[7 * 64], tmp);\
102     op2(sum2, (w2)[7 * 64], tmp);\
103 }
104
105 void RENAME(ff_mpadsp_apply_window)(MPA_INT *synth_buf, MPA_INT *window,
106                                   int *dither_state, OUT_INT *samples,
107                                   int incr)
108 {
109     register const MPA_INT *w, *w2, *p;
110     int j;
111     OUT_INT *samples2;
112 #if CONFIG_FLOAT
113     float sum, sum2;
114 #else
115     int64_t sum, sum2;
116 #endif
117
118     /* copy to avoid wrap */
119     memcpy(synth_buf + 512, synth_buf, 32 * sizeof(*synth_buf));
120
121     samples2 = samples + 31 * incr;
122     w = window;
123     w2 = window + 31;
124
125     sum = *dither_state;
126     p = synth_buf + 16;
127     SUM8(MACS, sum, w, p);
128     p = synth_buf + 48;
129     SUM8(MLSS, sum, w + 32, p);
130     *samples = round_sample(&sum);
131     samples += incr;
132     w++;
133
134     /* we calculate two samples at the same time to avoid one memory
135        access per two sample */
136     for(j=1;j<16;j++) {
137         sum2 = 0;
138         p = synth_buf + 16 + j;
139         SUM8P2(sum, MACS, sum2, MLSS, w, w2, p);
140         p = synth_buf + 48 - j;
141         SUM8P2(sum, MLSS, sum2, MLSS, w + 32, w2 + 32, p);
142
143         *samples = round_sample(&sum);
144         samples += incr;
145         sum += sum2;
146         *samples2 = round_sample(&sum);
147         samples2 -= incr;
148         w++;
149         w2--;
150     }
151
152     p = synth_buf + 32;
153     SUM8(MLSS, sum, w + 32, p);
154     *samples = round_sample(&sum);
155     *dither_state= sum;
156 }
157
158 /* 32 sub band synthesis filter. Input: 32 sub band samples, Output:
159    32 samples. */
160 void RENAME(ff_mpa_synth_filter)(MPADSPContext *s, MPA_INT *synth_buf_ptr,
161                                  int *synth_buf_offset,
162                                  MPA_INT *window, int *dither_state,
163                                  OUT_INT *samples, int incr,
164                                  MPA_INT *sb_samples)
165 {
166     MPA_INT *synth_buf;
167     int offset;
168
169     offset = *synth_buf_offset;
170     synth_buf = synth_buf_ptr + offset;
171
172     s->RENAME(dct32)(synth_buf, sb_samples);
173     s->RENAME(apply_window)(synth_buf, window, dither_state, samples, incr);
174
175     offset = (offset - 32) & 511;
176     *synth_buf_offset = offset;
177 }
178
179 void av_cold RENAME(ff_mpa_synth_init)(MPA_INT *window)
180 {
181     int i, j;
182
183     /* max = 18760, max sum over all 16 coefs : 44736 */
184     for(i=0;i<257;i++) {
185         INTFLOAT v;
186         v = ff_mpa_enwindow[i];
187 #if CONFIG_FLOAT
188         v *= 1.0 / (1LL<<(16 + FRAC_BITS));
189 #endif
190         window[i] = v;
191         if ((i & 63) != 0)
192             v = -v;
193         if (i != 0)
194             window[512 - i] = v;
195     }
196
197     // Needed for avoiding shuffles in ASM implementations
198     for(i=0; i < 8; i++)
199         for(j=0; j < 16; j++)
200             window[512+16*i+j] = window[64*i+32-j];
201
202     for(i=0; i < 8; i++)
203         for(j=0; j < 16; j++)
204             window[512+128+16*i+j] = window[64*i+48-j];
205 }