• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

libavcodec/ac3.c

Go to the documentation of this file.
00001 /*
00002  * Common code between the AC-3 encoder and decoder
00003  * Copyright (c) 2000 Fabrice Bellard
00004  *
00005  * This file is part of Libav.
00006  *
00007  * Libav is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * Libav is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with Libav; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00027 #include "avcodec.h"
00028 #include "ac3.h"
00029 #include "get_bits.h"
00030 
00034 const uint8_t ff_ac3_band_start_tab[AC3_CRITICAL_BANDS+1] = {
00035       0,  1,   2,   3,   4,   5,   6,   7,   8,   9,
00036      10,  11, 12,  13,  14,  15,  16,  17,  18,  19,
00037      20,  21, 22,  23,  24,  25,  26,  27,  28,  31,
00038      34,  37, 40,  43,  46,  49,  55,  61,  67,  73,
00039      79,  85, 97, 109, 121, 133, 157, 181, 205, 229, 253
00040 };
00041 
00042 #if CONFIG_HARDCODED_TABLES
00043 
00047 const uint8_t ff_ac3_bin_to_band_tab[253] = {
00048      0,
00049      1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12,
00050     13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
00051     25, 26, 27, 28, 28, 28, 29, 29, 29, 30, 30, 30,
00052     31, 31, 31, 32, 32, 32, 33, 33, 33, 34, 34, 34,
00053     35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36,
00054     37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38,
00055     39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40,
00056     41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
00057     42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
00058     43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
00059     44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
00060     45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
00061     45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
00062     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
00063     46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
00064     47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
00065     47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
00066     48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
00067     48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
00068     49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
00069     49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49
00070 };
00071 
00072 #else /* CONFIG_HARDCODED_TABLES */
00073 uint8_t ff_ac3_bin_to_band_tab[253];
00074 #endif
00075 
00076 static inline int calc_lowcomp1(int a, int b0, int b1, int c)
00077 {
00078     if ((b0 + 256) == b1) {
00079         a = c;
00080     } else if (b0 > b1) {
00081         a = FFMAX(a - 64, 0);
00082     }
00083     return a;
00084 }
00085 
00086 static inline int calc_lowcomp(int a, int b0, int b1, int bin)
00087 {
00088     if (bin < 7) {
00089         return calc_lowcomp1(a, b0, b1, 384);
00090     } else if (bin < 20) {
00091         return calc_lowcomp1(a, b0, b1, 320);
00092     } else {
00093         return FFMAX(a - 128, 0);
00094     }
00095 }
00096 
00097 void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd,
00098                                int16_t *band_psd)
00099 {
00100     int bin, band;
00101 
00102     /* exponent mapping to PSD */
00103     for (bin = start; bin < end; bin++) {
00104         psd[bin]=(3072 - (exp[bin] << 7));
00105     }
00106 
00107     /* PSD integration */
00108     bin  = start;
00109     band = ff_ac3_bin_to_band_tab[start];
00110     do {
00111         int v = psd[bin++];
00112         int band_end = FFMIN(ff_ac3_band_start_tab[band+1], end);
00113         for (; bin < band_end; bin++) {
00114             int max = FFMAX(v, psd[bin]);
00115             /* logadd */
00116             int adr = FFMIN(max - ((v + psd[bin] + 1) >> 1), 255);
00117             v = max + ff_ac3_log_add_tab[adr];
00118         }
00119         band_psd[band++] = v;
00120     } while (end > ff_ac3_band_start_tab[band]);
00121 }
00122 
00123 int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd,
00124                                int start, int end, int fast_gain, int is_lfe,
00125                                int dba_mode, int dba_nsegs, uint8_t *dba_offsets,
00126                                uint8_t *dba_lengths, uint8_t *dba_values,
00127                                int16_t *mask)
00128 {
00129     int16_t excite[AC3_CRITICAL_BANDS]; /* excitation */
00130     int band;
00131     int band_start, band_end, begin, end1;
00132     int lowcomp, fastleak, slowleak;
00133 
00134     /* excitation function */
00135     band_start = ff_ac3_bin_to_band_tab[start];
00136     band_end   = ff_ac3_bin_to_band_tab[end-1] + 1;
00137 
00138     if (band_start == 0) {
00139         lowcomp = 0;
00140         lowcomp = calc_lowcomp1(lowcomp, band_psd[0], band_psd[1], 384);
00141         excite[0] = band_psd[0] - fast_gain - lowcomp;
00142         lowcomp = calc_lowcomp1(lowcomp, band_psd[1], band_psd[2], 384);
00143         excite[1] = band_psd[1] - fast_gain - lowcomp;
00144         begin = 7;
00145         for (band = 2; band < 7; band++) {
00146             if (!(is_lfe && band == 6))
00147                 lowcomp = calc_lowcomp1(lowcomp, band_psd[band], band_psd[band+1], 384);
00148             fastleak = band_psd[band] - fast_gain;
00149             slowleak = band_psd[band] - s->slow_gain;
00150             excite[band] = fastleak - lowcomp;
00151             if (!(is_lfe && band == 6)) {
00152                 if (band_psd[band] <= band_psd[band+1]) {
00153                     begin = band + 1;
00154                     break;
00155                 }
00156             }
00157         }
00158 
00159         end1 = FFMIN(band_end, 22);
00160         for (band = begin; band < end1; band++) {
00161             if (!(is_lfe && band == 6))
00162                 lowcomp = calc_lowcomp(lowcomp, band_psd[band], band_psd[band+1], band);
00163             fastleak = FFMAX(fastleak - s->fast_decay, band_psd[band] - fast_gain);
00164             slowleak = FFMAX(slowleak - s->slow_decay, band_psd[band] - s->slow_gain);
00165             excite[band] = FFMAX(fastleak - lowcomp, slowleak);
00166         }
00167         begin = 22;
00168     } else {
00169         /* coupling channel */
00170         begin = band_start;
00171         fastleak = (s->cpl_fast_leak << 8) + 768;
00172         slowleak = (s->cpl_slow_leak << 8) + 768;
00173     }
00174 
00175     for (band = begin; band < band_end; band++) {
00176         fastleak = FFMAX(fastleak - s->fast_decay, band_psd[band] - fast_gain);
00177         slowleak = FFMAX(slowleak - s->slow_decay, band_psd[band] - s->slow_gain);
00178         excite[band] = FFMAX(fastleak, slowleak);
00179     }
00180 
00181     /* compute masking curve */
00182 
00183     for (band = band_start; band < band_end; band++) {
00184         int tmp = s->db_per_bit - band_psd[band];
00185         if (tmp > 0) {
00186             excite[band] += tmp >> 2;
00187         }
00188         mask[band] = FFMAX(ff_ac3_hearing_threshold_tab[band >> s->sr_shift][s->sr_code], excite[band]);
00189     }
00190 
00191     /* delta bit allocation */
00192 
00193     if (dba_mode == DBA_REUSE || dba_mode == DBA_NEW) {
00194         int i, seg, delta;
00195         if (dba_nsegs > 8)
00196             return -1;
00197         band = band_start;
00198         for (seg = 0; seg < dba_nsegs; seg++) {
00199             band += dba_offsets[seg];
00200             if (band >= AC3_CRITICAL_BANDS || dba_lengths[seg] > AC3_CRITICAL_BANDS-band)
00201                 return -1;
00202             if (dba_values[seg] >= 4) {
00203                 delta = (dba_values[seg] - 3) << 7;
00204             } else {
00205                 delta = (dba_values[seg] - 4) << 7;
00206             }
00207             for (i = 0; i < dba_lengths[seg]; i++) {
00208                 mask[band++] += delta;
00209             }
00210         }
00211     }
00212     return 0;
00213 }
00214 
00220 av_cold void ff_ac3_common_init(void)
00221 {
00222 #if !CONFIG_HARDCODED_TABLES
00223     /* compute ff_ac3_bin_to_band_tab from ff_ac3_band_start_tab */
00224     int bin = 0, band;
00225     for (band = 0; band < AC3_CRITICAL_BANDS; band++) {
00226         int band_end = ff_ac3_band_start_tab[band+1];
00227         while (bin < band_end)
00228             ff_ac3_bin_to_band_tab[bin++] = band;
00229     }
00230 #endif /* !CONFIG_HARDCODED_TABLES */
00231 }
Generated on Sat Mar 17 2012 12:57:42 for Libav by doxygen 1.7.1