LCOV - code coverage report
Current view: top level - libavcodec - mdct_template.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 90 101 89.1 %
Date: 2017-12-17 04:34:43 Functions: 15 15 100.0 %

          Line data    Source code
       1             : /*
       2             :  * MDCT/IMDCT transforms
       3             :  * Copyright (c) 2002 Fabrice Bellard
       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 <stdlib.h>
      23             : #include <string.h>
      24             : #include "libavutil/common.h"
      25             : #include "libavutil/libm.h"
      26             : #include "libavutil/mathematics.h"
      27             : #include "fft.h"
      28             : #include "fft-internal.h"
      29             : 
      30             : /**
      31             :  * @file
      32             :  * MDCT/IMDCT transforms.
      33             :  */
      34             : 
      35             : #if FFT_FLOAT
      36             : #   define RSCALE(x, y) ((x) + (y))
      37             : #else
      38             : #if FFT_FIXED_32
      39             : #   define RSCALE(x, y) ((int)((x) + (unsigned)(y) + 32) >> 6)
      40             : #else /* FFT_FIXED_32 */
      41             : #   define RSCALE(x, y) ((int)((x) + (unsigned)(y)) >> 1)
      42             : #endif /* FFT_FIXED_32 */
      43             : #endif
      44             : 
      45             : /**
      46             :  * init MDCT or IMDCT computation.
      47             :  */
      48        2394 : av_cold int ff_mdct_init(FFTContext *s, int nbits, int inverse, double scale)
      49             : {
      50             :     int n, n4, i;
      51             :     double alpha, theta;
      52             :     int tstep;
      53             : 
      54        2394 :     memset(s, 0, sizeof(*s));
      55        2394 :     n = 1 << nbits;
      56        2394 :     s->mdct_bits = nbits;
      57        2394 :     s->mdct_size = n;
      58        2394 :     n4 = n >> 2;
      59        2394 :     s->mdct_permutation = FF_MDCT_PERM_NONE;
      60             : 
      61        2394 :     if (ff_fft_init(s, s->mdct_bits - 2, inverse) < 0)
      62           0 :         goto fail;
      63             : 
      64        2394 :     s->tcos = av_malloc_array(n/2, sizeof(FFTSample));
      65        2394 :     if (!s->tcos)
      66           0 :         goto fail;
      67             : 
      68        2394 :     switch (s->mdct_permutation) {
      69        2394 :     case FF_MDCT_PERM_NONE:
      70        2394 :         s->tsin = s->tcos + n4;
      71        2394 :         tstep = 1;
      72        2394 :         break;
      73           0 :     case FF_MDCT_PERM_INTERLEAVE:
      74           0 :         s->tsin = s->tcos + 1;
      75           0 :         tstep = 2;
      76           0 :         break;
      77           0 :     default:
      78           0 :         goto fail;
      79             :     }
      80             : 
      81        2394 :     theta = 1.0 / 8.0 + (scale < 0 ? n4 : 0);
      82        2394 :     scale = sqrt(fabs(scale));
      83      545230 :     for(i=0;i<n4;i++) {
      84      542836 :         alpha = 2 * M_PI * (i + theta) / n;
      85             : #if FFT_FIXED_32
      86       30332 :         s->tcos[i*tstep] = lrint(-cos(alpha) * 2147483648.0);
      87       30332 :         s->tsin[i*tstep] = lrint(-sin(alpha) * 2147483648.0);
      88             : #else
      89      512504 :         s->tcos[i*tstep] = FIX15(-cos(alpha) * scale);
      90      512504 :         s->tsin[i*tstep] = FIX15(-sin(alpha) * scale);
      91             : #endif
      92             :     }
      93        2394 :     return 0;
      94           0 :  fail:
      95           0 :     ff_mdct_end(s);
      96           0 :     return -1;
      97             : }
      98             : 
      99             : /**
     100             :  * Compute the middle half of the inverse MDCT of size N = 2^nbits,
     101             :  * thus excluding the parts that can be derived by symmetry
     102             :  * @param output N/2 samples
     103             :  * @param input N/2 samples
     104             :  */
     105     2319892 : void ff_imdct_half_c(FFTContext *s, FFTSample *output, const FFTSample *input)
     106             : {
     107             :     int k, n8, n4, n2, n, j;
     108     2319892 :     const uint16_t *revtab = s->revtab;
     109     2319892 :     const FFTSample *tcos = s->tcos;
     110     2319892 :     const FFTSample *tsin = s->tsin;
     111             :     const FFTSample *in1, *in2;
     112     2319892 :     FFTComplex *z = (FFTComplex *)output;
     113             : 
     114     2319892 :     n = 1 << s->mdct_bits;
     115     2319892 :     n2 = n >> 1;
     116     2319892 :     n4 = n >> 2;
     117     2319892 :     n8 = n >> 3;
     118             : 
     119             :     /* pre rotation */
     120     2319892 :     in1 = input;
     121     2319892 :     in2 = input + n2 - 1;
     122   117205764 :     for(k = 0; k < n4; k++) {
     123   114885872 :         j=revtab[k];
     124   114885872 :         CMUL(z[j].re, z[j].im, *in2, *in1, tcos[k], tsin[k]);
     125   114885872 :         in1 += 2;
     126   114885872 :         in2 -= 2;
     127             :     }
     128     2319892 :     s->fft_calc(s, z);
     129             : 
     130             :     /* post rotation + reordering */
     131    59762828 :     for(k = 0; k < n8; k++) {
     132             :         FFTSample r0, i0, r1, i1;
     133    57442936 :         CMUL(r0, i1, z[n8-k-1].im, z[n8-k-1].re, tsin[n8-k-1], tcos[n8-k-1]);
     134    57442936 :         CMUL(r1, i0, z[n8+k  ].im, z[n8+k  ].re, tsin[n8+k  ], tcos[n8+k  ]);
     135    57442936 :         z[n8-k-1].re = r0;
     136    57442936 :         z[n8-k-1].im = i0;
     137    57442936 :         z[n8+k  ].re = r1;
     138    57442936 :         z[n8+k  ].im = i1;
     139             :     }
     140     2319892 : }
     141             : 
     142             : /**
     143             :  * Compute inverse MDCT of size N = 2^nbits
     144             :  * @param output N samples
     145             :  * @param input N/2 samples
     146             :  */
     147       25808 : void ff_imdct_calc_c(FFTContext *s, FFTSample *output, const FFTSample *input)
     148             : {
     149             :     int k;
     150       25808 :     int n = 1 << s->mdct_bits;
     151       25808 :     int n2 = n >> 1;
     152       25808 :     int n4 = n >> 2;
     153             : 
     154       25808 :     ff_imdct_half_c(s, output+n4, input);
     155             : 
     156     2864832 :     for(k = 0; k < n4; k++) {
     157     2839024 :         output[k] = -output[n2-k-1];
     158     2839024 :         output[n-k-1] = output[n2+k];
     159             :     }
     160       25808 : }
     161             : 
     162             : /**
     163             :  * Compute MDCT of size N = 2^nbits
     164             :  * @param input N samples
     165             :  * @param out N/2 samples
     166             :  */
     167       19964 : void ff_mdct_calc_c(FFTContext *s, FFTSample *out, const FFTSample *input)
     168             : {
     169             :     int i, j, n, n8, n4, n2, n3;
     170             :     FFTDouble re, im;
     171       19964 :     const uint16_t *revtab = s->revtab;
     172       19964 :     const FFTSample *tcos = s->tcos;
     173       19964 :     const FFTSample *tsin = s->tsin;
     174       19964 :     FFTComplex *x = (FFTComplex *)out;
     175             : 
     176       19964 :     n = 1 << s->mdct_bits;
     177       19964 :     n2 = n >> 1;
     178       19964 :     n4 = n >> 2;
     179       19964 :     n8 = n >> 3;
     180       19964 :     n3 = 3 * n4;
     181             : 
     182             :     /* pre rotation */
     183     3587830 :     for(i=0;i<n8;i++) {
     184     3567866 :         re = RSCALE(-input[2*i+n3], - input[n3-1-2*i]);
     185     3567866 :         im = RSCALE(-input[n4+2*i], + input[n4-1-2*i]);
     186     3567866 :         j = revtab[i];
     187     3567866 :         CMUL(x[j].re, x[j].im, re, im, -tcos[i], tsin[i]);
     188             : 
     189     3567866 :         re = RSCALE( input[2*i]   , - input[n2-1-2*i]);
     190     3567866 :         im = RSCALE(-input[n2+2*i], - input[ n-1-2*i]);
     191     3567866 :         j = revtab[n8 + i];
     192     3567866 :         CMUL(x[j].re, x[j].im, re, im, -tcos[n8 + i], tsin[n8 + i]);
     193             :     }
     194             : 
     195       19964 :     s->fft_calc(s, x);
     196             : 
     197             :     /* post rotation */
     198     3587830 :     for(i=0;i<n8;i++) {
     199             :         FFTSample r0, i0, r1, i1;
     200     3567866 :         CMUL(i1, r0, x[n8-i-1].re, x[n8-i-1].im, -tsin[n8-i-1], -tcos[n8-i-1]);
     201     3567866 :         CMUL(i0, r1, x[n8+i  ].re, x[n8+i  ].im, -tsin[n8+i  ], -tcos[n8+i  ]);
     202     3567866 :         x[n8-i-1].re = r0;
     203     3567866 :         x[n8-i-1].im = i0;
     204     3567866 :         x[n8+i  ].re = r1;
     205     3567866 :         x[n8+i  ].im = i1;
     206             :     }
     207       19964 : }
     208             : 
     209        2485 : av_cold void ff_mdct_end(FFTContext *s)
     210             : {
     211        2485 :     av_freep(&s->tcos);
     212        2485 :     ff_fft_end(s);
     213        2485 : }

Generated by: LCOV version 1.13