LCOV - code coverage report
Current view: top level - src/libavcodec - ac3.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 69 82 84.1 %
Date: 2017-06-24 07:01:58 Functions: 4 4 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Common code between the AC-3 encoder and decoder
       3             :  * Copyright (c) 2000 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             : /**
      23             :  * @file
      24             :  * Common code between the AC-3 encoder and decoder.
      25             :  */
      26             : 
      27             : #include "libavutil/common.h"
      28             : 
      29             : #include "avcodec.h"
      30             : #include "ac3.h"
      31             : 
      32             : /**
      33             :  * Starting frequency coefficient bin for each critical band.
      34             :  */
      35             : const uint8_t ff_ac3_band_start_tab[AC3_CRITICAL_BANDS+1] = {
      36             :       0,  1,   2,   3,   4,   5,   6,   7,   8,   9,
      37             :      10,  11, 12,  13,  14,  15,  16,  17,  18,  19,
      38             :      20,  21, 22,  23,  24,  25,  26,  27,  28,  31,
      39             :      34,  37, 40,  43,  46,  49,  55,  61,  67,  73,
      40             :      79,  85, 97, 109, 121, 133, 157, 181, 205, 229, 253
      41             : };
      42             : 
      43             : /**
      44             :  * Map each frequency coefficient bin to the critical band that contains it.
      45             :  */
      46             : const uint8_t ff_ac3_bin_to_band_tab[253] = {
      47             :      0,
      48             :      1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12,
      49             :     13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
      50             :     25, 26, 27, 28, 28, 28, 29, 29, 29, 30, 30, 30,
      51             :     31, 31, 31, 32, 32, 32, 33, 33, 33, 34, 34, 34,
      52             :     35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36,
      53             :     37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38,
      54             :     39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40,
      55             :     41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
      56             :     42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
      57             :     43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
      58             :     44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
      59             :     45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
      60             :     45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
      61             :     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
      62             :     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
      63             :     47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
      64             :     47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
      65             :     48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
      66             :     48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
      67             :     49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
      68             :     49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49
      69             : };
      70             : 
      71      254780 : static inline int calc_lowcomp1(int a, int b0, int b1, int c)
      72             : {
      73      254780 :     if ((b0 + 256) == b1) {
      74       14656 :         a = c;
      75      240124 :     } else if (b0 > b1) {
      76       68507 :         a = FFMAX(a - 64, 0);
      77             :     }
      78      254780 :     return a;
      79             : }
      80             : 
      81      230980 : static inline int calc_lowcomp(int a, int b0, int b1, int bin)
      82             : {
      83      230980 :     if (bin < 7) {
      84       41920 :         return calc_lowcomp1(a, b0, b1, 384);
      85      189060 :     } else if (bin < 20) {
      86      163852 :         return calc_lowcomp1(a, b0, b1, 320);
      87             :     } else {
      88       25208 :         return FFMAX(a - 128, 0);
      89             :     }
      90             : }
      91             : 
      92       17454 : void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd,
      93             :                                int16_t *band_psd)
      94             : {
      95             :     int bin, band;
      96             : 
      97             :     /* exponent mapping to PSD */
      98     2221247 :     for (bin = start; bin < end; bin++) {
      99     2203793 :         psd[bin]=(3072 - (exp[bin] << 7));
     100             :     }
     101             : 
     102             :     /* PSD integration */
     103       17454 :     bin  = start;
     104       17454 :     band = ff_ac3_bin_to_band_tab[start];
     105             :     do {
     106      590363 :         int v = psd[bin++];
     107      590363 :         int band_end = FFMIN(ff_ac3_band_start_tab[band+1], end);
     108     2203793 :         for (; bin < band_end; bin++) {
     109     1613430 :             int max = FFMAX(v, psd[bin]);
     110             :             /* logadd */
     111     1613430 :             int adr = FFMIN(max - ((v + psd[bin] + 1) >> 1), 255);
     112     1613430 :             v = max + ff_ac3_log_add_tab[adr];
     113             :         }
     114      590363 :         band_psd[band++] = v;
     115      590363 :     } while (end > ff_ac3_band_start_tab[band]);
     116       17454 : }
     117             : 
     118       17556 : int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd,
     119             :                                int start, int end, int fast_gain, int is_lfe,
     120             :                                int dba_mode, int dba_nsegs, uint8_t *dba_offsets,
     121             :                                uint8_t *dba_lengths, uint8_t *dba_values,
     122             :                                int16_t *mask)
     123             : {
     124             :     int16_t excite[AC3_CRITICAL_BANDS]; /* excitation */
     125             :     int band;
     126             :     int band_start, band_end, begin, end1;
     127             :     int lowcomp, fastleak, slowleak;
     128             : 
     129       17556 :     if (end <= 0)
     130           0 :         return AVERROR_INVALIDDATA;
     131             : 
     132             :     /* excitation function */
     133       17556 :     band_start = ff_ac3_bin_to_band_tab[start];
     134       17556 :     band_end   = ff_ac3_bin_to_band_tab[end-1] + 1;
     135             : 
     136       17556 :     if (band_start == 0) {
     137       13054 :         lowcomp = 0;
     138       13054 :         lowcomp = calc_lowcomp1(lowcomp, band_psd[0], band_psd[1], 384);
     139       13054 :         excite[0] = band_psd[0] - fast_gain - lowcomp;
     140       13054 :         lowcomp = calc_lowcomp1(lowcomp, band_psd[1], band_psd[2], 384);
     141       13054 :         excite[1] = band_psd[1] - fast_gain - lowcomp;
     142       13054 :         begin = 7;
     143       23063 :         for (band = 2; band < 7; band++) {
     144       22970 :             if (!(is_lfe && band == 6))
     145       22900 :                 lowcomp = calc_lowcomp1(lowcomp, band_psd[band], band_psd[band+1], 384);
     146       22970 :             fastleak = band_psd[band] - fast_gain;
     147       22970 :             slowleak = band_psd[band] - s->slow_gain;
     148       22970 :             excite[band] = fastleak - lowcomp;
     149       22970 :             if (!(is_lfe && band == 6)) {
     150       22900 :                 if (band_psd[band] <= band_psd[band+1]) {
     151       12961 :                     begin = band + 1;
     152       12961 :                     break;
     153             :                 }
     154             :             }
     155             :         }
     156             : 
     157       13054 :         end1 = FFMIN(band_end, 22);
     158      244414 :         for (band = begin; band < end1; band++) {
     159      231360 :             if (!(is_lfe && band == 6))
     160      230980 :                 lowcomp = calc_lowcomp(lowcomp, band_psd[band], band_psd[band+1], band);
     161      231360 :             fastleak = FFMAX(fastleak - s->fast_decay, band_psd[band] - fast_gain);
     162      231360 :             slowleak = FFMAX(slowleak - s->slow_decay, band_psd[band] - s->slow_gain);
     163      231360 :             excite[band] = FFMAX(fastleak - lowcomp, slowleak);
     164             :         }
     165       13054 :         begin = 22;
     166             :     } else {
     167             :         /* coupling channel */
     168        4502 :         begin = band_start;
     169        4502 :         fastleak = (s->cpl_fast_leak << 8) + 768;
     170        4502 :         slowleak = (s->cpl_slow_leak << 8) + 768;
     171             :     }
     172             : 
     173      330928 :     for (band = begin; band < band_end; band++) {
     174      313372 :         fastleak = FFMAX(fastleak - s->fast_decay, band_psd[band] - fast_gain);
     175      313372 :         slowleak = FFMAX(slowleak - s->slow_decay, band_psd[band] - s->slow_gain);
     176      313372 :         excite[band] = FFMAX(fastleak, slowleak);
     177             :     }
     178             : 
     179             :     /* compute masking curve */
     180             : 
     181      611366 :     for (band = band_start; band < band_end; band++) {
     182      593810 :         int tmp = s->db_per_bit - band_psd[band];
     183      593810 :         if (tmp > 0) {
     184      435908 :             excite[band] += tmp >> 2;
     185             :         }
     186      593810 :         mask[band] = FFMAX(ff_ac3_hearing_threshold_tab[band >> s->sr_shift][s->sr_code], excite[band]);
     187             :     }
     188             : 
     189             :     /* delta bit allocation */
     190             : 
     191       17556 :     if (dba_mode == DBA_REUSE || dba_mode == DBA_NEW) {
     192             :         int i, seg, delta;
     193           0 :         if (dba_nsegs > 8)
     194           0 :             return -1;
     195           0 :         band = band_start;
     196           0 :         for (seg = 0; seg < dba_nsegs; seg++) {
     197           0 :             band += dba_offsets[seg];
     198           0 :             if (band >= AC3_CRITICAL_BANDS || dba_lengths[seg] > AC3_CRITICAL_BANDS-band)
     199           0 :                 return -1;
     200           0 :             if (dba_values[seg] >= 4) {
     201           0 :                 delta = (dba_values[seg] - 3) * 128;
     202             :             } else {
     203           0 :                 delta = (dba_values[seg] - 4) * 128;
     204             :             }
     205           0 :             for (i = 0; i < dba_lengths[seg]; i++) {
     206           0 :                 mask[band++] += delta;
     207             :             }
     208             :         }
     209             :     }
     210       17556 :     return 0;
     211             : }

Generated by: LCOV version 1.13