pngdec: decode and expose iCCP chunks as side data
[ffmpeg.git] / libavcodec / mdct15.c
1 /*
2  * Copyright (c) 2013-2014 Mozilla Corporation
3  * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
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 /**
23  * @file
24  * Celt non-power of 2 iMDCT
25  */
26
27 #include <float.h>
28 #include <math.h>
29 #include <stddef.h>
30
31 #include "config.h"
32
33 #include "libavutil/attributes.h"
34 #include "libavutil/common.h"
35
36 #include "mdct15.h"
37
38 #define FFT_FLOAT 1
39 #include "fft-internal.h"
40
41 #define CMUL3(c, a, b) CMUL((c).re, (c).im, (a).re, (a).im, (b).re, (b).im)
42
43 av_cold void ff_mdct15_uninit(MDCT15Context **ps)
44 {
45     MDCT15Context *s = *ps;
46
47     if (!s)
48         return;
49
50     ff_fft_end(&s->ptwo_fft);
51
52     av_freep(&s->pfa_prereindex);
53     av_freep(&s->pfa_postreindex);
54     av_freep(&s->twiddle_exptab);
55     av_freep(&s->tmp);
56
57     av_freep(ps);
58 }
59
60 static inline int init_pfa_reindex_tabs(MDCT15Context *s)
61 {
62     int i, j;
63     const int b_ptwo = s->ptwo_fft.nbits; /* Bits for the power of two FFTs */
64     const int l_ptwo = 1 << b_ptwo; /* Total length for the power of two FFTs */
65     const int inv_1 = l_ptwo << ((4 - b_ptwo) & 3); /* (2^b_ptwo)^-1 mod 15 */
66     const int inv_2 = 0xeeeeeeef & ((1U << b_ptwo) - 1); /* 15^-1 mod 2^b_ptwo */
67
68     s->pfa_prereindex = av_malloc(15 * l_ptwo * sizeof(*s->pfa_prereindex));
69     if (!s->pfa_prereindex)
70         return 1;
71
72     s->pfa_postreindex = av_malloc(15 * l_ptwo * sizeof(*s->pfa_postreindex));
73     if (!s->pfa_postreindex)
74         return 1;
75
76     /* Pre/Post-reindex */
77     for (i = 0; i < l_ptwo; i++) {
78         for (j = 0; j < 15; j++) {
79             const int q_pre = ((l_ptwo * j)/15 + i) >> b_ptwo;
80             const int q_post = (((j*inv_1)/15) + (i*inv_2)) >> b_ptwo;
81             const int k_pre = 15*i + (j - q_pre*15)*(1 << b_ptwo);
82             const int k_post = i*inv_2*15 + j*inv_1 - 15*q_post*l_ptwo;
83             s->pfa_prereindex[i*15 + j] = k_pre;
84             s->pfa_postreindex[k_post] = l_ptwo*j + i;
85         }
86     }
87
88     return 0;
89 }
90
91 /* Stride is hardcoded to 3 */
92 static inline void fft5(FFTComplex *out, FFTComplex *in, FFTComplex exptab[2])
93 {
94     FFTComplex z0[4], t[6];
95
96     t[0].re = in[3].re + in[12].re;
97     t[0].im = in[3].im + in[12].im;
98     t[1].im = in[3].re - in[12].re;
99     t[1].re = in[3].im - in[12].im;
100     t[2].re = in[6].re + in[ 9].re;
101     t[2].im = in[6].im + in[ 9].im;
102     t[3].im = in[6].re - in[ 9].re;
103     t[3].re = in[6].im - in[ 9].im;
104
105     out[0].re = in[0].re + in[3].re + in[6].re + in[9].re + in[12].re;
106     out[0].im = in[0].im + in[3].im + in[6].im + in[9].im + in[12].im;
107
108     t[4].re = exptab[0].re * t[2].re - exptab[1].re * t[0].re;
109     t[4].im = exptab[0].re * t[2].im - exptab[1].re * t[0].im;
110     t[0].re = exptab[0].re * t[0].re - exptab[1].re * t[2].re;
111     t[0].im = exptab[0].re * t[0].im - exptab[1].re * t[2].im;
112     t[5].re = exptab[0].im * t[3].re - exptab[1].im * t[1].re;
113     t[5].im = exptab[0].im * t[3].im - exptab[1].im * t[1].im;
114     t[1].re = exptab[0].im * t[1].re + exptab[1].im * t[3].re;
115     t[1].im = exptab[0].im * t[1].im + exptab[1].im * t[3].im;
116
117     z0[0].re = t[0].re - t[1].re;
118     z0[0].im = t[0].im - t[1].im;
119     z0[1].re = t[4].re + t[5].re;
120     z0[1].im = t[4].im + t[5].im;
121
122     z0[2].re = t[4].re - t[5].re;
123     z0[2].im = t[4].im - t[5].im;
124     z0[3].re = t[0].re + t[1].re;
125     z0[3].im = t[0].im + t[1].im;
126
127     out[1].re = in[0].re + z0[3].re;
128     out[1].im = in[0].im + z0[0].im;
129     out[2].re = in[0].re + z0[2].re;
130     out[2].im = in[0].im + z0[1].im;
131     out[3].re = in[0].re + z0[1].re;
132     out[3].im = in[0].im + z0[2].im;
133     out[4].re = in[0].re + z0[0].re;
134     out[4].im = in[0].im + z0[3].im;
135 }
136
137 static void fft15_c(FFTComplex *out, FFTComplex *in, FFTComplex *exptab, ptrdiff_t stride)
138 {
139     int k;
140     FFTComplex tmp1[5], tmp2[5], tmp3[5];
141
142     fft5(tmp1, in + 0, exptab + 19);
143     fft5(tmp2, in + 1, exptab + 19);
144     fft5(tmp3, in + 2, exptab + 19);
145
146     for (k = 0; k < 5; k++) {
147         FFTComplex t[2];
148
149         CMUL3(t[0], tmp2[k], exptab[k]);
150         CMUL3(t[1], tmp3[k], exptab[2 * k]);
151         out[stride*k].re = tmp1[k].re + t[0].re + t[1].re;
152         out[stride*k].im = tmp1[k].im + t[0].im + t[1].im;
153
154         CMUL3(t[0], tmp2[k], exptab[k + 5]);
155         CMUL3(t[1], tmp3[k], exptab[2 * (k + 5)]);
156         out[stride*(k + 5)].re = tmp1[k].re + t[0].re + t[1].re;
157         out[stride*(k + 5)].im = tmp1[k].im + t[0].im + t[1].im;
158
159         CMUL3(t[0], tmp2[k], exptab[k + 10]);
160         CMUL3(t[1], tmp3[k], exptab[2 * k + 5]);
161         out[stride*(k + 10)].re = tmp1[k].re + t[0].re + t[1].re;
162         out[stride*(k + 10)].im = tmp1[k].im + t[0].im + t[1].im;
163     }
164 }
165
166 static void mdct15(MDCT15Context *s, float *dst, const float *src, ptrdiff_t stride)
167 {
168     int i, j;
169     const int len4 = s->len4, len3 = len4 * 3, len8 = len4 >> 1;
170     const int l_ptwo = 1 << s->ptwo_fft.nbits;
171     FFTComplex fft15in[15];
172
173     /* Folding and pre-reindexing */
174     for (i = 0; i < l_ptwo; i++) {
175         for (j = 0; j < 15; j++) {
176             float re, im;
177             const int k = s->pfa_prereindex[i*15 + j];
178             if (k < len8) {
179                 re = -src[2*k+len3] - src[len3-1-2*k];
180                 im = -src[len4+2*k] + src[len4-1-2*k];
181             } else {
182                 re =  src[2*k-len4] - src[1*len3-1-2*k];
183                 im = -src[2*k+len4] - src[5*len4-1-2*k];
184             }
185             CMUL(fft15in[j].re, fft15in[j].im, re, im, s->twiddle_exptab[k].re, -s->twiddle_exptab[k].im);
186         }
187         s->fft15(s->tmp + s->ptwo_fft.revtab[i], fft15in, s->exptab, l_ptwo);
188     }
189
190     /* Then a 15xN FFT (where N is a power of two) */
191     for (i = 0; i < 15; i++)
192         s->ptwo_fft.fft_calc(&s->ptwo_fft, s->tmp + l_ptwo*i);
193
194     /* Reindex again, apply twiddles and output */
195     for (i = 0; i < len8; i++) {
196         float re0, im0, re1, im1;
197         const int i0 = len8 + i, i1 = len8 - i - 1;
198         const int s0 = s->pfa_postreindex[i0], s1 = s->pfa_postreindex[i1];
199
200         CMUL(im1, re0, s->tmp[s1].re, s->tmp[s1].im, s->twiddle_exptab[i1].im, s->twiddle_exptab[i1].re);
201         CMUL(im0, re1, s->tmp[s0].re, s->tmp[s0].im, s->twiddle_exptab[i0].im, s->twiddle_exptab[i0].re);
202         dst[2*i1*stride         ] = re0;
203         dst[2*i1*stride + stride] = im0;
204         dst[2*i0*stride         ] = re1;
205         dst[2*i0*stride + stride] = im1;
206     }
207 }
208
209 static void imdct15_half(MDCT15Context *s, float *dst, const float *src,
210                          ptrdiff_t stride)
211 {
212     FFTComplex fft15in[15];
213     FFTComplex *z = (FFTComplex *)dst;
214     int i, j, len8 = s->len4 >> 1, l_ptwo = 1 << s->ptwo_fft.nbits;
215     const float *in1 = src, *in2 = src + (s->len2 - 1) * stride;
216
217     /* Reindex input, putting it into a buffer and doing an Nx15 FFT */
218     for (i = 0; i < l_ptwo; i++) {
219         for (j = 0; j < 15; j++) {
220             const int k = s->pfa_prereindex[i*15 + j];
221             FFTComplex tmp = { *(in2 - 2*k*stride), *(in1 + 2*k*stride) };
222             CMUL3(fft15in[j], tmp, s->twiddle_exptab[k]);
223         }
224         s->fft15(s->tmp + s->ptwo_fft.revtab[i], fft15in, s->exptab, l_ptwo);
225     }
226
227     /* Then a 15xN FFT (where N is a power of two) */
228     for (i = 0; i < 15; i++)
229         s->ptwo_fft.fft_calc(&s->ptwo_fft, s->tmp + l_ptwo*i);
230
231     /* Reindex again, apply twiddles and output */
232     for (i = 0; i < len8; i++) {
233         const int i0 = len8 + i, i1 = len8 - i - 1;
234         const int s0 = s->pfa_postreindex[i0], s1 = s->pfa_postreindex[i1];
235
236         CMUL(z[i1].re, z[i0].im, s->tmp[s1].im, s->tmp[s1].re,  s->twiddle_exptab[i1].im, s->twiddle_exptab[i1].re);
237         CMUL(z[i0].re, z[i1].im, s->tmp[s0].im, s->tmp[s0].re,  s->twiddle_exptab[i0].im, s->twiddle_exptab[i0].re);
238     }
239 }
240
241 av_cold int ff_mdct15_init(MDCT15Context **ps, int inverse, int N, double scale)
242 {
243     MDCT15Context *s;
244     double alpha, theta;
245     int len2 = 15 * (1 << N);
246     int len  = 2 * len2;
247     int i;
248
249     /* Tested and verified to work on everything in between */
250     if ((N < 2) || (N > 13))
251         return AVERROR(EINVAL);
252
253     s = av_mallocz(sizeof(*s));
254     if (!s)
255         return AVERROR(ENOMEM);
256
257     s->fft_n      = N - 1;
258     s->len4       = len2 / 2;
259     s->len2       = len2;
260     s->inverse    = inverse;
261     s->fft15      = fft15_c;
262     s->mdct       = mdct15;
263     s->imdct_half = imdct15_half;
264
265     if (ff_fft_init(&s->ptwo_fft, N - 1, s->inverse) < 0)
266         goto fail;
267
268     if (init_pfa_reindex_tabs(s))
269         goto fail;
270
271     s->tmp  = av_malloc_array(len, 2 * sizeof(*s->tmp));
272     if (!s->tmp)
273         goto fail;
274
275     s->twiddle_exptab  = av_malloc_array(s->len4, sizeof(*s->twiddle_exptab));
276     if (!s->twiddle_exptab)
277         goto fail;
278
279     theta = 0.125f + (scale < 0 ? s->len4 : 0);
280     scale = sqrt(fabs(scale));
281     for (i = 0; i < s->len4; i++) {
282         alpha = 2 * M_PI * (i + theta) / len;
283         s->twiddle_exptab[i].re = cosf(alpha) * scale;
284         s->twiddle_exptab[i].im = sinf(alpha) * scale;
285     }
286
287     /* 15-point FFT exptab */
288     for (i = 0; i < 19; i++) {
289         if (i < 15) {
290             double theta = (2.0f * M_PI * i) / 15.0f;
291             if (!s->inverse)
292                 theta *= -1;
293             s->exptab[i].re = cosf(theta);
294             s->exptab[i].im = sinf(theta);
295         } else { /* Wrap around to simplify fft15 */
296             s->exptab[i] = s->exptab[i - 15];
297         }
298     }
299
300     /* 5-point FFT exptab */
301     s->exptab[19].re = cosf(2.0f * M_PI / 5.0f);
302     s->exptab[19].im = sinf(2.0f * M_PI / 5.0f);
303     s->exptab[20].re = cosf(1.0f * M_PI / 5.0f);
304     s->exptab[20].im = sinf(1.0f * M_PI / 5.0f);
305
306     /* Invert the phase for an inverse transform, do nothing for a forward transform */
307     if (s->inverse) {
308         s->exptab[19].im *= -1;
309         s->exptab[20].im *= -1;
310     }
311
312     if (ARCH_X86)
313         ff_mdct15_init_x86(s);
314
315     *ps = s;
316
317     return 0;
318
319 fail:
320     ff_mdct15_uninit(&s);
321     return AVERROR(ENOMEM);
322 }