git.sesse.net Git - ffmpeg/blob - libavcodec/imdct15.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 "imdct15.h"
  37
  38 // complex c = a * b
  39 #define CMUL3(cre, cim, are, aim, bre, bim)          \
  40 do {                                                 \
  41     cre = are * bre - aim * bim;                     \
  42     cim = are * bim + aim * bre;                     \
  43 } while (0)
  44
  45 #define CMUL(c, a, b) CMUL3((c).re, (c).im, (a).re, (a).im, (b).re, (b).im)
  46
  47 av_cold void ff_imdct15_uninit(IMDCT15Context **ps)
  48 {
  49     IMDCT15Context *s = *ps;
  50
  51     if (!s)
  52         return;
  53
  54     ff_fft_end(&s->ptwo_fft);
  55
  56     av_freep(&s->pfa_prereindex);
  57     av_freep(&s->pfa_postreindex);
  58     av_freep(&s->twiddle_exptab);
  59     av_freep(&s->tmp);
  60
  61     av_freep(ps);
  62 }
  63
  64 static void imdct15_half(IMDCT15Context *s, float *dst, const float *src,
  65                          ptrdiff_t stride, float scale);
  66
  67 static inline int init_pfa_reindex_tabs(IMDCT15Context *s)
  68 {
  69     int i, j;
  70     const int b_ptwo = s->ptwo_fft.nbits; /* Bits for the power of two FFTs */
  71     const int l_ptwo = 1 << b_ptwo; /* Total length for the power of two FFTs */
  72     const int inv_1 = l_ptwo << ((4 - b_ptwo) & 3); /* (2^b_ptwo)^-1 mod 15 */
  73     const int inv_2 = 0xeeeeeeef & ((1U << b_ptwo) - 1); /* 15^-1 mod 2^b_ptwo */
  74
  75     s->pfa_prereindex = av_malloc(15 * l_ptwo * sizeof(*s->pfa_prereindex));
  76     if (!s->pfa_prereindex)
  77         return 1;
  78
  79     s->pfa_postreindex = av_malloc(15 * l_ptwo * sizeof(*s->pfa_postreindex));
  80     if (!s->pfa_postreindex)
  81         return 1;
  82
  83     /* Pre/Post-reindex */
  84     for (i = 0; i < l_ptwo; i++) {
  85         for (j = 0; j < 15; j++) {
  86             const int q_pre = ((l_ptwo * j)/15 + i) >> b_ptwo;
  87             const int q_post = (((j*inv_1)/15) + (i*inv_2)) >> b_ptwo;
  88             const int k_pre = 15*i + (j - q_pre*15)*l_ptwo;
  89             const int k_post = i*inv_2*15 + j*inv_1 - 15*q_post*l_ptwo;
  90             s->pfa_prereindex[i*15 + j] = k_pre;
  91             s->pfa_postreindex[k_post] = l_ptwo*j + i;
  92         }
  93     }
  94
  95     return 0;
  96 }
  97
  98 av_cold int ff_imdct15_init(IMDCT15Context **ps, int N)
  99 {
 100     IMDCT15Context *s;
 101     int len2 = 15 * (1 << N);
 102     int len  = 2 * len2;
 103     int i;
 104
 105     /* Tested and verified to work on everything in between */
 106     if ((N < 2) || (N > 13))
 107         return AVERROR(EINVAL);
 108
 109     s = av_mallocz(sizeof(*s));
 110     if (!s)
 111         return AVERROR(ENOMEM);
 112
 113     s->fft_n = N - 1;
 114     s->len4 = len2 / 2;
 115     s->len2 = len2;
 116     s->imdct_half = imdct15_half;
 117
 118     if (ff_fft_init(&s->ptwo_fft, N - 1, 1) < 0)
 119         goto fail;
 120
 121     if (init_pfa_reindex_tabs(s))
 122         goto fail;
 123
 124     s->tmp  = av_malloc_array(len, 2 * sizeof(*s->tmp));
 125     if (!s->tmp)
 126         goto fail;
 127
 128     s->twiddle_exptab  = av_malloc_array(s->len4, sizeof(*s->twiddle_exptab));
 129     if (!s->twiddle_exptab)
 130         goto fail;
 131
 132     for (i = 0; i < s->len4; i++) {
 133         s->twiddle_exptab[i].re = cos(2 * M_PI * (i + 0.125f + s->len4) / len);
 134         s->twiddle_exptab[i].im = sin(2 * M_PI * (i + 0.125f + s->len4) / len);
 135     }
 136
 137     /* 15-point FFT exptab */
 138     for (i = 0; i < 19; i++) {
 139         if (i < 15) {
 140             double theta = (2.0f * M_PI * i) / 15.0f;
 141             s->exptab[i].re = cos(theta);
 142             s->exptab[i].im = sin(theta);
 143         } else { /* Wrap around to simplify fft15 */
 144             s->exptab[i] = s->exptab[i - 15];
 145         }
 146     }
 147
 148     /* 5-point FFT exptab */
 149     s->exptab[19].re = cos(2.0f * M_PI / 5.0f);
 150     s->exptab[19].im = sin(2.0f * M_PI / 5.0f);
 151     s->exptab[20].re = cos(1.0f * M_PI / 5.0f);
 152     s->exptab[20].im = sin(1.0f * M_PI / 5.0f);
 153
 154     /* Invert the phase for an inverse transform, do nothing for a forward transform */
 155     s->exptab[19].im *= -1;
 156     s->exptab[20].im *= -1;
 157
 158     *ps = s;
 159
 160     return 0;
 161
 162 fail:
 163     ff_imdct15_uninit(&s);
 164     return AVERROR(ENOMEM);
 165 }
 166
 167 /* Stride is hardcoded to 3 */
 168 static inline void fft5(const FFTComplex exptab[2], FFTComplex *out,
 169                         const FFTComplex *in)
 170 {
 171     FFTComplex z0[4], t[6];
 172
 173     t[0].re = in[3].re + in[12].re;
 174     t[0].im = in[3].im + in[12].im;
 175     t[1].im = in[3].re - in[12].re;
 176     t[1].re = in[3].im - in[12].im;
 177     t[2].re = in[6].re + in[ 9].re;
 178     t[2].im = in[6].im + in[ 9].im;
 179     t[3].im = in[6].re - in[ 9].re;
 180     t[3].re = in[6].im - in[ 9].im;
 181
 182     out[0].re = in[0].re + in[3].re + in[6].re + in[9].re + in[12].re;
 183     out[0].im = in[0].im + in[3].im + in[6].im + in[9].im + in[12].im;
 184
 185     t[4].re = exptab[0].re * t[2].re - exptab[1].re * t[0].re;
 186     t[4].im = exptab[0].re * t[2].im - exptab[1].re * t[0].im;
 187     t[0].re = exptab[0].re * t[0].re - exptab[1].re * t[2].re;
 188     t[0].im = exptab[0].re * t[0].im - exptab[1].re * t[2].im;
 189     t[5].re = exptab[0].im * t[3].re - exptab[1].im * t[1].re;
 190     t[5].im = exptab[0].im * t[3].im - exptab[1].im * t[1].im;
 191     t[1].re = exptab[0].im * t[1].re + exptab[1].im * t[3].re;
 192     t[1].im = exptab[0].im * t[1].im + exptab[1].im * t[3].im;
 193
 194     z0[0].re = t[0].re - t[1].re;
 195     z0[0].im = t[0].im - t[1].im;
 196     z0[1].re = t[4].re + t[5].re;
 197     z0[1].im = t[4].im + t[5].im;
 198
 199     z0[2].re = t[4].re - t[5].re;
 200     z0[2].im = t[4].im - t[5].im;
 201     z0[3].re = t[0].re + t[1].re;
 202     z0[3].im = t[0].im + t[1].im;
 203
 204     out[1].re = in[0].re + z0[3].re;
 205     out[1].im = in[0].im + z0[0].im;
 206     out[2].re = in[0].re + z0[2].re;
 207     out[2].im = in[0].im + z0[1].im;
 208     out[3].re = in[0].re + z0[1].re;
 209     out[3].im = in[0].im + z0[2].im;
 210     out[4].re = in[0].re + z0[0].re;
 211     out[4].im = in[0].im + z0[3].im;
 212 }
 213
 214 static inline void fft15(const FFTComplex exptab[22], FFTComplex *out,
 215                          const FFTComplex *in, size_t stride)
 216 {
 217     int k;
 218     FFTComplex tmp1[5], tmp2[5], tmp3[5];
 219
 220     fft5(exptab + 19, tmp1, in + 0);
 221     fft5(exptab + 19, tmp2, in + 1);
 222     fft5(exptab + 19, tmp3, in + 2);
 223
 224     for (k = 0; k < 5; k++) {
 225         FFTComplex t[2];
 226
 227         CMUL(t[0], tmp2[k], exptab[k]);
 228         CMUL(t[1], tmp3[k], exptab[2 * k]);
 229         out[stride*k].re = tmp1[k].re + t[0].re + t[1].re;
 230         out[stride*k].im = tmp1[k].im + t[0].im + t[1].im;
 231
 232         CMUL(t[0], tmp2[k], exptab[k + 5]);
 233         CMUL(t[1], tmp3[k], exptab[2 * (k + 5)]);
 234         out[stride*(k + 5)].re = tmp1[k].re + t[0].re + t[1].re;
 235         out[stride*(k + 5)].im = tmp1[k].im + t[0].im + t[1].im;
 236
 237         CMUL(t[0], tmp2[k], exptab[k + 10]);
 238         CMUL(t[1], tmp3[k], exptab[2 * k + 5]);
 239         out[stride*(k + 10)].re = tmp1[k].re + t[0].re + t[1].re;
 240         out[stride*(k + 10)].im = tmp1[k].im + t[0].im + t[1].im;
 241     }
 242 }
 243
 244 static void imdct15_half(IMDCT15Context *s, float *dst, const float *src,
 245                          ptrdiff_t stride, float scale)
 246 {
 247     FFTComplex fft15in[15];
 248     FFTComplex *z = (FFTComplex *)dst;
 249     int i, j, len8 = s->len4 >> 1, l_ptwo = 1 << s->ptwo_fft.nbits;
 250     const float *in1 = src, *in2 = src + (s->len2 - 1) * stride;
 251
 252     /* Reindex input, putting it into a buffer and doing an Nx15 FFT */
 253     for (i = 0; i < l_ptwo; i++) {
 254         for (j = 0; j < 15; j++) {
 255             const int k = s->pfa_prereindex[i*15 + j];
 256             FFTComplex tmp = { *(in2 - 2*k*stride), *(in1 + 2*k*stride) };
 257             CMUL(fft15in[j], tmp, s->twiddle_exptab[k]);
 258         }
 259         fft15(s->exptab, s->tmp + s->ptwo_fft.revtab[i], fft15in, l_ptwo);
 260     }
 261
 262     /* Then a 15xN FFT (where N is a power of two) */
 263     for (i = 0; i < 15; i++)
 264         s->ptwo_fft.fft_calc(&s->ptwo_fft, s->tmp + l_ptwo*i);
 265
 266     /* Reindex again, apply twiddles and output */
 267     for (i = 0; i < len8; i++) {
 268         float re0, im0, re1, im1;
 269         const int i0 = len8 + i, i1 = len8 - i - 1;
 270         const int s0 = s->pfa_postreindex[i0], s1 = s->pfa_postreindex[i1];
 271
 272         CMUL3(re0, im1, s->tmp[s1].im, s->tmp[s1].re,  s->twiddle_exptab[i1].im, s->twiddle_exptab[i1].re);
 273         CMUL3(re1, im0, s->tmp[s0].im, s->tmp[s0].re,  s->twiddle_exptab[i0].im, s->twiddle_exptab[i0].re);
 274         z[i1].re = scale * re0;
 275         z[i1].im = scale * im0;
 276         z[i0].re = scale * re1;
 277         z[i0].im = scale * im1;
 278     }
 279 }