LCOV - code coverage report
Current view: top level - src/libavcodec - ac3dsp.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 158 167 94.6 %
Date: 2017-01-23 11:54:22 Functions: 15 15 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       64339 : 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       64339 :     if (snr_offset == -960) {
     115           0 :         memset(bap, 0, AC3_MAX_COEFS);
     116           0 :         return;
     117             :     }
     118             : 
     119       64339 :     bin  = start;
     120       64339 :     band = ff_ac3_bin_to_band_tab[start];
     121             :     do {
     122     2100770 :         int m = (FFMAX(mask[band] - snr_offset - floor, 0) & 0x1FE0) + floor;
     123     2100770 :         band_end = ff_ac3_band_start_tab[++band];
     124     2100770 :         band_end = FFMIN(band_end, end);
     125             : 
     126    10199093 :         for (; bin < band_end; bin++) {
     127     8098323 :             int address = av_clip_uintp2((psd[bin] - m) >> 5, 6);
     128     8098323 :             bap[bin] = bap_tab[address];
     129             :         }
     130     2100770 :     } 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        1436 : static void ac3_downmix_c(float **samples, float (*matrix)[2],
     217             :                           int out_ch, int in_ch, int len)
     218             : {
     219             :     int i, j;
     220             :     float v0, v1;
     221        1436 :     if (out_ch == 2) {
     222      183627 :         for (i = 0; i < len; i++) {
     223      182912 :             v0 = v1 = 0.0f;
     224     1000576 :             for (j = 0; j < in_ch; j++) {
     225      817664 :                 v0 += samples[j][i] * matrix[j][0];
     226      817664 :                 v1 += samples[j][i] * matrix[j][1];
     227             :             }
     228      182912 :             samples[0][i] = v0;
     229      182912 :             samples[1][i] = v1;
     230             :         }
     231         721 :     } else if (out_ch == 1) {
     232      185169 :         for (i = 0; i < len; i++) {
     233      184448 :             v0 = 0.0f;
     234     1008256 :             for (j = 0; j < in_ch; j++)
     235      823808 :                 v0 += samples[j][i] * matrix[j][0];
     236      184448 :             samples[0][i] = v0;
     237             :         }
     238             :     }
     239        1436 : }
     240             : 
     241         372 : static void ac3_downmix_c_fixed(int32_t **samples, int16_t (*matrix)[2],
     242             :                                 int out_ch, int in_ch, int len)
     243             : {
     244             :     int i, j;
     245             :     int64_t v0, v1;
     246         372 :     if (out_ch == 2) {
     247           0 :         for (i = 0; i < len; i++) {
     248           0 :             v0 = v1 = 0;
     249           0 :             for (j = 0; j < in_ch; j++) {
     250           0 :                 v0 += (int64_t)samples[j][i] * matrix[j][0];
     251           0 :                 v1 += (int64_t)samples[j][i] * matrix[j][1];
     252             :             }
     253           0 :             samples[0][i] = (v0+2048)>>12;
     254           0 :             samples[1][i] = (v1+2048)>>12;
     255             :         }
     256         372 :     } else if (out_ch == 1) {
     257       95476 :         for (i = 0; i < len; i++) {
     258       95104 :             v0 = 0;
     259      475520 :             for (j = 0; j < in_ch; j++)
     260      380416 :                 v0 += (int64_t)samples[j][i] * matrix[j][0];
     261       95104 :             samples[0][i] = (v0+2048)>>12;
     262             :         }
     263             :     }
     264         372 : }
     265             : 
     266        4320 : static void apply_window_int16_c(int16_t *output, const int16_t *input,
     267             :                                  const int16_t *window, unsigned int len)
     268             : {
     269             :     int i;
     270        4320 :     int len2 = len >> 1;
     271             : 
     272     1110240 :     for (i = 0; i < len2; i++) {
     273     1105920 :         int16_t w       = window[i];
     274     1105920 :         output[i]       = (MUL16(input[i],       w) + (1 << 14)) >> 15;
     275     1105920 :         output[len-i-1] = (MUL16(input[len-i-1], w) + (1 << 14)) >> 15;
     276             :     }
     277        4320 : }
     278             : 
     279          41 : av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
     280             : {
     281          41 :     c->ac3_exponent_min = ac3_exponent_min_c;
     282          41 :     c->ac3_max_msb_abs_int16 = ac3_max_msb_abs_int16_c;
     283          41 :     c->ac3_lshift_int16 = ac3_lshift_int16_c;
     284          41 :     c->ac3_rshift_int32 = ac3_rshift_int32_c;
     285          41 :     c->float_to_fixed24 = float_to_fixed24_c;
     286          41 :     c->bit_alloc_calc_bap = ac3_bit_alloc_calc_bap_c;
     287          41 :     c->update_bap_counts = ac3_update_bap_counts_c;
     288          41 :     c->compute_mantissa_size = ac3_compute_mantissa_size_c;
     289          41 :     c->extract_exponents = ac3_extract_exponents_c;
     290          41 :     c->sum_square_butterfly_int32 = ac3_sum_square_butterfly_int32_c;
     291          41 :     c->sum_square_butterfly_float = ac3_sum_square_butterfly_float_c;
     292          41 :     c->downmix = ac3_downmix_c;
     293          41 :     c->downmix_fixed = ac3_downmix_c_fixed;
     294          41 :     c->apply_window_int16 = apply_window_int16_c;
     295             : 
     296             :     if (ARCH_ARM)
     297             :         ff_ac3dsp_init_arm(c, bit_exact);
     298             :     if (ARCH_X86)
     299          41 :         ff_ac3dsp_init_x86(c, bit_exact);
     300             :     if (ARCH_MIPS)
     301             :         ff_ac3dsp_init_mips(c, bit_exact);
     302          41 : }

Generated by: LCOV version 1.12