libavcodec/ac3.c

   1 /*
   2  * Common code between AC3 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 ac3.c
  24  * Common code between AC3 encoder and decoder.
  25  */
  26
  27 #include "avcodec.h"
  28 #include "ac3.h"
  29 #include "ac3tab.h"
  30
  31 static inline int calc_lowcomp1(int a, int b0, int b1, int c)
  32 {
  33     if ((b0 + 256) == b1) {
  34         a = c;
  35     } else if (b0 > b1) {
  36         a = FFMAX(a - 64, 0);
  37     }
  38     return a;
  39 }
  40
  41 static inline int calc_lowcomp(int a, int b0, int b1, int bin)
  42 {
  43     if (bin < 7) {
  44         return calc_lowcomp1(a, b0, b1, 384);
  45     } else if (bin < 20) {
  46         return calc_lowcomp1(a, b0, b1, 320);
  47     } else {
  48         return FFMAX(a - 128, 0);
  49     }
  50 }
  51
  52 /* AC3 bit allocation. The algorithm is the one described in the AC3
  53    spec. */
  54 void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, uint8_t *bap,
  55                                    int8_t *exp, int start, int end,
  56                                    int snroffset, int fgain, int is_lfe,
  57                                    int deltbae,int deltnseg,
  58                                    uint8_t *deltoffst, uint8_t *deltlen, uint8_t *deltba)
  59 {
  60     int bin,i,j,k,end1,v,bndstrt,bndend,lowcomp,begin;
  61     int fastleak,slowleak,address,tmp;
  62     int16_t psd[256]; /* scaled exponents */
  63     int16_t bndpsd[50]; /* interpolated exponents */
  64     int16_t excite[50]; /* excitation */
  65     int16_t mask[50];   /* masking value */
  66
  67     /* exponent mapping to PSD */
  68     for(bin=start;bin<end;bin++) {
  69         psd[bin]=(3072 - (exp[bin] << 7));
  70     }
  71
  72     /* PSD integration */
  73     j=start;
  74     k=masktab[start];
  75     do {
  76         v=psd[j];
  77         j++;
  78         end1 = FFMIN(bndtab[k+1], end);
  79         for(i=j;i<end1;i++) {
  80             /* logadd */
  81             int adr = FFMIN(FFABS(v - psd[j]) >> 1, 255);
  82             v = FFMAX(v, psd[j]) + latab[adr];
  83             j++;
  84         }
  85         bndpsd[k]=v;
  86         k++;
  87     } while (end > bndtab[k]);
  88
  89     /* excitation function */
  90     bndstrt = masktab[start];
  91     bndend = masktab[end-1] + 1;
  92
  93     if (bndstrt == 0) {
  94         lowcomp = 0;
  95         lowcomp = calc_lowcomp1(lowcomp, bndpsd[0], bndpsd[1], 384);
  96         excite[0] = bndpsd[0] - fgain - lowcomp;
  97         lowcomp = calc_lowcomp1(lowcomp, bndpsd[1], bndpsd[2], 384);
  98         excite[1] = bndpsd[1] - fgain - lowcomp;
  99         begin = 7;
 100         for (bin = 2; bin < 7; bin++) {
 101             if (!(is_lfe && bin == 6))
 102                 lowcomp = calc_lowcomp1(lowcomp, bndpsd[bin], bndpsd[bin+1], 384);
 103             fastleak = bndpsd[bin] - fgain;
 104             slowleak = bndpsd[bin] - s->sgain;
 105             excite[bin] = fastleak - lowcomp;
 106             if (!(is_lfe && bin == 6)) {
 107                 if (bndpsd[bin] <= bndpsd[bin+1]) {
 108                     begin = bin + 1;
 109                     break;
 110                 }
 111             }
 112         }
 113
 114         end1=bndend;
 115         if (end1 > 22) end1=22;
 116
 117         for (bin = begin; bin < end1; bin++) {
 118             if (!(is_lfe && bin == 6))
 119                 lowcomp = calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin+1], bin);
 120
 121             fastleak = FFMAX(fastleak - s->fdecay, bndpsd[bin] - fgain);
 122             slowleak = FFMAX(slowleak - s->sdecay, bndpsd[bin] - s->sgain);
 123             excite[bin] = FFMAX(fastleak - lowcomp, slowleak);
 124         }
 125         begin = 22;
 126     } else {
 127         /* coupling channel */
 128         begin = bndstrt;
 129
 130         fastleak = (s->cplfleak << 8) + 768;
 131         slowleak = (s->cplsleak << 8) + 768;
 132     }
 133
 134     for (bin = begin; bin < bndend; bin++) {
 135         fastleak = FFMAX(fastleak - s->fdecay, bndpsd[bin] - fgain);
 136         slowleak = FFMAX(slowleak - s->sdecay, bndpsd[bin] - s->sgain);
 137         excite[bin] = FFMAX(fastleak, slowleak);
 138     }
 139
 140     /* compute masking curve */
 141
 142     for (bin = bndstrt; bin < bndend; bin++) {
 143         tmp = s->dbknee - bndpsd[bin];
 144         if (tmp > 0) {
 145             excite[bin] += tmp >> 2;
 146         }
 147         mask[bin] = FFMAX(hth[bin >> s->halfratecod][s->fscod], excite[bin]);
 148     }
 149
 150     /* delta bit allocation */
 151
 152     if (deltbae == 0 || deltbae == 1) {
 153         int band, seg, delta;
 154         band = 0;
 155         for (seg = 0; seg < deltnseg; seg++) {
 156             band += deltoffst[seg];
 157             if (deltba[seg] >= 4) {
 158                 delta = (deltba[seg] - 3) << 7;
 159             } else {
 160                 delta = (deltba[seg] - 4) << 7;
 161             }
 162             for (k = 0; k < deltlen[seg]; k++) {
 163                 mask[band] += delta;
 164                 band++;
 165             }
 166         }
 167     }
 168
 169     /* compute bit allocation */
 170
 171     i = start;
 172     j = masktab[start];
 173     do {
 174         v = (FFMAX(mask[j] - snroffset - s->floor, 0) & 0x1FE0) + s->floor;
 175         end1 = FFMIN(bndtab[j] + bndsz[j], end);
 176         for (k = i; k < end1; k++) {
 177             address = av_clip((psd[i] - v) >> 5, 0, 63);
 178             bap[i] = baptab[address];
 179             i++;
 180         }
 181     } while (end > bndtab[j++]);
 182 }
 183
 184 /**
 185  * Initializes some tables.
 186  * note: This function must remain thread safe because it is called by the
 187  *       AVParser init code.
 188  */
 189 void ac3_common_init(void)
 190 {
 191     int i, j, k, l, v;
 192     /* compute bndtab and masktab from bandsz */
 193     k = 0;
 194     l = 0;
 195     for(i=0;i<50;i++) {
 196         bndtab[i] = l;
 197         v = bndsz[i];
 198         for(j=0;j<v;j++) masktab[k++]=i;
 199         l += v;
 200     }
 201     bndtab[50] = l;
 202
 203     /* generate ff_ac3_frame_sizes table */
 204     for(i=0; i<38; i++) {
 205         int br = ff_ac3_bitratetab[i >> 1];
 206         ff_ac3_frame_sizes[i][0] = (  2*br      );
 207         ff_ac3_frame_sizes[i][1] = (320*br / 147) + (i & 1);
 208         ff_ac3_frame_sizes[i][2] = (  3*br      );
 209     }
 210 }