LCOV - code coverage report
Current view: top level - src/libavcodec - ac3dsp.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 251 260 96.5 %
Date: 2017-04-23 07:57:23 Functions: 21 21 100.0 %

          Line data    Source code
       1             : /*
       2             :  * AC-3 DSP functions
       3             :  * Copyright (c) 2011 Justin Ruggles
       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 "avcodec.h"
      23             : #include "ac3.h"
      24             : #include "ac3dsp.h"
      25             : #include "mathops.h"
      26             : 
      27        6382 : static void ac3_exponent_min_c(uint8_t *exp, int num_reuse_blocks, int nb_coefs)
      28             : {
      29             :     int blk, i;
      30             : 
      31        6382 :     if (!num_reuse_blocks)
      32        3991 :         return;
      33             : 
      34      614487 :     for (i = 0; i < nb_coefs; i++) {
      35      612096 :         uint8_t min_exp = *exp;
      36      612096 :         uint8_t *exp1 = exp + 256;
      37     2865920 :         for (blk = 0; blk < num_reuse_blocks; blk++) {
      38     2253824 :             uint8_t next_exp = *exp1;
      39     2253824 :             if (next_exp < min_exp)
      40      349729 :                 min_exp = next_exp;
      41     2253824 :             exp1 += 256;
      42             :         }
      43      612096 :         *exp++ = min_exp;
      44             :     }
      45             : }
      46             : 
      47        4320 : static int ac3_max_msb_abs_int16_c(const int16_t *src, int len)
      48             : {
      49        4320 :     int i, v = 0;
      50     2216160 :     for (i = 0; i < len; i++)
      51     2211840 :         v |= abs(src[i]);
      52        4320 :     return v;
      53             : }
      54             : 
      55        3972 : static void ac3_lshift_int16_c(int16_t *src, unsigned int len,
      56             :                                unsigned int shift)
      57             : {
      58        3972 :     uint32_t *src32 = (uint32_t *)src;
      59        3972 :     const uint32_t mask = ~(((1 << shift) - 1) << 16);
      60             :     int i;
      61        3972 :     len >>= 1;
      62      131076 :     for (i = 0; i < len; i += 8) {
      63      127104 :         src32[i  ] = (src32[i  ] << shift) & mask;
      64      127104 :         src32[i+1] = (src32[i+1] << shift) & mask;
      65      127104 :         src32[i+2] = (src32[i+2] << shift) & mask;
      66      127104 :         src32[i+3] = (src32[i+3] << shift) & mask;
      67      127104 :         src32[i+4] = (src32[i+4] << shift) & mask;
      68      127104 :         src32[i+5] = (src32[i+5] << shift) & mask;
      69      127104 :         src32[i+6] = (src32[i+6] << shift) & mask;
      70      127104 :         src32[i+7] = (src32[i+7] << shift) & mask;
      71             :     }
      72        3972 : }
      73             : 
      74      138240 : static void ac3_rshift_int32_c(int32_t *src, unsigned int len,
      75             :                                unsigned int shift)
      76             : {
      77             :     do {
      78      138240 :         *src++ >>= shift;
      79      138240 :         *src++ >>= shift;
      80      138240 :         *src++ >>= shift;
      81      138240 :         *src++ >>= shift;
      82      138240 :         *src++ >>= shift;
      83      138240 :         *src++ >>= shift;
      84      138240 :         *src++ >>= shift;
      85      138240 :         *src++ >>= shift;
      86      138240 :         len -= 8;
      87      138240 :     } while (len > 0);
      88        4320 : }
      89             : 
      90        3822 : static void float_to_fixed24_c(int32_t *dst, const float *src, unsigned int len)
      91             : {
      92        3822 :     const float scale = 1 << 24;
      93             :     do {
      94      327600 :         *dst++ = lrintf(*src++ * scale);
      95      327600 :         *dst++ = lrintf(*src++ * scale);
      96      327600 :         *dst++ = lrintf(*src++ * scale);
      97      327600 :         *dst++ = lrintf(*src++ * scale);
      98      327600 :         *dst++ = lrintf(*src++ * scale);
      99      327600 :         *dst++ = lrintf(*src++ * scale);
     100      327600 :         *dst++ = lrintf(*src++ * scale);
     101      327600 :         *dst++ = lrintf(*src++ * scale);
     102      327600 :         len -= 8;
     103      327600 :     } while (len > 0);
     104        3822 : }
     105             : 
     106       65453 : static void ac3_bit_alloc_calc_bap_c(int16_t *mask, int16_t *psd,
     107             :                                      int start, int end,
     108             :                                      int snr_offset, int floor,
     109             :                                      const uint8_t *bap_tab, uint8_t *bap)
     110             : {
     111             :     int bin, band, band_end;
     112             : 
     113             :     /* special case, if snr offset is -960, set all bap's to zero */
     114       65453 :     if (snr_offset == -960) {
     115           0 :         memset(bap, 0, AC3_MAX_COEFS);
     116           0 :         return;
     117             :     }
     118             : 
     119       65453 :     bin  = start;
     120       65453 :     band = ff_ac3_bin_to_band_tab[start];
     121             :     do {
     122     2135692 :         int m = (FFMAX(mask[band] - snr_offset - floor, 0) & 0x1FE0) + floor;
     123     2135692 :         band_end = ff_ac3_band_start_tab[++band];
     124     2135692 :         band_end = FFMIN(band_end, end);
     125             : 
     126    10365147 :         for (; bin < band_end; bin++) {
     127     8229455 :             int address = av_clip_uintp2((psd[bin] - m) >> 5, 6);
     128     8229455 :             bap[bin] = bap_tab[address];
     129             :         }
     130     2135692 :     } while (end > band_end);
     131             : }
     132             : 
     133      127518 : static void ac3_update_bap_counts_c(uint16_t mant_cnt[16], uint8_t *bap,
     134             :                                     int len)
     135             : {
     136    14007150 :     while (len-- > 0)
     137    13752114 :         mant_cnt[bap[len]]++;
     138      127518 : }
     139             : 
     140             : DECLARE_ALIGNED(16, const uint16_t, ff_ac3_bap_bits)[16] = {
     141             :     0,  0,  0,  3,  0,  4,  5,  6,  7,  8,  9, 10, 11, 12, 14, 16
     142             : };
     143             : 
     144        9313 : static int ac3_compute_mantissa_size_c(uint16_t mant_cnt[6][16])
     145             : {
     146             :     int blk, bap;
     147        9313 :     int bits = 0;
     148             : 
     149       65191 :     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
     150             :         // bap=1 : 3 mantissas in 5 bits
     151       55878 :         bits += (mant_cnt[blk][1] / 3) * 5;
     152             :         // bap=2 : 3 mantissas in 7 bits
     153             :         // bap=4 : 2 mantissas in 7 bits
     154       55878 :         bits += ((mant_cnt[blk][2] / 3) + (mant_cnt[blk][4] >> 1)) * 7;
     155             :         // bap=3 : 1 mantissa in 3 bits
     156       55878 :         bits += mant_cnt[blk][3] * 3;
     157             :         // bap=5 to 15 : get bits per mantissa from table
     158      670536 :         for (bap = 5; bap < 16; bap++)
     159      614658 :             bits += mant_cnt[blk][bap] * ff_ac3_bap_bits[bap];
     160             :     }
     161        9313 :     return bits;
     162             : }
     163             : 
     164        5407 : static void ac3_extract_exponents_c(uint8_t *exp, int32_t *coef, int nb_coefs)
     165             : {
     166             :     int i;
     167             : 
     168     4031071 :     for (i = 0; i < nb_coefs; i++) {
     169     4025664 :         int v = abs(coef[i]);
     170     4025664 :         exp[i] = v ? 23 - av_log2(v) : 24;
     171             :     }
     172        5407 : }
     173             : 
     174        4152 : static void ac3_sum_square_butterfly_int32_c(int64_t sum[4],
     175             :                                              const int32_t *coef0,
     176             :                                              const int32_t *coef1,
     177             :                                              int len)
     178             : {
     179             :     int i;
     180             : 
     181        4152 :     sum[0] = sum[1] = sum[2] = sum[3] = 0;
     182             : 
     183       91344 :     for (i = 0; i < len; i++) {
     184       87192 :         int lt = coef0[i];
     185       87192 :         int rt = coef1[i];
     186       87192 :         int md = lt + rt;
     187       87192 :         int sd = lt - rt;
     188       87192 :         MAC64(sum[0], lt, lt);
     189       87192 :         MAC64(sum[1], rt, rt);
     190       87192 :         MAC64(sum[2], md, md);
     191       87192 :         MAC64(sum[3], sd, sd);
     192             :     }
     193        4152 : }
     194             : 
     195       13104 : static void ac3_sum_square_butterfly_float_c(float sum[4],
     196             :                                              const float *coef0,
     197             :                                              const float *coef1,
     198             :                                              int len)
     199             : {
     200             :     int i;
     201             : 
     202       13104 :     sum[0] = sum[1] = sum[2] = sum[3] = 0;
     203             : 
     204      288288 :     for (i = 0; i < len; i++) {
     205      275184 :         float lt = coef0[i];
     206      275184 :         float rt = coef1[i];
     207      275184 :         float md = lt + rt;
     208      275184 :         float sd = lt - rt;
     209      275184 :         sum[0] += lt * lt;
     210      275184 :         sum[1] += rt * rt;
     211      275184 :         sum[2] += md * md;
     212      275184 :         sum[3] += sd * sd;
     213             :     }
     214       13104 : }
     215             : 
     216         342 : static void ac3_downmix_5_to_2_symmetric_c(float **samples, float **matrix,
     217             :                                            int len)
     218             : {
     219             :     int i;
     220             :     float v0, v1;
     221         342 :     float front_mix    = matrix[0][0];
     222         342 :     float center_mix   = matrix[0][1];
     223         342 :     float surround_mix = matrix[0][3];
     224             : 
     225       87894 :     for (i = 0; i < len; i++) {
     226      262656 :         v0 = samples[0][i] * front_mix  +
     227       87552 :              samples[1][i] * center_mix +
     228       87552 :              samples[3][i] * surround_mix;
     229             : 
     230      262656 :         v1 = samples[1][i] * center_mix +
     231       87552 :              samples[2][i] * front_mix  +
     232       87552 :              samples[4][i] * surround_mix;
     233             : 
     234       87552 :         samples[0][i] = v0;
     235       87552 :         samples[1][i] = v1;
     236             :     }
     237         342 : }
     238             : 
     239         342 : static void ac3_downmix_5_to_1_symmetric_c(float **samples, float **matrix,
     240             :                                            int len)
     241             : {
     242             :     int i;
     243         342 :     float front_mix    = matrix[0][0];
     244         342 :     float center_mix   = matrix[0][1];
     245         342 :     float surround_mix = matrix[0][3];
     246             : 
     247       87894 :     for (i = 0; i < len; i++) {
     248      262656 :         samples[0][i] = samples[0][i] * front_mix    +
     249      175104 :                         samples[1][i] * center_mix   +
     250      175104 :                         samples[2][i] * front_mix    +
     251      175104 :                         samples[3][i] * surround_mix +
     252       87552 :                         samples[4][i] * surround_mix;
     253             :     }
     254         342 : }
     255             : 
     256         764 : static void ac3_downmix_c(float **samples, float **matrix,
     257             :                           int out_ch, int in_ch, int len)
     258             : {
     259             :     int i, j;
     260             :     float v0, v1;
     261             : 
     262         764 :     if (out_ch == 2) {
     263       97275 :         for (i = 0; i < len; i++) {
     264       96896 :             v0 = v1 = 0.0f;
     265      484480 :             for (j = 0; j < in_ch; j++) {
     266      387584 :                 v0 += samples[j][i] * matrix[0][j];
     267      387584 :                 v1 += samples[j][i] * matrix[1][j];
     268             :             }
     269       96896 :             samples[0][i] = v0;
     270       96896 :             samples[1][i] = v1;
     271             :         }
     272         385 :     } else if (out_ch == 1) {
     273       98817 :         for (i = 0; i < len; i++) {
     274       98432 :             v0 = 0.0f;
     275      492160 :             for (j = 0; j < in_ch; j++)
     276      393728 :                 v0 += samples[j][i] * matrix[0][j];
     277       98432 :             samples[0][i] = v0;
     278             :         }
     279             :     }
     280         764 : }
     281             : 
     282         330 : static void ac3_downmix_5_to_2_symmetric_c_fixed(int32_t **samples, int16_t **matrix,
     283             :                                            int len)
     284             : {
     285             :     int i;
     286             :     int64_t v0, v1;
     287         330 :     int16_t front_mix    = matrix[0][0];
     288         330 :     int16_t center_mix   = matrix[0][1];
     289         330 :     int16_t surround_mix = matrix[0][3];
     290             : 
     291       84810 :     for (i = 0; i < len; i++) {
     292      253440 :         v0 = (int64_t)samples[0][i] * front_mix  +
     293       84480 :              (int64_t)samples[1][i] * center_mix +
     294       84480 :              (int64_t)samples[3][i] * surround_mix;
     295             : 
     296      253440 :         v1 = (int64_t)samples[1][i] * center_mix +
     297       84480 :              (int64_t)samples[2][i] * front_mix  +
     298       84480 :              (int64_t)samples[4][i] * surround_mix;
     299             : 
     300       84480 :         samples[0][i] = (v0+2048)>>12;
     301       84480 :         samples[1][i] = (v1+2048)>>12;
     302             :     }
     303         330 : }
     304             : 
     305         330 : static void ac3_downmix_5_to_1_symmetric_c_fixed(int32_t **samples, int16_t **matrix,
     306             :                                                  int len)
     307             : {
     308             :     int i;
     309             :     int64_t v0;
     310         330 :     int16_t front_mix    = matrix[0][0];
     311         330 :     int16_t center_mix   = matrix[0][1];
     312         330 :     int16_t surround_mix = matrix[0][3];
     313             : 
     314       84810 :     for (i = 0; i < len; i++) {
     315      253440 :         v0 = (int64_t)samples[0][i] * front_mix    +
     316      168960 :              (int64_t)samples[1][i] * center_mix   +
     317      168960 :              (int64_t)samples[2][i] * front_mix    +
     318       84480 :              (int64_t)samples[3][i] * surround_mix +
     319       84480 :              (int64_t)samples[4][i] * surround_mix;
     320             : 
     321       84480 :         samples[0][i] = (v0+2048)>>12;
     322             :     }
     323         330 : }
     324             : 
     325         372 : static void ac3_downmix_c_fixed(int32_t **samples, int16_t **matrix,
     326             :                                 int out_ch, int in_ch, int len)
     327             : {
     328             :     int i, j;
     329             :     int64_t v0, v1;
     330         372 :     if (out_ch == 2) {
     331           0 :         for (i = 0; i < len; i++) {
     332           0 :             v0 = v1 = 0;
     333           0 :             for (j = 0; j < in_ch; j++) {
     334           0 :                 v0 += (int64_t)samples[j][i] * matrix[0][j];
     335           0 :                 v1 += (int64_t)samples[j][i] * matrix[1][j];
     336             :             }
     337           0 :             samples[0][i] = (v0+2048)>>12;
     338           0 :             samples[1][i] = (v1+2048)>>12;
     339             :         }
     340         372 :     } else if (out_ch == 1) {
     341       95476 :         for (i = 0; i < len; i++) {
     342       95104 :             v0 = 0;
     343      475520 :             for (j = 0; j < in_ch; j++)
     344      380416 :                 v0 += (int64_t)samples[j][i] * matrix[0][j];
     345       95104 :             samples[0][i] = (v0+2048)>>12;
     346             :         }
     347             :     }
     348         372 : }
     349             : 
     350        1032 : void ff_ac3dsp_downmix_fixed(AC3DSPContext *c, int32_t **samples, int16_t **matrix,
     351             :                              int out_ch, int in_ch, int len)
     352             : {
     353        1032 :     if (c->in_channels != in_ch || c->out_channels != out_ch) {
     354           3 :         c->in_channels  = in_ch;
     355           3 :         c->out_channels = out_ch;
     356           3 :         c->downmix_fixed = NULL;
     357             : 
     358           4 :         if (in_ch == 5 && out_ch == 2 &&
     359           5 :             !(matrix[1][0] | matrix[0][2]  |
     360           2 :               matrix[1][3] | matrix[0][4]  |
     361           1 :              (matrix[0][1] ^ matrix[1][1]) |
     362           1 :              (matrix[0][0] ^ matrix[1][2]))) {
     363           1 :             c->downmix_fixed = ac3_downmix_5_to_2_symmetric_c_fixed;
     364           3 :         } else if (in_ch == 5 && out_ch == 1 &&
     365           2 :                    matrix[0][0] == matrix[0][2] &&
     366           1 :                    matrix[0][3] == matrix[0][4]) {
     367           1 :             c->downmix_fixed = ac3_downmix_5_to_1_symmetric_c_fixed;
     368             :         }
     369             :     }
     370             : 
     371        1032 :     if (c->downmix_fixed)
     372         660 :         c->downmix_fixed(samples, matrix, len);
     373             :     else
     374         372 :         ac3_downmix_c_fixed(samples, matrix, out_ch, in_ch, len);
     375        1032 : }
     376             : 
     377        4320 : static void apply_window_int16_c(int16_t *output, const int16_t *input,
     378             :                                  const int16_t *window, unsigned int len)
     379             : {
     380             :     int i;
     381        4320 :     int len2 = len >> 1;
     382             : 
     383     1110240 :     for (i = 0; i < len2; i++) {
     384     1105920 :         int16_t w       = window[i];
     385     1105920 :         output[i]       = (MUL16(input[i],       w) + (1 << 14)) >> 15;
     386     1105920 :         output[len-i-1] = (MUL16(input[len-i-1], w) + (1 << 14)) >> 15;
     387             :     }
     388        4320 : }
     389             : 
     390        1448 : void ff_ac3dsp_downmix(AC3DSPContext *c, float **samples, float **matrix,
     391             :                        int out_ch, int in_ch, int len)
     392             : {
     393        1448 :     if (c->in_channels != in_ch || c->out_channels != out_ch) {
     394          11 :         int **matrix_cmp = (int **)matrix;
     395             : 
     396          11 :         c->in_channels  = in_ch;
     397          11 :         c->out_channels = out_ch;
     398          11 :         c->downmix      = NULL;
     399             : 
     400          14 :         if (in_ch == 5 && out_ch == 2 &&
     401           6 :             !(matrix_cmp[1][0] | matrix_cmp[0][2]   |
     402           9 :               matrix_cmp[1][3] | matrix_cmp[0][4]   |
     403           6 :              (matrix_cmp[0][1] ^ matrix_cmp[1][1]) |
     404           3 :              (matrix_cmp[0][0] ^ matrix_cmp[1][2]))) {
     405           3 :             c->downmix = ac3_downmix_5_to_2_symmetric_c;
     406          11 :         } else if (in_ch == 5 && out_ch == 1 &&
     407           6 :                    matrix_cmp[0][0] == matrix_cmp[0][2] &&
     408           3 :                    matrix_cmp[0][3] == matrix_cmp[0][4]) {
     409           3 :             c->downmix = ac3_downmix_5_to_1_symmetric_c;
     410             :         }
     411             : 
     412             :         if (ARCH_X86)
     413          11 :             ff_ac3dsp_set_downmix_x86(c);
     414             :     }
     415             : 
     416        1448 :     if (c->downmix)
     417         684 :         c->downmix(samples, matrix, len);
     418             :     else
     419         764 :         ac3_downmix_c(samples, matrix, out_ch, in_ch, len);
     420        1448 : }
     421             : 
     422          45 : av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
     423             : {
     424          45 :     c->ac3_exponent_min = ac3_exponent_min_c;
     425          45 :     c->ac3_max_msb_abs_int16 = ac3_max_msb_abs_int16_c;
     426          45 :     c->ac3_lshift_int16 = ac3_lshift_int16_c;
     427          45 :     c->ac3_rshift_int32 = ac3_rshift_int32_c;
     428          45 :     c->float_to_fixed24 = float_to_fixed24_c;
     429          45 :     c->bit_alloc_calc_bap = ac3_bit_alloc_calc_bap_c;
     430          45 :     c->update_bap_counts = ac3_update_bap_counts_c;
     431          45 :     c->compute_mantissa_size = ac3_compute_mantissa_size_c;
     432          45 :     c->extract_exponents = ac3_extract_exponents_c;
     433          45 :     c->sum_square_butterfly_int32 = ac3_sum_square_butterfly_int32_c;
     434          45 :     c->sum_square_butterfly_float = ac3_sum_square_butterfly_float_c;
     435          45 :     c->in_channels           = 0;
     436          45 :     c->out_channels          = 0;
     437          45 :     c->downmix               = NULL;
     438          45 :     c->downmix_fixed         = NULL;
     439          45 :     c->apply_window_int16 = apply_window_int16_c;
     440             : 
     441             :     if (ARCH_ARM)
     442             :         ff_ac3dsp_init_arm(c, bit_exact);
     443             :     if (ARCH_X86)
     444          45 :         ff_ac3dsp_init_x86(c, bit_exact);
     445             :     if (ARCH_MIPS)
     446             :         ff_ac3dsp_init_mips(c, bit_exact);
     447          45 : }

Generated by: LCOV version 1.13